Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| f3114b076a | |||
| fbfa90edec |
@@ -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
@@ -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()
|
||||
|
||||
@@ -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,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
@@ -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)
|
||||
|
||||
@@ -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
@@ -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
@@ -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]:
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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
@@ -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,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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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',
|
||||
|
||||
@@ -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
@@ -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():
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user