diff --git a/src/decode/party_memory.py b/src/decode/party_memory.py new file mode 100644 index 0000000..c02dae4 --- /dev/null +++ b/src/decode/party_memory.py @@ -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 diff --git a/src/decode/translate.py b/src/decode/translate.py index 99fe41f..3986535 100644 --- a/src/decode/translate.py +++ b/src/decode/translate.py @@ -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) diff --git a/src/decode/world.py b/src/decode/world.py index 55c1be0..c8f7142 100644 --- a/src/decode/world.py +++ b/src/decode/world.py @@ -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 diff --git a/src/environment.py b/src/environment.py index 69642f0..dcc57b3 100644 --- a/src/environment.py +++ b/src/environment.py @@ -28,6 +28,11 @@ DISCOVERY_LOG_PATH = ( _arg_value('--log-path') ) +REMEMBER_LAST_PARTY = bool( + os.getenv('AOSTATS_REMEMBER_LAST_PARTY') or + '--remember-last-party' in sys.argv +) + def is_verbose(): return VERBOSE @@ -37,6 +42,10 @@ def discovery_log_path(): return DISCOVERY_LOG_PATH +def remember_last_party(): + return REMEMBER_LAST_PARTY + + def qt_args(argv: List[str]) -> List[str]: """Return argv with app-specific options removed before Qt sees them.""" result = [] @@ -52,6 +61,8 @@ def qt_args(argv: List[str]) -> List[str]: continue if arg.startswith('--log-path='): continue + if arg == '--remember-last-party': + continue result.append(arg) return result diff --git a/src/gui/modules/main.py b/src/gui/modules/main.py index 6dfa8d1..4120655 100644 --- a/src/gui/modules/main.py +++ b/src/gui/modules/main.py @@ -9,6 +9,7 @@ from PySide6.QtWidgets import QFrame # type: ignore from PySide6.QtWidgets import QGridLayout # type: ignore from PySide6.QtWidgets import QHBoxLayout # type: ignore from PySide6.QtWidgets import QLabel # type: ignore +from PySide6.QtWidgets import QListView # type: ignore from PySide6.QtWidgets import QPushButton # type: ignore from PySide6.QtWidgets import QScrollArea # type: ignore from PySide6.QtWidgets import QVBoxLayout # type: ignore @@ -171,7 +172,7 @@ class ItemsPanel(QFrame): title = QLabel('Items Collected') title.setObjectName('PanelTitle') self.layout.addWidget(title) - self.list = ListItemView() + self.list = PlainStatsListView() self.layout.addWidget(self.list, 1) self.layout.addStretch(1) self.setLayout(self.layout) @@ -180,6 +181,22 @@ class ItemsPanel(QFrame): self.list.update(items) +class PlainStatsListView(QListView): + def __init__(self): + QListView.__init__(self) + self.model = QtGui.QStandardItemModel(self) + self.setModel(self.model) + + def update(self, items): + self.model.clear() + for item in items: + row = QtGui.QStandardItem( + f'{item.name} {item.value} ({item.percentage}%)') + row.setFlags(row.flags() & ~Qt.ItemIsSelectable) + row.setForeground(QtGui.QBrush(QtGui.QColor('#d8dbe2'))) + self.model.appendRow(row) + + class SettingsPanel(QWidget): def __init__(self, clipboard): QWidget.__init__(self) @@ -272,6 +289,9 @@ class MainWidget(QWidget): self.primary_list = ListItemView() self.main_layout.addWidget(self.primary_list, 1) + self.plain_list = PlainStatsListView() + self.main_layout.addWidget(self.plain_list, 1) + self.total_healing_label = QLabel('Total Healing') self.total_healing_label.setObjectName('PanelTitle') self.total_healing_list = ListItemView() @@ -361,6 +381,7 @@ class MainWidget(QWidget): def _set_page_copy(self, players, total_healing, silver, items): self.primary_list.hide() + self.plain_list.hide() self.primary_label.hide() self.total_healing_label.hide() self.total_healing_list.hide() @@ -406,8 +427,8 @@ class MainWidget(QWidget): 'Silver tracking is active with conservative packet filters. Looted Silver and Other Silver are separated for validation against your next capture.') self.primary_label.setText('Silver Gained') self.primary_label.show() - self.primary_list.show() - self.primary_list.update(silver) + self.plain_list.show() + self.plain_list.update(silver) return if self.current_page == Page.Items: @@ -416,8 +437,8 @@ class MainWidget(QWidget): 'Collected item quantities from item pickup packets. The right panel shows selected-scope item totals on every page.') self.primary_label.setText('Items by Quantity') self.primary_label.show() - self.primary_list.show() - self.primary_list.update(items) + self.plain_list.show() + self.plain_list.update(items) return self.page_title.setText('Settings') diff --git a/src/stats/visibility.py b/src/stats/visibility.py index 4c86f54..ee49a8d 100644 --- a/src/stats/visibility.py +++ b/src/stats/visibility.py @@ -3,7 +3,6 @@ import functools from dataclasses import dataclass, field from typing import List -import re from src.utils.config import config from ..event_receiver import VisibilityEventReceiver @@ -24,13 +23,13 @@ class Visibility(VisibilityEventReceiver): if _is_visible_by_config(): # Note: only for testing purposes return True - pattern = '|'.join(self.visible_players) + '|{}'.format( - self.main_player_name) if self.visible_players else self.main_player_name - return self.main_player_name and bool(_compile_pattern(pattern).match(name)) + visible = set(self.visible_players) + visible.add(self.main_player_name) + return bool(self.main_player_name and name in visible) @property def is_main_player_visible(self) -> bool: - return self.main_player_name is not "" + return self.main_player_name != "" @functools.lru_cache(maxsize=128) @@ -39,8 +38,3 @@ def _is_visible_by_config(): return True return False - - -@functools.lru_cache(maxsize=128) -def _compile_pattern(pattern: str): - return re.compile(pattern) diff --git a/tests/test_decode.py b/tests/test_decode.py index a14a22f..cda8b28 100644 --- a/tests/test_decode.py +++ b/tests/test_decode.py @@ -3,11 +3,13 @@ import struct import pytest from src.decode import photon +from src.decode import party_memory from src.decode import translate from src.decode.photon import PhotonDecoder, decode_message18 from src.decode.translate import into_game_message from src.decode.world import IdCache, World from src.net.capture import _extract_udp_payload +from src.utils import platform_utils # --- Protocol18 value builders ------------------------------------------------- @@ -194,6 +196,27 @@ def test_unknown_opcode_ignored(): assert into_game_message(message) is None +def test_party_roster_without_opcode_translates(): + message = photon.PhotonMessage('Event', 1, { + 0: 123, + 9: ['bionicKatana', 'Sweetpea23042'], + }, None, None) + + game = into_game_message(message) + + assert game is not None + assert game.name == 'PartyRoster' + assert translate.msg_party_roster_names(game) == [ + 'bionicKatana', 'Sweetpea23042'] + + +def test_unlock_response_string_lists_are_not_party_rosters(): + message = photon.PhotonMessage('Response', 1, { + 9: ['UNLOCKED_CLAIMABLE', 'UNLOCKED_CLAIMABLE'], + }, None, None) + assert into_game_message(message) is None + + # --- world ---------------------------------------------------------------------- def game(name, params=None): @@ -375,6 +398,71 @@ def test_party_events_from_structures(): assert left[0]['value']['player_names'] == ['Alice'] +def test_party_roster_event_updates_party(): + world = World() + events = world.transform(game('PartyRoster', { + 9: ['bionicKatana', 'Sweetpea23042'], + })) + + assert events == [{ + 'name': 'UpdateParty', + 'value': {'player_names': ['bionicKatana', 'Sweetpea23042']}, + }] + + +def test_remembered_party_reemits_on_join(monkeypatch, tmp_path): + monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path)) + party_memory.save_last_party([ + 'bionicKatana', 'fatbrick', 'Froedrick712', 'rainbowShade']) + + world = World(remember_last_party=True) + events = world.transform(game('Join', {0: 98, 2: 'bionicKatana'})) + + assert events[-1] == { + 'name': 'UpdateParty', + 'value': {'player_names': [ + 'bionicKatana', 'fatbrick', 'Froedrick712', 'rainbowShade']}, + } + + +def test_party_inference_grows_during_zone_load(monkeypatch, tmp_path): + monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path)) + world = World(remember_last_party=True) + + world.transform(game('NewCharacter', {0: 97, 1: 'rainbowShade'})) + join = world.transform(game('Join', {0: 98, 2: 'bionicKatana'})) + fatbrick = world.transform(game('NewCharacter', {0: 161, 1: 'fatbrick'})) + froedrick = world.transform(game('NewCharacter', {0: 211, 1: 'Froedrick712'})) + + assert _last_party_names(join) == [ + 'rainbowShade', 'bionicKatana'] + assert _last_party_names(fatbrick) == [ + 'rainbowShade', 'bionicKatana', 'fatbrick'] + assert _last_party_names(froedrick) == [ + 'rainbowShade', 'bionicKatana', 'fatbrick', 'Froedrick712'] + assert party_memory.load_last_party() == [ + 'rainbowShade', 'bionicKatana', 'fatbrick', 'Froedrick712'] + + +def test_party_disband_clears_remembered_party(monkeypatch, tmp_path): + monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path)) + world = World(remember_last_party=True) + + world.transform(game('PartyRoster', { + 9: ['bionicKatana', 'fatbrick'], + })) + assert party_memory.load_last_party() == ['bionicKatana', 'fatbrick'] + + world.transform(game('PartyDisbanded')) + + assert party_memory.load_last_party() == [] + + +def _last_party_names(events): + party_events = [e for e in events if e['name'] == 'UpdateParty'] + return party_events[-1]['value']['player_names'] + + def test_party_main_player_left_disbands(): world = World() world.party.set_main_player_name('Alice') diff --git a/tests/test_environment.py b/tests/test_environment.py new file mode 100644 index 0000000..cdccb73 --- /dev/null +++ b/tests/test_environment.py @@ -0,0 +1,16 @@ +import importlib +import sys + +import src.environment as environment + + +def test_remember_last_party_flag_is_removed_from_qt_args(monkeypatch): + monkeypatch.setattr(sys, 'argv', ['aostats', '--remember-last-party']) + reloaded = importlib.reload(environment) + + assert reloaded.remember_last_party() is True + assert reloaded.qt_args(['aostats', '--remember-last-party', '--verbose']) == [ + 'aostats'] + + sys.argv = ['aostats'] + importlib.reload(environment) diff --git a/tests/test_party_memory.py b/tests/test_party_memory.py new file mode 100644 index 0000000..a595939 --- /dev/null +++ b/tests/test_party_memory.py @@ -0,0 +1,27 @@ +import os + +from src.decode import party_memory +from src.utils import platform_utils + + +def test_party_memory_save_load_and_clear(monkeypatch, tmp_path): + monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path)) + + party_memory.save_last_party([ + 'bionicKatana', 'fatbrick', 'fatbrick', '', None]) + + assert party_memory.load_last_party() == ['bionicKatana', 'fatbrick'] + assert os.path.isfile(tmp_path / 'last-party.json') + + party_memory.clear_last_party() + + assert party_memory.load_last_party() == [] + assert not os.path.exists(tmp_path / 'last-party.json') + + +def test_party_memory_ignores_corrupt_file(monkeypatch, tmp_path): + monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path)) + path = tmp_path / 'last-party.json' + path.write_text('{not json') + + assert party_memory.load_last_party() == [] diff --git a/tests/test_visibility.py b/tests/test_visibility.py new file mode 100644 index 0000000..87d56fb --- /dev/null +++ b/tests/test_visibility.py @@ -0,0 +1,32 @@ +from src.stats import visibility as visibility_module +from src.stats.visibility import Visibility + + +def test_visibility_uses_exact_names(monkeypatch): + monkeypatch.delenv('TESTING', raising=False) + monkeypatch.setattr(visibility_module, 'config', lambda: {'app': {}}) + visibility_module._is_visible_by_config.cache_clear() + + visibility = Visibility() + visibility.on_player_appeared('bionicKatana') + visibility.on_visible_players_changed(['Sweetpea23042']) + + assert visibility.test('bionicKatana') + assert visibility.test('Sweetpea23042') + assert not visibility.test('Sweetpea') + assert not visibility.test('bionicKatanaExtra') + + +def test_visibility_treats_regex_characters_as_plain_names(monkeypatch): + monkeypatch.delenv('TESTING', raising=False) + monkeypatch.setattr(visibility_module, 'config', lambda: {'app': {}}) + visibility_module._is_visible_by_config.cache_clear() + + visibility = Visibility() + visibility.on_player_appeared('main.player') + visibility.on_visible_players_changed(['Arcane+Fire']) + + assert visibility.test('main.player') + assert visibility.test('Arcane+Fire') + assert not visibility.test('mainXplayer') + assert not visibility.test('ArcaneeeFire')