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