3 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
bionickatana 13b1dcdd97 Fixed UI crash
Build / Build source distribution (push) Failing after 9s
Build / Execute unit tests (push) Failing after 7s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
2026-10-10 20:39:02 -06:00
25 changed files with 1027 additions and 268 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">
+2 -1
View File
@@ -4,7 +4,8 @@ from src.version import version
install_requires = [
"requests>=2.26",
"PySide6>=6.2",
"PySide6==6.7.3",
"shiboken6==6.7.3",
"toml>=0.10.2",
"pillow>=8.4",
# On Linux the app ships a pure-Python Protocol18 decoder and captures with
+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
+15
View File
@@ -19,6 +19,7 @@ class Pipeline:
self.decoder = PhotonDecoder()
self.world = World()
self._lock = threading.RLock()
self._warned_unknown = set()
def on_udp(self, payload: bytes):
logger.debug("received UDP payload: %d bytes", len(payload))
@@ -40,6 +41,7 @@ class Pipeline:
def _events_from_message(self, message: PhotonMessage) -> List[dict]:
game_message = into_game_message(message)
if game_message is None:
self._warn_unknown_game_message(message)
return []
discovery.log(
'game_message',
@@ -50,3 +52,16 @@ class Pipeline:
discovery.log('app_event', event=event)
logger.debug("emitting app event: %s", event)
return events
def _warn_unknown_game_message(self, message: PhotonMessage):
if message.kind == 'Event':
key = ('Event', message.code, message.params.get(252))
elif message.kind in ('Request', 'Response'):
key = (message.kind, message.code, message.params.get(253))
else:
return
if key in self._warned_unknown:
return
self._warned_unknown.add(key)
logger.warning("ignoring unknown Photon game message: kind=%s code=%s opcode=%s params=%s",
key[0], key[1], key[2], message.params)
+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]]:
+37 -18
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 []
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'
return [{
events.append({
'name': event_name,
'value': {'source': actor_static,
'target': self.cache.get_static_id(victim_id),
'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
+15 -10
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,8 +82,7 @@ def run():
logger.debug("python: %s (%s)", sys.executable, sys.version)
logger.debug("platform: %s", platform_utils.system())
initialization_result = initialize()
logger.debug("backend initialization result: %s", initialization_result)
replaying = bool(replay_path())
conf = config()
window_config = conf['window']
@@ -91,15 +90,18 @@ def run():
WIDTH = window_config['width']
HEIGHT = window_config['height']
perms_ok = True
if platform_utils.is_linux():
perms_ok = capture_permissions_ok()
logger.debug("capture permissions probe: %s", perms_ok)
app = QApplication(app_argv)
QtCore.qInstallMessageHandler(_qt_message_handler)
_install_heartbeat(app)
perms_ok = True
if platform_utils.is_linux() and not replaying:
perms_ok = capture_permissions_ok()
logger.debug("capture permissions probe: %s", perms_ok)
initialization_result = initialize()
logger.debug("backend initialization result: %s", initialization_result)
app.setStyleSheet(style)
clipboard = app.clipboard()
@@ -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)
)
+145 -61
View File
@@ -9,7 +9,6 @@ from PySide6.QtWidgets import QFrame # type: ignore
from PySide6.QtWidgets import QGridLayout # type: ignore
from PySide6.QtWidgets import QHBoxLayout # type: ignore
from PySide6.QtWidgets import QLabel # type: ignore
from PySide6.QtWidgets import QListView # type: ignore
from PySide6.QtWidgets import QPushButton # type: ignore
from PySide6.QtWidgets import QScrollArea # type: ignore
from PySide6.QtWidgets import QVBoxLayout # type: ignore
@@ -28,6 +27,7 @@ from .views.list_view import ListItemView
class Page:
Overview = 'overview'
Damage = 'damage'
DamageTaken = 'damage_taken'
Healing = 'healing'
Economy = 'economy'
Items = 'items'
@@ -37,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'),
@@ -139,7 +140,7 @@ class StatCard(QFrame):
self.setLayout(self.layout)
def update_value(self, value):
self.value.setText(str(value))
_set_text(self.value, str(value))
class HeaderBar(QWidget):
@@ -158,9 +159,11 @@ class HeaderBar(QWidget):
def update_status(self):
if engine.is_ready():
self.status.setText('Tracking live Albion Online traffic')
_set_text(self.status, 'Tracking live Albion Online traffic')
else:
self.status.setText('Waiting for zone change to identify your character')
_set_text(
self.status,
'Waiting for zone change to identify your character')
class ItemsPanel(QFrame):
@@ -181,20 +184,25 @@ class ItemsPanel(QFrame):
self.list.update(items)
class PlainStatsListView(QListView):
class PlainStatsListView(QLabel):
def __init__(self):
QListView.__init__(self)
self.model = QtGui.QStandardItemModel(self)
self.setModel(self.model)
QLabel.__init__(self)
self._last_text = None
self.setObjectName('MutedText')
self.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft)
self.setWordWrap(True)
def update(self, items):
self.model.clear()
for item in items:
row = QtGui.QStandardItem(
f'{item.name} {item.value} ({item.percentage}%)')
row.setFlags(row.flags() & ~Qt.ItemIsSelectable)
row.setForeground(QtGui.QBrush(QtGui.QColor('#d8dbe2')))
self.model.appendRow(row)
if not items:
text = 'No entries yet.'
else:
text = '\n'.join(
f'{item.name} {item.value} ({item.percentage}%)'
for item in items)
if text == self._last_text:
return
self._last_text = text
self.setText(text)
class SettingsPanel(QWidget):
@@ -244,6 +252,8 @@ class MainWidget(QWidget):
self.clipboard = clipboard
self.current_page = Page.Overview
self.current_scope = StatsType.ZONE
self._layout_key = None
self._last_snapshot = None
self.root_layout = QHBoxLayout()
self.root_layout.setContentsMargins(0, 0, 0, 0)
@@ -298,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)
@@ -314,7 +331,7 @@ class MainWidget(QWidget):
self.refresh()
timer = QTimer(self)
timer.timeout.connect(self.refresh)
timer.start(500)
timer.start(1000)
def set_page(self, page):
self.current_page = page
@@ -330,6 +347,12 @@ class MainWidget(QWidget):
silver = self.silver_stats()
items = self.item_stats()
snapshot = self._snapshot(
players, total_healing, silver, items, fame_stat, elapsed)
if snapshot == self._last_snapshot:
return
self._last_snapshot = snapshot
self.header.update_status()
self.elapsed_card.update_value(self._format_time(elapsed))
self.fame_card.update_value(fame_stat.fame)
@@ -337,12 +360,28 @@ class MainWidget(QWidget):
self.ready_card.update_value('Ready' if engine.is_ready() else 'Not ready')
self.items_panel.update(items)
self._set_page_copy(players, total_healing, silver, items)
self._ensure_page_layout()
self._update_page_data(players, total_healing, silver, items)
def _snapshot(self, players, total_healing, silver, items, fame_stat, elapsed):
return (
self.current_page,
self.current_scope,
engine.is_ready(),
self._format_time(elapsed),
str(fame_stat.fame),
str(fame_stat.fame_per_hour),
_list_signature(players),
_list_signature(total_healing),
_list_signature(silver),
_list_signature(items),
)
def primary_stats(self):
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,
@@ -379,71 +418,99 @@ class MainWidget(QWidget):
}
return getters[self.current_scope]()
def _set_page_copy(self, players, total_healing, silver, items):
self.primary_list.hide()
self.plain_list.hide()
self.primary_label.hide()
self.total_healing_label.hide()
self.total_healing_list.hide()
self.placeholder.hide()
self.settings_panel.hide()
def _ensure_page_layout(self):
layout_key = (self.current_page, self.current_scope)
if layout_key == self._layout_key:
return
self._layout_key = layout_key
_set_visible(self.primary_list, False)
_set_visible(self.plain_list, False)
_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)
if self.current_page == Page.Overview:
self.page_title.setText('Overview')
self.page_description.setText(
_set_text(self.page_title, 'Overview')
_set_text(self.page_description,
'A quick session summary for the selected scope. Use the left menu to inspect damage, healing, economy, and loot in more detail.')
self.primary_label.setText('Top Damage Dealers')
self.primary_label.show()
self.primary_list.show()
self.primary_list.update(players)
_set_text(self.primary_label, 'Top Damage Dealers')
_set_visible(self.primary_label, True)
_set_visible(self.primary_list, True)
return
if self.current_page == Page.Damage:
self.page_title.setText('Damage Done')
self.page_description.setText(
_set_text(self.page_title, 'Damage Done')
_set_text(self.page_description,
'Damage attributed to each visible tracked player during the selected scope. DPS is based on combat time.')
self.primary_label.setText('Damage by Player')
self.primary_label.show()
self.primary_list.show()
self.primary_list.update(players)
_set_text(self.primary_label, 'Damage by Player')
_set_visible(self.primary_label, True)
_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:
self.page_title.setText('Healing Done')
self.page_description.setText(
_set_text(self.page_title, 'Healing Done')
_set_text(self.page_description,
'Combat healing counts healing during fights. Total healing includes self-healing and post-fight recovery.')
self.primary_label.setText('Combat Healing')
self.primary_label.show()
self.primary_list.show()
self.primary_list.update(players)
self.total_healing_label.show()
self.total_healing_list.show()
self.total_healing_list.update(total_healing)
_set_text(self.primary_label, 'Combat Healing')
_set_visible(self.primary_label, True)
_set_visible(self.primary_list, True)
_set_visible(self.total_healing_label, True)
_set_visible(self.total_healing_list, True)
return
if self.current_page == Page.Economy:
self.page_title.setText('Economy')
self.page_description.setText(
_set_text(self.page_title, 'Economy')
_set_text(self.page_description,
'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.plain_list.show()
self.plain_list.update(silver)
_set_text(self.primary_label, 'Silver Gained')
_set_visible(self.primary_label, True)
_set_visible(self.plain_list, True)
return
if self.current_page == Page.Items:
self.page_title.setText('Items Collected')
self.page_description.setText(
_set_text(self.page_title, 'Items Collected')
_set_text(self.page_description,
'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.plain_list.show()
self.plain_list.update(items)
_set_text(self.primary_label, 'Items by Quantity')
_set_visible(self.primary_label, True)
_set_visible(self.plain_list, True)
return
self.page_title.setText('Settings')
self.page_description.setText('Reset scopes, view app information, and configure dashboard behavior.')
self.settings_panel.show()
_set_text(self.page_title, 'Settings')
_set_text(self.page_description,
'Reset scopes, view app information, and configure dashboard behavior.')
_set_visible(self.settings_panel, True)
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)
elif self.current_page == Page.Economy:
self.plain_list.update(silver)
elif self.current_page == Page.Items:
self.plain_list.update(items)
def _format_time(self, seconds):
seconds = int(seconds or 0)
@@ -453,3 +520,20 @@ class MainWidget(QWidget):
if hours:
return f'{hours}h {minutes}m {remainder}s'
return f'{minutes}m {remainder}s'
def _set_text(widget, text):
if widget.text() != text:
widget.setText(text)
def _set_visible(widget, visible):
if widget.isVisible() != visible:
widget.setVisible(visible)
def _list_signature(items):
return tuple(
(item.name, str(item.value), str(item.value_per_second),
str(item.percentage), item.combat_state)
for item in items)
+37 -149
View File
@@ -1,163 +1,51 @@
import collections
import functools
import re
from typing import List
from PySide6 import QtCore # type: ignore
from PySide6 import QtGui # type: ignore
from PySide6.QtCore import Qt # type: ignore
from PySide6.QtGui import QStandardItem # type: ignore
from PySide6.QtGui import QStandardItemModel # type: ignore
from PySide6.QtWidgets import QApplication # type: ignore
from PySide6.QtWidgets import QComboBox # type: ignore
from PySide6.QtWidgets import QHBoxLayout # type: ignore
from PySide6.QtWidgets import QLabel # type: ignore
from PySide6.QtWidgets import QListView # type: ignore
from PySide6.QtWidgets import QMessageBox # type: ignore
from PySide6.QtWidgets import QProgressBar # type: ignore
from PySide6.QtWidgets import QPushButton # type: ignore
from PySide6.QtWidgets import QVBoxLayout # type: ignore
from .....stats.list_item import PlayerListItem
from .....utils import assets
from .....utils import names
from .....utils import weapon
Style = collections.namedtuple('Style', ['bg', 'fg'])
enchant_re = re.compile(r"(.*)@(\d+)")
def map_name(name):
match = enchant_re.match(name)
if match:
return names.map_name(match[1])
return names.map_name(name)
def player_style(items):
weapon_type = weapon.get_weapon_type(items)
if weapon_type == weapon.WeaponType.Arcane:
return Style(bg='#f032e6', fg='#ffffff')
elif weapon_type == weapon.WeaponType.Axe:
return Style(bg='#800000', fg='#7fffff')
elif weapon_type == weapon.WeaponType.Bow:
return Style(bg='#469990', fg='#ED9247')
elif weapon_type == weapon.WeaponType.Crossbow:
return Style(bg='#000075', fg='#ffff8a')
elif weapon_type == weapon.WeaponType.Curse:
return Style(bg='#911eb4', fg='#6ee14b')
elif weapon_type == weapon.WeaponType.Dagger:
return Style(bg='#4d5f20', fg='#ffffff')
elif weapon_type == weapon.WeaponType.Fire:
return Style(bg='#e6194B', fg='#4763ED')
elif weapon_type == weapon.WeaponType.Frost:
return Style(bg='#4363d8', fg='#eeeeee')
elif weapon_type == weapon.WeaponType.Hammer:
return Style(bg='#9A6324', fg='#2FEAED')
elif weapon_type == weapon.WeaponType.Holy:
return Style(bg='#42d4f4', fg='#bd2b0b')
elif weapon_type == weapon.WeaponType.Mace:
return Style(bg='#808000', fg='#2FEAED')
elif weapon_type == weapon.WeaponType.Nature:
return Style(bg='#3cb44b', fg='#EDC647')
elif weapon_type == weapon.WeaponType.Quarterstaff:
return Style(bg='#f58231', fg='#0a7dce')
elif weapon_type == weapon.WeaponType.Spear:
return Style(bg='#a9a9a9', fg='#18ED54')
elif weapon_type == weapon.WeaponType.Sword:
return Style(bg='#b59d00', fg='#4a62ff')
else:
return Style(bg='#42413c', fg='#bdbec3')
class ListItemView(QListView):
class Item(QtGui.QStandardItem):
def __init__(self, player, parent):
QtGui.QStandardItem .__init__(self)
self.parent = parent
self.player = player
self.update(player)
self.setFlags(self.flags() & ~Qt.ItemIsSelectable)
self.setTextAlignment(
QtCore.Qt.AlignmentFlag.AlignHCenter | QtCore.Qt.AlignmentFlag.AlignVCenter)
def update(self, player):
self.player = player
self.setText("{} {} ({}, {}%)".format(
self.player.name, self.player.value, self.player.value_per_second, self.player.percentage
))
self.refresh()
def refresh(self):
value = round(self.player.value / self.player.best_value, 2)
QRectF = QtCore.QRectF(self.parent.rect())
gradient = QtGui.QLinearGradient(
QRectF.topLeft(), QRectF.topRight())
gradient.setColorAt(value-0.001 if value > 0 else 0,
QtGui.QColor(player_style(self.player.items).bg))
gradient.setColorAt(value, QtGui.QColor('#000000'))
gradient.setColorAt(value+0.001 if value <
1 else 1, QtGui.QColor('#000000'))
brush = QtGui.QBrush(gradient)
self.setBackground(brush)
brush_fg = QtGui.QBrush(QtGui.QColor(
player_style(self.player.items).fg))
self.setForeground(brush_fg)
self.setToolTip('\n'.join(
[f'{k}: {map_name(v)}' for (k, v) in self.player.items.items() if v]))
class SortProxyModel(QtCore.QSortFilterProxyModel):
def lessThan(self, left, right):
l = self.sourceModel().item(left.row())
r = self.sourceModel().item(right.row())
return l.player.percentage < r.player.percentage
class ItemModel(QStandardItemModel):
def __init__(self, view):
QStandardItemModel .__init__(self, view)
def __init__(self):
QListView .__init__(self)
self.setIconSize(QtCore.QSize(20, 20))
self.model = self.ItemModel(self)
self.proxy = self.SortProxyModel()
self.proxy.setSourceModel(self.model)
self.setModel(self.proxy)
class ListItemView(QLabel):
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)
self.setWordWrap(True)
self.setText('No entries yet.')
def update(self, players: List[PlayerListItem]):
if not players:
self.model.clear()
sorted_players = sorted(players, key=lambda p: p.value, reverse=True)
signature = tuple(_player_signature(p) for p in sorted_players)
if signature == self._last_signature:
return
self._last_signature = signature
self._players = sorted_players
visible_names = []
for player in players:
items = (self.model.item(i) for i in range(self.model.rowCount()))
found = next(
(i for i in items if i.player.name == player.name), None)
if found:
found.update(player)
else:
self.model.appendRow(self.Item(player, self))
visible_names.append(player.name)
for i in range(self.model.rowCount()):
item = self.model.item(i)
if hasattr(item, 'player') and hasattr(item.player, 'name') and item.player.name not in visible_names:
self.model.removeRow(i)
self.proxy.sort(0, QtCore.Qt.DescendingOrder)
if not sorted_players:
self.setText('No entries yet.')
return
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 sorted(
[self.model.item(i).player for i in range(self.model.rowCount())],
key=lambda i: i.value,
reverse=True)
return list(self._players)
def _player_signature(player: PlayerListItem):
return (
player.name,
str(player.value),
str(player.value_per_second),
str(player.percentage),
player.combat_state,
)
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