Updated silver and item collection

This commit is contained in:
2026-10-10 12:10:06 -06:00
parent 59a9fa4098
commit 85a844208a
17 changed files with 615 additions and 33 deletions
+8
View File
@@ -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
+6
View File
@@ -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'
+110
View File
@@ -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}]')
+20 -4
View File
@@ -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
return items
+12
View File
@@ -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
+25 -1
View File
@@ -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 ''
return v if v is not None else ''
+53 -2
View File
@@ -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)
return sum(party_structure)
+58 -6
View File
@@ -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))
+49 -1
View File
@@ -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:
+20
View File
@@ -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):
+2 -2
View File
@@ -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)
+38 -17
View File
@@ -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')
+1
View File
@@ -0,0 +1 @@
11898,Keeper Memory - Shameless or Daring
+92
View File
@@ -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)
+61
View File
@@ -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
+31
View File
@@ -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',
}]
+29
View File
@@ -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