486 lines
19 KiB
Python
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
|