Compare commits
3 Commits
887667af07
..
master
| Author | SHA1 | Date | |
|---|---|---|---|
| f3114b076a | |||
| fbfa90edec | |||
| 13b1dcdd97 |
@@ -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">
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
+15
-10
@@ -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
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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