Files
aostats-custom/src/decode/world.py
T
bionickatana f3114b076a
Build / Build source distribution (push) Failing after 8s
Build / Execute unit tests (push) Failing after 6s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
Added 'damage taken' section to the UI
2026-10-10 23:38:32 -06:00

486 lines
19 KiB
Python

import logging
from typing import Dict, List, Optional
from .. import environment
from . import items as itemdb
from . import party_memory
from . import translate
from .translate import GameMessage
FIX_POINT = 10000.0
FAME_MIN_TOTAL = 1000000 # albion-lens sanity filter for UpdateFame events
logger = logging.getLogger(__name__)
class IdCache:
"""Maps dynamic (per-session) ids to stable ids and names.
Mirrors aoaddons src/game/id_cache.rs: ids are assigned sequentially by
player name, so reconnecting to a zone keeps the same id for a player.
"""
def __init__(self):
self.dyn_to_static: Dict[int, int] = {}
self.static_to_name: Dict[int, str] = {}
self.static_to_dyn: Dict[int, int] = {}
self.last_id = 0
def save(self, dynamic_id: int, name: str):
if not name:
return
static_id = self._find_static_id(name)
if static_id is not None:
old_dyn = self.static_to_dyn.get(static_id)
if old_dyn is not None:
self.dyn_to_static.pop(old_dyn, None)
self.dyn_to_static[dynamic_id] = static_id
self.static_to_dyn[static_id] = dynamic_id
return
static_id = self.last_id
self.last_id += 1
self.dyn_to_static[dynamic_id] = static_id
self.static_to_dyn[static_id] = dynamic_id
self.static_to_name[static_id] = name
def _find_static_id(self, name: str) -> Optional[int]:
for sid, sid_name in self.static_to_name.items():
if sid_name == name:
return sid
return None
def get_static_id(self, dynamic_id: int) -> Optional[int]:
return self.dyn_to_static.get(dynamic_id)
def get_name(self, static_id: int) -> Optional[str]:
return self.static_to_name.get(static_id)
class Party:
"""Tracks party membership from party events (aoaddons src/game/party.rs)."""
def __init__(self):
self.main_player_name: Optional[str] = None
self.items: List[dict] = [] # {'name', 'id'}
self.last_names: List[str] = []
def set_main_player_name(self, name: str):
self.main_player_name = name
def _game_event(self) -> dict:
self.last_names = _unique_names([item['name'] for item in self.items])
return {'name': 'UpdateParty', 'value': {
'player_names': self.last_names}}
def set_names(self, names: List[str]):
self.items = [
{'name': name, 'id': index}
for index, name in enumerate(_unique_names(names))
]
self.last_names = [item['name'] for item in self.items]
def joined(self, msg: GameMessage) -> Optional[dict]:
structures = translate.msg_party_structures(msg)
names = translate.msg_party_names(msg)
self.items = []
for structure, name in zip(structures, names):
self.items.append({'name': name, 'id': _party_id(structure)})
return self._game_event()
def disbanded(self) -> Optional[dict]:
self.items = []
self.last_names = []
return self._game_event()
def player_left(self, msg: GameMessage) -> Optional[dict]:
if self.main_player_name is None:
return None
structure_id = _party_id(translate.msg_party_structure(msg))
party_item = next((i for i in self.items if i['id'] == structure_id), None)
if party_item is None:
return None
if party_item['name'] == self.main_player_name:
return self.disbanded()
self.items = [i for i in self.items if i['id'] != structure_id]
return self._game_event()
def single_player_joined(self, msg: GameMessage) -> Optional[dict]:
self.items.append({
'name': translate.msg_party_name(msg),
'id': _party_id(translate.msg_party_structure(msg)),
})
return self._game_event()
def roster(self, msg: GameMessage) -> Optional[dict]:
self.set_names(translate.msg_party_roster_names(msg))
return self._game_event()
def remembered(self, names: List[str]) -> Optional[dict]:
self.set_names(names)
return self._game_event()
class UnconsumedMessages:
"""Buffers messages tagged with a dynamic id whose static id is unknown.
Replayed once the id is resolved (aoaddons src/game/unconsumed_messages.rs).
"""
def __init__(self):
self._messages: Dict[int, List[GameMessage]] = {}
def add(self, dynamic_id: int, msg: GameMessage):
self._messages.setdefault(dynamic_id, []).append(msg)
def get_for_id(self, dynamic_id: int) -> List[GameMessage]:
return self._messages.get(dynamic_id, [])
class World:
"""Transforms translated game messages into app events (aoaddons world.rs)."""
def __init__(self, remember_last_party: Optional[bool] = None):
self.cache = IdCache()
self.party = Party()
self.unconsumed_messages = UnconsumedMessages()
self.main_player_id: Optional[int] = None
self._main_player_joined = False
self._fame_totals: Dict[int, int] = {}
self._seen_item_pickups = set()
self._remember_last_party = (environment.remember_last_party()
if remember_last_party is None
else remember_last_party)
self._remembered_party_names = (party_memory.load_last_party()
if self._remember_last_party else [])
if self._remember_last_party:
logger.debug("remember_last_party enabled; loaded names: %s",
self._remembered_party_names)
else:
logger.debug("remember_last_party disabled; saved party will not autoload")
self._zone_candidate_names: List[str] = []
self._explicit_party_seen = False
self._party_inferred = False
def transform(self, message: GameMessage) -> List[dict]:
if message.name == 'NewCharacter':
return self._on_new_character(message)
if message.name == 'Join':
return self._on_join(message)
if message.name == 'ChangeCluster':
return self._on_change_cluster(message)
if message.name == 'Leave':
return self._on_leave(message)
if message.name == 'HealthUpdate':
return self._on_health_update(message)
if message.name == 'RegenerationHealthChanged':
return self._on_regeneration(message)
if message.name == 'KnockedDown':
return self._on_knocked_down(message)
if message.name == 'UpdateFame':
return self._on_update_fame(message)
if message.name == 'ItemGained':
return self._on_item_gained(message)
if message.name == 'TakeSilver':
return self._on_take_silver(message)
if message.name == 'CharacterEquipmentChanged':
return self._on_character_equipment_changed(message)
if message.name == 'PartyJoined':
return self._explicit_party_event(self.party.joined(message))
if message.name == 'PartyDisbanded':
return self._explicit_party_event(self.party.disbanded())
if message.name == 'PartyPlayerJoined':
return self._explicit_party_event(self.party.single_player_joined(message))
if message.name == 'PartyPlayerLeft':
return self._explicit_party_event(self.party.player_left(message))
if message.name == 'PartyRoster':
return self._explicit_party_event(self.party.roster(message))
return []
def _party_event(self, event: Optional[dict]) -> List[dict]:
return [event] if event is not None else []
def _explicit_party_event(self, event: Optional[dict]) -> List[dict]:
self._explicit_party_seen = True
self._party_inferred = False
self._remember_party_event(event)
return self._party_event(event)
def _on_new_character(self, msg: GameMessage) -> List[dict]:
name = translate.msg_new_character_name(msg)
dynamic_id = _dyn(translate.msg_source(msg))
if not name:
return []
self.cache.save(dynamic_id, name)
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None:
return []
result = [{
'name': 'PlayerAppeared',
'value': {'id': static_id, 'name': name},
}]
result.extend(self._infer_party_from_zone_name(name))
items = itemdb.decode_items(translate.msg_new_character_items(msg))
if items:
result.append({
'name': 'UpdateItems',
'value': {'source': static_id, 'value': items},
})
result.extend(self._replay(dynamic_id))
if self.main_player_id is None:
self.main_player_id = static_id
return result
def _on_join(self, msg: GameMessage) -> List[dict]:
name = translate.msg_character_name(msg)
dynamic_id = _dyn(translate.msg_source(msg))
if not name:
return []
self.cache.save(dynamic_id, name)
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None:
return []
self.party.set_main_player_name(name)
result = []
if not self._main_player_joined:
result.append({'name': 'ZoneChange'})
self.main_player_id = static_id
self._main_player_joined = True
self._zone_candidate_names = _unique_names(self._zone_candidate_names + [name])
self._explicit_party_seen = False
self._party_inferred = False
self._seen_item_pickups.clear()
result.append({
'name': 'MainPlayerAppeared',
'value': {'id': static_id, 'name': name},
})
result.extend(self._remembered_party_events(name))
result.extend(self._infer_party_from_zone_name(name))
result.extend(self._replay(dynamic_id))
return result
def _on_change_cluster(self, msg: GameMessage) -> List[dict]:
if self.main_player_id is None:
return []
self._reset_zone_party_inference()
self._seen_item_pickups.clear()
return [{'name': 'ZoneChange'}]
def _on_leave(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg))
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None:
return []
if self.main_player_id == static_id:
self.main_player_id = None
self._main_player_joined = False
self._reset_zone_party_inference()
self._seen_item_pickups.clear()
return [{'name': 'ZoneChange'}]
return []
def _on_health_update(self, msg: GameMessage) -> List[dict]:
# params: [0]=target (entity whose health changed), [2]=signed delta,
# [6]=source (attacker/healer). aoaddons emits Damage{source: params[6],
# target: params[0]} which the app attributes to the dealer/healer.
value = translate.msg_value(msg)
if value == 0.0:
return []
actor_id = _dyn(translate.msg_target(msg)) # param 6
victim_id = _dyn(translate.msg_source(msg)) # param 0
actor_static = self.cache.get_static_id(actor_id)
victim_static = self.cache.get_static_id(victim_id)
events = []
if actor_static is not None:
event_name = 'DamageDone' if value < 0.0 else 'HealthReceived'
events.append({
'name': event_name,
'value': {'source': actor_static,
'target': victim_static,
'value': float(abs(value))},
})
if value < 0.0 and victim_static is not None:
events.append({
'name': 'DamageTaken',
'value': {'source': victim_static,
'value': float(abs(value))},
})
return events
def _on_regeneration(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg))
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None:
return []
name = self.cache.get_name(static_id) or ''
if not name:
return []
event_name = ('LeaveCombat' if translate.msg_regeneration_rate(msg) is not None
else 'EnterCombat')
return [{'name': event_name, 'value': {'id': static_id, 'name': name}}]
def _on_knocked_down(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg))
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None:
return []
name = self.cache.get_name(static_id) or ''
if not name:
return []
return [{'name': 'LeaveCombat', 'value': {'id': static_id, 'name': name}}]
def _on_update_fame(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg))
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None:
return []
total = translate.msg_total_fame(msg)
if total < FAME_MIN_TOTAL:
return []
prev = self._fame_totals.get(static_id)
if prev == total:
return []
gained = translate.msg_fame_gained(msg)
self._fame_totals[static_id] = total
if gained is None:
if prev is None or total < prev:
return []
gained = total - prev
if gained <= 0:
return []
# Match the in-game display: zone/event bonus factor and premium are
# applied on top of the base fame, plus any satchel (insight bag) fame.
value = float(gained)
if translate.msg_fame_is_premium(msg):
value *= 1.5
value += float(translate.msg_fame_satchel(msg))
value *= 1.0 + translate.msg_fame_bonus_factor(msg)
return [{'name': 'UpdateFame', 'value': {'value': value / FIX_POINT}}]
def _on_item_gained(self, msg: GameMessage) -> List[dict]:
if not self._main_player_joined:
return []
source_id = _dyn(translate.msg_source(msg))
item_id = translate.msg_collected_item_id(msg)
quantity = translate.msg_collected_item_quantity(msg)
if item_id is None or quantity is None or quantity <= 0:
return []
pickup_key = (source_id, item_id, quantity)
if pickup_key in self._seen_item_pickups:
return []
self._seen_item_pickups.add(pickup_key)
item_name = itemdb.display_name(item_id)
value = {
'item_id': item_id,
'item_name': item_name,
'quantity': quantity,
}
estimated_value = translate.msg_collected_item_value(msg)
if estimated_value is not None:
value['estimated_value'] = estimated_value
return [{'name': 'ItemCollected', 'value': value}]
def _on_take_silver(self, msg: GameMessage) -> List[dict]:
if not self._main_player_joined:
return []
dynamic_id = _dyn(translate.msg_source(msg))
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None or static_id != self.main_player_id:
return []
yield_pre_tax = translate.msg_silver_yield_pre_tax(msg)
if yield_pre_tax is None or yield_pre_tax <= 0:
return []
taxes = (translate.msg_silver_cluster_tax(msg)
+ translate.msg_silver_guild_tax(msg)
+ translate.msg_silver_alliance_penalty(msg))
gained = max(0, yield_pre_tax - taxes)
if gained <= 0:
return []
return [{'name': 'SilverGained', 'value': {
'value': float(gained / FIX_POINT),
'silver_type': 'looted',
}}]
def _on_character_equipment_changed(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg))
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None:
self.unconsumed_messages.add(dynamic_id, msg)
return []
items = itemdb.decode_items(translate.msg_items(msg))
return [{'name': 'UpdateItems', 'value': {'source': static_id, 'value': items}}]
def _replay(self, dynamic_id: int) -> List[dict]:
result: List[dict] = []
for msg in self.unconsumed_messages.get_for_id(dynamic_id):
result.extend(self.transform(msg))
return result
def _remembered_party_events(self, main_player_name: str) -> List[dict]:
if not self._remember_last_party or not self._remembered_party_names:
return []
if main_player_name not in self._remembered_party_names:
return []
event = self.party.remembered(self._remembered_party_names)
return self._party_event(event)
def _infer_party_from_zone_name(self, name: str) -> List[dict]:
if not self._remember_last_party or self._explicit_party_seen:
return []
if name:
self._zone_candidate_names = _unique_names(
self._zone_candidate_names + [name])
if not self._main_player_joined:
return []
if self.party.last_names and not self._party_inferred:
return []
if self._remembered_party_names and not self._party_inferred:
names = [n for n in self._remembered_party_names
if n in self._zone_candidate_names]
if self.party.main_player_name in self._remembered_party_names:
names = self._remembered_party_names
else:
names = self._zone_candidate_names
if len(names) < 2 or len(names) > 5:
return []
event = self.party.remembered(names)
self._party_inferred = True
self._remember_party_event(event)
return self._party_event(event)
def _remember_party_event(self, event: Optional[dict]):
if event is None:
return
names = event.get('value', {}).get('player_names', [])
remembered_names = _unique_names(names)
if remembered_names:
self._remembered_party_names = remembered_names
party_memory.save_last_party(remembered_names)
elif self._remember_last_party:
self._remembered_party_names = []
logger.debug("empty party event cleared in-memory party only")
def _reset_zone_party_inference(self):
self._zone_candidate_names = []
self._explicit_party_seen = False
self._party_inferred = False
self.party.items = []
self.party.last_names = []
def _dyn(value) -> int:
return int(value) & 0xFFFFFFFF
def _party_id(party_structure: List[int]) -> int:
return sum(party_structure)
def _unique_names(names: List[str]) -> List[str]:
out = []
seen = set()
for name in names:
if not name or name in seen:
continue
seen.add(name)
out.append(name)
return out