Files
aostats-custom/tests/capture_analysis.py
T
bionickatana 7279b3c207
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
Working advanced tracking code
2026-10-13 09:08:38 -06:00

243 lines
8.7 KiB
Python

"""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