Compare commits

3 Commits

Author SHA1 Message Date
bionickatana 7279b3c207 Working advanced tracking code
Build / Build source distribution (push) Failing after 13s
Build / Execute unit tests (push) Failing after 8s
Build / Verify generated game data is current (push) Failing after 7s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
2026-10-13 09:08:38 -06:00
bionickatana f3114b076a Added 'damage taken' section to the UI
Build / Build source distribution (push) Failing after 8s
Build / Execute unit tests (push) Failing after 6s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
2026-10-10 23:38:32 -06:00
bionickatana fbfa90edec Added replay ability 2026-10-10 23:00:04 -06:00
41 changed files with 337740 additions and 7566 deletions
+16
View File
@@ -35,6 +35,22 @@ jobs:
python -m pip install --upgrade tox python -m pip install --upgrade tox
- name: Run unit tests - name: Run unit tests
run: python -m tox -e ut run: python -m tox -e ut
gamedata:
name: Verify generated game data is current
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions/setup-python@v2
name: Install Python
with:
python-version: '3.7'
# The tables under src/static are generated from the game data dumps.
# They are committed, so this job fails if someone edits them by hand or
# if upstream game data moved on and nobody regenerated them.
- name: Check committed tables match the dumps
run: make gamedata-check
upload_pypi: upload_pypi:
if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags') if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
needs: [build_sdist] needs: [build_sdist]
+3 -1
View File
@@ -14,4 +14,6 @@ albion-online-stats.cfg
.mypy_cache .mypy_cache
aoaddons.log aoaddons.log
.eggs .eggs
.idea .idea
# fetched game data dumps (scripts/fetch_gamedata.py)
.cache
+32
View File
@@ -0,0 +1,32 @@
PYTHON ?= python3
CACHE ?= .cache/gamedata
.PHONY: help gamedata gamedata-check gamedata-force test lint clean-gamedata
help:
@echo 'Targets:'
@echo ' gamedata regenerate src/static tables from the game dumps'
@echo ' gamedata-check verify the committed tables are up to date'
@echo ' test run the unit tests'
# Regenerate the shipped lookup tables. Fetches the game dumps first if the
# cache is missing. Tables land in src/static and should be committed.
gamedata:
$(PYTHON) scripts/fetch_gamedata.py --cache $(CACHE)
$(PYTHON) scripts/gen_gamedata.py --cache $(CACHE)
# Regenerate from a fresh checkout of the dumps.
gamedata-force:
$(PYTHON) scripts/fetch_gamedata.py --cache $(CACHE) --force
$(PYTHON) scripts/gen_gamedata.py --cache $(CACHE)
# CI guard: fail if the committed tables have drifted from the dumps.
gamedata-check:
$(PYTHON) scripts/fetch_gamedata.py --cache $(CACHE)
$(PYTHON) scripts/gen_gamedata.py --cache $(CACHE) --check
test:
$(PYTHON) -m pytest tests
clean-gamedata:
rm -rf .cache
+18
View File
@@ -101,6 +101,24 @@ This writes raw UDP payloads, decoded Photon messages, translated game messages,
On Linux, when the app has no permission to capture packets the backend still reports successful initialization; the app detects this and shows a "Fix capture permissions" button regardless. 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 ## Is This Allowed
<p align="center"> <p align="center">
<img src="assets/sbistatement.png"> <img src="assets/sbistatement.png">
+141
View File
@@ -0,0 +1,141 @@
"""Fetch the large game data dumps that generated tables are built from.
The app ships small, generated lookup tables (see ``src/static/vendor``). The
dumps they are derived from are far too large to version, so they are fetched
on demand into a gitignored cache.
This is a shallow, blobless, sparse clone, so it transfers only the handful of
files listed below rather than the repository's full history.
Usage:
python scripts/fetch_gamedata.py [--cache DIR] [--force] [--check]
"""
import argparse
import hashlib
import json
import os
import shutil
import subprocess
import sys
UPSTREAM_URL = 'https://github.com/ao-data/ao-bin-dumps.git'
PINNED_COMMIT = '47e4f5aca4d30b7495afa5a625ce0d5795e32050'
# Only what the generators actually read. `localization.json` is deliberately
# absent: it is 90 MB, and it cannot supply a display name for every mob
# anyway (883 of 5479 mob definitions have no namelocatag). Nothing in
# attribution depends on it. See src/static/vendor/PROVENANCE.md.
REQUIRED_FILES = (
'items.json',
'spells.json',
'mobs.json',
'gamedata.json',
# Source for the vendored src/static/vendor/item_ids.txt.
'formatted/items.txt',
)
# Anchored to the repo root. Without the leading slash gitcone matches the
# basename anywhere in the tree, which drags in the redundant 24 MB
# formatted/items.json alongside the root one.
SPARSE_PATTERNS = tuple('/' + name for name in REQUIRED_FILES)
DEFAULT_CACHE = os.path.join('.cache', 'gamedata')
def _run(args, cwd=None):
result = subprocess.run(
args,
cwd=cwd,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
)
if result.returncode != 0:
sys.stderr.write(result.stdout.decode('utf-8', 'replace'))
raise SystemExit('command failed: {}'.format(' '.join(args)))
return result.stdout.decode('utf-8', 'replace')
def _checksums(directory):
"""Map of filename -> sha256 for the required files."""
digests = {}
for name in REQUIRED_FILES:
path = os.path.join(directory, name)
digest = hashlib.sha256()
with open(path, 'rb') as handle:
for chunk in iter(lambda: handle.read(1 << 20), b''):
digest.update(chunk)
digests[name] = digest.hexdigest()
return digests
def is_populated(directory):
return all(os.path.exists(os.path.join(directory, name))
for name in REQUIRED_FILES)
def fetch(cache_dir, force=False):
"""Ensure the dumps are present in ``cache_dir`` and return that path."""
if force and os.path.isdir(cache_dir):
shutil.rmtree(cache_dir)
elif is_populated(cache_dir):
return cache_dir
parent = os.path.dirname(os.path.abspath(cache_dir)) or '.'
os.makedirs(parent, exist_ok=True)
if os.path.isdir(cache_dir):
shutil.rmtree(cache_dir)
# --filter=blob:none avoids the full history; --sparse plus the final
# checkout limits us to the files we name.
_run([
'git', 'clone',
'--filter=blob:none',
'--no-checkout',
'--depth', '1',
UPSTREAM_URL,
cache_dir,
])
_run(['git', 'sparse-checkout', 'set', '--no-cone', *SPARSE_PATTERNS],
cwd=cache_dir)
_run(['git', 'checkout', PINNED_COMMIT], cwd=cache_dir)
missing = [name for name in REQUIRED_FILES
if not os.path.exists(os.path.join(cache_dir, name))]
if missing:
raise SystemExit('fetch incomplete, missing: {}'.format(missing))
return cache_dir
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--cache', default=DEFAULT_CACHE,
help='cache directory (default: %(default)s)')
parser.add_argument('--force', action='store_true',
help='re-fetch even if the cache is already populated')
parser.add_argument('--check', action='store_true',
help='verify the cache matches the pinned commit, '
'without fetching')
args = parser.parse_args(argv)
if args.check:
if not is_populated(args.cache):
print('cache is not populated: {}'.format(args.cache))
return 1
head = _run(['git', 'rev-parse', 'HEAD'], cwd=args.cache).strip()
if head != PINNED_COMMIT:
print('cache at {}, expected {}'.format(head, PINNED_COMMIT))
return 1
print('cache OK at {}'.format(PINNED_COMMIT))
print(json.dumps(_checksums(args.cache), indent=2, sort_keys=True))
return 0
fetch(args.cache, force=args.force)
print('game data ready in {}'.format(args.cache))
return 0
if __name__ == '__main__':
raise SystemExit(main())
+466
View File
@@ -0,0 +1,466 @@
"""Generate the small game-data lookup tables the app actually ships.
The raw dumps are ~50 MB and are fetched on demand (see fetch_gamedata.py).
This reduces them to a handful of compact tables under ``src/static``.
Everything here is derived mechanically from the dumps. There are no
hand-written mappings, and no observed damage is ever used to infer a value --
strength comes from item power, which is a property of the item definition.
Usage:
python scripts/gen_gamedata.py [--cache DIR] [--check]
"""
import argparse
import json
import os
import re
import sys
STATIC_DIR = os.path.join('src', 'static')
DEFAULT_CACHE = os.path.join('.cache', 'gamedata')
# Mob template IDs are the enumeration index of the mobs.bin XML, which differs
# from the order of mobs.json by a constant. Six independent template IDs seen
# in real captures resolve to the correct mob on both name and max HP with this
# offset, across ~2300 entries of the file. The rule producing it is not
# understood -- the 16 skipped entries are all category=roaming, which is the
# signature of a filtered enumeration rather than a statement of the filter.
# Accepted as a constant by decision; see .opencode/plans/effective-damage.md.
MOB_TEMPLATE_OFFSET = 16
ARMOR_TYPES = ('physicalarmor', 'magicresistance')
_ITEM_LINE = re.compile(r'\s*(\d+):\s*(\S+?)\s*(?::|$)')
def _load(cache_dir, name):
with open(os.path.join(cache_dir, name), encoding='utf-8') as handle:
return json.load(handle)
def _as_list(value):
if value is None:
return []
if isinstance(value, list):
return value
return [value]
# --------------------------------------------------------------------------
# item_ids.txt
# --------------------------------------------------------------------------
def gen_item_ids(cache_dir):
"""Rewrite src/static/item_ids.txt in the format the app reads.
The app's loader expects ``<id>,<uniquename>``. Upstream ships
`` <id>: <uniquename> : <display name>``; 846 entries have no display
name and end after the unique name.
"""
out_path = os.path.join(STATIC_DIR, 'item_ids.txt')
lines = []
src = os.path.join(cache_dir, 'formatted', 'items.txt')
with open(src, encoding='utf-8', errors='replace') as handle:
for line in handle:
match = _ITEM_LINE.match(line)
if match:
lines.append('{},{}'.format(match.group(1), match.group(2)))
lines.sort(key=lambda entry: int(entry.split(',', 1)[0]))
_write_text(out_path, '\n'.join(lines) + '\n')
return out_path, len(lines)
# --------------------------------------------------------------------------
# item_spells.json
# --------------------------------------------------------------------------
def _index_items(items_root):
"""Unique name -> definition, in document order across all groups."""
index = {}
for group, value in items_root.items():
if group.startswith('@') or group == 'shopcategories':
continue
for entry in _as_list(value):
if isinstance(entry, dict) and entry.get('@uniquename'):
index[entry['@uniquename']] = entry
return index
def _resolve_spells(item_index, name, depth=0, seen=None):
"""Flatten craftingspelllist, following @reference and removespell.
Most weapons carry no spells of their own -- they inherit a whole ability
set from a base item. Resolving that inheritance is what turns 471 weapons
with an apparently empty spell list into full coverage.
"""
seen = seen if seen is not None else set()
if name in seen or depth > 12:
return []
seen.add(name)
entry = item_index.get(name)
if not entry:
return []
spell_list = entry.get('craftingspelllist')
if not spell_list:
return []
if not isinstance(spell_list, dict):
return []
spells = []
reference = spell_list.get('@reference')
if reference:
spells += _resolve_spells(item_index, reference, depth + 1, seen)
removed = set()
for rem in _as_list(spell_list.get('removespell')):
if isinstance(rem, dict) and rem.get('@uniquename'):
removed.add(rem['@uniquename'])
for craft in _as_list(spell_list.get('craftspell')):
if isinstance(craft, dict) and craft.get('@uniquename'):
spells.append(craft)
return [s for s in spells if s['@uniquename'] not in removed]
def gen_item_spells(cache_dir):
item_index = _index_items(_load(cache_dir, 'items.json')['items'])
result = {}
for name in item_index:
spells = _resolve_spells(item_index, name)
if not spells:
continue
entries = [{'slot': s.get('@slots'), 'spell': s['@uniquename']}
for s in spells]
result[name] = entries
# A packet identifies an enchanted item as BASE@LEVEL, but only the
# base item exists in the dump. Emit the variants as aliases so a
# lookup straight from a packet id finds the abilities, rather than
# silently getting nothing.
enchantments = item_index[name].get('enchantments')
if not enchantments:
continue
variants = _as_list(
enchantments.get('enchantment') if isinstance(enchantments, dict)
else enchantments)
for variant in variants:
if isinstance(variant, dict) and variant.get('@enchantmentlevel'):
result['{}@{}'.format(name, variant['@enchantmentlevel'])] = \
entries
out_path = os.path.join(STATIC_DIR, 'item_spells.json')
_write_json(out_path, result, sort_keys=True)
return out_path, len(result)
# --------------------------------------------------------------------------
# debuff_spells.json
# --------------------------------------------------------------------------
def _index_spells(spells_root):
index = {}
for group in ('activespell', 'passivespell', 'togglespell'):
for spell in spells_root.get(group) or []:
if spell.get('@uniquename'):
index[spell['@uniquename']] = spell
return index
def _spell_links(spell_index, name):
"""Spells one hop downstream of ``name``.
An ability rarely carries its debuff directly. ARMORPIERCER declares no
buffovertime at all: it points at ARMORPIERCER_EFFECT via spelleffectarea,
which in turn applies ARMORPIERCER_DEBUFF_EFFECT via applyspell. Only the
last link actually holds the armour numbers, so every hop has to be walked.
"""
spell = spell_index.get(name)
if not spell:
return []
out = []
for applied in _as_list(spell.get('applyspell')):
if isinstance(applied, dict) and applied.get('@spell'):
out.append(applied['@spell'])
for area in _as_list(spell.get('spelleffectarea')):
if isinstance(area, dict) and area.get('@effect'):
out.append(area['@effect'])
return out
def _collect_debuffs(spell_index, name, depth=0, seen=None):
"""Negative armour/resistance effects reachable from ``name``."""
seen = seen if seen is not None else set()
if name in seen or depth > 3:
return []
seen.add(name)
found = []
spell = spell_index.get(name)
if spell:
for effect in _as_list(spell.get('buffovertime')):
if not isinstance(effect, dict):
continue
if effect.get('@type') not in ARMOR_TYPES:
continue
try:
value = float(effect.get('@value') or 0)
except ValueError:
continue
if value < 0:
found.append((name, effect))
for nxt in _spell_links(spell_index, name):
found += _collect_debuffs(spell_index, nxt, depth + 1, seen)
return found
def _flatten_effect(effect):
flat = {
'type': effect.get('@type'),
'value': float(effect.get('@value') or 0),
'time': float(effect.get('@time') or 0),
}
# Armour Piercer scales with how many targets the caster hit, so its
# magnitude must be read off the observed effect, never assumed.
bonus = effect.get('@targetcountvaluebonusfactor')
if bonus:
flat['targetcountvaluebonusfactor'] = float(bonus)
# SUNDERARMOR2 is weaker against players than mobs; pick per victim type.
target_type = effect.get('IfTargetType')
if isinstance(target_type, dict) and target_type.get('@type'):
flat['iftargettype'] = target_type['@type']
target = effect.get('@target')
if target:
flat['target'] = target
return flat
def gen_debuff_spells(cache_dir):
item_index = _index_items(_load(cache_dir, 'items.json')['items'])
spell_index = _index_spells(_load(cache_dir, 'spells.json')['spells'])
abilities = set()
for name in item_index:
for spell in _resolve_spells(item_index, name):
unique = spell.get('@uniquename')
if unique and not unique.startswith('PASSIVE'):
abilities.add(unique)
# effect spell -> abilities that produce it
producers = {}
for ability in abilities:
for effect_name, effect in _collect_debuffs(spell_index, ability):
producers.setdefault(effect_name, {}).setdefault(
ability, []).append(_flatten_effect(effect))
result = {}
for effect_name, by_ability in sorted(producers.items()):
spell = spell_index.get(effect_name, {})
result[effect_name] = {
'abilities': sorted(by_ability),
'category': spell.get('@category'),
'uitype': spell.get('@uitype'),
'maxstack': _maybe_int(spell.get('@maxstack')),
'maxcharges': _maybe_int(spell.get('@maxcharges')),
'effects': sorted(
{json.dumps(e, sort_keys=True): e
for group in by_ability.values() for e in group}.values(),
key=lambda e: (e['type'], e['value']),
),
}
out_path = os.path.join(STATIC_DIR, 'debuff_spells.json')
_write_json(out_path, result, sort_keys=True)
return out_path, len(result)
def _maybe_int(value):
if value in (None, ''):
return None
try:
return int(value)
except (TypeError, ValueError):
return None
# --------------------------------------------------------------------------
# progression.json
# --------------------------------------------------------------------------
def gen_progression(cache_dir):
"""Item-power progression constants for armour and damage.
Albion scales a character's stats from item power, so attacker strength is
a property of the equipped item and not of any observed hit. This keeps the
arithmetic correct as players level their gear.
"""
game = _load(cache_dir, 'gamedata.json')['AO-GameData']
source = game['Items']['ItemPowerProgression']
result = {'slots': {}, 'shares': {}}
for key, value in source.items():
if key in ('armorshare', 'ccrshare', 'hitpointsshare', 'energyshare',
'trackingtime'):
result['shares'][key] = value
elif isinstance(value, dict) and '@armorbase' in value:
result['slots'][key] = {
'armorbase': float(value['@armorbase']),
'armorprogression': float(value['@armorprogression']),
'attackdamageprogression': float(
value.get('@attackdamageprogression') or 0),
'hitpointsprogression': float(
value.get('@hitpointsprogression') or 0),
}
out_path = os.path.join(STATIC_DIR, 'progression.json')
_write_json(out_path, result, sort_keys=True)
return out_path, len(result['slots'])
# --------------------------------------------------------------------------
# mob_armor.json
# --------------------------------------------------------------------------
def gen_mob_armor(cache_dir):
mobs = _load(cache_dir, 'mobs.json')['Mobs']['Mob']
result = {}
for position, mob in enumerate(mobs):
template_id = position + MOB_TEMPLATE_OFFSET
result[str(template_id)] = {
'name': mob.get('@uniquename'),
'tier': _maybe_int(mob.get('@tier')),
'armor': _maybe_int(mob.get('@physicalarmor')),
'resistance': _maybe_int(mob.get('@magicresistance')),
'hitpointsmax': _maybe_int(mob.get('@hitpointsmax')),
'category': mob.get('@category'),
}
out_path = os.path.join(STATIC_DIR, 'mob_armor.json')
_write_json(out_path, result, sort_keys=True)
return out_path, len(result)
# --------------------------------------------------------------------------
# item_power.json
# --------------------------------------------------------------------------
def gen_item_power(cache_dir):
"""Item power per unique name, including enchantment variants.
A packet carries the enchanted variant as part of the item id
(``T5_MAIN_HOLYSTAFF_AVALON@1``), and item power scales with the
enchantment level, so both are needed.
"""
item_index = _index_items(_load(cache_dir, 'items.json')['items'])
result = {}
for name, entry in item_index.items():
base = _maybe_int(entry.get('@itempower'))
if base is not None:
result[name] = base
enchantments = entry.get('enchantments')
if not enchantments:
continue
for variant in _as_list(enchantments.get('enchantment')
if isinstance(enchantments, dict)
else enchantments):
if not isinstance(variant, dict):
continue
level = variant.get('@enchantmentlevel')
power = _maybe_int(variant.get('@itempower'))
if level is None or power is None:
continue
result['{}@{}'.format(name, level)] = power
out_path = os.path.join(STATIC_DIR, 'item_power.json')
_write_json(out_path, result, sort_keys=True)
return out_path, len(result)
# --------------------------------------------------------------------------
def _write_json(path, data, sort_keys=True):
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, 'w', encoding='utf-8') as handle:
json.dump(data, handle, indent=1, sort_keys=sort_keys)
handle.write('\n')
def _write_text(path, text):
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, 'w', encoding='utf-8') as handle:
handle.write(text)
GENERATORS = (
('item_ids.txt', gen_item_ids),
('item_spells.json', gen_item_spells),
('debuff_spells.json', gen_debuff_spells),
('progression.json', gen_progression),
('mob_armor.json', gen_mob_armor),
('item_power.json', gen_item_power),
)
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--cache', default=DEFAULT_CACHE)
parser.add_argument('--check', action='store_true',
help='regenerate into a temp dir and report drift '
'instead of overwriting the committed tables')
args = parser.parse_args(argv)
if not os.path.isdir(args.cache):
raise SystemExit(
'no game data at {}; run scripts/fetch_gamedata.py first'.format(
args.cache))
if args.check:
return _check(args.cache)
for label, generator in GENERATORS:
path, count = generator(args.cache)
print('{:24s} {:>7d} entries {}'.format(
label, count, os.path.relpath(path)))
return 0
def _check(cache_dir):
import tempfile
import shutil
global STATIC_DIR
original = STATIC_DIR
drifted = []
tmp = tempfile.mkdtemp(prefix='gamedata-check-')
try:
STATIC_DIR = tmp
for label, generator in GENERATORS:
generated, _ = generator(cache_dir)
committed = os.path.join(original, label)
if not os.path.exists(committed):
drifted.append('{}: missing from src/static'.format(label))
elif _read(generated) != _read(committed):
drifted.append('{}: committed copy is stale'.format(label))
finally:
STATIC_DIR = original
shutil.rmtree(tmp, ignore_errors=True)
if drifted:
print('game data is out of date:')
for line in drifted:
print(' - {}'.format(line))
print('\nrun: make gamedata')
return 1
print('game data tables are up to date')
return 0
def _read(path):
with open(path, encoding='utf-8') as handle:
return handle.read()
if __name__ == '__main__':
sys.exit(main())
+13 -1
View File
@@ -1,4 +1,16 @@
from .gui.app import run import sys
from .environment import replay_path, replay_headless
def run():
if replay_path() and replay_headless():
from .replay_cli import run_headless
sys.exit(run_headless())
from .gui.app import run as run_gui
run_gui()
if __name__ == '__main__': if __name__ == '__main__':
run() run()
+25
View File
@@ -43,9 +43,13 @@ INITIALIZATION_RESULT = {
NATIVE_BACKEND_AVAILABLE = platform_utils.is_linux() NATIVE_BACKEND_AVAILABLE = platform_utils.is_linux()
_capture = None _capture = None
_replay = None
def initialize(): def initialize():
if environment.replay_path():
return InitializationResult.Ok
if TEST_ENV_ENABLED: if TEST_ENV_ENABLED:
return InitializationResult.Ok return InitializationResult.Ok
@@ -68,6 +72,9 @@ def subscribe(callback):
_testing_call_sequence(callback) _testing_call_sequence(callback)
return True return True
if environment.replay_path():
return _start_replay_backend(callback)
if NATIVE_BACKEND_AVAILABLE: if NATIVE_BACKEND_AVAILABLE:
return _start_native_backend(callback) return _start_native_backend(callback)
@@ -98,6 +105,24 @@ def _start_native_backend(callback):
return True 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 _testing_call_sequence(callback):
def add_player(id, name, weapon, event_name='PlayerAppeared'): def add_player(id, name, weapon, event_name='PlayerAppeared'):
return [ return [
+1
View File
@@ -1,6 +1,7 @@
EvNameMainPlayerAppeared: str = 'MainPlayerAppeared' EvNameMainPlayerAppeared: str = 'MainPlayerAppeared'
EvNamePlayerAppeared: str = 'PlayerAppeared' EvNamePlayerAppeared: str = 'PlayerAppeared'
EvNameDamageDone: str = 'DamageDone' EvNameDamageDone: str = 'DamageDone'
EvNameDamageTaken: str = 'DamageTaken'
EvNameHealthReceived: str = 'HealthReceived' EvNameHealthReceived: str = 'HealthReceived'
EvNameZoneChange: str = 'ZoneChange' EvNameZoneChange: str = 'ZoneChange'
EvNameEnterCombat: str = 'EnterCombat' EvNameEnterCombat: str = 'EnterCombat'
+13 -1
View File
@@ -4,7 +4,7 @@ import threading
from datetime import datetime, timezone from datetime import datetime, timezone
from typing import Any, Dict, List 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 from . import items as itemdb
@@ -16,11 +16,23 @@ def enabled() -> bool:
return bool(discovery_log_path()) 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): def log(record_type: str, **fields):
path = discovery_log_path() path = discovery_log_path()
if not path: if not path:
return return
# Never clobber the log we are replaying from.
source = replay_path()
if source and _same_file(path, source):
return
global _initialized global _initialized
with _lock: with _lock:
log_dir = os.path.dirname(path) log_dir = os.path.dirname(path)
+9 -3
View File
@@ -135,10 +135,16 @@ def deserialize18(buf: bytes, pos: int, tc: int):
return rd_f64le(buf, pos) return rd_f64le(buf, pos)
if tc == P18['String']: if tc == P18['String']:
return read_string18(buf, pos) return read_string18(buf, pos)
if tc in (P18['Null'], P18['BooleanFalse'], P18['BooleanTrue'], if tc == P18['Null']:
P18['ShortZero'], P18['IntZero'], P18['LongZero'],
P18['FloatZero'], P18['DoubleZero']):
return None, pos 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']: if tc == P18['CompressedInt']:
v, p = rd_varint(buf, pos) v, p = rd_varint(buf, pos)
return zigzag(v), p return zigzag(v), p
+205 -8
View File
@@ -9,12 +9,15 @@ PHOTON_GAME_CODE = 1
# Current opcodes (albion-lens numbering, verified against captured traffic) # Current opcodes (albion-lens numbering, verified against captured traffic)
EVENT_LEAVE = 1 EVENT_LEAVE = 1
EVENT_HEALTH_UPDATE = 6 EVENT_HEALTH_UPDATE = 6
EVENT_BATCHED_HEALTH_UPDATE = 7
EVENT_EFFECT_STACK_UPDATE = 22
EVENT_NEW_CHARACTER = 29 EVENT_NEW_CHARACTER = 29
EVENT_ITEM_GAINED = 32 EVENT_ITEM_GAINED = 32
EVENT_TAKE_SILVER = 62
EVENT_UPDATE_FAME = 82 EVENT_UPDATE_FAME = 82
EVENT_CHARACTER_EQUIPMENT_CHANGED = 90 EVENT_CHARACTER_EQUIPMENT_CHANGED = 90
EVENT_REGENERATION_HEALTH_CHANGED = 91 EVENT_REGENERATION_HEALTH_CHANGED = 91
EVENT_SILVER_GAINED = 153 EVENT_MOB_SPAWNED = 123
EVENT_KNOCKED_DOWN = 166 EVENT_KNOCKED_DOWN = 166
EVENT_PARTY_INVITATION = 229 EVENT_PARTY_INVITATION = 229
EVENT_PARTY_JOIN_REQUEST = 230 EVENT_PARTY_JOIN_REQUEST = 230
@@ -75,6 +78,24 @@ def _as_int_list(value) -> List[int]:
return [] return []
def _as_byte_list(value) -> List[int]:
"""Unpack a Photon byte array into ints.
Batched health-update params arrive either as ``bytes`` or as a dict with a
``bytes_hex`` field (which is how the discovery log serialises them), and
occasionally as an already-decoded list. All three shapes occur for the
same parameter, so accept each of them.
"""
if isinstance(value, (bytes, bytearray)):
return list(value)
if isinstance(value, dict):
raw = value.get('bytes_hex')
if isinstance(raw, str):
return [int(raw[i:i + 2], 16) for i in range(0, len(raw) - 1, 2)]
return []
return _as_int_list(value)
@dataclass @dataclass
class GameMessage: class GameMessage:
name: str name: str
@@ -85,6 +106,17 @@ class GameMessage:
return self.params.get(key) return self.params.get(key)
@dataclass(frozen=True)
class EffectApplication:
"""One entry of a victim's active effect list.
``applier`` is the entity that put the effect on the target; the game
sends it explicitly rather than leaving it to be inferred.
"""
applier: int
effect_id: int
def into_game_message(message: PhotonMessage) -> Optional[GameMessage]: def into_game_message(message: PhotonMessage) -> Optional[GameMessage]:
if message.code != PHOTON_GAME_CODE: if message.code != PHOTON_GAME_CODE:
return None return None
@@ -113,12 +145,15 @@ def into_game_message(message: PhotonMessage) -> Optional[GameMessage]:
EVENT_NAMES = { EVENT_NAMES = {
EVENT_LEAVE: 'Leave', EVENT_LEAVE: 'Leave',
EVENT_HEALTH_UPDATE: 'HealthUpdate', EVENT_HEALTH_UPDATE: 'HealthUpdate',
EVENT_BATCHED_HEALTH_UPDATE: 'BatchedHealthUpdate',
EVENT_EFFECT_STACK_UPDATE: 'EffectStackUpdate',
EVENT_NEW_CHARACTER: 'NewCharacter', EVENT_NEW_CHARACTER: 'NewCharacter',
EVENT_ITEM_GAINED: 'ItemGained', EVENT_ITEM_GAINED: 'ItemGained',
EVENT_TAKE_SILVER: 'TakeSilver',
EVENT_UPDATE_FAME: 'UpdateFame', EVENT_UPDATE_FAME: 'UpdateFame',
EVENT_CHARACTER_EQUIPMENT_CHANGED: 'CharacterEquipmentChanged', EVENT_CHARACTER_EQUIPMENT_CHANGED: 'CharacterEquipmentChanged',
EVENT_REGENERATION_HEALTH_CHANGED: 'RegenerationHealthChanged', EVENT_REGENERATION_HEALTH_CHANGED: 'RegenerationHealthChanged',
EVENT_SILVER_GAINED: 'SilverGained', EVENT_MOB_SPAWNED: 'MobSpawned',
EVENT_KNOCKED_DOWN: 'KnockedDown', EVENT_KNOCKED_DOWN: 'KnockedDown',
EVENT_PARTY_INVITATION: 'PartyInvitation', EVENT_PARTY_INVITATION: 'PartyInvitation',
EVENT_PARTY_JOIN_REQUEST: 'PartyJoinRequest', EVENT_PARTY_JOIN_REQUEST: 'PartyJoinRequest',
@@ -137,7 +172,18 @@ OPERATION_NAMES = {
# Parameter accessors used by the world state machine. Field names follow # Parameter accessors used by the world state machine. Field names follow
# aoaddons' messages.json layouts, with the current opcode space from albion-lens. # aoaddons' messages.json layouts, with the current opcode space from albion-lens.
def msg_source(msg: GameMessage) -> int: #
# Naming note: the older messages.json labelled HealthUpdate params as
# ``source@0`` / ``target@6``, but the capture data shows the opposite of what
# those names suggest -- param 0 is the entity whose health changed (the victim)
# and param 6 is the entity that caused it (the attacker). The accessors below
# are named for what the wire actually carries.
def msg_subject_id(msg: GameMessage) -> int:
"""Param 0: the entity the event is about.
For most events that is simply the subject (the character that joined, left,
or changed equipment). For HealthUpdate it is the *victim*.
"""
v = _int(msg.params.get(0)) v = _int(msg.params.get(0))
return v if v is not None else 0 return v if v is not None else 0
@@ -156,16 +202,140 @@ def msg_map_index(msg: GameMessage) -> Optional[str]:
return _string(msg.params.get(8)) return _string(msg.params.get(8))
def msg_target(msg: GameMessage) -> int: def msg_attacker_id(msg: GameMessage) -> int:
"""Param 6: the entity responsible for a health change (attacker or healer)."""
v = _int(msg.params.get(6)) v = _int(msg.params.get(6))
return v if v is not None else 0 return v if v is not None else 0
def msg_value(msg: GameMessage) -> float: def msg_value(msg: GameMessage) -> float:
"""Param 2: the signed health delta. Negative is damage, positive is healing."""
v = _float(msg.params.get(2)) v = _float(msg.params.get(2))
return v if v is not None else 0.0 return v if v is not None else 0.0
def msg_health_after(msg: GameMessage) -> Optional[float]:
"""Param 3: the victim's health once the hit has been applied."""
return _float(msg.params.get(3))
def msg_hit_type(msg: GameMessage) -> Optional[int]:
"""Param 5: hit-type enum.
Observed values split into two groups. ``0`` and ``1`` accompany basic
attacks (median damage ~45) and always carry ``-1`` for param 7; ``2``, ``3``,
``5`` and ``6`` accompany ability hits (median ~164-242). The exact meaning
of each value is not yet known, so it is carried through untranslated.
"""
return _int(msg.params.get(5))
def msg_batched_victim_id(msg: GameMessage) -> int:
"""Param 0 of a batched health update: the entity every hit landed on."""
return msg_subject_id(msg)
def msg_batched_ticks(msg: GameMessage) -> List[int]:
"""Param 1: one tick counter per hit."""
return _as_int_list(msg.params.get(1))
def msg_batched_values(msg: GameMessage) -> List[float]:
"""Param 2: one signed health delta per hit."""
v = msg.params.get(2)
if not isinstance(v, list):
return []
out = []
for item in v:
f = _float(item)
if f is not None:
out.append(f)
return out
def msg_batched_health_after(msg: GameMessage) -> List[float]:
"""Param 3: one resulting-health value per hit."""
v = msg.params.get(3)
if not isinstance(v, list):
return []
out = []
for item in v:
f = _float(item)
if f is not None:
out.append(f)
return out
def msg_batched_hit_types(msg: GameMessage) -> List[int]:
"""Param 5: one hit-type enum per hit.
These arrive as a raw byte array rather than a decoded list, so they need
unpacking rather than the usual int coercion.
"""
return _as_byte_list(msg.params.get(5))
def msg_batched_attacker_ids(msg: GameMessage) -> List[int]:
"""Param 6: one attacker entity id per hit.
Also a raw byte array. Unlike param 2/3/5 the decoder sometimes produces a
plain list here instead, so both shapes are accepted.
"""
return _as_byte_list(msg.params.get(6))
def msg_effect_stack_appliers(msg: GameMessage) -> List[int]:
"""Param 1: the entity responsible for each effect on the victim.
Index-aligned with ``msg_effect_stack_ids``. The game sends the applier
outright, so attribution does not have to infer who applied a debuff from
the attacker's weapon -- which is what the original plan assumed.
"""
return _as_int_list(msg.params.get(1))
def msg_effect_stack_ids(msg: GameMessage) -> List[int]:
"""Param 2: one effect id per entry in the victim's active effect list.
These are runtime-assigned ids. They are stable for the life of a session
and usually unique to one (spell, caster) pair, but they are not the spell
ids used by the game data files, so they cannot be looked up statically.
"""
return _as_int_list(msg.params.get(2))
def msg_effect_stack_applications(msg: GameMessage) -> List[EffectApplication]:
"""Pair up the applier and effect id lists.
The two arrays are index-aligned and the same length on every observed
message. If a capture ever produced a ragged pair the mismatched tail is
dropped rather than guessed at.
"""
appliers = msg_effect_stack_appliers(msg)
effects = msg_effect_stack_ids(msg)
return [EffectApplication(applier, effect)
for applier, effect in zip(appliers, effects)]
def msg_mob_template_id(msg: GameMessage) -> Optional[int]:
"""Param 1: the numeric mob template this entity spawned from.
Template ids are the enumeration index of the mob table. They are a
different id space from item ids -- 454 is the Giant Snake as a mob but a
gathering skillbook as an item -- so this must never be resolved through
the item table.
"""
return _int(msg.params.get(1))
def msg_mob_hitpoints_max(msg: GameMessage) -> Optional[float]:
"""Param 13: the mob's maximum hit points at spawn.
Doubles as a cross-check on the template id: the two must agree.
"""
return _float(msg.params.get(13))
def msg_items(msg: GameMessage) -> List[int]: def msg_items(msg: GameMessage) -> List[int]:
return _as_int_list(msg.params.get(2)) return _as_int_list(msg.params.get(2))
@@ -191,6 +361,22 @@ def msg_fame_gained(msg: GameMessage) -> Optional[int]:
return _int(msg.params.get(2)) 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]: def msg_collected_item_id(msg: GameMessage) -> Optional[int]:
return _int(msg.params.get(1)) return _int(msg.params.get(1))
@@ -203,12 +389,23 @@ def msg_collected_item_value(msg: GameMessage) -> Optional[int]:
return _int(msg.params.get(4)) return _int(msg.params.get(4))
def msg_silver_source_type(msg: GameMessage) -> Optional[int]: def msg_silver_yield_pre_tax(msg: GameMessage) -> Optional[int]:
return _int(msg.params.get(1)) return _int(msg.params.get(3))
def msg_silver_amount(msg: GameMessage) -> Optional[int]: def msg_silver_cluster_tax(msg: GameMessage) -> int:
return _int(msg.params.get(2)) 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]]: def msg_party_structures(msg: GameMessage) -> List[List[int]]:
+106 -35
View File
@@ -9,7 +9,6 @@ from .translate import GameMessage
FIX_POINT = 10000.0 FIX_POINT = 10000.0
FAME_MIN_TOTAL = 1000000 # albion-lens sanity filter for UpdateFame events FAME_MIN_TOTAL = 1000000 # albion-lens sanity filter for UpdateFame events
SILVER_SOURCE_LOOTED = 54
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@@ -172,6 +171,8 @@ class World:
return self._on_leave(message) return self._on_leave(message)
if message.name == 'HealthUpdate': if message.name == 'HealthUpdate':
return self._on_health_update(message) return self._on_health_update(message)
if message.name == 'BatchedHealthUpdate':
return self._on_batched_health_update(message)
if message.name == 'RegenerationHealthChanged': if message.name == 'RegenerationHealthChanged':
return self._on_regeneration(message) return self._on_regeneration(message)
if message.name == 'KnockedDown': if message.name == 'KnockedDown':
@@ -180,8 +181,8 @@ class World:
return self._on_update_fame(message) return self._on_update_fame(message)
if message.name == 'ItemGained': if message.name == 'ItemGained':
return self._on_item_gained(message) return self._on_item_gained(message)
if message.name == 'SilverGained': if message.name == 'TakeSilver':
return self._on_silver_gained(message) return self._on_take_silver(message)
if message.name == 'CharacterEquipmentChanged': if message.name == 'CharacterEquipmentChanged':
return self._on_character_equipment_changed(message) return self._on_character_equipment_changed(message)
if message.name == 'PartyJoined': if message.name == 'PartyJoined':
@@ -207,7 +208,7 @@ class World:
def _on_new_character(self, msg: GameMessage) -> List[dict]: def _on_new_character(self, msg: GameMessage) -> List[dict]:
name = translate.msg_new_character_name(msg) name = translate.msg_new_character_name(msg)
dynamic_id = _dyn(translate.msg_source(msg)) dynamic_id = _dyn(translate.msg_subject_id(msg))
if not name: if not name:
return [] return []
self.cache.save(dynamic_id, name) self.cache.save(dynamic_id, name)
@@ -232,7 +233,7 @@ class World:
def _on_join(self, msg: GameMessage) -> List[dict]: def _on_join(self, msg: GameMessage) -> List[dict]:
name = translate.msg_character_name(msg) name = translate.msg_character_name(msg)
dynamic_id = _dyn(translate.msg_source(msg)) dynamic_id = _dyn(translate.msg_subject_id(msg))
if not name: if not name:
return [] return []
self.cache.save(dynamic_id, name) self.cache.save(dynamic_id, name)
@@ -266,7 +267,7 @@ class World:
return [{'name': 'ZoneChange'}] return [{'name': 'ZoneChange'}]
def _on_leave(self, msg: GameMessage) -> List[dict]: def _on_leave(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg)) dynamic_id = _dyn(translate.msg_subject_id(msg))
static_id = self.cache.get_static_id(dynamic_id) static_id = self.cache.get_static_id(dynamic_id)
if static_id is None: if static_id is None:
return [] return []
@@ -279,27 +280,85 @@ class World:
return [] return []
def _on_health_update(self, msg: GameMessage) -> List[dict]: def _on_health_update(self, msg: GameMessage) -> List[dict]:
# params: [0]=target (entity whose health changed), [2]=signed delta, # Params: [0]=victim (entity whose health changed), [2]=signed delta,
# [6]=source (attacker/healer). aoaddons emits Damage{source: params[6], # [3]=victim health after the hit, [5]=hit type, [6]=attacker/healer.
# target: params[0]} which the app attributes to the dealer/healer.
value = translate.msg_value(msg) value = translate.msg_value(msg)
if value == 0.0: if value == 0.0:
return [] return []
actor_id = _dyn(translate.msg_target(msg)) # param 6 victim_id = _dyn(translate.msg_subject_id(msg))
victim_id = _dyn(translate.msg_source(msg)) # param 0 attacker_id = _dyn(translate.msg_attacker_id(msg))
actor_static = self.cache.get_static_id(actor_id) hit_type = translate.msg_hit_type(msg)
if actor_static is None: health_after = translate.msg_health_after(msg)
return self._health_events(
attacker_id=attacker_id,
victim_id=victim_id,
value=value,
hit_type=hit_type,
health_after=health_after)
def _on_batched_health_update(self, msg: GameMessage) -> List[dict]:
# Batched form of HealthUpdate: one victim, several hits delivered in a
# single packet, with parallel arrays indexed per hit. Verified against
# captures to be additional damage rather than a repeat of the scalar
# form -- see PLAN.md F2.
values = translate.msg_batched_values(msg)
if not values:
return [] return []
event_name = 'DamageDone' if value < 0.0 else 'HealthReceived' victim_id = _dyn(translate.msg_batched_victim_id(msg))
return [{ health_after = translate.msg_batched_health_after(msg)
'name': event_name, hit_types = translate.msg_batched_hit_types(msg)
'value': {'source': actor_static, attackers = translate.msg_batched_attacker_ids(msg)
'target': self.cache.get_static_id(victim_id),
'value': float(abs(value))}, events: List[dict] = []
}] for index, value in enumerate(values):
if value == 0.0:
continue
attacker = attackers[index] if index < len(attackers) else None
hit_type = hit_types[index] if index < len(hit_types) else None
after = health_after[index] if index < len(health_after) else None
events.extend(self._health_events(
attacker_id=_dyn(attacker) if attacker is not None else None,
victim_id=victim_id,
value=value,
hit_type=hit_type,
health_after=after))
return events
def _health_events(self, attacker_id: Optional[int], victim_id: int,
value: float, hit_type: Optional[int],
health_after: Optional[float]) -> List[dict]:
"""Build the damage/heal events for a single health change.
``DamageDone`` and ``DamageTaken`` are emitted independently so a hit
from an unknown attacker (a mob, say) still registers against a tracked
victim, and a hit on an untracked victim still registers for a tracked
attacker.
"""
attacker_static = (self.cache.get_static_id(attacker_id)
if attacker_id is not None else None)
victim_static = self.cache.get_static_id(victim_id)
events = []
if attacker_static is not None:
payload = {'source': attacker_static,
'target': victim_static,
'value': float(abs(value)),
'hit_type': hit_type,
'health_after': health_after}
events.append({
'name': 'DamageDone' if value < 0.0 else 'HealthReceived',
'value': payload,
})
if value < 0.0 and victim_static is not None:
events.append({
'name': 'DamageTaken',
'value': {'source': victim_static,
'value': float(abs(value)),
'hit_type': hit_type},
})
return events
def _on_regeneration(self, msg: GameMessage) -> List[dict]: def _on_regeneration(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg)) dynamic_id = _dyn(translate.msg_subject_id(msg))
static_id = self.cache.get_static_id(dynamic_id) static_id = self.cache.get_static_id(dynamic_id)
if static_id is None: if static_id is None:
return [] return []
@@ -311,7 +370,7 @@ class World:
return [{'name': event_name, 'value': {'id': static_id, 'name': name}}] return [{'name': event_name, 'value': {'id': static_id, 'name': name}}]
def _on_knocked_down(self, msg: GameMessage) -> List[dict]: def _on_knocked_down(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg)) dynamic_id = _dyn(translate.msg_subject_id(msg))
static_id = self.cache.get_static_id(dynamic_id) static_id = self.cache.get_static_id(dynamic_id)
if static_id is None: if static_id is None:
return [] return []
@@ -321,7 +380,7 @@ class World:
return [{'name': 'LeaveCombat', 'value': {'id': static_id, 'name': name}}] return [{'name': 'LeaveCombat', 'value': {'id': static_id, 'name': name}}]
def _on_update_fame(self, msg: GameMessage) -> List[dict]: def _on_update_fame(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg)) dynamic_id = _dyn(translate.msg_subject_id(msg))
static_id = self.cache.get_static_id(dynamic_id) static_id = self.cache.get_static_id(dynamic_id)
if static_id is None: if static_id is None:
return [] return []
@@ -339,12 +398,19 @@ class World:
gained = total - prev gained = total - prev
if gained <= 0: if gained <= 0:
return [] 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]: def _on_item_gained(self, msg: GameMessage) -> List[dict]:
if not self._main_player_joined: if not self._main_player_joined:
return [] return []
source_id = _dyn(translate.msg_source(msg)) source_id = _dyn(translate.msg_subject_id(msg))
item_id = translate.msg_collected_item_id(msg) item_id = translate.msg_collected_item_id(msg)
quantity = translate.msg_collected_item_quantity(msg) quantity = translate.msg_collected_item_quantity(msg)
if item_id is None or quantity is None or quantity <= 0: if item_id is None or quantity is None or quantity <= 0:
@@ -364,24 +430,29 @@ class World:
value['estimated_value'] = estimated_value value['estimated_value'] = estimated_value
return [{'name': 'ItemCollected', 'value': 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: if not self._main_player_joined:
return [] return []
amount = translate.msg_silver_amount(msg) dynamic_id = _dyn(translate.msg_subject_id(msg))
source_type = translate.msg_silver_source_type(msg) static_id = self.cache.get_static_id(dynamic_id)
if amount is None or amount <= 0: if static_id is None or static_id != self.main_player_id:
return [] return []
if source_type == SILVER_SOURCE_LOOTED: yield_pre_tax = translate.msg_silver_yield_pre_tax(msg)
silver_type = 'looted' if yield_pre_tax is None or yield_pre_tax <= 0:
else: 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 []
return [{'name': 'SilverGained', 'value': { return [{'name': 'SilverGained', 'value': {
'value': float(amount), 'value': float(gained / FIX_POINT),
'silver_type': silver_type, 'silver_type': 'looted',
}}] }}]
def _on_character_equipment_changed(self, msg: GameMessage) -> List[dict]: def _on_character_equipment_changed(self, msg: GameMessage) -> List[dict]:
dynamic_id = _dyn(translate.msg_source(msg)) dynamic_id = _dyn(translate.msg_subject_id(msg))
static_id = self.cache.get_static_id(dynamic_id) static_id = self.cache.get_static_id(dynamic_id)
if static_id is None: if static_id is None:
self.unconsumed_messages.add(dynamic_id, msg) self.unconsumed_messages.add(dynamic_id, msg)
+10
View File
@@ -36,6 +36,7 @@ class StatType:
@dataclass(frozen=True) @dataclass(frozen=True)
class CombatStatType: class CombatStatType:
Damage: str = 'Damage' Damage: str = 'Damage'
DamageTaken: str = 'DamageTaken'
Healing: str = 'Healing' Healing: str = 'Healing'
@@ -104,6 +105,14 @@ class GameStats():
elif stat_type == VisibilityType.Overall: elif stat_type == VisibilityType.Overall:
return self.history[StatType.Combat].combined(self.zone[StatType.Combat]).players_damage() 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): def get_healing_stats(self, stat_type):
if stat_type == VisibilityType.Zone: if stat_type == VisibilityType.Zone:
return self.zone[StatType.Combat].players_healing() return self.zone[StatType.Combat].players_healing()
@@ -236,6 +245,7 @@ def get_stats(stat_type: str, combat_stat_type: str):
cached_players = { cached_players = {
CombatStatType.Damage: lambda stat_type: game_stats.get_damage_stats(stat_type), 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( CombatStatType.Healing: lambda stat_type: game_stats.get_healing_stats(
stat_type) stat_type)
}[combat_stat_type](stat_type) }[combat_stat_type](stat_type)
+48
View File
@@ -35,6 +35,35 @@ REMEMBER_LAST_PARTY = bool(
'--remember-last-party' in sys.argv '--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 _fault_file = None
@@ -50,6 +79,18 @@ def remember_last_party():
return 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]: def app_log_path() -> Optional[str]:
if not DISCOVERY_LOG_PATH: if not DISCOVERY_LOG_PATH:
return None return None
@@ -73,6 +114,13 @@ def qt_args(argv: List[str]) -> List[str]:
continue continue
if arg == '--remember-last-party': if arg == '--remember-last-party':
continue 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) result.append(arg)
return result return result
+7
View File
@@ -76,6 +76,9 @@ class CombatEventReceiver(EventReceiver):
elif event_name == consts.EvNameDamageDone: elif event_name == consts.EvNameDamageDone:
self.on_damage_done( self.on_damage_done(
value[consts.EvKeySource], value[consts.EvKeyValue]) 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: elif event_name == consts.EvNameHealthReceived:
self.on_health_received( self.on_health_received(
value[consts.EvKeySource], value[consts.EvKeyTarget], value[consts.EvKeyValue]) 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): def on_damage_done(self, id: int, damage: float):
pass pass
@abc.abstractmethod
def on_damage_taken(self, id: int, damage: float):
pass
@abc.abstractmethod @abc.abstractmethod
def on_health_received(self, id: int, target_id: int, health: float): def on_health_received(self, id: int, target_id: int, health: float):
pass pass
+9 -4
View File
@@ -19,7 +19,7 @@ from PySide6.QtWidgets import QPushButton # type: ignore
from ..engine import InitializationResult from ..engine import InitializationResult
from ..engine import initialize from ..engine import initialize
from ..utils.config import config 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 .modules.main import MainWidget
from .styling import style from .styling import style
@@ -82,6 +82,8 @@ def run():
logger.debug("python: %s (%s)", sys.executable, sys.version) logger.debug("python: %s (%s)", sys.executable, sys.version)
logger.debug("platform: %s", platform_utils.system()) logger.debug("platform: %s", platform_utils.system())
replaying = bool(replay_path())
conf = config() conf = config()
window_config = conf['window'] window_config = conf['window']
@@ -93,7 +95,7 @@ def run():
_install_heartbeat(app) _install_heartbeat(app)
perms_ok = True perms_ok = True
if platform_utils.is_linux(): if platform_utils.is_linux() and not replaying:
perms_ok = capture_permissions_ok() perms_ok = capture_permissions_ok()
logger.debug("capture permissions probe: %s", perms_ok) logger.debug("capture permissions probe: %s", perms_ok)
@@ -107,7 +109,10 @@ def run():
widget = MainWidget(clipboard) widget = MainWidget(clipboard)
widget.setWindowOpacity(window_config['opacity']) 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'))) widget.setWindowIcon(QtGui.QIcon(path('albion-stats-icon.png')))
if window_config['always_on_top']: if window_config['always_on_top']:
@@ -134,7 +139,7 @@ def run():
msg.setStandardButtons(QMessageBox.Ok) msg.setStandardButtons(QMessageBox.Ok)
msg.show() msg.show()
need_capture_fix = ( need_capture_fix = not replaying and (
initialization_result != InitializationResult.Ok initialization_result != InitializationResult.Ok
or (platform_utils.is_linux() and not perms_ok) or (platform_utils.is_linux() and not perms_ok)
) )
+27
View File
@@ -27,6 +27,7 @@ from .views.list_view import ListItemView
class Page: class Page:
Overview = 'overview' Overview = 'overview'
Damage = 'damage' Damage = 'damage'
DamageTaken = 'damage_taken'
Healing = 'healing' Healing = 'healing'
Economy = 'economy' Economy = 'economy'
Items = 'items' Items = 'items'
@@ -36,6 +37,7 @@ class Page:
PAGE_LABELS = { PAGE_LABELS = {
Page.Overview: ('O', 'Overview'), Page.Overview: ('O', 'Overview'),
Page.Damage: ('D', 'Damage Done'), Page.Damage: ('D', 'Damage Done'),
Page.DamageTaken: ('T', 'Damage Taken'),
Page.Healing: ('H', 'Healing Done'), Page.Healing: ('H', 'Healing Done'),
Page.Economy: ('$', 'Economy'), Page.Economy: ('$', 'Economy'),
Page.Items: ('I', 'Items Collected'), 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_label)
self.main_layout.addWidget(self.total_healing_list, 1) 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 = QLabel('')
self.placeholder.setObjectName('MutedText') self.placeholder.setObjectName('MutedText')
self.placeholder.setWordWrap(True) self.placeholder.setWordWrap(True)
@@ -372,6 +381,7 @@ class MainWidget(QWidget):
stat_kind = { stat_kind = {
Page.Overview: engine.CombatStatType.Damage, Page.Overview: engine.CombatStatType.Damage,
Page.Damage: engine.CombatStatType.Damage, Page.Damage: engine.CombatStatType.Damage,
Page.DamageTaken: engine.CombatStatType.DamageTaken,
Page.Healing: engine.CombatStatType.Healing, Page.Healing: engine.CombatStatType.Healing,
Page.Economy: engine.CombatStatType.Damage, Page.Economy: engine.CombatStatType.Damage,
Page.Items: engine.CombatStatType.Damage, Page.Items: engine.CombatStatType.Damage,
@@ -419,6 +429,8 @@ class MainWidget(QWidget):
_set_visible(self.primary_label, False) _set_visible(self.primary_label, False)
_set_visible(self.total_healing_label, False) _set_visible(self.total_healing_label, False)
_set_visible(self.total_healing_list, 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.placeholder, False)
_set_visible(self.settings_panel, False) _set_visible(self.settings_panel, False)
@@ -440,6 +452,16 @@ class MainWidget(QWidget):
_set_visible(self.primary_list, True) _set_visible(self.primary_list, True)
return 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: if self.current_page == Page.Healing:
_set_text(self.page_title, 'Healing Done') _set_text(self.page_title, 'Healing Done')
_set_text(self.page_description, _set_text(self.page_description,
@@ -477,6 +499,11 @@ class MainWidget(QWidget):
def _update_page_data(self, players, total_healing, silver, items): def _update_page_data(self, players, total_healing, silver, items):
if self.current_page in (Page.Overview, Page.Damage): if self.current_page in (Page.Overview, Page.Damage):
self.primary_list.update(players) 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: elif self.current_page == Page.Healing:
self.primary_list.update(players) self.primary_list.update(players)
self.total_healing_list.update(total_healing) self.total_healing_list.update(total_healing)
+9 -5
View File
@@ -7,8 +7,9 @@ from .....stats.list_item import PlayerListItem
class ListItemView(QLabel): class ListItemView(QLabel):
def __init__(self): def __init__(self, show_per_second: bool = True):
QLabel.__init__(self) QLabel.__init__(self)
self._show_per_second = show_per_second
self._last_signature = None self._last_signature = None
self._players: List[PlayerListItem] = [] self._players: List[PlayerListItem] = []
self.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft) self.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft)
@@ -26,7 +27,7 @@ class ListItemView(QLabel):
if not sorted_players: if not sorted_players:
self.setText('No entries yet.') self.setText('No entries yet.')
return 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]: def get_player_list_items(self) -> List[PlayerListItem]:
return list(self._players) return list(self._players)
@@ -42,6 +43,9 @@ def _player_signature(player: PlayerListItem):
) )
def _player_line(player: PlayerListItem): def _player_line(player: PlayerListItem, show_per_second: bool = True):
return "{} {} ({}, {}%)".format( if show_per_second:
player.name, player.value, player.value_per_second, player.percentage) return "{} {} ({}, {}%)".format(
player.name, player.value, player.value_per_second, player.percentage)
return "{} {} ({}%)".format(
player.name, player.value, player.percentage)
+139
View File
@@ -0,0 +1,139 @@
import json
import logging
import os
import re
import threading
from datetime import datetime
from typing import Callable, Iterator, List, Optional, Tuple
from .. import environment
logger = logging.getLogger(__name__)
_RAW_PAYLOAD_RE = re.compile(r'Raw payload:\s*\[([0-9,\s]*)\]')
def _record_timestamp(record: dict) -> Optional[float]:
raw = record.get('timestamp')
if not raw:
return None
try:
return datetime.fromisoformat(raw).timestamp()
except ValueError:
return None
def _json_payload(record: dict) -> Optional[bytes]:
if record.get('type') != 'udp_payload':
return None
payload_hex = record.get('payload_hex')
if not payload_hex:
return None
return bytes.fromhex(payload_hex)
def _raw_payload(line: str) -> Optional[bytes]:
match = _RAW_PAYLOAD_RE.search(line)
if not match:
return None
parts = [part.strip() for part in match.group(1).split(',')]
numbers = [int(part) for part in parts if part]
if not numbers:
return None
return bytes(numbers)
def iter_records(path: str) -> Iterator[Tuple[bytes, Optional[float]]]:
"""Yield ``(payload, timestamp)`` for every captured packet in ``path``.
Supports both the discovery JSONL format (records of ``type``
``udp_payload`` with a ``payload_hex`` field) and the legacy aoaddons
``Raw payload: [...]`` text format. All other record types are ignored.
"""
with open(path, encoding='utf-8', errors='replace') as log:
for line in log:
line = line.strip()
if not line:
continue
if line.startswith('{'):
try:
record = json.loads(line)
except json.JSONDecodeError:
record = None
if isinstance(record, dict):
payload = _json_payload(record)
if payload is not None:
yield payload, _record_timestamp(record)
continue
payload = _raw_payload(line)
if payload is not None:
yield payload, None
def load_payloads(path: str) -> List[bytes]:
"""Return every captured UDP payload from ``path`` in order."""
return [payload for payload, _ in iter_records(path)]
class ReplayEngine:
"""Feeds previously captured UDP payloads into a decode callback.
Mirrors :class:`src.net.capture.CaptureEngine` so the rest of the app can
treat a replayed log exactly like live traffic.
"""
def __init__(self, on_udp: Callable[[bytes], None],
path: Optional[str] = None,
speed: Optional[float] = None):
self._on_udp = on_udp
self._path = path if path is not None else environment.replay_path()
self._speed = speed if speed is not None else environment.replay_speed()
self._stop = threading.Event()
self._thread: Optional[threading.Thread] = None
self.packet_count = 0
def start(self) -> bool:
if self._thread is not None:
return True
if not self._path:
logger.error("replay requested but no log path was given")
return False
if not os.path.isfile(self._path):
logger.error("replay log does not exist: %s", self._path)
return False
self._thread = threading.Thread(
target=self._run, name='aostats-replay', daemon=True)
self._thread.start()
return True
def stop(self):
self._stop.set()
def wait(self, timeout: Optional[float] = None):
if self._thread is not None:
self._thread.join(timeout)
def _run(self):
logger.info("replaying %s (speed=%s)", self._path, self._speed)
previous: Optional[float] = None
try:
for payload, timestamp in iter_records(self._path):
if self._stop.is_set():
return
if self._speed and self._speed > 0 \
and timestamp is not None and previous is not None:
delay = (timestamp - previous) / self._speed
if delay > 0 and self._stop.wait(delay):
return
if timestamp is not None:
previous = timestamp
try:
self._on_udp(payload)
except Exception:
logger.exception("error replaying payload")
self.packet_count += 1
except OSError:
logger.exception("unable to read replay log: %s", self._path)
return
logger.info("replay finished: %d packets", self.packet_count)
+135
View File
@@ -0,0 +1,135 @@
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 _player_names(events: List[dict]) -> dict:
"""Map static player ids to names using the appearance events."""
names = {}
for event in events:
name = event[consts.EvKeyName]
if name in (consts.EvNamePlayerAppeared, consts.EvNameMainPlayerAppeared):
value = _event_value(event)
if value.get('id') is not None and value.get('name'):
names[value['id']] = value['name']
return names
def _damage_by_player(events: List[dict], names: dict, event_name: str):
"""Total damage per player, most first.
Reporting only a combined figure is misleading: the summary sits next to
"main player: <name>", so a party-wide total reads as if it belonged to
that one player.
"""
totals = Counter()
for event in events:
if event[consts.EvKeyName] != event_name:
continue
totals[_event_value(event).get(consts.EvKeySource, 0)] += \
_event_value(event).get('value', 0.0)
return totals, names
def _format_player_lines(totals, names: dict, limit: int = 8) -> List[str]:
if not totals:
return [' (none)']
ordered = sorted(totals.items(), key=lambda item: item[1], reverse=True)
lines = []
for player_id, total in ordered[:limit]:
label = names.get(player_id, f'player #{player_id}')
lines.append(f' {label}: {_fmt(total)}')
if len(ordered) > limit:
lines.append(f' ... and {len(ordered) - limit} more')
return lines
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
names = _player_names(events)
damage_by_player, _ = _damage_by_player(
events, names, consts.EvNameDamageDone)
damage_taken_by_player, _ = _damage_by_player(
events, names, consts.EvNameDamageTaken)
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)} (all players)')
lines.append(f' damage taken: {_fmt(damage_taken)} (all players)')
lines.append(' damage done by player:')
lines.extend(_format_player_lines(damage_by_player, names))
lines.append(' damage taken by player:')
lines.extend(_format_player_lines(damage_taken_by_player, names))
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
+372
View File
@@ -0,0 +1,372 @@
{
"ACID_BOMB_EFFECT": {
"abilities": [
"ACID_BOMB"
],
"category": "instant",
"effects": [
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 3.5,
"type": "magicresistance",
"value": -0.14
},
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 3.5,
"type": "physicalarmor",
"value": -0.14
}
],
"maxcharges": null,
"maxstack": null,
"uitype": "damage"
},
"ARMORPIERCER_DEBUFF_EFFECT": {
"abilities": [
"ARMORPIERCER"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 4.0,
"type": "magicresistance",
"value": -0.17
},
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 4.0,
"type": "physicalarmor",
"value": -0.17
}
],
"maxcharges": null,
"maxstack": null,
"uitype": "debuff"
},
"AXESMASH_EFFECT": {
"abilities": [
"AXESMASH"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"time": 8.0,
"type": "magicresistance",
"value": -0.16
},
{
"target": "enemy",
"time": 8.0,
"type": "physicalarmor",
"value": -0.16
}
],
"maxcharges": null,
"maxstack": null,
"uitype": "debuff"
},
"BEARTRAP_HIDEMOB_BONUS": {
"abilities": [
"BEARTRAP"
],
"category": "crowdcontrol",
"effects": [
{
"target": "enemy",
"time": 8.0,
"type": "magicresistance",
"value": -0.55
},
{
"target": "enemy",
"time": 8.0,
"type": "physicalarmor",
"value": -0.55
}
],
"maxcharges": null,
"maxstack": 3,
"uitype": "crowdcontrol"
},
"CURSEULTIMATE_EFFECT": {
"abilities": [
"CURSEULTIMATE"
],
"category": "damage",
"effects": [
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 6.0,
"type": "magicresistance",
"value": -0.18
},
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 6.0,
"type": "physicalarmor",
"value": -0.18
}
],
"maxcharges": null,
"maxstack": 1,
"uitype": "damage"
},
"DEADLYSHOT_DEBUFF": {
"abilities": [
"DEADLYSHOT"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 5.0,
"type": "magicresistance",
"value": -0.03
},
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 5.0,
"type": "physicalarmor",
"value": -0.03
}
],
"maxcharges": 3,
"maxstack": 5,
"uitype": "debuff"
},
"FROST_LANCE_EFFECT": {
"abilities": [
"FROST_LANCE"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 3.0,
"type": "magicresistance",
"value": -0.12
},
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 3.0,
"type": "physicalarmor",
"value": -0.12
}
],
"maxcharges": 1,
"maxstack": 1,
"uitype": "damage"
},
"IRONBREAKER_EFFECT": {
"abilities": [
"IRONBREAKER"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 4.0,
"type": "magicresistance",
"value": -0.12
},
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 4.0,
"type": "physicalarmor",
"value": -0.12
}
],
"maxcharges": null,
"maxstack": null,
"uitype": "debuff"
},
"SHAPE_Q_CONE_PIERCE": {
"abilities": [
"SHAPE_Q_CONE_MELEE"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"time": 6.0,
"type": "magicresistance",
"value": -0.02
},
{
"target": "enemy",
"time": 6.0,
"type": "physicalarmor",
"value": -0.02
}
],
"maxcharges": 3,
"maxstack": null,
"uitype": "damage"
},
"SMELLOFBLOOD_DEBUFF": {
"abilities": [
"SMELLOFBLOOD"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"time": 4.0,
"type": "magicresistance",
"value": -0.35
},
{
"target": "enemy",
"time": 4.0,
"type": "physicalarmor",
"value": -0.35
}
],
"maxcharges": null,
"maxstack": null,
"uitype": "debuff"
},
"SNIPESHOT_CROSSBOW_DEBUFF": {
"abilities": [
"SNIPESHOT_CROSSBOW"
],
"category": "damage",
"effects": [
{
"target": "enemy",
"time": 4.0,
"type": "magicresistance",
"value": -0.15
},
{
"target": "enemy",
"time": 4.0,
"type": "physicalarmor",
"value": -0.15
}
],
"maxcharges": null,
"maxstack": null,
"uitype": "debuff"
},
"SUNDERARMOR2": {
"abilities": [
"SUNDERARMOR2"
],
"category": "debuff",
"effects": [
{
"iftargettype": "mob",
"target": "enemy",
"time": 8.0,
"type": "magicresistance",
"value": -0.06
},
{
"iftargettype": "player",
"target": "enemy",
"time": 8.0,
"type": "magicresistance",
"value": -0.04
},
{
"iftargettype": "mob",
"target": "enemy",
"time": 8.0,
"type": "physicalarmor",
"value": -0.06
},
{
"iftargettype": "player",
"target": "enemy",
"time": 8.0,
"type": "physicalarmor",
"value": -0.04
}
],
"maxcharges": 3,
"maxstack": 3,
"uitype": "debuff"
},
"SUNDERSHOT_DEBUFF": {
"abilities": [
"SUNDERSHOT"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"time": 4.0,
"type": "magicresistance",
"value": -0.027
},
{
"target": "enemy",
"time": 4.0,
"type": "physicalarmor",
"value": -0.027
}
],
"maxcharges": 10,
"maxstack": null,
"uitype": "debuff"
},
"TAINTED_STEEL_AREA": {
"abilities": [
"TAINTED_STEEL"
],
"category": "instant",
"effects": [
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 4.0,
"type": "magicresistance",
"value": -0.04
}
],
"maxcharges": null,
"maxstack": 1,
"uitype": "damage"
},
"TAINTED_STEEL_EFFECT": {
"abilities": [
"TAINTED_STEEL"
],
"category": "debuff",
"effects": [
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 4.0,
"type": "magicresistance",
"value": -0.12
},
{
"target": "enemy",
"targetcountvaluebonusfactor": 0.08,
"time": 4.0,
"type": "physicalarmor",
"value": -0.12
}
],
"maxcharges": null,
"maxstack": null,
"uitype": "damage"
}
}
+12237 -7493
View File
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+195
View File
@@ -0,0 +1,195 @@
{
"shares": {
"armorshare": {
"@armor": "1.0",
"@avalonshield": "0",
"@book": "0",
"@cane": "0",
"@cape": "0",
"@censer": "0",
"@crystalbook": "0",
"@crystalshield": "0",
"@crystaltorch": "0",
"@demonskull": "0",
"@head": "0",
"@horn": "0",
"@lamp": "0",
"@mainhand": "0",
"@orb": "0",
"@prototype": "0",
"@shield": "0",
"@shoes": "0",
"@skullshield": "0",
"@spikedshield": "0",
"@talisman": "0",
"@torch": "0",
"@totem": "0",
"@towershield": "0",
"@transformation": "1.0"
},
"ccrshare": {
"@armor": "1.0",
"@avalonshield": "0",
"@book": "0",
"@cane": "0",
"@cape": "0",
"@censer": "0",
"@crystalbook": "0",
"@crystalshield": "0",
"@crystaltorch": "-1.2",
"@demonskull": "0",
"@head": "0",
"@horn": "0",
"@lamp": "0",
"@mainhand": "0",
"@orb": "0",
"@prototype": "0",
"@shield": "0.60",
"@shoes": "0",
"@skullshield": "0",
"@spikedshield": "0",
"@talisman": "1.8",
"@torch": "0",
"@totem": "0",
"@towershield": "0",
"@transformation": "1.0"
},
"energyshare": {
"@armor": "0.25",
"@avalonshield": "0",
"@book": "0.15",
"@cane": "0",
"@cape": "0.10",
"@censer": "0",
"@crystalbook": "0",
"@crystalshield": "0.125",
"@crystaltorch": "0",
"@demonskull": "0",
"@head": "0.5",
"@horn": "0",
"@lamp": "0",
"@mainhand": "0",
"@orb": "0.5",
"@prototype": "0",
"@shield": "0",
"@shoes": "0.15",
"@skullshield": "0",
"@spikedshield": "0",
"@talisman": "0",
"@torch": "0",
"@totem": "0",
"@towershield": "0",
"@transformation": "1.0"
},
"hitpointsshare": {
"@armor": "0.5",
"@avalonshield": "0",
"@book": "0",
"@cane": "0",
"@cape": "0",
"@censer": "0",
"@crystalbook": "0",
"@crystalshield": "0",
"@crystaltorch": "0",
"@demonskull": "0",
"@head": "0.25",
"@horn": "0",
"@lamp": "0",
"@mainhand": "0",
"@orb": "0",
"@prototype": "0.125",
"@shield": "0",
"@shoes": "0.25",
"@skullshield": "0",
"@spikedshield": "0",
"@talisman": "0",
"@torch": "0",
"@totem": "0.25",
"@towershield": "0",
"@transformation": "1.0"
},
"trackingtime": {
"@base": "0"
}
},
"slots": {
"armor": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"bag": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"cape": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"food": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"head": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"legendaryitemtraits": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"mainhand_1h": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0825,
"hitpointsprogression": 1.06
},
"mainhand_2h": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"mount": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"offhand": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"potion": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"shoes": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
},
"transformation": {
"armorbase": 100.0,
"armorprogression": 1.03,
"attackdamageprogression": 1.0918,
"hitpointsprogression": 1.06
}
}
}
+60
View File
@@ -0,0 +1,60 @@
# Game data provenance
This directory contains data vendored from the Albion Online game client.
It is **not** hand-maintained and must not be edited by hand.
## `item_ids.txt`
| | |
| --- | --- |
| Upstream | [`ao-data/ao-bin-dumps`](https://github.com/ao-data/ao-bin-dumps) |
| Path in upstream | `formatted/items.txt` |
| Commit | `47e4f5aca4d30b7495afa5a625ce0d5795e32050` |
| Commit date | 2026-09-23 |
| Retrieved | 2026-10-11 |
| Licence | MIT |
| Entries | 12,237 (IDs 1–12237, contiguous, no duplicates) |
Format is ` <id>: <uniquename> : <localized display name>`. Some entries have
no display name (846 of them), in which case the line ends after the unique
name.
`src/static/item_ids.txt` is generated from this file by `make gamedata`. It is
what the app reads, in the `<id>,<uniquename>` form its loader expects.
### Why this replaces the previous table
The table previously committed at `src/static/item_ids.txt` held 7,493 entries
and was a valid **older build** of this same data. Albion re-orders IDs between
builds, so the two agree on almost nothing: on the overlapping 7,239 IDs they
disagree on **100%**.
It is not merely stale — it is actively wrong. Scoring both tables against a
real equipment array from a capture, where each slot's position is known:
- this file: **8/8** slots resolve to the correct item and slot
- the old table: **0/8** (a helmet resolved to a firestaff, armor to a backpack)
Regenerate with `make gamedata`; the same command rewrites this file.
## Everything else is fetched, not committed
The remaining game data is too large to version, so `scripts/fetch_gamedata.py`
pulls it at build time into a gitignored cache:
| File | Size | Used for |
| --- | --- | --- |
| `items.json` | 17 MB | item → ability-slot bindings |
| `spells.json` | 15 MB | spell and debuff effect definitions |
| `mobs.json` | 19 MB | mob armor/resistance, mob template IDs |
| `gamedata.json` | 184 KB | item-power → armor/damage progression constants |
`localization.json` (90 MB) is deliberately **not** fetched. It is only needed
for localized display strings, and it cannot supply a display name for every
mob anyway — 883 of 5,479 mob definitions have no `namelocatag` at all,
including `T5_MOB_HIDE_SWAMP_GIANTSNAKE`. Nothing in attribution depends on it.
## Attribution
MIT, from the upstream repositories. See the upstream `LICENSE` file for the
authoritative text.
+12237
View File
File diff suppressed because it is too large Load Diff
+19 -1
View File
@@ -49,6 +49,7 @@ class Player(Stats):
party: Party party: Party
items: dict = field(default_factory=lambda: {'weapon': None}) items: dict = field(default_factory=lambda: {'weapon': None})
damage_done: float = 0.0 damage_done: float = 0.0
damage_taken: float = 0.0
healing_done: float = 0.0 healing_done: float = 0.0
total_healing_done: float = 0.0 total_healing_done: float = 0.0
combat_time: CombatTime = field(default_factory=lambda: CombatTime()) combat_time: CombatTime = field(default_factory=lambda: CombatTime())
@@ -62,7 +63,7 @@ class Player(Stats):
return self.active return self.active
def has_stats(self) -> bool: 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 @staticmethod
def new(self): def new(self):
@@ -75,6 +76,7 @@ class Player(Stats):
def update(self, other): def update(self, other):
self.name = other.name self.name = other.name
self.damage_done += other.damage_done self.damage_done += other.damage_done
self.damage_taken += other.damage_taken
self.healing_done += other.healing_done self.healing_done += other.healing_done
self.total_healing_done += other.total_healing_done self.total_healing_done += other.total_healing_done
self.combat_state = other.combat_state self.combat_state = other.combat_state
@@ -102,6 +104,10 @@ class Player(Stats):
self.healing_done += value self.healing_done += value
def register_damage_taken(self, value):
self.damage_taken += value
self.activate()
def enter_combat(self): def enter_combat(self):
self.combat_time.entered_combat = time_utils.now() self.combat_time.entered_combat = time_utils.now()
self.combat_state = CombatState.InCombat self.combat_state = CombatState.InCombat
@@ -116,6 +122,10 @@ class Player(Stats):
return StandalonePlayerListItem( return StandalonePlayerListItem(
self.name, self.items, self.damage_done, self.dps, self.combat_state) 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: def into_healing_list_item(self) -> StandalonePlayerListItem:
return StandalonePlayerListItem( return StandalonePlayerListItem(
self.name, self.items, self.healing_done, self.hps, self.combat_state) 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() 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]: def players_healing(self) -> List[PlayerListItem]:
return to_player_list_items([player.into_healing_list_item() return to_player_list_items([player.into_healing_list_item()
for player in self.visible_players() for player in self.visible_players()
@@ -230,6 +245,9 @@ class CombatStats(CombatEventReceiver, Stats):
def on_damage_done(self, id: int, damage: float): def on_damage_done(self, id: int, damage: float):
self.players[id].register_damage_done(damage) 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): def on_health_received(self, id: int, target_id: int, health: float):
self.players[id].register_healing_done(health) self.players[id].register_healing_done(health)
+242
View File
@@ -0,0 +1,242 @@
"""Helpers for analysing captured discovery logs.
Captures are large (tens of MB) and live outside the repository, so tests that
use them skip themselves when none are available. Set ``AOSTATS_CAPTURE_GLOB``
to point at a different location, e.g.::
AOSTATS_CAPTURE_GLOB='/tmp/aostats-in-party*.jsonl' pytest tests
Records are read from the ``photon_message`` stream rather than the decoder's
``game_message`` stream. That matters for opcode research: ``game_message`` only
contains opcodes that ``src/decode/translate.py`` currently knows about, which
is exactly the set we are trying to extend.
"""
import glob
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Iterator, List, Optional
CAPTURE_GLOB_ENV = 'AOSTATS_CAPTURE_GLOB'
DEFAULT_CAPTURE_GLOB = '/tmp/aostats-in-party-with-items-and-silver*.jsonl'
# Opcodes under investigation, by Photon parameter id.
EVENT_PARAM = 252
OPCODE_HEALTH_UPDATE = 6
OPCODE_DAMAGE_BATCH = 7
OPCODE_ENTITY_STATS = 18
@dataclass(frozen=True)
class DecodedMessage:
"""A Photon message as captured, before opcode translation."""
timestamp: str
kind: str
opcode: Optional[int]
params: Dict[str, Any]
@dataclass(frozen=True)
class DamageHit:
"""One damage or healing tick against a victim.
``opcode`` is retained so a hit can be attributed to either the scalar
(``OPCODE_HEALTH_UPDATE``) or batched (``OPCODE_DAMAGE_BATCH``) encoding.
"""
timestamp: str
opcode: int
victim: Any
attacker: Any
delta: float
health_after: Optional[float]
def capture_glob() -> str:
return os.getenv(CAPTURE_GLOB_ENV) or DEFAULT_CAPTURE_GLOB
def capture_paths() -> List[str]:
return sorted(path for path in glob.glob(capture_glob()) if not path.endswith('.app.log'))
def captures_available() -> bool:
return bool(capture_paths())
def param(params: Dict[str, Any], key: int, default: Any = None) -> Any:
"""Read a Photon parameter by numeric id (JSON keys are strings)."""
return params.get(str(key), default)
def byte_list(value: Any) -> List[int]:
"""Normalise a parameter that may arrive as raw bytes or a decoded list."""
if isinstance(value, dict) and 'bytes_hex' in value:
raw = value['bytes_hex']
return [int(raw[i:i + 2], 16) for i in range(0, len(raw), 2)]
if isinstance(value, list):
return [v for v in value if isinstance(v, int)]
return []
def iter_messages(path: str) -> Iterator[DecodedMessage]:
"""Yield every captured Photon message in ``path`` in arrival order."""
with open(path, encoding='utf-8', errors='replace') as log:
for line in log:
if '"photon_message"' not in line:
continue
try:
record = json.loads(line)
except json.JSONDecodeError:
continue
message = record.get('message') or {}
params = message.get('params') or {}
kind = message.get('kind')
if kind == 'Event':
opcode = param(params, EVENT_PARAM)
elif kind in ('Request', 'Response'):
opcode = param(params, 253)
else:
opcode = None
yield DecodedMessage(
timestamp=record.get('timestamp') or '',
kind=kind,
opcode=opcode if isinstance(opcode, int) else None,
params=params,
)
def damage_hits(path: str) -> Iterator[DamageHit]:
"""Yield every damage/healing tick from both health-update encodings."""
for message in iter_messages(path):
if message.kind != 'Event':
continue
if message.opcode == OPCODE_HEALTH_UPDATE:
delta = param(message.params, 2)
health_after = param(message.params, 3)
if not isinstance(delta, (int, float)):
continue
yield DamageHit(
timestamp=message.timestamp,
opcode=OPCODE_HEALTH_UPDATE,
victim=param(message.params, 0),
attacker=param(message.params, 6),
delta=float(delta),
health_after=health_after if isinstance(health_after, (int, float)) else None,
)
elif message.opcode == OPCODE_DAMAGE_BATCH:
deltas = param(message.params, 2) or []
health_afters = param(message.params, 3) or []
attackers = byte_list(param(message.params, 6))
for index, delta in enumerate(deltas):
if not isinstance(delta, (int, float)):
continue
attacker = attackers[index] if index < len(attackers) else None
health_after = health_afters[index] if index < len(health_afters) else None
yield DamageHit(
timestamp=message.timestamp,
opcode=OPCODE_DAMAGE_BATCH,
victim=param(message.params, 0),
attacker=attacker,
delta=float(delta),
health_after=health_after if isinstance(health_after, (int, float)) else None,
)
def entity_multipliers(path: str) -> Iterator[tuple]:
"""Yield ``(timestamp, entity, multiplier)`` from the entity-stats opcode."""
for message in iter_messages(path):
if message.kind != 'Event' or message.opcode != OPCODE_ENTITY_STATS:
continue
multiplier = param(message.params, 6)
if isinstance(multiplier, (int, float)):
yield message.timestamp, param(message.params, 0), float(multiplier)
def damage_type(message: DecodedMessage) -> Any:
"""Param 5 of a health update: an ability/hit category enum."""
return param(message.params, 5)
def perfect_scalar_chains(path: str, min_steps: int = 5) -> List[List[DamageHit]]:
"""Victims whose scalar-opcode health chain is perfectly consistent.
These are the calibration set for the duplicate test: a stream that merely
repeats known hits cannot survive being injected into an already-exact
chain, so the damage a stream adds to this set is genuine.
"""
by_victim: Dict[Any, List[DamageHit]] = {}
for hit in damage_hits(path):
by_victim.setdefault(hit.victim, []).append(hit)
perfect = []
for victim_hits in by_victim.values():
scalar = check_chain(victim_hits, include_batched=False)
if scalar.steps >= min_steps and scalar.breaks == 0:
perfect.append(victim_hits)
return perfect
@dataclass
class ChainReport:
"""Whether each victim's reported health can be explained by observed hits.
Every health update reports the health the victim was left at. Walking a
victim's hits in time order and applying each delta to the running total
should land exactly on the next reported value:
previous.health_after + delta == health_after
When it does not, something moved the victim's health that we did not
observe -- regeneration, food, an offline update, or simply a hit missing
from this stream. Those are ``breaks``.
The decisive property: a stream that is a *duplicate* of another adds no
information while perturbing the running total, so it can only increase
breaks. The correct encoding therefore has the fewest breaks.
"""
steps: int = 0
breaks: int = 0
@property
def break_rate(self) -> float:
return self.breaks / self.steps if self.steps else 0.0
def merge(self, other: 'ChainReport') -> 'ChainReport':
return ChainReport(self.steps + other.steps, self.breaks + other.breaks)
def check_chain(hits: List[DamageHit],
include_batched: bool) -> ChainReport:
"""Walk each victim's health chain using one encoding or both.
Healing is included in the walk (it is a real health change) but a step is
only counted when both endpoints reported their resulting health.
"""
by_victim: Dict[Any, List[DamageHit]] = {}
for hit in hits:
if not include_batched and hit.opcode == OPCODE_DAMAGE_BATCH:
continue
by_victim.setdefault(hit.victim, []).append(hit)
report = ChainReport()
for victim_hits in by_victim.values():
ordered = sorted(victim_hits, key=lambda h: (h.timestamp, h.opcode))
previous = ordered[0]
if previous.health_after is None:
continue
running = previous.health_after
for current in ordered[1:]:
if current.health_after is None:
previous = current
continue
report.steps += 1
if abs(running + current.delta - current.health_after) > 0.01:
report.breaks += 1
# Trust the server's reported value; re-anchor after any break.
running = current.health_after
previous = current
return report
+196
View File
@@ -0,0 +1,196 @@
"""End-to-end findings from the Armor Piercer capture.
Source: /tmp/aostats-party01.jsonl, a T5 Morgana dungeon run. bionicKatana
wore a T6_MAIN_CURSEDSTAFF@1 (Armor Piercer) from 16:48:10 to 16:52:40;
Froedrick712 shared the party and finished the mobs.
These tests establish the premise the whole effective-damage feature rests on:
that applying a debuff measurably raises another player's damage, that the
debuff's lifetime is visible, and that the responsible player is recoverable
from the packets.
The capture lives outside the repository, so everything here is skipped when it
is absent.
"""
import collections
import json
import os
import statistics
import pytest
CAPTURE = '/tmp/aostats-party01.jsonl'
BIOMIC = 90547
FROEDRICK = 90362
# Effect ids bionicKatana applies only while holding the cursed staff. They
# appear together on several victims within a millisecond, which is the
# multi-target beam of Armor Piercer.
ARMOR_PIERCER_EFFECTS = (3097, 3098, 3099)
# Armor Piercer's debuff lasts 4 seconds.
DEBUFF_SECONDS = 4.0
pytestmark = pytest.mark.skipif(
not os.path.exists(CAPTURE), reason='Armor Piercer capture not available')
def _records():
with open(CAPTURE, errors='replace') as handle:
for line in handle:
try:
yield json.loads(line)
except ValueError:
continue
def _is_photon_event(record, opcode):
if record.get('type') != 'photon_message':
return False
message = record.get('message') or {}
if message.get('code') != 1 or message.get('kind') != 'Event':
return False
return (message.get('params') or {}).get('252') == opcode
def effect_windows():
"""Victim -> timestamps at which Armor Piercer landed on it."""
windows = collections.defaultdict(list)
for record in _records():
if not _is_photon_event(record, 22):
continue
params = (record.get('message') or {}).get('params') or {}
appliers, effects = params.get('1'), params.get('2')
if not isinstance(appliers, list) or not isinstance(effects, list):
continue
if len(appliers) != len(effects):
continue
if BIOMIC in appliers and any(
e in ARMOR_PIERCER_EFFECTS for e in effects):
windows[params.get('0')].append(_ts(record['timestamp']))
return windows
def basic_hits(attacker):
"""(timestamp, victim, damage) for basic auto-attacks."""
out = []
for record in _records():
if record.get('type') != 'game_message':
continue
message = record.get('message') or {}
if message.get('name') != 'HealthUpdate':
continue
params = message.get('params') or {}
if params.get('6') != attacker or params.get('5') != 0:
continue
out.append((_ts(record['timestamp']), params.get('0'),
abs(params.get('2') or 0)))
return out
def _ts(stamp):
import datetime
return datetime.datetime.fromisoformat(stamp).timestamp()
def _static(name):
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
with open(os.path.join(root, 'src', 'static', name),
encoding='utf-8') as handle:
return json.load(handle)
# --- the premise -------------------------------------------------------------
def test_debuff_raises_another_players_damage():
"""The whole feature depends on this being true and measurable.
Froedrick712's basic hits on mob 78724 go 35 -> 48 -> 35 across a single
Armor Piercer application. Mob 78724 is a
T5_MOB_ROAMING_KEEPER_GIANT_CHAMPION with 136 armour.
"""
windows = effect_windows()
assert windows.get(78724), 'no Armor Piercer application found on 78724'
hits = [h for h in basic_hits(FROEDRICK) if h[1] == 78724]
applied = windows[78724][0]
inside = [d for t, _, d in hits
if 0 <= t - applied <= DEBUFF_SECONDS]
before = [d for t, _, d in hits if applied - 60 <= t < applied]
assert before, 'no baseline hits before the debuff'
assert inside, 'no hits inside the debuff window'
assert statistics.median(inside) > statistics.median(before)
def test_damage_returns_to_baseline_after_the_debuff():
"""The debuff expires, and the return to baseline is observable.
This is what makes the magnitude recoverable from data rather than needing
the spell definition: compare a victim's hits inside and outside the
window instead of trusting a static table.
"""
windows = effect_windows()
hits = [h for h in basic_hits(FROEDRICK) if h[1] == 78724]
applied = windows[78724][0]
inside = [d for t, _, d in hits
if 0 <= t - applied <= DEBUFF_SECONDS]
after = [d for t, _, d in hits if t - applied > DEBUFF_SECONDS]
assert inside and after
assert statistics.median(after) < statistics.median(inside)
def test_surplus_is_positive_across_the_capture():
"""Not a one-mob fluke: the same shift shows up over the whole run."""
windows = effect_windows()
hits = basic_hits(FROEDRICK)
def in_window(t, victim):
return any(0 <= t - applied <= DEBUFF_SECONDS
for applied in windows.get(victim, []))
inside = [d for t, v, d in hits if in_window(t, v)]
outside = [d for t, v, d in hits if not in_window(t, v)]
assert len(inside) >= 10
assert statistics.median(inside) > statistics.median(outside)
# Every hit inside a debuff window beats the outside median, which is what
# a genuine shift in the damage model looks like.
assert min(inside) > statistics.median(outside)
# --- the attribution chain ---------------------------------------------------
def test_applier_is_recoverable_without_inference():
"""The responsible player comes from the packet, not from the weapon.
This is better than the plan assumed: it removes the need to match spells
to equipped weapons for the common case.
"""
windows = effect_windows()
assert windows, 'no Armor Piercer applications found'
for victim, applied in windows.items():
assert victim is not None
assert applied
def test_mob_template_and_max_health_agree():
"""Mob 78724's template must agree with the hit points in the spawn."""
mob_armor = _static('mob_armor.json')
for record in _records():
if not _is_photon_event(record, 123):
continue
params = (record.get('message') or {}).get('params') or {}
if params.get('0') != 78724:
continue
entry = mob_armor[str(params.get('1'))]
assert entry['hitpointsmax'] == pytest.approx(params.get('13'))
assert entry['name'] == 'T5_MOB_ROAMING_KEEPER_GIANT_CHAMPION'
assert entry['armor'] == 136
return
pytest.fail('mob 78724 spawn not found in capture')
+63
View File
@@ -93,6 +93,69 @@ def test_start_native_backend_reports_start_failure(monkeypatch):
assert backend_proxy._capture is None 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): def test_engine_initialize_reports_subscribe_failure(monkeypatch):
monkeypatch.setattr( monkeypatch.setattr(
engine.backend_proxy, 'initialize', engine.backend_proxy, 'initialize',
+249
View File
@@ -0,0 +1,249 @@
"""Findings about the Albion health-update protocol, verified against captures.
These tests double as the specification for the Phase 1 decode work. They read
raw ``photon_message`` records rather than the decoder's ``game_message``
stream, because several of the behaviours under test concern opcodes that
``src/decode/translate.py`` does not handle yet.
Captures live outside the repository and are skipped when absent.
"""
import collections
import statistics
import pytest
from capture_analysis import (
OPCODE_DAMAGE_BATCH,
OPCODE_ENTITY_STATS,
OPCODE_HEALTH_UPDATE,
DamageHit,
capture_paths,
check_chain,
damage_hits,
damage_type,
iter_messages,
param,
perfect_scalar_chains,
)
pytestmark = pytest.mark.skipif(
not capture_paths(),
reason='discovery captures are not available')
def _scalar_messages():
for path in capture_paths():
for message in iter_messages(path):
if message.opcode == OPCODE_HEALTH_UPDATE:
yield message
def _all_hits():
for path in capture_paths():
for hit in damage_hits(path):
yield hit
# --- Opcode 7 is additional damage, not a repeat of opcode 6 ---------------
def test_batched_damage_is_not_a_duplicate_of_scalar_damage():
"""Echoing known hits destroys an exact health chain; real E7 does not.
Each victim picked here has a scalar-opcode health chain that reconciles
perfectly. Injecting a stream that merely repeats those same hits makes
every step inconsistent, because the repeated delta is applied twice. If
the batched opcode were such a repeat it would behave the same way.
Rates are pooled across captures rather than compared per capture: a
single-break sample from a two-step victim would otherwise dominate.
"""
real_breaks = real_steps = 0
synthetic_breaks = synthetic_steps = 0
for path in capture_paths():
for group in perfect_scalar_chains(path):
base = check_chain(group, include_batched=False)
actual = check_chain(group, include_batched=True)
real_steps += actual.steps - base.steps
real_breaks += actual.breaks - base.breaks
echoed = list(group) + [
DamageHit(h.timestamp, OPCODE_DAMAGE_BATCH, h.victim,
h.attacker, h.delta, h.health_after)
for h in group]
doubled = check_chain(echoed, include_batched=True)
synthetic_steps += doubled.steps - base.steps
synthetic_breaks += doubled.breaks - base.breaks
assert real_steps > 20, f'only {real_steps} extra steps introduced'
assert synthetic_steps > 20, f'only {synthetic_steps} synthetic steps'
real_rate = real_breaks / real_steps
synthetic_rate = synthetic_breaks / synthetic_steps
assert real_rate < 0.25, \
f'real batched damage should not double-count, got {real_rate:.2%}'
assert synthetic_rate > 0.75, \
f'a genuine duplicate should double-count, got {synthetic_rate:.2%}'
def test_batched_damage_carries_substantial_volume():
"""The batched opcode accounts for a large share of total damage.
This is the size of the undercount that Phase 1 exists to fix.
"""
scalar = batched = 0.0
for hit in _all_hits():
if hit.delta >= 0:
continue
if hit.opcode == OPCODE_HEALTH_UPDATE:
scalar += -hit.delta
else:
batched += -hit.delta
assert scalar > 0 and batched > 0
share = batched / (scalar + batched)
assert 0.3 < share < 0.5, f'batched share of damage drifted to {share:.2%}'
def test_batched_damage_reports_health_after_each_hit():
"""Every batched hit carries its own resulting health and attacker.
These are the fields Phase 1 needs to credit damage without guessing.
"""
checked = 0
for hit in _all_hits():
if hit.opcode != OPCODE_DAMAGE_BATCH or hit.delta >= 0:
continue
assert hit.health_after is not None, 'batched hit without resulting health'
assert hit.attacker is not None, 'batched hit without an attacker'
checked += 1
assert checked > 100, f'only {checked} batched damage hits to check'
# --- Health-update parameter layout ---------------------------------------
def test_health_after_param_reconciles_with_deltas():
"""Param 3 is the victim's health once the hit has been applied."""
report = check_chain(list(_all_hits()), include_batched=False)
assert report.steps > 1000, f'only {report.steps} steps to reconcile'
assert report.break_rate < 0.6, \
f'param 3 does not reconcile (break rate {report.break_rate:.2%})'
def test_damage_type_separates_basic_hits_from_abilities():
"""Param 5 splits basic attacks (0, 1) from ability hits (2+).
The groups do not overlap and differ sharply in magnitude, which is what
makes param 5 useful for splitting damage by hit type.
"""
magnitudes = collections.defaultdict(list)
for message in _scalar_messages():
delta = param(message.params, 2)
if not isinstance(delta, (int, float)) or delta >= 0:
continue
magnitudes[damage_type(message)].append(-delta)
assert set(magnitudes) >= {0, 1, 2, 3}, f'unexpected param 5 domain: {sorted(magnitudes)}'
basic = magnitudes[0] + magnitudes[1]
abilities = magnitudes[2] + magnitudes[3]
assert statistics.median(basic) < statistics.median(abilities) * 0.5, \
f'basic {statistics.median(basic):.0f} vs ability ' \
f'{statistics.median(abilities):.0f} are not separable'
def test_max_health_param_presence_is_a_function_of_damage_type():
"""Param 7 is populated for exactly the param 5 values 2 and above.
"Populated" means a value of at least zero; basic hits carry -1 as a
placeholder. Presence therefore carries no information beyond param 5, so
param 7 adds no independent damage signal. Recorded so Phase 1 does not
model the same partition twice.
"""
populated = collections.defaultdict(set)
for message in _scalar_messages():
value = damage_type(message)
raw = param(message.params, 7)
populated[value].add(isinstance(raw, (int, float)) and raw >= 0)
for value, flags in populated.items():
assert len(flags) == 1, \
f'param 7 presence varies within param 5={value}: {flags}'
absent = {value for value, flags in populated.items() if flags == {False}}
assert absent == {0, 1}, f'param 7 absent for {sorted(absent)}, expected 0 and 1'
# --- Opcode 18 param 6 is not a damage multiplier --------------------------
def test_entity_stats_multiplier_does_not_track_damage():
"""Damage does not change across opcode 18 multiplier transitions.
This refutes the Phase 0 hypothesis that opcode 18 carries a live incoming
damage multiplier. The multiplier moves while the median damage either side
of the transition stays flat, so it cannot be used to infer mitigation
state. Recorded here so Phase 2 does not build on it.
"""
import statistics as stats
followed = 0
for path in capture_paths():
multipliers = collections.defaultdict(list)
damage = collections.defaultdict(list)
for message in iter_messages(path):
if message.opcode == OPCODE_ENTITY_STATS:
value = param(message.params, 6)
if isinstance(value, (int, float)):
multipliers[param(message.params, 0)].append(
(message.timestamp, value))
for hit in damage_hits(path):
damage[hit.victim].append((hit.timestamp, hit))
for entity, sequence in multipliers.items():
if not damage.get(entity):
continue
for index in range(1, len(sequence)):
(before_ts, before_m), (after_ts, after_m) = sequence[index - 1], sequence[index]
if before_m == after_m:
continue
earlier = [-hit.delta for ts, hit in damage[entity]
if hit.delta < 0 and before_ts < ts <= after_ts]
later = [-hit.delta for ts, hit in damage[entity]
if hit.delta < 0 and ts > after_ts][:20]
if len(earlier) < 3 or len(later) < 3:
continue
followed += 1
expected = abs(after_m / before_m)
observed = abs(stats.median(later) / stats.median(earlier))
assert abs(observed - expected) > 0.2 * max(expected, 1e-9), \
f'damage tracked the multiplier x{expected:.2f} ' \
f'(observed x{observed:.2f}) -- it may be a damage multiplier'
assert followed > 0, 'no opcode 18 multiplier transitions with surrounding damage'
def test_entity_stats_multiplier_is_often_constant_per_entity():
"""Where param 6 varies, it is a minority of samples for that entity.
Consistent with a cosmetic or interpolation factor rather than a
continuously tracked combat statistic.
"""
unstable = seen = 0
for path in capture_paths():
per_entity = collections.defaultdict(collections.Counter)
for message in iter_messages(path):
if message.opcode != OPCODE_ENTITY_STATS:
continue
value = param(message.params, 6)
if isinstance(value, (int, float)):
per_entity[param(message.params, 0)][round(value, 4)] += 1
for counts in per_entity.values():
seen += 1
if len(counts) > 1:
unstable += 1
assert seen > 0, 'no opcode 18 records found'
assert unstable / seen < 0.5, \
f'{unstable}/{seen} entities vary, too many for a cosmetic value'
+37
View File
@@ -6,6 +6,11 @@ class VisibleAll:
return True return True
class VisibleNone:
def test(self, _name):
return False
def test_self_healing_counts_while_in_combat(): def test_self_healing_counts_while_in_combat():
stats = CombatStats(VisibleAll()) stats = CombatStats(VisibleAll())
stats.on_player_appeared(0, 'Healer') 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 combat_healing[0].value == 100.0
assert total_healing[0].value == 150.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() == []
+189 -14
View File
@@ -168,10 +168,10 @@ def test_fragment_reassembly():
(6, 'HealthUpdate'), (6, 'HealthUpdate'),
(29, 'NewCharacter'), (29, 'NewCharacter'),
(32, 'ItemGained'), (32, 'ItemGained'),
(62, 'TakeSilver'),
(82, 'UpdateFame'), (82, 'UpdateFame'),
(90, 'CharacterEquipmentChanged'), (90, 'CharacterEquipmentChanged'),
(91, 'RegenerationHealthChanged'), (91, 'RegenerationHealthChanged'),
(153, 'SilverGained'),
(166, 'KnockedDown'), (166, 'KnockedDown'),
(231, 'PartyJoined'), (231, 'PartyJoined'),
(233, 'PartyPlayerJoined'), (233, 'PartyPlayerJoined'),
@@ -271,16 +271,157 @@ def test_world_health_update_damage_and_heal():
assert damage[0]['value']['target'] == 0 # victim assert damage[0]['value']['target'] == 0 # victim
assert damage[0]['value']['value'] == 80.0 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})) heal = world.transform(game('HealthUpdate', {0: 10, 6: 20, 2: 40.0}))
assert heal[0]['name'] == 'HealthReceived' assert heal[0]['name'] == 'HealthReceived'
assert heal[0]['value']['source'] == 1 assert heal[0]['value']['source'] == 1
assert heal[0]['value']['value'] == 40.0 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 = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'})) 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
# --- Health update accessors ---------------------------------------------------
def test_health_update_accessors():
msg = game('HealthUpdate', {0: 10, 2: -80.0, 3: 420.0, 5: 3, 6: 20, 7: -1})
assert translate.msg_subject_id(msg) == 10 # param 0 is the victim
assert translate.msg_attacker_id(msg) == 20 # param 6 is the attacker
assert translate.msg_value(msg) == -80.0
assert translate.msg_health_after(msg) == 420.0
assert translate.msg_hit_type(msg) == 3
def test_health_update_accessors_tolerate_missing_params():
msg = game('HealthUpdate', {})
assert translate.msg_subject_id(msg) == 0
assert translate.msg_attacker_id(msg) == 0
assert translate.msg_value(msg) == 0.0
assert translate.msg_health_after(msg) is None
assert translate.msg_hit_type(msg) is None
def test_byte_list_unpacks_every_encoded_shape():
# Batched params arrive as raw bytes, as the discovery log's dict form, or
# as an already-decoded list depending on the decoder path.
assert translate._as_byte_list(b'\x01\x02') == [1, 2]
assert translate._as_byte_list({'bytes_hex': 'c5c5', 'len': 2}) == [197, 197]
assert translate._as_byte_list([3, 4]) == [3, 4]
assert translate._as_byte_list(None) == []
def test_batched_health_update_accessors():
msg = game('BatchedHealthUpdate', {
0: 76,
1: [11, 12],
2: [-41.0, -135.0],
3: [3416.0, 3281.0],
5: b'\x00\x02',
6: b'\xc5\x58',
})
assert translate.msg_batched_victim_id(msg) == 76
assert translate.msg_batched_ticks(msg) == [11, 12]
assert translate.msg_batched_values(msg) == [-41.0, -135.0]
assert translate.msg_batched_health_after(msg) == [3416.0, 3281.0]
assert translate.msg_batched_hit_types(msg) == [0, 2]
assert translate.msg_batched_attacker_ids(msg) == [197, 88]
# --- Batched health update -----------------------------------------------------
def test_world_batched_health_update_emits_one_event_per_hit():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
world.transform(game('NewCharacter', {0: 20, 1: 'Attacker'}))
world.transform(game('NewCharacter', {0: 30, 1: 'Other'}))
events = world.transform(game('BatchedHealthUpdate', {
0: 10,
2: [-41.0, -135.0],
3: [3416.0, 3281.0],
5: b'\x00\x02',
6: b'\x14\x1e',
}))
# two hits, each producing DamageDone and DamageTaken
assert len(events) == 4
assert [e['name'] for e in events] == [
'DamageDone', 'DamageTaken', 'DamageDone', 'DamageTaken']
assert [e['value']['value'] for e in events] == [41.0, 41.0, 135.0, 135.0]
# the attacker differs per hit and must be credited per hit, not per packet
assert events[0]['value']['source'] == 1 # attacker 20
assert events[2]['value']['source'] == 2 # attacker 30
assert [e['value']['hit_type'] for e in (events[0], events[2])] == [0, 2]
assert [e['value']['health_after'] for e in (events[0], events[2])] == [3416.0, 3281.0]
def test_world_batched_health_update_skips_zero_and_unknown():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
world.transform(game('NewCharacter', {0: 20, 1: 'Attacker'}))
events = world.transform(game('BatchedHealthUpdate', {
0: 10, 2: [0.0, -25.0], 3: [500.0, 475.0], 6: b'\x14\x14'}))
assert [e['name'] for e in events] == ['DamageDone', 'DamageTaken']
assert events[0]['value']['value'] == 25.0
# a victim nobody tracks, hit by nobody tracked, produces nothing
assert world.transform(game('BatchedHealthUpdate', {
0: 777, 2: [-10.0], 3: [90.0], 6: b'\x88'})) == []
def test_world_batched_health_update_tolerates_short_arrays():
"""A missing attacker list must not raise or misattribute the hit."""
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
events = world.transform(game('BatchedHealthUpdate', {
0: 10, 2: [-25.0], 3: [475.0]}))
assert [e['name'] for e in events] == ['DamageTaken']
assert events[0]['value']['source'] == 0
def test_world_batched_health_update_empty_yields_nothing():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
assert world.transform(game('BatchedHealthUpdate', {0: 10, 2: []})) == []
def test_batched_health_update_opcode_is_translated():
from src.decode.pipeline import Pipeline
events = []
pipeline = Pipeline(events.append)
payload = enet_unreliable_packet(
0x07, event_payload(7, [(0, p18_short(76)), (2, p18_string('x'))]))
pipeline.on_udp(payload)
# recognised as a game message even though it carries no usable deltas
assert events == []
def test_world_regeneration_combat_states(): def test_world_regeneration_combat_states():
@@ -315,15 +456,35 @@ def test_world_update_fame_delta_from_total():
assert events[0]['value']['value'] == pytest.approx(0.1) 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(): def test_world_item_gained_emits_collected_item():
world = World() world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'})) world.transform(game('Join', {0: 63, 2: 'Alice'}))
events = world.transform(game('ItemGained', {1: 522, 2: 3, 4: 10000000})) events = world.transform(game('ItemGained', {1: 522, 2: 3, 4: 10000000}))
# Item 522 is T1_SILVERBAG_NONTRADABLE in the current game data. This test
# previously expected T4_MEAL_SALAD_FISH@3, which is what the stale item id
# table claimed; ids are reassigned between game builds, and that table
# resolved 0 of 8 slots on a real equipment array.
assert events == [{ assert events == [{
'name': 'ItemCollected', 'name': 'ItemCollected',
'value': { 'value': {
'item_id': 522, 'item_id': 522,
'item_name': 'T4_MEAL_SALAD_FISH@3', 'item_name': 'T1_SILVERBAG_NONTRADABLE',
'quantity': 3, 'quantity': 3,
'estimated_value': 10000000, 'estimated_value': 10000000,
}, },
@@ -356,22 +517,36 @@ def test_world_item_gained_uses_display_name_and_deduplicates():
assert duplicate == [] assert duplicate == []
def test_world_silver_gained_tracks_known_sources(): def test_world_take_silver_tracks_main_player():
world = World() world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'})) world.transform(game('Join', {0: 63, 2: 'Alice'}))
looted = world.transform(game('SilverGained', {1: 54, 2: 45})) events = world.transform(game('TakeSilver', {0: 63, 3: 648351}))
other = world.transform(game('SilverGained', {1: 168, 2: 45}))
ignored = world.transform(game('SilverGained', {1: 126, 2: 81}))
assert looted == [{'name': 'SilverGained', 'value': { assert events[0]['name'] == 'SilverGained'
'value': 45.0, 'silver_type': 'looted'}}] assert events[0]['value']['silver_type'] == 'looted'
assert other == [] assert events[0]['value']['value'] == pytest.approx(64.8351)
assert ignored == []
def test_world_silver_gained_waits_for_main_player_join(): def test_world_take_silver_subtracts_taxes():
world = World() 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(): def test_world_unconsumed_equipment_replayed_on_new_character():
+11
View File
@@ -13,6 +13,17 @@ def test_qt_args_removes_app_specific_options():
'aostats', '--log-path=/tmp/capture.jsonl']) == ['aostats'] '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): def test_discovery_log_writes_jsonl_with_item_annotations(monkeypatch, tmp_path):
path = tmp_path / 'capture.jsonl' path = tmp_path / 'capture.jsonl'
monkeypatch.setattr(discovery, 'discovery_log_path', lambda: str(path)) monkeypatch.setattr(discovery, 'discovery_log_path', lambda: str(path))
+171
View File
@@ -0,0 +1,171 @@
"""Protocol tests for the effect stack and mob spawn opcodes.
Both were identified from /tmp/aostats-party01.jsonl, a T5 Morgana dungeon run
in which one player applied Armor Piercer and a party mate finished the mobs.
Every assertion here is anchored to a specific observation in that capture.
"""
import json
import pytest
from src.decode.translate import (
EffectApplication,
GameMessage,
into_game_message,
msg_effect_stack_applications,
msg_mob_hitpoints_max,
msg_mob_template_id,
)
def effect_msg(victim, appliers, effect_ids, flags='00', values='00'):
"""Build the EffectStackUpdate shape seen on the wire."""
n = len(appliers)
return GameMessage('EffectStackUpdate', 22, {
0: victim,
1: list(appliers),
2: list(effect_ids),
3: {'bytes_hex': flags * n, 'len': n},
4: {'bytes_hex': values * n, 'len': n},
})
def mob_msg(entity, template, hitpoints_max):
return GameMessage('MobSpawned', 123, {
0: entity,
1: template,
2: 255,
13: float(hitpoints_max),
14: float(hitpoints_max),
})
# --- effect stack ------------------------------------------------------------
def test_effect_stack_pairs_applier_with_effect():
msg = effect_msg(78724, [90362, 90547, 90547], [3163, 3097, 3098])
assert msg_effect_stack_applications(msg) == [
EffectApplication(applier=90362, effect_id=3163),
EffectApplication(applier=90547, effect_id=3097),
EffectApplication(applier=90547, effect_id=3098),
]
def test_applier_is_sent_explicitly():
"""Attribution does not have to guess who applied a debuff.
This is the reason the game sends the applier per effect. The original
plan assumed it would have to be inferred from the attacker's equipped
weapon; the packets do not require that.
"""
msg = effect_msg(78724, [90547, 90547, 90547], [3097, 3098, 3099])
appliers = {a.applier for a in msg_effect_stack_applications(msg)}
assert appliers == {90547}
def test_one_applier_can_hold_several_effects():
"""Armor Piercer is a beam that hits several targets at once.
Observed at 16:49:54.256: bionicKatana's three effect ids landed on three
different victims within a millisecond of each other, which is the
multi-target shape of the spell.
"""
msg = effect_msg(78724,
[90547, 90547, 90547, 90547, 90547],
[3097, 3098, 3099, 3092, 3093])
apps = msg_effect_stack_applications(msg)
assert len(apps) == 5
assert all(a.applier == 90547 for a in apps)
assert {a.effect_id for a in apps} == {3092, 3093, 3097, 3098, 3099}
def test_ragged_arrays_are_truncated_not_guessed():
"""A mismatched pair drops the tail rather than pairing unrelated ids."""
msg = effect_msg(78724, [90547, 90547, 90547], [3097, 3098])
assert len(msg_effect_stack_applications(msg)) == 2
def test_effect_stack_opcode_is_named():
"""Opcode 22 resolves to a name instead of being dropped."""
raw = _photon(code=1, kind='Event',
params={0: 78724, 1: [90547], 2: [3097], 252: 22})
msg = into_game_message(raw)
assert msg is not None
assert msg.name == 'EffectStackUpdate'
# --- mob spawn ---------------------------------------------------------------
def test_mob_spawn_carries_template_and_max_hp():
"""Template 2501 is a T5 Keeper Giant Champion, and max HP agrees.
Both fields were cross-checked against the packet, which is what makes the
template id safe to trust.
"""
msg = mob_msg(78724, 2501, 3282.0)
assert msg_mob_template_id(msg) == 2501
assert msg_mob_hitpoints_max(msg) == pytest.approx(3282.0)
def test_mob_spawn_opcode_is_named():
raw = _photon(code=1, kind='Event',
params={0: 78724, 1: 2501, 13: 3282.0, 252: 123})
msg = into_game_message(raw)
assert msg is not None
assert msg.name == 'MobSpawned'
def test_mob_template_is_not_an_item_id():
"""Mob template ids and item ids are different id spaces.
The discovery logger labels every integer it sees using the item table, so
this separation has to hold or every spawned mob would be reported as
whatever item happens to share its number.
"""
from src.decode import items as itemdb
db = itemdb.get_db()
# 454 was observed as a mob template for a Giant Snake...
msg = mob_msg(1, 454, 1162.0)
assert msg_mob_template_id(msg) == 454
# ...while item 454 is something else entirely.
assert db[454] == 'T5_SKILLBOOK_GATHER_FIBER'
assert mob_armor_name(454) == 'T5_MOB_HIDE_SWAMP_GIANTSNAKE'
def mob_armor_name(template_id):
with open(_static_path('mob_armor.json'), encoding='utf-8') as handle:
return json.load(handle)[str(template_id)]['name']
def _static_path(name):
import os
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
return os.path.join(root, 'src', 'static', name)
# --- capture-derived findings ------------------------------------------------
@pytest.mark.parametrize('applier,effect_ids', [
(90547, [3097, 3098, 3099]),
(90547, [3092, 3093]),
(90362, [3163]),
])
def test_real_payload_shapes_decode(applier, effect_ids):
"""Shapes taken verbatim from the capture still decode cleanly."""
msg = effect_msg(78724, [applier] * len(effect_ids), effect_ids)
apps = msg_effect_stack_applications(msg)
assert [a.effect_id for a in apps] == effect_ids
assert all(a.applier == applier for a in apps)
def _photon(code, kind, params):
class Raw:
pass
raw = Raw()
raw.code = code
raw.kind = kind
raw.params = params
raw.debug_message = None
return raw
+28
View File
@@ -14,3 +14,31 @@ def test_remember_last_party_flag_is_removed_from_qt_args(monkeypatch):
sys.argv = ['aostats'] sys.argv = ['aostats']
importlib.reload(environment) 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)
+312
View File
@@ -0,0 +1,312 @@
"""Regression tests for the generated game data tables.
These assert facts established against real captures. Each one is anchored to a
specific observation, and the item-id assertions in particular fail against the
table this project used to ship -- which is the point: that table was silently
wrong, and nothing caught it.
"""
import json
import os
import pytest
from src.decode import items as itemdb
_ARMOR_TYPES = ('physicalarmor', 'magicresistance')
_REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
STATIC = os.path.join(_REPO, 'src', 'static')
def _load(name):
with open(os.path.join(STATIC, name), encoding='utf-8') as handle:
return json.load(handle)
@pytest.fixture(scope='module')
def item_spells():
return _load('item_spells.json')
@pytest.fixture(scope='module')
def debuff_spells():
return _load('debuff_spells.json')
@pytest.fixture(scope='module')
def mob_armor():
return _load('mob_armor.json')
@pytest.fixture(scope='module')
def item_power():
return _load('item_power.json')
@pytest.fixture(scope='module')
def progression():
return _load('progression.json')
# --- item ids ----------------------------------------------------------------
def test_real_equipment_array_resolves_by_position():
"""Every slot of a real equipment array resolves to the matching item.
The array is the equipment payload from a capture in
/tmp/aostats-debuff-test03, in wire order: weapon, offhand, helmet, armor,
boots, bag, cape, mount. The table this replaces scored 0 of these 8; it
reported a helmet as a firestaff and armor as a backpack.
"""
array = [7739, 2372, 5054, 4168, 4648, 2888, 2600, 3030]
expected = [
'T5_MAIN_HOLYSTAFF_AVALON@1',
'T7_OFF_TORCH',
'T7_HEAD_CLOTH_HELL',
'T6_ARMOR_LEATHER_SET2',
'T7_SHOES_LEATHER_AVALON',
'T4_BAG',
'T7_CAPEITEM_FW_LYMHURST@1',
'T5_MOUNT_HORSE',
]
assert [itemdb.get_db()[i] for i in array] == expected
def test_cursed_staff_resolves_to_armor_piercer(item_spells):
"""The weapon that actually cast Armor Piercer in the capture.
The packet carries the enchanted variant, T6_MAIN_CURSEDSTAFF@1, but only
the base item exists in the dump -- so the table aliases the variants.
Without that alias a lookup straight from a packet id finds nothing.
"""
assert item_spells['T6_MAIN_CURSEDSTAFF@1'] == \
item_spells['T6_MAIN_CURSEDSTAFF']
by_slot = {}
for entry in item_spells['T6_MAIN_CURSEDSTAFF@1']:
by_slot.setdefault(entry['slot'], []).append(entry['spell'])
assert by_slot['2'] == ['ARMORPIERCER', 'CURSENOVA', 'CURSEDHANDS_STACKUP',
'CURSEDBEAM', 'DARKMATTER']
assert by_slot['3'] == ['DEATHCURSE2']
def test_enchantment_variants_have_distinct_ids():
"""Enchantment level is in the item id, not folded into the base."""
db = itemdb.get_db()
assert db[7738] == 'T5_MAIN_HOLYSTAFF_AVALON'
assert db[7739] == 'T5_MAIN_HOLYSTAFF_AVALON@1'
assert db[7740] == 'T5_MAIN_HOLYSTAFF_AVALON@2'
# --- item power --------------------------------------------------------------
def test_item_power_follows_enchantment(item_power):
"""Item power scales with enchantment, so it can anchor damage maths.
This is what keeps the model correct as a player levels their weapon,
rather than inferring a constant from observed hits.
"""
assert item_power['T5_MAIN_HOLYSTAFF_AVALON'] == 900
assert item_power['T5_MAIN_HOLYSTAFF_AVALON@1'] == 1000
assert item_power['T5_MAIN_HOLYSTAFF_AVALON@4'] == 1300
# --- item -> spell binding ---------------------------------------------------
def test_spell_binding_follows_reference_inheritance(item_spells):
"""T5_MAIN_HOLYSTAFF_AVALON has no craftingspelllist of its own.
It inherits through two levels of @reference, and only the base carries
the abilities. Unresolved, it would have no spells at all.
"""
spells = item_spells['T5_MAIN_HOLYSTAFF_AVALON']
assert spells, 'inherited spell list is empty'
by_slot = {}
for entry in spells:
by_slot.setdefault(entry['slot'], []).append(entry['spell'])
assert 'HEALINGBEAM' in by_slot['2']
assert 'DIVINE_JUMP' in by_slot['3']
def test_removespell_drops_inherited_ability(item_spells):
"""T4_MAIN_HOLYSTAFF_AVALON inherits the base but drops one spell."""
inherited = {e['spell'] for e in item_spells['T4_MAIN_HOLYSTAFF']}
avalon = {e['spell'] for e in item_spells['T4_MAIN_HOLYSTAFF_AVALON']}
assert 'HOLYDESPERATEPRAYER2' in inherited
assert 'HOLYDESPERATEPRAYER2' not in avalon
assert 'DIVINE_JUMP' in avalon
def test_every_spell_bearing_item_resolves(item_spells):
"""100% coverage: no item that has ability slots lacks its spell list.
Naively 471 weapons look empty until @reference is resolved.
"""
cache = os.path.join('.cache', 'gamedata', 'items.json')
if not os.path.exists(cache):
pytest.skip('game data cache absent; run scripts/fetch_gamedata.py')
with open(cache, encoding='utf-8') as handle:
items_root = json.load(handle)['items']
index = {}
for group, value in items_root.items():
if group.startswith('@') or group == 'shopcategories':
continue
entries = value if isinstance(value, list) else (
[value] if isinstance(value, dict) else [])
for entry in entries:
if isinstance(entry, dict) and entry.get('@uniquename'):
index[entry['@uniquename']] = entry
missing = []
for name, entry in index.items():
slots = entry.get('@activespellslots')
if not slots or str(slots) in ('0', ''):
continue
if not item_spells.get(name):
missing.append(name)
assert not missing, 'items with ability slots but no spells: {}'.format(
missing[:5])
# --- debuff resolution ------------------------------------------------------
def test_debuff_reached_through_spell_chain(debuff_spells):
"""ARMORPIERCER carries no buffovertime of its own.
The armour numbers live two hops away:
ARMORPIERCER -> spelleffectarea -> ARMORPIERCER_EFFECT
-> applyspell -> ARMORPIERCER_DEBUFF_EFFECT
Matching only an ability's own effects would find nothing at all.
"""
entry = debuff_spells['ARMORPIERCER_DEBUFF_EFFECT']
assert entry['abilities'] == ['ARMORPIERCER']
physical = [e for e in entry['effects'] if e['type'] == 'physicalarmor']
assert len(physical) == 1
assert physical[0]['value'] == pytest.approx(-0.17)
assert physical[0]['time'] == pytest.approx(4.0)
def test_debuff_magnitude_scaling_is_preserved(debuff_spells):
"""Armor Piercer is stronger against more targets.
The multiplier must be carried through, because attribution has to read the
magnitude off the observed effect rather than assume the base value.
"""
for effect in debuff_spells['ARMORPIERCER_DEBUFF_EFFECT']['effects']:
assert effect['targetcountvaluebonusfactor'] == pytest.approx(0.08)
def test_mob_and_player_variants_are_distinguished(debuff_spells):
"""SUNDERARMOR2 is weaker against players than against mobs."""
effects = debuff_spells['SUNDERARMOR2']['effects']
by_target = {}
for effect in effects:
if effect['type'] == 'physicalarmor':
by_target[effect.get('iftargettype')] = effect['value']
assert by_target['player'] == pytest.approx(-0.04)
assert by_target['mob'] == pytest.approx(-0.06)
assert debuff_spells['SUNDERARMOR2']['maxstack'] == 3
def test_every_debuff_is_attributable_to_an_ability(debuff_spells):
"""Each debuff effect names the ability that caused it.
That link is what turns an observed effect into a player, via the ability's
slot on the attacker's weapon.
"""
for name, entry in debuff_spells.items():
assert entry['abilities'], '{} has no producing ability'.format(name)
assert entry['effects'], '{} has no effects'.format(name)
def test_armour_debuffs_combine_additively(debuff_spells):
"""No armour debuff uses a stacking rule.
Absence of @stackingrule means same-type effects sum, which is what makes
the combined victim reduction a plain sum rather than a priority puzzle.
"""
cache = os.path.join('.cache', 'gamedata', 'spells.json')
if not os.path.exists(cache):
pytest.skip('game data cache absent; run scripts/fetch_gamedata.py')
with open(cache, encoding='utf-8') as handle:
spells_root = json.load(handle)['spells']
checked = 0
for group in ('activespell', 'passivespell', 'togglespell'):
for spell in spells_root.get(group) or []:
bot = spell.get('buffovertime')
entries = bot if isinstance(bot, list) else ([bot] if bot else [])
if not any(isinstance(e, dict)
and e.get('@type') in _ARMOR_TYPES
for e in entries):
continue
checked += 1
assert not spell.get('@stackingrule'), (
'armour debuff {} declares a stacking rule'.format(
spell.get('@uniquename')))
assert not spell.get('@stackinggroup'), (
'armour debuff {} declares a stacking group'.format(
spell.get('@uniquename')))
assert checked > 100
# --- mob templates ----------------------------------------------------------
def test_mob_template_resolves_to_known_mob(mob_armor):
"""Template 454 is the Giant Snake from the controlled capture.
Opcode 252/123 carries the template id in param 1 and max HP in param 13;
both were cross-checked against the packet.
"""
assert mob_armor['454'] == {
'name': 'T5_MOB_HIDE_SWAMP_GIANTSNAKE',
'tier': 5,
'armor': 136,
'resistance': 136,
'hitpointsmax': 1162,
'category': 'hidemob',
}
@pytest.mark.parametrize('template_id,expected_name,expected_hp', [
('448', 'T1_MOB_HIDE_SWAMP_TOAD', 20),
('2722', 'T5_MOB_CITY_SWAMP_GUARD', 1509),
('2724', 'T4_MOB_CITY_SWAMP_KNIGHT_ELITE', 11606),
('2725', 'T5_MOB_CITY_SWAMP_BOSS', 27795),
('2757', 'T6_MOB_GUARD_TOWER', 153572),
])
def test_mob_templates_match_observed_max_hp(
mob_armor, template_id, expected_name, expected_hp):
"""Each was seen in a capture alongside its max HP."""
entry = mob_armor[template_id]
assert entry['name'] == expected_name
assert entry['hitpointsmax'] == expected_hp
def test_mob_and_item_ids_are_separate_spaces(mob_armor):
"""Template 454 and item 454 are different things.
Worth pinning: the discovery logger walks every integer in every message
and labels it with the item table, so decoding opcode 123 naively would
report the Giant Snake as a gathering skillbook.
"""
assert mob_armor['454']['name'] == 'T5_MOB_HIDE_SWAMP_GIANTSNAKE'
assert itemdb.get_db()[454] == 'T5_SKILLBOOK_GATHER_FIBER'
# --- progression ------------------------------------------------------------
def test_progression_constants_present(progression):
"""Armour and damage scale off item power using these constants."""
slot = progression['slots']['mainhand_2h']
assert slot['armorbase'] == pytest.approx(100.0)
assert slot['armorprogression'] == pytest.approx(1.03)
assert slot['attackdamageprogression'] == pytest.approx(1.0918)
share = progression['shares']['armorshare']
assert float(share['@armor']) == pytest.approx(1.0)
assert float(share['@head']) == pytest.approx(0.0)
+193
View File
@@ -0,0 +1,193 @@
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
def test_summarize_breaks_damage_down_per_player():
"""A combined total next to "main player" reads as that player's damage.
Two players damaged a mob; the report must attribute each share rather
than printing one ambiguous number.
"""
events = [
{'name': 'MainPlayerAppeared', 'value': {'id': 0, 'name': 'Alice'}},
{'name': 'PlayerAppeared', 'value': {'id': 1, 'name': 'Bob'}},
{'name': 'DamageDone', 'value': {'source': 1, 'value': 1309.0}},
{'name': 'DamageDone', 'value': {'source': 1, 'value': 100.0}},
{'name': 'DamageDone', 'value': {'source': 0, 'value': 232.0}},
{'name': 'DamageTaken', 'value': {'source': 1, 'value': 244.0}},
]
report = summarize(events)
assert 'Bob: 1409.00' in report
assert 'Alice: 232.00' in report
# the party-wide figure is still reported, but labelled as such
assert 'damage done: 1641.00 (all players)' in report
assert 'damage taken by player:' in report
assert 'Bob: 244.00' in report
def test_summarize_labels_unknown_player_ids():
events = [
{'name': 'MainPlayerAppeared', 'value': {'id': 0, 'name': 'Alice'}},
{'name': 'DamageDone', 'value': {'source': 7, 'value': 50.0}},
]
report = summarize(events)
# no appearance event for id 7, so it must not be silently attributed
assert 'player #7: 50.00' in report
def test_summarize_reports_empty_damage_sections():
report = summarize([
{'name': 'MainPlayerAppeared', 'value': {'id': 0, 'name': 'Alice'}},
])
assert 'damage done by player:' in report
assert 'damage taken by player:' in report
assert '(none)' 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