Working advanced tracking code
Build / Build source distribution (push) Failing after 13s
Build / Execute unit tests (push) Failing after 8s
Build / Verify generated game data is current (push) Failing after 7s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
Build / Build source distribution (push) Failing after 13s
Build / Execute unit tests (push) Failing after 8s
Build / Verify generated game data is current (push) Failing after 7s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
This commit is contained in:
@@ -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
|
||||
|
||||
|
||||
# --- 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():
|
||||
world = World()
|
||||
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
|
||||
@@ -360,11 +476,15 @@ def test_world_item_gained_emits_collected_item():
|
||||
world = World()
|
||||
world.transform(game('Join', {0: 63, 2: 'Alice'}))
|
||||
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 == [{
|
||||
'name': 'ItemCollected',
|
||||
'value': {
|
||||
'item_id': 522,
|
||||
'item_name': 'T4_MEAL_SALAD_FISH@3',
|
||||
'item_name': 'T1_SILVERBAG_NONTRADABLE',
|
||||
'quantity': 3,
|
||||
'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
|
||||
|
||||
|
||||
def test_summarize_breaks_damage_down_per_player():
|
||||
"""A combined total next to "main player" reads as that player's damage.
|
||||
|
||||
Two players damaged a mob; the report must attribute each share rather
|
||||
than printing one ambiguous number.
|
||||
"""
|
||||
events = [
|
||||
{'name': 'MainPlayerAppeared', 'value': {'id': 0, 'name': 'Alice'}},
|
||||
{'name': 'PlayerAppeared', 'value': {'id': 1, 'name': 'Bob'}},
|
||||
{'name': 'DamageDone', 'value': {'source': 1, 'value': 1309.0}},
|
||||
{'name': 'DamageDone', 'value': {'source': 1, 'value': 100.0}},
|
||||
{'name': 'DamageDone', 'value': {'source': 0, 'value': 232.0}},
|
||||
{'name': 'DamageTaken', 'value': {'source': 1, 'value': 244.0}},
|
||||
]
|
||||
|
||||
report = summarize(events)
|
||||
|
||||
assert 'Bob: 1409.00' in report
|
||||
assert 'Alice: 232.00' in report
|
||||
# the party-wide figure is still reported, but labelled as such
|
||||
assert 'damage done: 1641.00 (all players)' in report
|
||||
assert 'damage taken by player:' in report
|
||||
assert 'Bob: 244.00' in report
|
||||
|
||||
|
||||
def test_summarize_labels_unknown_player_ids():
|
||||
events = [
|
||||
{'name': 'MainPlayerAppeared', 'value': {'id': 0, 'name': 'Alice'}},
|
||||
{'name': 'DamageDone', 'value': {'source': 7, 'value': 50.0}},
|
||||
]
|
||||
|
||||
report = summarize(events)
|
||||
|
||||
# no appearance event for id 7, so it must not be silently attributed
|
||||
assert 'player #7: 50.00' in report
|
||||
|
||||
|
||||
def test_summarize_reports_empty_damage_sections():
|
||||
report = summarize([
|
||||
{'name': 'MainPlayerAppeared', 'value': {'id': 0, 'name': 'Alice'}},
|
||||
])
|
||||
|
||||
assert 'damage done by player:' in report
|
||||
assert 'damage taken by player:' in report
|
||||
assert '(none)' in report
|
||||
|
||||
|
||||
pytestmark = pytest.mark.skipif(
|
||||
not os.path.exists(RAW_LOG_PATH),
|
||||
reason='aoaddons.log capture fixture is not available')
|
||||
|
||||
Reference in New Issue
Block a user