diff --git a/README.md b/README.md index c749f1c..4eb40c2 100644 --- a/README.md +++ b/README.md @@ -91,6 +91,14 @@ This prints the backend initialization result, the capture-permission probe, and On Linux the app uses its own `AF_PACKET` capture and Protocol18 decoder; every interface it listens on and every decoded event is logged with `--verbose`. +To collect packet-discovery data for decoding new features such as silver and item pickup tracking, pass a JSONL log path: + +```shell +aostats --verbose --log-path /tmp/aostats-discovery.jsonl +``` + +This writes raw UDP payloads, decoded Photon messages, translated game messages, emitted app events, and possible item-id annotations to the JSONL file. If `--verbose` is also set, normal app logs are written to `/tmp/aostats-discovery.jsonl.app.log`. + On Linux, when the app has no permission to capture packets the backend still reports successful initialization; the app detects this and shows a "Fix capture permissions" button regardless. ## Is This Allowed diff --git a/src/consts/events.py b/src/consts/events.py index f19d982..0f41e45 100644 --- a/src/consts/events.py +++ b/src/consts/events.py @@ -8,6 +8,8 @@ EvNameLeaveCombat: str = 'LeaveCombat' EvNameUpdateFame: str = 'UpdateFame' EvNameUpdateItems: str = 'UpdateItems' EvNameUpdateParty: str = 'UpdateParty' +EvNameSilverGained: str = 'SilverGained' +EvNameItemCollected: str = 'ItemCollected' EvKeyName: str = 'name' EvKeyValue: str = 'value' @@ -15,3 +17,7 @@ EvKeySource: str = 'source' EvKeyTarget: str = 'target' EvKeyId: str = 'id' EvKeyPlayerNames: str = 'player_names' +EvKeyItemId: str = 'item_id' +EvKeyItemName: str = 'item_name' +EvKeyQuantity: str = 'quantity' +EvKeySilverType: str = 'silver_type' diff --git a/src/decode/discovery.py b/src/decode/discovery.py new file mode 100644 index 0000000..785492c --- /dev/null +++ b/src/decode/discovery.py @@ -0,0 +1,110 @@ +import json +import os +import threading +from datetime import datetime, timezone +from typing import Any, Dict, List + +from ..environment import discovery_log_path +from . import items as itemdb + + +_lock = threading.Lock() +_initialized = False + + +def enabled() -> bool: + return bool(discovery_log_path()) + + +def log(record_type: str, **fields): + path = discovery_log_path() + if not path: + return + + global _initialized + with _lock: + log_dir = os.path.dirname(path) + if log_dir: + os.makedirs(log_dir, exist_ok=True) + mode = 'a' if _initialized else 'w' + with open(path, mode, encoding='utf-8') as out: + if not _initialized: + out.write(json.dumps({ + 'type': 'session_start', + 'timestamp': _timestamp(), + 'format': 'aostats-discovery-jsonl-v1', + }, sort_keys=True) + '\n') + _initialized = True + out.write(json.dumps({ + 'type': record_type, + 'timestamp': _timestamp(), + **_clean(fields), + }, sort_keys=True) + '\n') + + +def message_record(message) -> Dict[str, Any]: + params = getattr(message, 'params', {}) or {} + return { + 'kind': getattr(message, 'kind', None), + 'code': getattr(message, 'code', None), + 'return_code': getattr(message, 'return_code', None), + 'debug_message': _clean(getattr(message, 'debug_message', None)), + 'params': _clean(params), + 'item_id_candidates': item_candidates(params), + } + + +def game_message_record(game_message) -> Dict[str, Any]: + params = getattr(game_message, 'params', {}) or {} + return { + 'name': getattr(game_message, 'name', None), + 'code': getattr(game_message, 'code', None), + 'params': _clean(params), + 'item_id_candidates': item_candidates(params), + } + + +def item_candidates(params: Dict[Any, Any]) -> List[Dict[str, Any]]: + db = itemdb.get_db() + found: List[Dict[str, Any]] = [] + for key, value in (params or {}).items(): + for path, number in _walk_numbers(value, str(key)): + if number in db: + found.append({ + 'path': path, + 'id': number, + 'unique_name': db[number], + }) + return found + + +def _timestamp() -> str: + return datetime.now(timezone.utc).isoformat(timespec='milliseconds') + + +def _clean(value): + if isinstance(value, bytes): + return {'bytes_hex': value.hex(), 'len': len(value)} + if isinstance(value, dict): + return {str(k): _clean(v) for k, v in value.items()} + if isinstance(value, (list, tuple)): + return [_clean(v) for v in value] + return value + + +def _walk_numbers(value, path: str): + if isinstance(value, bool): + return + if isinstance(value, int): + yield path, value + return + if isinstance(value, float) and value.is_integer(): + yield path, int(value) + return + if isinstance(value, dict): + for key, item in value.items(): + yield from _walk_numbers(item, f'{path}.{key}') + return + if isinstance(value, (list, tuple)): + for i, item in enumerate(value): + yield from _walk_numbers(item, f'{path}[{i}]') diff --git a/src/decode/items.py b/src/decode/items.py index 9da4590..0f68711 100644 --- a/src/decode/items.py +++ b/src/decode/items.py @@ -2,12 +2,14 @@ import os from typing import Dict, Optional _ITEM_DB: Optional[Dict[int, str]] = None +_ITEM_NAME_DB: Optional[Dict[int, str]] = None _ITEM_DB_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'static', 'item_ids.txt') +_ITEM_NAMES_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'static', 'item_names.txt') -def _load() -> Dict[int, str]: +def _load_file(path: str) -> Dict[int, str]: db = {} - with open(_ITEM_DB_PATH, encoding='utf-8') as f: + with open(path, encoding='utf-8') as f: for line in f: parts = line.strip().split(',', 1) if len(parts) != 2: @@ -25,10 +27,24 @@ def _load() -> Dict[int, str]: def get_db() -> Dict[int, str]: global _ITEM_DB if _ITEM_DB is None: - _ITEM_DB = _load() + _ITEM_DB = _load_file(_ITEM_DB_PATH) return _ITEM_DB +def get_name_db() -> Dict[int, str]: + global _ITEM_NAME_DB + if _ITEM_NAME_DB is None: + if os.path.exists(_ITEM_NAMES_PATH): + _ITEM_NAME_DB = _load_file(_ITEM_NAMES_PATH) + else: + _ITEM_NAME_DB = {} + return _ITEM_NAME_DB + + +def display_name(item_id: int) -> str: + return get_name_db().get(item_id) or get_db().get(item_id) or str(item_id) + + ITEMS_SLOTS = ('weapon', 'offhand', 'helmet', 'armor', 'boots', 'bag', 'cape', 'mount', 'potion', 'food') @@ -47,4 +63,4 @@ def decode_items(item_array) -> Dict[str, Optional[str]]: code = item_array[slot] if code and code in db: items[_id] = db[code] - return items \ No newline at end of file + return items diff --git a/src/decode/pipeline.py b/src/decode/pipeline.py index ffc3573..5ece65b 100644 --- a/src/decode/pipeline.py +++ b/src/decode/pipeline.py @@ -5,6 +5,7 @@ from typing import Callable, List from .photon import PhotonDecoder, PhotonMessage from .translate import into_game_message from .world import World +from . import discovery logger = logging.getLogger(__name__) @@ -21,11 +22,18 @@ class Pipeline: def on_udp(self, payload: bytes): logger.debug("received UDP payload: %d bytes", len(payload)) + discovery.log( + 'udp_payload', + length=len(payload), + payload_hex=payload.hex()) messages = self.decoder.decode_packet(payload) if not messages: return with self._lock: for message in messages: + discovery.log( + 'photon_message', + message=discovery.message_record(message)) for event in self._events_from_message(message): self.emit(event) @@ -33,8 +41,12 @@ class Pipeline: game_message = into_game_message(message) if game_message is None: return [] + discovery.log( + 'game_message', + message=discovery.game_message_record(game_message)) logger.debug("translated game message: %s", game_message) events = self.world.transform(game_message) for event in events: + discovery.log('app_event', event=event) logger.debug("emitting app event: %s", event) return events diff --git a/src/decode/translate.py b/src/decode/translate.py index c00d8e8..99fe41f 100644 --- a/src/decode/translate.py +++ b/src/decode/translate.py @@ -10,9 +10,11 @@ PHOTON_GAME_CODE = 1 EVENT_LEAVE = 1 EVENT_HEALTH_UPDATE = 6 EVENT_NEW_CHARACTER = 29 +EVENT_ITEM_GAINED = 32 EVENT_UPDATE_FAME = 82 EVENT_CHARACTER_EQUIPMENT_CHANGED = 90 EVENT_REGENERATION_HEALTH_CHANGED = 91 +EVENT_SILVER_GAINED = 153 EVENT_KNOCKED_DOWN = 166 EVENT_PARTY_INVITATION = 229 EVENT_PARTY_JOIN_REQUEST = 230 @@ -98,9 +100,11 @@ EVENT_NAMES = { EVENT_LEAVE: 'Leave', EVENT_HEALTH_UPDATE: 'HealthUpdate', EVENT_NEW_CHARACTER: 'NewCharacter', + EVENT_ITEM_GAINED: 'ItemGained', EVENT_UPDATE_FAME: 'UpdateFame', EVENT_CHARACTER_EQUIPMENT_CHANGED: 'CharacterEquipmentChanged', EVENT_REGENERATION_HEALTH_CHANGED: 'RegenerationHealthChanged', + EVENT_SILVER_GAINED: 'SilverGained', EVENT_KNOCKED_DOWN: 'KnockedDown', EVENT_PARTY_INVITATION: 'PartyInvitation', EVENT_PARTY_JOIN_REQUEST: 'PartyJoinRequest', @@ -173,6 +177,26 @@ def msg_fame_gained(msg: GameMessage) -> Optional[int]: return _int(msg.params.get(2)) +def msg_collected_item_id(msg: GameMessage) -> Optional[int]: + return _int(msg.params.get(1)) + + +def msg_collected_item_quantity(msg: GameMessage) -> Optional[int]: + return _int(msg.params.get(2)) + + +def msg_collected_item_value(msg: GameMessage) -> Optional[int]: + return _int(msg.params.get(4)) + + +def msg_silver_source_type(msg: GameMessage) -> Optional[int]: + return _int(msg.params.get(1)) + + +def msg_silver_amount(msg: GameMessage) -> Optional[int]: + return _int(msg.params.get(2)) + + def msg_party_structures(msg: GameMessage) -> List[List[int]]: out = [] for item in msg.params.get(4, []) or []: @@ -195,4 +219,4 @@ 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 '' \ No newline at end of file + return v if v is not None else '' diff --git a/src/decode/world.py b/src/decode/world.py index 7b6ecae..55c1be0 100644 --- a/src/decode/world.py +++ b/src/decode/world.py @@ -6,6 +6,7 @@ from .translate import GameMessage FIX_POINT = 10000.0 FAME_MIN_TOTAL = 1000000 # albion-lens sanity filter for UpdateFame events +SILVER_SOURCE_LOOTED = 54 class IdCache: @@ -121,7 +122,9 @@ class World: 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() def transform(self, message: GameMessage) -> List[dict]: if message.name == 'NewCharacter': @@ -140,6 +143,10 @@ class World: 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 == 'SilverGained': + return self._on_silver_gained(message) if message.name == 'CharacterEquipmentChanged': return self._on_character_equipment_changed(message) if message.name == 'PartyJoined': @@ -190,9 +197,11 @@ class World: return [] self.party.set_main_player_name(name) result = [] - if self.main_player_id is None: + if not self._main_player_joined: result.append({'name': 'ZoneChange'}) self.main_player_id = static_id + self._main_player_joined = True + self._seen_item_pickups.clear() result.append({ 'name': 'MainPlayerAppeared', 'value': {'id': static_id, 'name': name}, @@ -203,6 +212,7 @@ class World: def _on_change_cluster(self, msg: GameMessage) -> List[dict]: if self.main_player_id is None: return [] + self._seen_item_pickups.clear() return [{'name': 'ZoneChange'}] def _on_leave(self, msg: GameMessage) -> List[dict]: @@ -212,6 +222,8 @@ class World: return [] if self.main_player_id == static_id: self.main_player_id = None + self._main_player_joined = False + self._seen_item_pickups.clear() return [{'name': 'ZoneChange'}] return [] @@ -278,6 +290,45 @@ class World: return [] return [{'name': 'UpdateFame', 'value': {'value': float(gained / 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_silver_gained(self, msg: GameMessage) -> List[dict]: + if not self._main_player_joined: + return [] + amount = translate.msg_silver_amount(msg) + source_type = translate.msg_silver_source_type(msg) + if amount is None or amount <= 0: + return [] + if source_type == SILVER_SOURCE_LOOTED: + silver_type = 'looted' + else: + return [] + return [{'name': 'SilverGained', 'value': { + 'value': float(amount), + 'silver_type': silver_type, + }}] + 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) @@ -299,4 +350,4 @@ def _dyn(value) -> int: def _party_id(party_structure: List[int]) -> int: - return sum(party_structure) \ No newline at end of file + return sum(party_structure) diff --git a/src/engine.py b/src/engine.py index db95aed..e200ddf 100644 --- a/src/engine.py +++ b/src/engine.py @@ -9,7 +9,7 @@ from .environment import TEST_ENV_ENABLED from . import backend_proxy from .backend_proxy import InitializationResult, INITIALIZATION_RESULT -from .stats import combat_stats, fame_stats, time_stats, combat_state +from .stats import combat_stats, economy_stats, fame_stats, time_stats, combat_state from .consts import events as ev_consts from .event_receiver import VisibilityEventReceiver from .stats.visibility import Visibility @@ -30,6 +30,7 @@ class StatType: Combat: str = 'Combat' Fame: str = 'Fame' Time: str = 'Time' + Economy: str = 'Economy' @dataclass(frozen=True) @@ -46,16 +47,19 @@ class GameStats(): StatType.Combat: combat_stats.CombatStats(self.visibility), StatType.Fame: fame_stats.FameStats(), StatType.Time: time_stats.TimeStats(), + StatType.Economy: economy_stats.EconomyStats(), } self.last_fight = { StatType.Combat: combat_stats.CombatStats(self.visibility), StatType.Fame: fame_stats.FameStats(), StatType.Time: time_stats.TimeStats(), + StatType.Economy: economy_stats.EconomyStats(), } self.history = { StatType.Combat: combat_stats.CombatStats(self.visibility), StatType.Fame: fame_stats.FameStats(), StatType.Time: time_stats.TimeStats(), + StatType.Economy: economy_stats.EconomyStats(), } def register_event(self, event): @@ -68,6 +72,7 @@ class GameStats(): self.zone[StatType.Combat]) self.history[StatType.Fame].update(self.zone[StatType.Fame]) self.history[StatType.Time].update(self.zone[StatType.Time]) + self.history[StatType.Economy].update(self.zone[StatType.Economy]) self._construct_new_stats([VisibilityType.Zone]) @@ -75,11 +80,13 @@ class GameStats(): self.last_fight[StatType.Combat].receive(event) self.zone[StatType.Fame].receive(event) self.last_fight[StatType.Fame].receive(event) + self.zone[StatType.Economy].receive(event) + self.last_fight[StatType.Economy].receive(event) self.visibility.receive(event) def reset(self, stat_type): if stat_type == VisibilityType.Zone: - for t in (StatType.Combat, StatType.Time, StatType.Fame): + for t in (StatType.Combat, StatType.Time, StatType.Fame, StatType.Economy): self.history[t].update(self.zone[t]) self._construct_new_stats( (VisibilityType.Zone, VisibilityType.LastFight)) @@ -129,8 +136,32 @@ class GameStats(): elif stat_type == VisibilityType.Overall: return self.history[StatType.Time].combined(self.zone[StatType.Time]).stats() + def economy_stats(self, stat_type): + if stat_type == VisibilityType.Zone: + return self.zone[StatType.Economy].stats() + elif stat_type == VisibilityType.LastFight: + return self.last_fight[StatType.Economy].stats() + elif stat_type == VisibilityType.Overall: + return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).stats() + + def item_stats(self, stat_type): + if stat_type == VisibilityType.Zone: + return self.zone[StatType.Economy].item_list() + elif stat_type == VisibilityType.LastFight: + return self.last_fight[StatType.Economy].item_list() + elif stat_type == VisibilityType.Overall: + return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).item_list() + + def silver_stats(self, stat_type): + if stat_type == VisibilityType.Zone: + return self.zone[StatType.Economy].silver_list() + elif stat_type == VisibilityType.LastFight: + return self.last_fight[StatType.Economy].silver_list() + elif stat_type == VisibilityType.Overall: + return self.history[StatType.Economy].combined(self.zone[StatType.Economy]).silver_list() + def _construct_new_stats(self, scope: Iterable[str]): - types = (StatType.Combat, StatType.Time, StatType.Fame) + types = (StatType.Combat, StatType.Time, StatType.Fame, StatType.Economy) for s in scope: for t in types: if t == StatType.Time: @@ -140,6 +171,8 @@ class GameStats(): getattr(self, s)[t]) elif t == StatType.Fame: getattr(self, s)[t] = fame_stats.FameStats() + elif t == StatType.Economy: + getattr(self, s)[t] = economy_stats.EconomyStats() game_stats = GameStats() @@ -181,13 +214,17 @@ cached_stat_type = None cached_combat_stat_type = None -def get_stats(stat_type: str, combat_stat_type: str): - global cached_players, cached_stat_type, cached_combat_stat_type +def _drain_events(): new_events = False - while not event_queue.empty(): new_events = True game_stats.register_event(event_queue.get_nowait()) + return new_events + + +def get_stats(stat_type: str, combat_stat_type: str): + global cached_players, cached_stat_type, cached_combat_stat_type + new_events = _drain_events() fame = game_stats.fame_stats(stat_type) time = game_stats.time_stats(stat_type)['seconds_in_game'] @@ -209,6 +246,21 @@ def get_stats(stat_type: str, combat_stat_type: str): return (cached_players, fame, time) +def economy_stats_for(stat_type: str): + _drain_events() + return game_stats.economy_stats(stat_type) + + +def item_stats_for(stat_type: str): + _drain_events() + return game_stats.item_stats(stat_type) + + +def silver_stats_for(stat_type: str): + _drain_events() + return game_stats.silver_stats(stat_type) + + def queue_an_event(event): event_queue.put(event) logger.debug("event received: %s", event.get(ev_consts.EvKeyName)) diff --git a/src/environment.py b/src/environment.py index 469a86b..69642f0 100644 --- a/src/environment.py +++ b/src/environment.py @@ -1,6 +1,7 @@ import logging import os import sys +from typing import List, Optional TEST_ENV_ENABLED = bool(os.getenv('TESTING')) @@ -12,10 +13,49 @@ VERBOSE = bool( ) +def _arg_value(name: str) -> Optional[str]: + prefix = name + '=' + for i, arg in enumerate(sys.argv): + if arg.startswith(prefix): + return arg[len(prefix):] + if arg == name and i + 1 < len(sys.argv): + return sys.argv[i + 1] + return None + + +DISCOVERY_LOG_PATH = ( + os.getenv('AOSTATS_LOG_PATH') or + _arg_value('--log-path') +) + + def is_verbose(): return VERBOSE +def discovery_log_path(): + return DISCOVERY_LOG_PATH + + +def qt_args(argv: List[str]) -> List[str]: + """Return argv with app-specific options removed before Qt sees them.""" + result = [] + skip_next = False + for arg in argv: + if skip_next: + skip_next = False + continue + if arg in ('--verbose', '-v'): + continue + if arg == '--log-path': + skip_next = True + continue + if arg.startswith('--log-path='): + continue + result.append(arg) + return result + + def setup_logging(): """Enable verbose logging for the app and the packet capture backend. @@ -27,10 +67,18 @@ def setup_logging(): os.environ['BACKEND_LOG_LEVEL'] = 'debug' + handlers = [logging.StreamHandler()] + if DISCOVERY_LOG_PATH: + log_dir = os.path.dirname(DISCOVERY_LOG_PATH) + if log_dir: + os.makedirs(log_dir, exist_ok=True) + handlers.append(logging.FileHandler(DISCOVERY_LOG_PATH + '.app.log')) + logging.basicConfig( level=logging.DEBUG, format='%(asctime)s %(levelname)-8s %(name)s: %(message)s', - datefmt='%H:%M:%S') + datefmt='%H:%M:%S', + handlers=handlers) class TestType: diff --git a/src/event_receiver.py b/src/event_receiver.py index db6d983..d4410fa 100644 --- a/src/event_receiver.py +++ b/src/event_receiver.py @@ -44,6 +44,26 @@ class FameEventReceiver(EventReceiver): pass +class EconomyEventReceiver(EventReceiver): + + def on_event(self, event_name: str, value: dict): + if event_name == consts.EvNameSilverGained: + self.on_silver_gained( + value[consts.EvKeyValue], value[consts.EvKeySilverType]) + elif event_name == consts.EvNameItemCollected: + self.on_item_collected( + value[consts.EvKeyItemId], value[consts.EvKeyItemName], + value[consts.EvKeyQuantity]) + + @abc.abstractmethod + def on_silver_gained(self, value: float, silver_type: str): + pass + + @abc.abstractmethod + def on_item_collected(self, item_id: int, item_name: str, quantity: int): + pass + + class CombatEventReceiver(EventReceiver): def on_event(self, event_name: str, value: dict): diff --git a/src/gui/app.py b/src/gui/app.py index 2c79381..357549a 100644 --- a/src/gui/app.py +++ b/src/gui/app.py @@ -14,7 +14,7 @@ from PySide6.QtWidgets import QPushButton # type: ignore from ..engine import InitializationResult from ..engine import initialize from ..utils.config import config -from ..environment import setup_logging +from ..environment import qt_args, setup_logging from .modules.main import MainWidget from .styling import style @@ -48,7 +48,7 @@ def fix_network(): def run(): setup_logging() - app_argv = [a for a in sys.argv if a not in ('--verbose', '-v')] + app_argv = qt_args(sys.argv) logger.info("Albion Online Stats v%s starting", get_current_version()) logger.debug("python: %s (%s)", sys.executable, sys.version) diff --git a/src/gui/modules/main.py b/src/gui/modules/main.py index 3cf4f47..6dfa8d1 100644 --- a/src/gui/modules/main.py +++ b/src/gui/modules/main.py @@ -170,16 +170,15 @@ class ItemsPanel(QFrame): self.layout.setContentsMargins(16, 16, 16, 16) title = QLabel('Items Collected') title.setObjectName('PanelTitle') - body = QLabel( - 'Looted item tracking will appear here once item pickup packets are mapped.\n\n' - 'This panel stays visible while you review damage, healing, and economy stats.') - body.setObjectName('MutedText') - body.setWordWrap(True) self.layout.addWidget(title) - self.layout.addWidget(body) + self.list = ListItemView() + self.layout.addWidget(self.list, 1) self.layout.addStretch(1) self.setLayout(self.layout) + def update(self, items): + self.list.update(items) + class SettingsPanel(QWidget): def __init__(self, clipboard): @@ -288,7 +287,8 @@ class MainWidget(QWidget): self.main_layout.addWidget(self.settings_panel, 1) self.root_layout.addWidget(self.main_area, 1) - self.root_layout.addWidget(ItemsPanel()) + self.items_panel = ItemsPanel() + self.root_layout.addWidget(self.items_panel) self.setLayout(self.root_layout) self.refresh() @@ -307,6 +307,8 @@ class MainWidget(QWidget): def refresh(self): players, fame_stat, elapsed = self.primary_stats() total_healing = self.total_healing_stats() + silver = self.silver_stats() + items = self.item_stats() self.header.update_status() self.elapsed_card.update_value(self._format_time(elapsed)) @@ -314,7 +316,8 @@ class MainWidget(QWidget): self.fph_card.update_value(fame_stat.fame_per_hour) self.ready_card.update_value('Ready' if engine.is_ready() else 'Not ready') - self._set_page_copy(players, total_healing) + self.items_panel.update(items) + self._set_page_copy(players, total_healing, silver, items) def primary_stats(self): stat_kind = { @@ -340,7 +343,23 @@ class MainWidget(QWidget): } return getters[self.current_scope]() - def _set_page_copy(self, players, total_healing): + def silver_stats(self): + getters = { + StatsType.ZONE: functools.partial(engine.silver_stats_for, engine.VisibilityType.Zone), + StatsType.LAST_FIGHT: functools.partial(engine.silver_stats_for, engine.VisibilityType.LastFight), + StatsType.OVERALL: functools.partial(engine.silver_stats_for, engine.VisibilityType.Overall), + } + return getters[self.current_scope]() + + def item_stats(self): + getters = { + StatsType.ZONE: functools.partial(engine.item_stats_for, engine.VisibilityType.Zone), + StatsType.LAST_FIGHT: functools.partial(engine.item_stats_for, engine.VisibilityType.LastFight), + StatsType.OVERALL: functools.partial(engine.item_stats_for, engine.VisibilityType.Overall), + } + return getters[self.current_scope]() + + def _set_page_copy(self, players, total_healing, silver, items): self.primary_list.hide() self.primary_label.hide() self.total_healing_label.hide() @@ -384,19 +403,21 @@ class MainWidget(QWidget): if self.current_page == Page.Economy: self.page_title.setText('Economy') self.page_description.setText( - 'Fame is tracked now. Looted silver and other silver categories will appear here after their packet fields are mapped.') - self.placeholder.setText( - 'Silver tracking is not active yet. Planned categories: Looted Silver, Looted Silver per Hour, Other Silver, and Other Silver per Hour.') - self.placeholder.show() + '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) return if self.current_page == Page.Items: self.page_title.setText('Items Collected') self.page_description.setText( - 'Collected item quantities will be shown here after item pickup packets are mapped. The right panel remains visible on every page.') - self.placeholder.setText( - 'No item pickup data is available yet. Once enabled, this page will show item name, quantity, and session scope totals.') - self.placeholder.show() + '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) return self.page_title.setText('Settings') diff --git a/src/static/item_names.txt b/src/static/item_names.txt new file mode 100644 index 0000000..b90c3b0 --- /dev/null +++ b/src/static/item_names.txt @@ -0,0 +1 @@ +11898,Keeper Memory - Shameless or Daring diff --git a/src/stats/economy_stats.py b/src/stats/economy_stats.py new file mode 100644 index 0000000..8626644 --- /dev/null +++ b/src/stats/economy_stats.py @@ -0,0 +1,92 @@ +from dataclasses import dataclass, field +from typing import Dict + +from ..event_receiver import EconomyEventReceiver +from .combat_state import CombatState +from .list_item import PlayerListItem, StandalonePlayerListItem, to_player_list_items +from .statistics import Stats + + +@dataclass +class ItemTotal: + item_id: int + item_name: str + quantity: int = 0 + + +@dataclass +class EconomyStats(EconomyEventReceiver, Stats): + looted_silver: float = 0.0 + other_silver: float = 0.0 + items: Dict[int, ItemTotal] = field(default_factory=dict) + + @classmethod + def new(self): + return EconomyStats() + + @classmethod + def from_other(other): + return EconomyStats( + looted_silver=other.looted_silver, + other_silver=other.other_silver, + items={k: ItemTotal(v.item_id, v.item_name, v.quantity) + for k, v in other.items.items()}, + ) + + def update(self, other): + self.looted_silver += other.looted_silver + self.other_silver += other.other_silver + for item_id, item in other.items.items(): + if item_id not in self.items: + self.items[item_id] = ItemTotal(item.item_id, item.item_name) + self.items[item_id].quantity += item.quantity + + def on_silver_gained(self, value: float, silver_type: str): + if silver_type == 'looted': + self.looted_silver += value + else: + self.other_silver += value + + def on_item_collected(self, item_id: int, item_name: str, quantity: int): + if item_id not in self.items: + self.items[item_id] = ItemTotal(item_id, item_name) + self.items[item_id].quantity += quantity + + def stats(self): + return { + 'looted_silver': self.looted_silver, + 'other_silver': self.other_silver, + 'total_silver': self.looted_silver + self.other_silver, + } + + def item_list(self): + standalone = [ + StandalonePlayerListItem( + item.item_name, + {'weapon': None}, + float(item.quantity), + 0.0, + CombatState.OutOfCombat, + ) + for item in self.items.values() + if item.quantity > 0 + ] + return to_player_list_items(standalone) + + def silver_list(self): + values = [ + ('Looted Silver', self.looted_silver), + ('Other Silver', self.other_silver), + ] + standalone = [ + StandalonePlayerListItem( + name, + {'weapon': None}, + value, + 0.0, + CombatState.OutOfCombat, + ) + for name, value in values + if value > 0 + ] + return to_player_list_items(standalone) diff --git a/tests/test_decode.py b/tests/test_decode.py index 9c62b4d..a14a22f 100644 --- a/tests/test_decode.py +++ b/tests/test_decode.py @@ -165,9 +165,11 @@ def test_fragment_reassembly(): (1, 'Leave'), (6, 'HealthUpdate'), (29, 'NewCharacter'), + (32, 'ItemGained'), (82, 'UpdateFame'), (90, 'CharacterEquipmentChanged'), (91, 'RegenerationHealthChanged'), + (153, 'SilverGained'), (166, 'KnockedDown'), (231, 'PartyJoined'), (233, 'PartyPlayerJoined'), @@ -290,6 +292,65 @@ def test_world_update_fame_delta_from_total(): assert events[0]['value']['value'] == pytest.approx(0.1) +def test_world_item_gained_emits_collected_item(): + world = World() + world.transform(game('Join', {0: 63, 2: 'Alice'})) + events = world.transform(game('ItemGained', {1: 522, 2: 3, 4: 10000000})) + assert events == [{ + 'name': 'ItemCollected', + 'value': { + 'item_id': 522, + 'item_name': 'T4_MEAL_SALAD_FISH@3', + 'quantity': 3, + 'estimated_value': 10000000, + }, + }] + + +def test_world_item_gained_waits_for_main_player_join(): + world = World() + assert world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1})) == [] + + world.transform(game('NewCharacter', {0: 10, 1: 'SomeoneElse'})) + assert world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1})) == [] + + +def test_world_item_gained_uses_display_name_and_deduplicates(): + world = World() + world.transform(game('Join', {0: 63, 2: 'Alice'})) + + first = world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1})) + duplicate = world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1})) + + assert first == [{ + 'name': 'ItemCollected', + 'value': { + 'item_id': 11898, + 'item_name': 'Keeper Memory - Shameless or Daring', + 'quantity': 1, + }, + }] + assert duplicate == [] + + +def test_world_silver_gained_tracks_known_sources(): + world = World() + world.transform(game('Join', {0: 63, 2: 'Alice'})) + looted = world.transform(game('SilverGained', {1: 54, 2: 45})) + other = world.transform(game('SilverGained', {1: 168, 2: 45})) + ignored = world.transform(game('SilverGained', {1: 126, 2: 81})) + + assert looted == [{'name': 'SilverGained', 'value': { + 'value': 45.0, 'silver_type': 'looted'}}] + assert other == [] + assert ignored == [] + + +def test_world_silver_gained_waits_for_main_player_join(): + world = World() + assert world.transform(game('SilverGained', {1: 54, 2: 45})) == [] + + def test_world_unconsumed_equipment_replayed_on_new_character(): world = World() # equipment arrives before the player is named -> buffered diff --git a/tests/test_discovery_logging.py b/tests/test_discovery_logging.py new file mode 100644 index 0000000..213d3f2 --- /dev/null +++ b/tests/test_discovery_logging.py @@ -0,0 +1,31 @@ +import json + +from src import environment +from src.decode import discovery + + +def test_qt_args_removes_app_specific_options(): + assert environment.qt_args([ + 'aostats', '--verbose', '--log-path', '/tmp/capture.jsonl', + '--style', 'fusion']) == ['aostats', '--style', 'fusion'] + + assert environment.qt_args([ + 'aostats', '--log-path=/tmp/capture.jsonl']) == ['aostats'] + + +def test_discovery_log_writes_jsonl_with_item_annotations(monkeypatch, tmp_path): + path = tmp_path / 'capture.jsonl' + monkeypatch.setattr(discovery, 'discovery_log_path', lambda: str(path)) + monkeypatch.setattr(discovery, '_initialized', False) + monkeypatch.setattr(discovery.itemdb, 'get_db', lambda: {836: 'T6_STONEBLOCK'}) + + discovery.log('game_message', params={1: [836], 2: b'\x01'}) + + rows = [json.loads(line) for line in path.read_text().splitlines()] + assert rows[0]['type'] == 'session_start' + assert rows[1]['type'] == 'game_message' + assert discovery.item_candidates({1: [836]}) == [{ + 'path': '1[0]', + 'id': 836, + 'unique_name': 'T6_STONEBLOCK', + }] diff --git a/tests/test_economy_stats.py b/tests/test_economy_stats.py new file mode 100644 index 0000000..dcdc231 --- /dev/null +++ b/tests/test_economy_stats.py @@ -0,0 +1,29 @@ +from src.stats.economy_stats import EconomyStats + + +def test_economy_stats_accumulates_silver_and_items(): + stats = EconomyStats() + stats.receive({'name': 'SilverGained', 'value': { + 'value': 45.0, 'silver_type': 'looted'}}) + stats.receive({'name': 'SilverGained', 'value': { + 'value': 12.0, 'silver_type': 'other'}}) + stats.receive({'name': 'ItemCollected', 'value': { + 'item_id': 522, + 'item_name': 'T4_MEAL_SALAD_FISH@3', + 'quantity': 3, + }}) + stats.receive({'name': 'ItemCollected', 'value': { + 'item_id': 522, + 'item_name': 'T4_MEAL_SALAD_FISH@3', + 'quantity': 4, + }}) + + assert stats.stats() == { + 'looted_silver': 45.0, + 'other_silver': 12.0, + 'total_silver': 57.0, + } + items = stats.item_list() + assert len(items) == 1 + assert items[0].name == 'T4_MEAL_SALAD_FISH@3' + assert items[0].value == 7.0