Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 7279b3c207 |
@@ -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]
|
||||||
|
|||||||
@@ -15,3 +15,5 @@ albion-online-stats.cfg
|
|||||||
aoaddons.log
|
aoaddons.log
|
||||||
.eggs
|
.eggs
|
||||||
.idea
|
.idea
|
||||||
|
# fetched game data dumps (scripts/fetch_gamedata.py)
|
||||||
|
.cache
|
||||||
|
|||||||
@@ -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
|
||||||
@@ -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())
|
||||||
@@ -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())
|
||||||
+172
-2
@@ -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_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_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_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_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))
|
||||||
|
|
||||||
|
|||||||
+74
-22
@@ -171,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':
|
||||||
@@ -206,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)
|
||||||
@@ -231,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)
|
||||||
@@ -265,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 []
|
||||||
@@ -278,35 +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)
|
||||||
|
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 []
|
||||||
|
victim_id = _dyn(translate.msg_batched_victim_id(msg))
|
||||||
|
health_after = translate.msg_batched_health_after(msg)
|
||||||
|
hit_types = translate.msg_batched_hit_types(msg)
|
||||||
|
attackers = translate.msg_batched_attacker_ids(msg)
|
||||||
|
|
||||||
|
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)
|
victim_static = self.cache.get_static_id(victim_id)
|
||||||
events = []
|
events = []
|
||||||
if actor_static is not None:
|
if attacker_static is not None:
|
||||||
event_name = 'DamageDone' if value < 0.0 else 'HealthReceived'
|
payload = {'source': attacker_static,
|
||||||
events.append({
|
|
||||||
'name': event_name,
|
|
||||||
'value': {'source': actor_static,
|
|
||||||
'target': victim_static,
|
'target': victim_static,
|
||||||
'value': float(abs(value))},
|
'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:
|
if value < 0.0 and victim_static is not None:
|
||||||
events.append({
|
events.append({
|
||||||
'name': 'DamageTaken',
|
'name': 'DamageTaken',
|
||||||
'value': {'source': victim_static,
|
'value': {'source': victim_static,
|
||||||
'value': float(abs(value))},
|
'value': float(abs(value)),
|
||||||
|
'hit_type': hit_type},
|
||||||
})
|
})
|
||||||
return events
|
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 []
|
||||||
@@ -318,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 []
|
||||||
@@ -328,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 []
|
||||||
@@ -358,7 +410,7 @@ class World:
|
|||||||
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:
|
||||||
@@ -381,7 +433,7 @@ class World:
|
|||||||
def _on_take_silver(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 []
|
||||||
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 or static_id != self.main_player_id:
|
if static_id is None or static_id != self.main_player_id:
|
||||||
return []
|
return []
|
||||||
@@ -400,7 +452,7 @@ class World:
|
|||||||
}}]
|
}}]
|
||||||
|
|
||||||
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)
|
||||||
|
|||||||
+53
-2
@@ -16,6 +16,47 @@ def _event_value(event: dict) -> dict:
|
|||||||
return event.get(consts.EvKeyValue) or {}
|
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,
|
def summarize(events: List[dict], path: Optional[str] = None,
|
||||||
packet_count: Optional[int] = None) -> str:
|
packet_count: Optional[int] = None) -> str:
|
||||||
"""Build a human readable summary of the events produced by a replay."""
|
"""Build a human readable summary of the events produced by a replay."""
|
||||||
@@ -39,6 +80,12 @@ def summarize(events: List[dict], path: Optional[str] = None,
|
|||||||
main_player = _event_value(event).get('name')
|
main_player = _event_value(event).get('name')
|
||||||
break
|
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']
|
lines = ['Replay summary']
|
||||||
if path:
|
if path:
|
||||||
lines.append(f' log: {path}')
|
lines.append(f' log: {path}')
|
||||||
@@ -49,8 +96,12 @@ def summarize(events: List[dict], path: Optional[str] = None,
|
|||||||
lines.append(f' zone changes: {counts.get(consts.EvNameZoneChange, 0)}')
|
lines.append(f' zone changes: {counts.get(consts.EvNameZoneChange, 0)}')
|
||||||
lines.append(f' fame gained: {_fmt(fame)}')
|
lines.append(f' fame gained: {_fmt(fame)}')
|
||||||
lines.append(f' silver looted: {_fmt(silver)}')
|
lines.append(f' silver looted: {_fmt(silver)}')
|
||||||
lines.append(f' damage done: {_fmt(damage)}')
|
lines.append(f' damage done: {_fmt(damage)} (all players)')
|
||||||
lines.append(f' damage taken: {_fmt(damage_taken)}')
|
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)
|
top = counts.most_common(8)
|
||||||
if top:
|
if top:
|
||||||
|
|||||||
@@ -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
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
+257954
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -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
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Vendored
+60
@@ -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.
|
||||||
Vendored
+12237
File diff suppressed because it is too large
Load Diff
@@ -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
|
||||||
@@ -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')
|
||||||
@@ -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'
|
||||||
+121
-1
@@ -308,6 +308,122 @@ def test_world_health_update_known_actor_unknown_target_emits_damage_done():
|
|||||||
assert events[0]['value']['target'] is None
|
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():
|
||||||
world = World()
|
world = World()
|
||||||
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
|
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
|
||||||
@@ -360,11 +476,15 @@ 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,
|
||||||
},
|
},
|
||||||
|
|||||||
@@ -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
|
||||||
@@ -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)
|
||||||
@@ -113,6 +113,53 @@ def test_summarize_reports_fame_silver_and_player():
|
|||||||
assert 'packets: 42' 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(
|
pytestmark = pytest.mark.skipif(
|
||||||
not os.path.exists(RAW_LOG_PATH),
|
not os.path.exists(RAW_LOG_PATH),
|
||||||
reason='aoaddons.log capture fixture is not available')
|
reason='aoaddons.log capture fixture is not available')
|
||||||
|
|||||||
Reference in New Issue
Block a user