Working on party stuff, mostly works

This commit is contained in:
2026-10-10 14:07:14 -06:00
parent 85a844208a
commit 60137a2de4
10 changed files with 400 additions and 21 deletions
+59
View File
@@ -0,0 +1,59 @@
import json
import os
from typing import List
from ..utils import platform_utils
FILE_NAME = 'last-party.json'
def memory_path() -> str:
cfg_dir = platform_utils.config_dir()
if not cfg_dir:
cfg_dir = os.getcwd()
return os.path.join(cfg_dir, FILE_NAME)
def load_last_party() -> List[str]:
try:
with open(memory_path(), 'r') as party_file:
data = json.load(party_file)
except (OSError, json.JSONDecodeError):
return []
names = data.get('player_names') if isinstance(data, dict) else None
if not isinstance(names, list):
return []
return _clean_names(names)
def save_last_party(names: List[str]):
clean_names = _clean_names(names)
if not clean_names:
clear_last_party()
return
path = memory_path()
directory = os.path.dirname(path)
if directory:
os.makedirs(directory, exist_ok=True)
with open(path, 'w') as party_file:
json.dump({'player_names': clean_names}, party_file)
def clear_last_party():
try:
os.remove(memory_path())
except FileNotFoundError:
pass
except OSError:
pass
def _clean_names(names: List[str]) -> List[str]:
out = []
seen = set()
for name in names:
if not isinstance(name, str) or not name or name in seen:
continue
seen.add(name)
out.append(name)
return out
+27
View File
@@ -51,6 +51,17 @@ def _string(value) -> Optional[str]:
return None
def _string_list(value) -> List[str]:
if not isinstance(value, list):
return []
out = []
for item in value:
s = _string(item)
if s:
out.append(s)
return out
def _as_int_list(value) -> List[int]:
if isinstance(value, bytes):
return list(value)
@@ -80,6 +91,9 @@ def into_game_message(message: PhotonMessage) -> Optional[GameMessage]:
if message.kind == 'Event':
code = _int(message.params.get(252))
if code is None:
names = msg_party_roster_names_from_params(message.params)
if names:
return GameMessage('PartyRoster', 0, message.params)
return None
name = EVENT_NAMES.get(code)
if name is None:
@@ -220,3 +234,16 @@ def msg_party_structure(msg: GameMessage) -> List[int]:
def msg_party_name(msg: GameMessage) -> str:
v = _string(msg.params.get(2))
return v if v is not None else ''
def msg_party_roster_names_from_params(params: dict) -> List[str]:
names = _string_list(params.get(9))
if len(names) < 2:
return []
if any(name.startswith('UNLOCKED_') for name in names):
return []
return names
def msg_party_roster_names(msg: GameMessage) -> List[str]:
return msg_party_roster_names_from_params(msg.params)
+110 -6
View File
@@ -1,6 +1,8 @@
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
@@ -58,13 +60,22 @@ class Party:
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': [item['name'] for item in self.items]}}
'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)
@@ -76,6 +87,7 @@ class Party:
def disbanded(self) -> Optional[dict]:
self.items = []
self.last_names = []
return self._game_event()
def player_left(self, msg: GameMessage) -> Optional[dict]:
@@ -97,6 +109,14 @@ class Party:
})
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.
@@ -117,7 +137,7 @@ class UnconsumedMessages:
class World:
"""Transforms translated game messages into app events (aoaddons world.rs)."""
def __init__(self):
def __init__(self, remember_last_party: Optional[bool] = None):
self.cache = IdCache()
self.party = Party()
self.unconsumed_messages = UnconsumedMessages()
@@ -125,6 +145,14 @@ class World:
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 [])
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':
@@ -150,18 +178,26 @@ class World:
if message.name == 'CharacterEquipmentChanged':
return self._on_character_equipment_changed(message)
if message.name == 'PartyJoined':
return self._party_event(self.party.joined(message))
return self._explicit_party_event(self.party.joined(message))
if message.name == 'PartyDisbanded':
return self._party_event(self.party.disbanded())
return self._explicit_party_event(self.party.disbanded())
if message.name == 'PartyPlayerJoined':
return self._party_event(self.party.single_player_joined(message))
return self._explicit_party_event(self.party.single_player_joined(message))
if message.name == 'PartyPlayerLeft':
return self._party_event(self.party.player_left(message))
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))
@@ -175,6 +211,7 @@ class World:
'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({
@@ -201,17 +238,23 @@ class World:
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'}]
@@ -223,6 +266,7 @@ class World:
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 []
@@ -344,6 +388,55 @@ class World:
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 not self._remember_last_party or event is None:
return
names = event.get('value', {}).get('player_names', [])
self._remembered_party_names = _unique_names(names)
if self._remembered_party_names:
party_memory.save_last_party(self._remembered_party_names)
else:
party_memory.clear_last_party()
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
@@ -351,3 +444,14 @@ def _dyn(value) -> int:
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