Compare commits

2 Commits

Author SHA1 Message Date
bionickatana f3114b076a Added 'damage taken' section to the UI
Build / Build source distribution (push) Failing after 8s
Build / Execute unit tests (push) Failing after 6s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
2026-10-10 23:38:32 -06:00
bionickatana fbfa90edec Added replay ability 2026-10-10 23:00:04 -06:00
23 changed files with 858 additions and 56 deletions
+18
View File
@@ -101,6 +101,24 @@ This writes raw UDP payloads, decoded Photon messages, translated game messages,
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.
### Replaying a captured log
To debug the decoder and stats without being in game, replay a captured log as if the packets were arriving from the server:
```shell
aostats --replay /tmp/aostats-discovery.jsonl
```
The app opens normally but feeds the log's packets through the same decode pipeline, so every page updates exactly as it would live. Packets are replayed as fast as possible by default; use `--replay-speed 1` to follow the log's original timing, or any other multiplier (for example `--replay-speed 4` for four times faster). No packet-capture permissions are needed while replaying.
For a quick, scriptable report without the GUI, add `--replay-headless`:
```shell
aostats --replay /tmp/aostats-discovery.jsonl --replay-headless
```
This prints packet/event counts together with the fame, silver and damage totals and then exits. Both the discovery JSONL format and the legacy aoaddons `Raw payload: [...]` text logs are supported. Avoid pointing `--log-path` at the same file you are replaying; the app refuses to overwrite its own replay source.
## Is This Allowed
<p align="center">
<img src="assets/sbistatement.png">
+13 -1
View File
@@ -1,4 +1,16 @@
from .gui.app import run
import sys
from .environment import replay_path, replay_headless
def run():
if replay_path() and replay_headless():
from .replay_cli import run_headless
sys.exit(run_headless())
from .gui.app import run as run_gui
run_gui()
if __name__ == '__main__':
run()
+25
View File
@@ -43,9 +43,13 @@ INITIALIZATION_RESULT = {
NATIVE_BACKEND_AVAILABLE = platform_utils.is_linux()
_capture = None
_replay = None
def initialize():
if environment.replay_path():
return InitializationResult.Ok
if TEST_ENV_ENABLED:
return InitializationResult.Ok
@@ -68,6 +72,9 @@ def subscribe(callback):
_testing_call_sequence(callback)
return True
if environment.replay_path():
return _start_replay_backend(callback)
if NATIVE_BACKEND_AVAILABLE:
return _start_native_backend(callback)
@@ -98,6 +105,24 @@ def _start_native_backend(callback):
return True
def _start_replay_backend(callback):
global _replay
if _replay is not None:
return True
from .decode.pipeline import Pipeline
from .net.replay import ReplayEngine
pipeline = Pipeline(callback)
replay = ReplayEngine(pipeline.on_udp)
if not replay.start():
logger.error("replay backend could not start; check the log path")
return False
_replay = replay
return True
def _testing_call_sequence(callback):
def add_player(id, name, weapon, event_name='PlayerAppeared'):
return [
+1
View File
@@ -1,6 +1,7 @@
EvNameMainPlayerAppeared: str = 'MainPlayerAppeared'
EvNamePlayerAppeared: str = 'PlayerAppeared'
EvNameDamageDone: str = 'DamageDone'
EvNameDamageTaken: str = 'DamageTaken'
EvNameHealthReceived: str = 'HealthReceived'
EvNameZoneChange: str = 'ZoneChange'
EvNameEnterCombat: str = 'EnterCombat'
+13 -1
View File
@@ -4,7 +4,7 @@ import threading
from datetime import datetime, timezone
from typing import Any, Dict, List
from ..environment import discovery_log_path
from ..environment import discovery_log_path, replay_path
from . import items as itemdb
@@ -16,11 +16,23 @@ def enabled() -> bool:
return bool(discovery_log_path())
def _same_file(a: str, b: str) -> bool:
try:
return os.path.abspath(a) == os.path.abspath(b)
except (TypeError, ValueError):
return False
def log(record_type: str, **fields):
path = discovery_log_path()
if not path:
return
# Never clobber the log we are replaying from.
source = replay_path()
if source and _same_file(path, source):
return
global _initialized
with _lock:
log_dir = os.path.dirname(path)
+9 -3
View File
@@ -135,10 +135,16 @@ def deserialize18(buf: bytes, pos: int, tc: int):
return rd_f64le(buf, pos)
if tc == P18['String']:
return read_string18(buf, pos)
if tc in (P18['Null'], P18['BooleanFalse'], P18['BooleanTrue'],
P18['ShortZero'], P18['IntZero'], P18['LongZero'],
P18['FloatZero'], P18['DoubleZero']):
if tc == P18['Null']:
return None, pos
if tc == P18['BooleanFalse']:
return False, pos
if tc == P18['BooleanTrue']:
return True, pos
if tc in (P18['ShortZero'], P18['IntZero'], P18['LongZero']):
return 0, pos
if tc in (P18['FloatZero'], P18['DoubleZero']):
return 0.0, pos
if tc == P18['CompressedInt']:
v, p = rd_varint(buf, pos)
return zigzag(v), p
+33 -6
View File
@@ -11,10 +11,10 @@ EVENT_LEAVE = 1
EVENT_HEALTH_UPDATE = 6
EVENT_NEW_CHARACTER = 29
EVENT_ITEM_GAINED = 32
EVENT_TAKE_SILVER = 62
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
@@ -115,10 +115,10 @@ EVENT_NAMES = {
EVENT_HEALTH_UPDATE: 'HealthUpdate',
EVENT_NEW_CHARACTER: 'NewCharacter',
EVENT_ITEM_GAINED: 'ItemGained',
EVENT_TAKE_SILVER: 'TakeSilver',
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',
@@ -191,6 +191,22 @@ def msg_fame_gained(msg: GameMessage) -> Optional[int]:
return _int(msg.params.get(2))
def msg_fame_is_premium(msg: GameMessage) -> bool:
return msg.params.get(5) is True
def msg_fame_satchel(msg: GameMessage) -> int:
v = _int(msg.params.get(10))
return v if v is not None else 0
def msg_fame_bonus_factor(msg: GameMessage) -> float:
if 17 not in msg.params:
return 0.0
v = _float(msg.params.get(17))
return v if v is not None else 0.0
def msg_collected_item_id(msg: GameMessage) -> Optional[int]:
return _int(msg.params.get(1))
@@ -203,12 +219,23 @@ 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_yield_pre_tax(msg: GameMessage) -> Optional[int]:
return _int(msg.params.get(3))
def msg_silver_amount(msg: GameMessage) -> Optional[int]:
return _int(msg.params.get(2))
def msg_silver_cluster_tax(msg: GameMessage) -> int:
v = _int(msg.params.get(4))
return v if v is not None else 0
def msg_silver_guild_tax(msg: GameMessage) -> int:
v = _int(msg.params.get(5))
return v if v is not None else 0
def msg_silver_alliance_penalty(msg: GameMessage) -> int:
v = _int(msg.params.get(6))
return v if v is not None else 0
def msg_party_structures(msg: GameMessage) -> List[List[int]]:
+41 -22
View File
@@ -9,7 +9,6 @@ from .translate import GameMessage
FIX_POINT = 10000.0
FAME_MIN_TOTAL = 1000000 # albion-lens sanity filter for UpdateFame events
SILVER_SOURCE_LOOTED = 54
logger = logging.getLogger(__name__)
@@ -180,8 +179,8 @@ class World:
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 == 'TakeSilver':
return self._on_take_silver(message)
if message.name == 'CharacterEquipmentChanged':
return self._on_character_equipment_changed(message)
if message.name == 'PartyJoined':
@@ -288,15 +287,23 @@ class World:
actor_id = _dyn(translate.msg_target(msg)) # param 6
victim_id = _dyn(translate.msg_source(msg)) # param 0
actor_static = self.cache.get_static_id(actor_id)
if actor_static is None:
return []
event_name = 'DamageDone' if value < 0.0 else 'HealthReceived'
return [{
'name': event_name,
'value': {'source': actor_static,
'target': self.cache.get_static_id(victim_id),
'value': float(abs(value))},
}]
victim_static = self.cache.get_static_id(victim_id)
events = []
if actor_static is not None:
event_name = 'DamageDone' if value < 0.0 else 'HealthReceived'
events.append({
'name': event_name,
'value': {'source': actor_static,
'target': victim_static,
'value': float(abs(value))},
})
if value < 0.0 and victim_static is not None:
events.append({
'name': 'DamageTaken',
'value': {'source': victim_static,
'value': float(abs(value))},
})
return events
def _on_regeneration(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg))
@@ -339,7 +346,14 @@ class World:
gained = total - prev
if gained <= 0:
return []
return [{'name': 'UpdateFame', 'value': {'value': float(gained / FIX_POINT)}}]
# Match the in-game display: zone/event bonus factor and premium are
# applied on top of the base fame, plus any satchel (insight bag) fame.
value = float(gained)
if translate.msg_fame_is_premium(msg):
value *= 1.5
value += float(translate.msg_fame_satchel(msg))
value *= 1.0 + translate.msg_fame_bonus_factor(msg)
return [{'name': 'UpdateFame', 'value': {'value': value / FIX_POINT}}]
def _on_item_gained(self, msg: GameMessage) -> List[dict]:
if not self._main_player_joined:
@@ -364,20 +378,25 @@ class World:
value['estimated_value'] = estimated_value
return [{'name': 'ItemCollected', 'value': value}]
def _on_silver_gained(self, msg: GameMessage) -> List[dict]:
def _on_take_silver(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:
dynamic_id = _dyn(translate.msg_source(msg))
static_id = self.cache.get_static_id(dynamic_id)
if static_id is None or static_id != self.main_player_id:
return []
if source_type == SILVER_SOURCE_LOOTED:
silver_type = 'looted'
else:
yield_pre_tax = translate.msg_silver_yield_pre_tax(msg)
if yield_pre_tax is None or yield_pre_tax <= 0:
return []
taxes = (translate.msg_silver_cluster_tax(msg)
+ translate.msg_silver_guild_tax(msg)
+ translate.msg_silver_alliance_penalty(msg))
gained = max(0, yield_pre_tax - taxes)
if gained <= 0:
return []
return [{'name': 'SilverGained', 'value': {
'value': float(amount),
'silver_type': silver_type,
'value': float(gained / FIX_POINT),
'silver_type': 'looted',
}}]
def _on_character_equipment_changed(self, msg: GameMessage) -> List[dict]:
+10
View File
@@ -36,6 +36,7 @@ class StatType:
@dataclass(frozen=True)
class CombatStatType:
Damage: str = 'Damage'
DamageTaken: str = 'DamageTaken'
Healing: str = 'Healing'
@@ -104,6 +105,14 @@ class GameStats():
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_damage()
def get_damage_taken_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Combat].players_damage_taken()
elif stat_type == VisibilityType.LastFight:
return self.last_fight[StatType.Combat].players_damage_taken()
elif stat_type == VisibilityType.Overall:
return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_damage_taken()
def get_healing_stats(self, stat_type):
if stat_type == VisibilityType.Zone:
return self.zone[StatType.Combat].players_healing()
@@ -236,6 +245,7 @@ def get_stats(stat_type: str, combat_stat_type: str):
cached_players = {
CombatStatType.Damage: lambda stat_type: game_stats.get_damage_stats(stat_type),
CombatStatType.DamageTaken: lambda stat_type: game_stats.get_damage_taken_stats(stat_type),
CombatStatType.Healing: lambda stat_type: game_stats.get_healing_stats(
stat_type)
}[combat_stat_type](stat_type)
+48
View File
@@ -35,6 +35,35 @@ REMEMBER_LAST_PARTY = bool(
'--remember-last-party' in sys.argv
)
# Replay a captured discovery log instead of capturing live packets, e.g.
# ``aostats --replay /tmp/capture.jsonl``.
REPLAY_PATH = (
os.getenv('AOSTATS_REPLAY') or
_arg_value('--replay')
)
def _float_arg(name: str) -> Optional[float]:
value = _arg_value(name)
if value is None:
return None
try:
return float(value)
except ValueError:
return None
# Replay pacing: 0 means as fast as possible (default), 1.0 means real time
# (honour the timestamps in the log), N means N times faster than real time.
REPLAY_SPEED = _float_arg('--replay-speed') or 0.0
# When replaying, ``--replay-headless`` prints a summary and exits instead of
# opening the GUI.
REPLAY_HEADLESS = bool(
os.getenv('AOSTATS_REPLAY_HEADLESS') or
'--replay-headless' in sys.argv
)
_fault_file = None
@@ -50,6 +79,18 @@ def remember_last_party():
return REMEMBER_LAST_PARTY
def replay_path() -> Optional[str]:
return REPLAY_PATH
def replay_speed() -> float:
return REPLAY_SPEED
def replay_headless() -> bool:
return REPLAY_HEADLESS
def app_log_path() -> Optional[str]:
if not DISCOVERY_LOG_PATH:
return None
@@ -73,6 +114,13 @@ def qt_args(argv: List[str]) -> List[str]:
continue
if arg == '--remember-last-party':
continue
if arg == '--replay' or arg == '--replay-speed':
skip_next = True
continue
if arg.startswith('--replay=') or arg.startswith('--replay-speed='):
continue
if arg == '--replay-headless':
continue
result.append(arg)
return result
+7
View File
@@ -76,6 +76,9 @@ class CombatEventReceiver(EventReceiver):
elif event_name == consts.EvNameDamageDone:
self.on_damage_done(
value[consts.EvKeySource], value[consts.EvKeyValue])
elif event_name == consts.EvNameDamageTaken:
self.on_damage_taken(
value[consts.EvKeySource], value[consts.EvKeyValue])
elif event_name == consts.EvNameHealthReceived:
self.on_health_received(
value[consts.EvKeySource], value[consts.EvKeyTarget], value[consts.EvKeyValue])
@@ -95,6 +98,10 @@ class CombatEventReceiver(EventReceiver):
def on_damage_done(self, id: int, damage: float):
pass
@abc.abstractmethod
def on_damage_taken(self, id: int, damage: float):
pass
@abc.abstractmethod
def on_health_received(self, id: int, target_id: int, health: float):
pass
+9 -4
View File
@@ -19,7 +19,7 @@ from PySide6.QtWidgets import QPushButton # type: ignore
from ..engine import InitializationResult
from ..engine import initialize
from ..utils.config import config
from ..environment import is_verbose, qt_args, remember_last_party, setup_logging
from ..environment import is_verbose, qt_args, remember_last_party, replay_path, setup_logging
from .modules.main import MainWidget
from .styling import style
@@ -82,6 +82,8 @@ def run():
logger.debug("python: %s (%s)", sys.executable, sys.version)
logger.debug("platform: %s", platform_utils.system())
replaying = bool(replay_path())
conf = config()
window_config = conf['window']
@@ -93,7 +95,7 @@ def run():
_install_heartbeat(app)
perms_ok = True
if platform_utils.is_linux():
if platform_utils.is_linux() and not replaying:
perms_ok = capture_permissions_ok()
logger.debug("capture permissions probe: %s", perms_ok)
@@ -107,7 +109,10 @@ def run():
widget = MainWidget(clipboard)
widget.setWindowOpacity(window_config['opacity'])
widget.setWindowTitle('Albion Online Stats')
title = 'Albion Online Stats'
if replaying:
title += ' (replay)'
widget.setWindowTitle(title)
widget.setWindowIcon(QtGui.QIcon(path('albion-stats-icon.png')))
if window_config['always_on_top']:
@@ -134,7 +139,7 @@ def run():
msg.setStandardButtons(QMessageBox.Ok)
msg.show()
need_capture_fix = (
need_capture_fix = not replaying and (
initialization_result != InitializationResult.Ok
or (platform_utils.is_linux() and not perms_ok)
)
+27
View File
@@ -27,6 +27,7 @@ from .views.list_view import ListItemView
class Page:
Overview = 'overview'
Damage = 'damage'
DamageTaken = 'damage_taken'
Healing = 'healing'
Economy = 'economy'
Items = 'items'
@@ -36,6 +37,7 @@ class Page:
PAGE_LABELS = {
Page.Overview: ('O', 'Overview'),
Page.Damage: ('D', 'Damage Done'),
Page.DamageTaken: ('T', 'Damage Taken'),
Page.Healing: ('H', 'Healing Done'),
Page.Economy: ('$', 'Economy'),
Page.Items: ('I', 'Items Collected'),
@@ -306,6 +308,13 @@ class MainWidget(QWidget):
self.main_layout.addWidget(self.total_healing_label)
self.main_layout.addWidget(self.total_healing_list, 1)
self.damage_taken_list = ListItemView(show_per_second=False)
self.main_layout.addWidget(self.damage_taken_list, 1)
self.damage_taken_total_label = QLabel('')
self.damage_taken_total_label.setObjectName('PanelTitle')
self.main_layout.addWidget(self.damage_taken_total_label)
self.placeholder = QLabel('')
self.placeholder.setObjectName('MutedText')
self.placeholder.setWordWrap(True)
@@ -372,6 +381,7 @@ class MainWidget(QWidget):
stat_kind = {
Page.Overview: engine.CombatStatType.Damage,
Page.Damage: engine.CombatStatType.Damage,
Page.DamageTaken: engine.CombatStatType.DamageTaken,
Page.Healing: engine.CombatStatType.Healing,
Page.Economy: engine.CombatStatType.Damage,
Page.Items: engine.CombatStatType.Damage,
@@ -419,6 +429,8 @@ class MainWidget(QWidget):
_set_visible(self.primary_label, False)
_set_visible(self.total_healing_label, False)
_set_visible(self.total_healing_list, False)
_set_visible(self.damage_taken_list, False)
_set_visible(self.damage_taken_total_label, False)
_set_visible(self.placeholder, False)
_set_visible(self.settings_panel, False)
@@ -440,6 +452,16 @@ class MainWidget(QWidget):
_set_visible(self.primary_list, True)
return
if self.current_page == Page.DamageTaken:
_set_text(self.page_title, 'Damage Taken')
_set_text(self.page_description,
'Damage taken by each visible tracked player during the selected scope. Includes damage from mobs and other players.')
_set_text(self.primary_label, 'Damage Taken by Player')
_set_visible(self.primary_label, True)
_set_visible(self.damage_taken_list, True)
_set_visible(self.damage_taken_total_label, True)
return
if self.current_page == Page.Healing:
_set_text(self.page_title, 'Healing Done')
_set_text(self.page_description,
@@ -477,6 +499,11 @@ class MainWidget(QWidget):
def _update_page_data(self, players, total_healing, silver, items):
if self.current_page in (Page.Overview, Page.Damage):
self.primary_list.update(players)
elif self.current_page == Page.DamageTaken:
self.damage_taken_list.update(players)
total = sum(player.value.number for player in players)
self.damage_taken_total_label.setText(
'Party Total: {}'.format(Number(total)))
elif self.current_page == Page.Healing:
self.primary_list.update(players)
self.total_healing_list.update(total_healing)
+9 -5
View File
@@ -7,8 +7,9 @@ from .....stats.list_item import PlayerListItem
class ListItemView(QLabel):
def __init__(self):
def __init__(self, show_per_second: bool = True):
QLabel.__init__(self)
self._show_per_second = show_per_second
self._last_signature = None
self._players: List[PlayerListItem] = []
self.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft)
@@ -26,7 +27,7 @@ class ListItemView(QLabel):
if not sorted_players:
self.setText('No entries yet.')
return
self.setText('\n'.join(_player_line(p) for p in sorted_players))
self.setText('\n'.join(_player_line(p, self._show_per_second) for p in sorted_players))
def get_player_list_items(self) -> List[PlayerListItem]:
return list(self._players)
@@ -42,6 +43,9 @@ def _player_signature(player: PlayerListItem):
)
def _player_line(player: PlayerListItem):
return "{} {} ({}, {}%)".format(
player.name, player.value, player.value_per_second, player.percentage)
def _player_line(player: PlayerListItem, show_per_second: bool = True):
if show_per_second:
return "{} {} ({}, {}%)".format(
player.name, player.value, player.value_per_second, player.percentage)
return "{} {} ({}%)".format(
player.name, player.value, player.percentage)
+139
View File
@@ -0,0 +1,139 @@
import json
import logging
import os
import re
import threading
from datetime import datetime
from typing import Callable, Iterator, List, Optional, Tuple
from .. import environment
logger = logging.getLogger(__name__)
_RAW_PAYLOAD_RE = re.compile(r'Raw payload:\s*\[([0-9,\s]*)\]')
def _record_timestamp(record: dict) -> Optional[float]:
raw = record.get('timestamp')
if not raw:
return None
try:
return datetime.fromisoformat(raw).timestamp()
except ValueError:
return None
def _json_payload(record: dict) -> Optional[bytes]:
if record.get('type') != 'udp_payload':
return None
payload_hex = record.get('payload_hex')
if not payload_hex:
return None
return bytes.fromhex(payload_hex)
def _raw_payload(line: str) -> Optional[bytes]:
match = _RAW_PAYLOAD_RE.search(line)
if not match:
return None
parts = [part.strip() for part in match.group(1).split(',')]
numbers = [int(part) for part in parts if part]
if not numbers:
return None
return bytes(numbers)
def iter_records(path: str) -> Iterator[Tuple[bytes, Optional[float]]]:
"""Yield ``(payload, timestamp)`` for every captured packet in ``path``.
Supports both the discovery JSONL format (records of ``type``
``udp_payload`` with a ``payload_hex`` field) and the legacy aoaddons
``Raw payload: [...]`` text format. All other record types are ignored.
"""
with open(path, encoding='utf-8', errors='replace') as log:
for line in log:
line = line.strip()
if not line:
continue
if line.startswith('{'):
try:
record = json.loads(line)
except json.JSONDecodeError:
record = None
if isinstance(record, dict):
payload = _json_payload(record)
if payload is not None:
yield payload, _record_timestamp(record)
continue
payload = _raw_payload(line)
if payload is not None:
yield payload, None
def load_payloads(path: str) -> List[bytes]:
"""Return every captured UDP payload from ``path`` in order."""
return [payload for payload, _ in iter_records(path)]
class ReplayEngine:
"""Feeds previously captured UDP payloads into a decode callback.
Mirrors :class:`src.net.capture.CaptureEngine` so the rest of the app can
treat a replayed log exactly like live traffic.
"""
def __init__(self, on_udp: Callable[[bytes], None],
path: Optional[str] = None,
speed: Optional[float] = None):
self._on_udp = on_udp
self._path = path if path is not None else environment.replay_path()
self._speed = speed if speed is not None else environment.replay_speed()
self._stop = threading.Event()
self._thread: Optional[threading.Thread] = None
self.packet_count = 0
def start(self) -> bool:
if self._thread is not None:
return True
if not self._path:
logger.error("replay requested but no log path was given")
return False
if not os.path.isfile(self._path):
logger.error("replay log does not exist: %s", self._path)
return False
self._thread = threading.Thread(
target=self._run, name='aostats-replay', daemon=True)
self._thread.start()
return True
def stop(self):
self._stop.set()
def wait(self, timeout: Optional[float] = None):
if self._thread is not None:
self._thread.join(timeout)
def _run(self):
logger.info("replaying %s (speed=%s)", self._path, self._speed)
previous: Optional[float] = None
try:
for payload, timestamp in iter_records(self._path):
if self._stop.is_set():
return
if self._speed and self._speed > 0 \
and timestamp is not None and previous is not None:
delay = (timestamp - previous) / self._speed
if delay > 0 and self._stop.wait(delay):
return
if timestamp is not None:
previous = timestamp
try:
self._on_udp(payload)
except Exception:
logger.exception("error replaying payload")
self.packet_count += 1
except OSError:
logger.exception("unable to read replay log: %s", self._path)
return
logger.info("replay finished: %d packets", self.packet_count)
+84
View File
@@ -0,0 +1,84 @@
import sys
from collections import Counter
from typing import List, Optional
from .consts import events as consts
from .decode.pipeline import Pipeline
from .net.replay import load_payloads
from .environment import replay_path, setup_logging
def _fmt(value: float) -> str:
return f'{value:.2f}'
def _event_value(event: dict) -> dict:
return event.get(consts.EvKeyValue) or {}
def summarize(events: List[dict], path: Optional[str] = None,
packet_count: Optional[int] = None) -> str:
"""Build a human readable summary of the events produced by a replay."""
counts = Counter(event[consts.EvKeyName] for event in events)
fame = sum(_event_value(e).get('value', 0.0)
for e in events if e[consts.EvKeyName] == consts.EvNameUpdateFame)
silver = sum(_event_value(e).get('value', 0.0)
for e in events
if e[consts.EvKeyName] == consts.EvNameSilverGained)
damage = sum(_event_value(e).get('value', 0.0)
for e in events
if e[consts.EvKeyName] == consts.EvNameDamageDone)
damage_taken = sum(_event_value(e).get('value', 0.0)
for e in events
if e[consts.EvKeyName] == consts.EvNameDamageTaken)
main_player = None
for event in events:
if event[consts.EvKeyName] == consts.EvNameMainPlayerAppeared:
main_player = _event_value(event).get('name')
break
lines = ['Replay summary']
if path:
lines.append(f' log: {path}')
if packet_count is not None:
lines.append(f' packets: {packet_count}')
lines.append(f' events: {len(events)}')
lines.append(f' main player: {main_player or "(unknown)"}')
lines.append(f' zone changes: {counts.get(consts.EvNameZoneChange, 0)}')
lines.append(f' fame gained: {_fmt(fame)}')
lines.append(f' silver looted: {_fmt(silver)}')
lines.append(f' damage done: {_fmt(damage)}')
lines.append(f' damage taken: {_fmt(damage_taken)}')
top = counts.most_common(8)
if top:
lines.append(' top events:')
for name, count in top:
lines.append(f' {name}: {count}')
return '\n'.join(lines)
def run_headless() -> int:
"""Replay the configured log through the pipeline and print a summary."""
setup_logging()
path = replay_path()
if not path:
print('--replay requires a log path', file=sys.stderr)
return 2
try:
packets = load_payloads(path)
except OSError as error:
print(f'unable to read replay log {path}: {error}', file=sys.stderr)
return 1
events: List[dict] = []
pipeline = Pipeline(events.append)
for payload in packets:
pipeline.on_udp(payload)
print(summarize(events, path=path, packet_count=len(packets)))
return 0
+19 -1
View File
@@ -49,6 +49,7 @@ class Player(Stats):
party: Party
items: dict = field(default_factory=lambda: {'weapon': None})
damage_done: float = 0.0
damage_taken: float = 0.0
healing_done: float = 0.0
total_healing_done: float = 0.0
combat_time: CombatTime = field(default_factory=lambda: CombatTime())
@@ -62,7 +63,7 @@ class Player(Stats):
return self.active
def has_stats(self) -> bool:
return bool(self.damage_done or self.healing_done or self.total_healing_done)
return bool(self.damage_done or self.damage_taken or self.healing_done or self.total_healing_done)
@staticmethod
def new(self):
@@ -75,6 +76,7 @@ class Player(Stats):
def update(self, other):
self.name = other.name
self.damage_done += other.damage_done
self.damage_taken += other.damage_taken
self.healing_done += other.healing_done
self.total_healing_done += other.total_healing_done
self.combat_state = other.combat_state
@@ -102,6 +104,10 @@ class Player(Stats):
self.healing_done += value
def register_damage_taken(self, value):
self.damage_taken += value
self.activate()
def enter_combat(self):
self.combat_time.entered_combat = time_utils.now()
self.combat_state = CombatState.InCombat
@@ -116,6 +122,10 @@ class Player(Stats):
return StandalonePlayerListItem(
self.name, self.items, self.damage_done, self.dps, self.combat_state)
def into_damage_taken_list_item(self) -> StandalonePlayerListItem:
return StandalonePlayerListItem(
self.name, self.items, self.damage_taken, 0.0, self.combat_state)
def into_healing_list_item(self) -> StandalonePlayerListItem:
return StandalonePlayerListItem(
self.name, self.items, self.healing_done, self.hps, self.combat_state)
@@ -204,6 +214,11 @@ class CombatStats(CombatEventReceiver, Stats):
for player in self.visible_players()
])
def players_damage_taken(self) -> List[PlayerListItem]:
return to_player_list_items([player.into_damage_taken_list_item()
for player in self.visible_players()
])
def players_healing(self) -> List[PlayerListItem]:
return to_player_list_items([player.into_healing_list_item()
for player in self.visible_players()
@@ -230,6 +245,9 @@ class CombatStats(CombatEventReceiver, Stats):
def on_damage_done(self, id: int, damage: float):
self.players[id].register_damage_done(damage)
def on_damage_taken(self, id: int, damage: float):
self.players[id].register_damage_taken(damage)
def on_health_received(self, id: int, target_id: int, health: float):
self.players[id].register_healing_done(health)
+63
View File
@@ -93,6 +93,69 @@ def test_start_native_backend_reports_start_failure(monkeypatch):
assert backend_proxy._capture is None
def test_initialize_ok_with_replay(monkeypatch):
monkeypatch.setattr(
backend_proxy.environment, 'replay_path', lambda: '/tmp/x.jsonl')
assert backend_proxy.initialize() == backend_proxy.InitializationResult.Ok
def test_subscribe_starts_replay_backend(monkeypatch):
monkeypatch.setattr(
backend_proxy.environment, 'replay_path', lambda: '/tmp/x.jsonl')
started = []
monkeypatch.setattr(
backend_proxy, '_start_replay_backend',
lambda callback: started.append(callback) or True)
callback = lambda event: event
assert backend_proxy.subscribe(callback) is True
assert started == [callback]
def test_start_replay_backend_uses_pipeline(monkeypatch):
import src.net.replay as replay_mod
monkeypatch.setattr(backend_proxy, '_replay', None)
created = {}
class FakeReplay:
def __init__(self, on_udp):
created['on_udp'] = on_udp
def start(self):
created['started'] = True
return True
monkeypatch.setattr(replay_mod, 'ReplayEngine', FakeReplay)
assert backend_proxy._start_replay_backend(lambda event: event) is True
assert created['started'] is True
assert callable(created['on_udp'])
assert backend_proxy._replay is not None
backend_proxy._replay = None
def test_start_replay_backend_reports_start_failure(monkeypatch):
import src.net.replay as replay_mod
monkeypatch.setattr(backend_proxy, '_replay', None)
class FakeReplay:
def __init__(self, on_udp):
self.on_udp = on_udp
def start(self):
return False
monkeypatch.setattr(replay_mod, 'ReplayEngine', FakeReplay)
assert backend_proxy._start_replay_backend(lambda event: event) is False
assert backend_proxy._replay is None
def test_engine_initialize_reports_subscribe_failure(monkeypatch):
monkeypatch.setattr(
engine.backend_proxy, 'initialize',
+37
View File
@@ -6,6 +6,11 @@ class VisibleAll:
return True
class VisibleNone:
def test(self, _name):
return False
def test_self_healing_counts_while_in_combat():
stats = CombatStats(VisibleAll())
stats.on_player_appeared(0, 'Healer')
@@ -35,3 +40,35 @@ def test_total_healing_includes_post_combat_healing():
assert combat_healing[0].value == 100.0
assert total_healing[0].value == 150.0
def test_damage_taken_accumulates_per_player():
stats = CombatStats(VisibleAll())
stats.on_player_appeared(0, 'Tank')
stats.on_damage_taken(0, 250.0)
stats.on_damage_taken(0, 150.0)
damage_taken = stats.players_damage_taken()
assert damage_taken[0].name == 'Tank'
assert damage_taken[0].value == 400.0
assert damage_taken[0].value_per_second == 0.0
def test_damage_taken_counts_out_of_combat():
stats = CombatStats(VisibleAll())
stats.on_player_appeared(0, 'Tank')
stats.on_damage_taken(0, 75.0)
assert stats.players_damage_taken()[0].value == 75.0
def test_damage_taken_excludes_non_visible_players():
stats = CombatStats(VisibleNone())
stats.on_player_appeared(0, 'Enemy')
stats.on_damage_taken(0, 300.0)
assert stats.players_damage_taken() == []
+68 -13
View File
@@ -168,10 +168,10 @@ def test_fragment_reassembly():
(6, 'HealthUpdate'),
(29, 'NewCharacter'),
(32, 'ItemGained'),
(62, 'TakeSilver'),
(82, 'UpdateFame'),
(90, 'CharacterEquipmentChanged'),
(91, 'RegenerationHealthChanged'),
(153, 'SilverGained'),
(166, 'KnockedDown'),
(231, 'PartyJoined'),
(233, 'PartyPlayerJoined'),
@@ -271,16 +271,41 @@ def test_world_health_update_damage_and_heal():
assert damage[0]['value']['target'] == 0 # victim
assert damage[0]['value']['value'] == 80.0
assert damage[1]['name'] == 'DamageTaken'
assert damage[1]['value']['source'] == 0 # victim
assert damage[1]['value']['value'] == 80.0
heal = world.transform(game('HealthUpdate', {0: 10, 6: 20, 2: 40.0}))
assert heal[0]['name'] == 'HealthReceived'
assert heal[0]['value']['source'] == 1
assert heal[0]['value']['value'] == 40.0
assert len(heal) == 1 # healing is not damage taken
def test_world_health_update_unknown_actor_dropped():
def test_world_health_update_unknown_actor_emits_damage_taken():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
assert world.transform(game('HealthUpdate', {0: 10, 6: 999, 2: -50.0})) == []
events = world.transform(game('HealthUpdate', {0: 10, 6: 999, 2: -50.0}))
assert len(events) == 1
assert events[0]['name'] == 'DamageTaken'
assert events[0]['value']['source'] == 0
assert events[0]['value']['value'] == 50.0
def test_world_health_update_unknown_victim_and_actor_dropped():
world = World()
# neither the attacker nor the victim has a known static id
assert world.transform(game('HealthUpdate', {0: 999, 6: 888, 2: -50.0})) == []
def test_world_health_update_known_actor_unknown_target_emits_damage_done():
world = World()
world.transform(game('NewCharacter', {0: 20, 1: 'Attacker'}))
events = world.transform(game('HealthUpdate', {0: 999, 6: 20, 2: -50.0}))
assert len(events) == 1
assert events[0]['name'] == 'DamageDone'
assert events[0]['value']['source'] == 0
assert events[0]['value']['target'] is None
def test_world_regeneration_combat_states():
@@ -315,6 +340,22 @@ def test_world_update_fame_delta_from_total():
assert events[0]['value']['value'] == pytest.approx(0.1)
def test_world_update_fame_applies_bonus_factor():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
events = world.transform(
game('UpdateFame', {0: 10, 1: 5000000, 2: 30000, 17: 0.25}))
assert events[0]['value']['value'] == pytest.approx(3.75)
def test_world_update_fame_applies_premium_and_satchel():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
events = world.transform(
game('UpdateFame', {0: 10, 1: 5000000, 2: 30000, 5: True, 10: 10000}))
assert events[0]['value']['value'] == pytest.approx(5.5)
def test_world_item_gained_emits_collected_item():
world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'}))
@@ -356,22 +397,36 @@ def test_world_item_gained_uses_display_name_and_deduplicates():
assert duplicate == []
def test_world_silver_gained_tracks_known_sources():
def test_world_take_silver_tracks_main_player():
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}))
events = world.transform(game('TakeSilver', {0: 63, 3: 648351}))
assert looted == [{'name': 'SilverGained', 'value': {
'value': 45.0, 'silver_type': 'looted'}}]
assert other == []
assert ignored == []
assert events[0]['name'] == 'SilverGained'
assert events[0]['value']['silver_type'] == 'looted'
assert events[0]['value']['value'] == pytest.approx(64.8351)
def test_world_silver_gained_waits_for_main_player_join():
def test_world_take_silver_subtracts_taxes():
world = World()
assert world.transform(game('SilverGained', {1: 54, 2: 45})) == []
world.transform(game('Join', {0: 63, 2: 'Alice'}))
events = world.transform(
game('TakeSilver', {0: 63, 3: 500000, 4: 20000, 5: 10000, 6: 5000}))
assert events[0]['value']['value'] == pytest.approx(46.5)
def test_world_take_silver_ignores_other_players():
world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'}))
world.transform(game('NewCharacter', {0: 70, 1: 'Bob'}))
assert world.transform(game('TakeSilver', {0: 70, 3: 450000})) == []
def test_world_take_silver_waits_for_main_player_join():
world = World()
assert world.transform(game('TakeSilver', {0: 63, 3: 450000})) == []
def test_world_unconsumed_equipment_replayed_on_new_character():
+11
View File
@@ -13,6 +13,17 @@ def test_qt_args_removes_app_specific_options():
'aostats', '--log-path=/tmp/capture.jsonl']) == ['aostats']
def test_discovery_log_skips_replay_source(monkeypatch, tmp_path):
path = tmp_path / 'capture.jsonl'
monkeypatch.setattr(discovery, 'discovery_log_path', lambda: str(path))
monkeypatch.setattr(discovery, 'replay_path', lambda: str(path))
monkeypatch.setattr(discovery, '_initialized', False)
discovery.log('game_message', params={})
assert not path.exists()
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))
+28
View File
@@ -14,3 +14,31 @@ def test_remember_last_party_flag_is_removed_from_qt_args(monkeypatch):
sys.argv = ['aostats']
importlib.reload(environment)
def test_replay_flags_are_parsed_and_removed_from_qt_args(monkeypatch):
monkeypatch.setattr(sys, 'argv', [
'aostats', '--replay', '/tmp/capture.jsonl',
'--replay-speed', '2', '--replay-headless'])
reloaded = importlib.reload(environment)
assert reloaded.replay_path() == '/tmp/capture.jsonl'
assert reloaded.replay_speed() == 2.0
assert reloaded.replay_headless() is True
assert reloaded.qt_args(sys.argv) == ['aostats']
sys.argv = ['aostats']
importlib.reload(environment)
def test_replay_equals_syntax_and_default_speed(monkeypatch):
monkeypatch.setattr(sys, 'argv', ['aostats', '--replay=/tmp/x.jsonl'])
reloaded = importlib.reload(environment)
assert reloaded.replay_path() == '/tmp/x.jsonl'
assert reloaded.replay_speed() == 0.0
assert reloaded.replay_headless() is False
assert reloaded.qt_args(['aostats', '--replay=/tmp/x.jsonl']) == ['aostats']
sys.argv = ['aostats']
importlib.reload(environment)
+146
View File
@@ -0,0 +1,146 @@
import json
import os
import re
import time
from collections import Counter
import pytest
from src.decode.pipeline import Pipeline
from src.net.replay import ReplayEngine, load_payloads
from src.replay_cli import summarize
RAW_LOG_PATH = os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'aoaddons.log')
def _write_jsonl(path, payloads):
with open(path, 'w', encoding='utf-8') as out:
out.write(json.dumps({'type': 'session_start'}) + '\n')
for i, payload in enumerate(payloads):
out.write(json.dumps({
'type': 'udp_payload',
'timestamp': f'2026-10-10T00:00:{i:02d}.000+00:00',
'payload_hex': payload.hex(),
}) + '\n')
out.write(json.dumps({'type': 'game_message', 'name': 'UpdateFame'}) + '\n')
def test_load_payloads_reads_jsonl_and_ignores_other_records(tmp_path):
path = tmp_path / 'capture.jsonl'
_write_jsonl(str(path), [b'\x01\x02', b'\x03\x04\x05'])
assert load_payloads(str(path)) == [b'\x01\x02', b'\x03\x04\x05']
def test_load_payloads_supports_legacy_raw_format(tmp_path):
path = tmp_path / 'aoaddons.log'
path.write_text(
'some log line\n'
'Raw payload: [1, 2, 3]\n'
'unrelated\n'
'Raw payload: [4, 5]\n',
encoding='utf-8')
assert load_payloads(str(path)) == [b'\x01\x02\x03', b'\x04\x05']
def test_replay_engine_start_fails_for_missing_file():
engine = ReplayEngine(lambda payload: None, path='/does/not/exist.jsonl')
assert engine.start() is False
def test_replay_engine_feeds_payloads_in_order(tmp_path):
path = tmp_path / 'capture.jsonl'
_write_jsonl(str(path), [b'\xaa', b'\xbb', b'\xcc'])
received = []
engine = ReplayEngine(received.append, path=str(path), speed=0.0)
assert engine.start() is True
engine.wait(timeout=5)
assert received == [b'\xaa', b'\xbb', b'\xcc']
assert engine.packet_count == 3
def test_replay_engine_paces_with_timestamps(tmp_path):
path = tmp_path / 'capture.jsonl'
with open(path, 'w', encoding='utf-8') as out:
out.write(json.dumps({'type': 'session_start'}) + '\n')
for i in range(3):
out.write(json.dumps({
'type': 'udp_payload',
'timestamp': f'2026-10-10T00:00:00.{i * 100:03d}+00:00',
'payload_hex': 'aa',
}) + '\n')
started = time.monotonic()
engine = ReplayEngine(lambda payload: None, path=str(path), speed=1.0)
engine.start()
engine.wait(timeout=5)
elapsed = time.monotonic() - started
assert elapsed >= 0.15
def test_replay_engine_ignores_duplicate_start(tmp_path):
path = tmp_path / 'capture.jsonl'
_write_jsonl(str(path), [b'\xaa'])
engine = ReplayEngine(lambda payload: None, path=str(path))
assert engine.start() is True
assert engine.start() is True
engine.wait(timeout=5)
assert engine.packet_count == 1
def test_summarize_reports_fame_silver_and_player():
events = [
{'name': 'MainPlayerAppeared', 'value': {'id': 0, 'name': 'Alice'}},
{'name': 'ZoneChange'},
{'name': 'UpdateFame', 'value': {'value': 857.472}},
{'name': 'SilverGained', 'value': {
'value': 64.8351, 'silver_type': 'looted'}},
{'name': 'DamageDone', 'value': {'source': 1, 'value': 120.0}},
]
report = summarize(events, path='/tmp/capture.jsonl', packet_count=42)
assert 'Alice' in report
assert '857.47' in report
assert '64.84' in report
assert '120.00' in report
assert 'packets: 42' in report
pytestmark = pytest.mark.skipif(
not os.path.exists(RAW_LOG_PATH),
reason='aoaddons.log capture fixture is not available')
def _raw_payloads():
payloads = []
pattern = re.compile(r'Raw payload: \[([0-9, ]+)\]')
with open(RAW_LOG_PATH, encoding='utf-8', errors='replace') as log:
for line in log:
match = pattern.search(line)
if match:
payloads.append(
bytes(int(part) for part in match.group(1).split(',')))
return payloads
def test_replay_engine_integration_produces_events(tmp_path):
path = tmp_path / 'capture.jsonl'
_write_jsonl(str(path), _raw_payloads())
events = []
pipeline = Pipeline(events.append)
engine = ReplayEngine(pipeline.on_udp, path=str(path), speed=0.0)
assert engine.start() is True
engine.wait(timeout=10)
counts = Counter(event['name'] for event in events)
assert counts['MainPlayerAppeared'] >= 1
assert counts['PlayerAppeared'] == 2
assert counts['ZoneChange'] == 3