1172 lines
60 KiB
Python
1172 lines
60 KiB
Python
"""Experimental fixed-clock offline combat; never an original-engine replay.
|
|
|
|
The public runtime runs CPU work in a disposable module subprocess. No game
|
|
API, production engine, GUI, estimator, or AIR runtime is imported here.
|
|
``simulate`` is the direct deterministic test/research entrypoint.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from collections import Counter
|
|
from collections.abc import Mapping
|
|
from dataclasses import asdict, dataclass, field, replace
|
|
from functools import lru_cache
|
|
import gzip
|
|
import hashlib
|
|
import heapq
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
import random
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
from types import MappingProxyType
|
|
|
|
ORIGINAL_APK_SHA256 = "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d"
|
|
DATA_DIR = Path(__file__).with_name("data")
|
|
CONTEXTS = frozenset(("ordinary_stage", "task_battle", "task_pass_stage"))
|
|
KNOWN_SKILLS = frozenset((3, 5, 7, 9, 38))
|
|
FPS = 50 # Original MYRMain.app SWF header: 50 fps.
|
|
MAX_TRACE = 10000
|
|
MAX_UNITS = 1024
|
|
MAX_WIRE_BYTES = 16 * 1024 * 1024
|
|
LIMITATIONS = (
|
|
"Experimental fixed clock: not validated against original AIR battle trajectories.",
|
|
"Straight-line ground movement; collision, inertia, flight height and animation joins are approximated.",
|
|
"Nearest spatial targeting with source range box; target-search jump cadence is approximated.",
|
|
"Original hit callbacks and projectile speed inform delays; visual offsets, easing and rocket paths are omitted.",
|
|
"Skills 3, 5, 7, 9, 38 have partial source ports; all other skills are omitted and individually reported.",
|
|
"Skill presentation callbacks are replaced with immediate model activation; AI checks use modeled cadence.",
|
|
"Knockback, cosmetic equipment animations and special equipment words are omitted.",
|
|
"Python seeded RNG is not the original Random helper or Math.random stream.",
|
|
"Only elimination objectives are supported; authored controllers, triggers and active field areas are rejected.",
|
|
"Original cheat-check execution is incomplete; detected model anomalies are preserved, not a clean-engine verdict.",
|
|
)
|
|
|
|
|
|
class SimulationInputError(ValueError):
|
|
"""The model cannot interpret the supplied original inputs."""
|
|
|
|
|
|
def _get(obj, key, default=None):
|
|
return obj.get(key, default) if isinstance(obj, Mapping) else getattr(obj, key, default)
|
|
|
|
|
|
def _number(value, name="number"):
|
|
try:
|
|
result = float(value)
|
|
if isinstance(value, bool) or not math.isfinite(result):
|
|
raise ValueError
|
|
return result
|
|
except (TypeError, ValueError, OverflowError) as exc:
|
|
# Do not echo arbitrary input (potentially account material) in errors.
|
|
raise SimulationInputError(f"Invalid numeric field: {name}") from exc
|
|
|
|
|
|
def _int(value, name="integer"):
|
|
return int(_number(value, name)) # AS3 int coercion truncates toward zero.
|
|
|
|
|
|
def _freeze(value):
|
|
if isinstance(value, dict):
|
|
return MappingProxyType({k: _freeze(v) for k, v in value.items()})
|
|
if isinstance(value, list):
|
|
return tuple(_freeze(v) for v in value)
|
|
return value
|
|
|
|
|
|
def _plain(value):
|
|
if isinstance(value, Mapping):
|
|
return {str(k): _plain(v) for k, v in value.items()}
|
|
if isinstance(value, (tuple, list)):
|
|
return [_plain(v) for v in value]
|
|
return value
|
|
|
|
|
|
def _position(value):
|
|
if value is None:
|
|
return None
|
|
# Original BattlePosition fields only; never serialize arbitrary account
|
|
# envelope fields from a caller-provided object.
|
|
return {key: _get(value, key) for key in ("battleType", "stageId", "stageLevel", "taskTypeId", "taskStep")
|
|
if _get(value, key) is not None}
|
|
|
|
|
|
@lru_cache(maxsize=4)
|
|
def _combat_artifact(name, directory):
|
|
try:
|
|
directory = Path(directory)
|
|
manifest = json.loads((directory / "combat_manifest.json").read_text(encoding="utf-8"))
|
|
if manifest["schema_version"] != 1 or manifest["source"]["apk_sha256"] != ORIGINAL_APK_SHA256:
|
|
raise SimulationInputError("Combat data source identity mismatch")
|
|
meta = manifest["artifacts"][name]
|
|
artifact = (directory / name).read_bytes()
|
|
if hashlib.sha256(artifact).hexdigest() != meta["sha256"]:
|
|
raise SimulationInputError("Combat artifact hash mismatch")
|
|
decoded = gzip.decompress(artifact)
|
|
if hashlib.sha256(decoded).hexdigest() != meta["decoded_sha256"]:
|
|
raise SimulationInputError("Decoded combat artifact hash mismatch")
|
|
data = json.loads(decoded)
|
|
if data["schema_version"] != 1:
|
|
raise SimulationInputError("Unsupported combat data schema")
|
|
if name == "combat_tables.json.gz" and data.get("clock", {}).get("fps") != FPS:
|
|
raise SimulationInputError("Original combat frame rate does not match this model")
|
|
return _freeze(data)
|
|
except (OSError, KeyError, ValueError, EOFError) as exc:
|
|
if isinstance(exc, SimulationInputError):
|
|
raise
|
|
raise SimulationInputError("Cannot load bundled original combat tables") from exc
|
|
|
|
|
|
def combat_tables(directory=DATA_DIR):
|
|
"""Independent, immutable numeric/skill cache. Never opens an APK."""
|
|
return _combat_artifact("combat_tables.json.gz", directory)
|
|
|
|
|
|
def combat_battles(directory=DATA_DIR):
|
|
"""Lazy public research corpus; run/inspect never need the full corpus."""
|
|
return _combat_artifact("combat_battles.json.gz", directory)
|
|
|
|
|
|
def _envelope():
|
|
return {"execution_mode": "experimental", "approximate": True, "faithful": False,
|
|
"settlement_eligible": False, "requires_realtime_wait": True,
|
|
"experimental_settlement_eligible": False,
|
|
"experimental_eligibility_reasons": ["No completed supported model trajectory"],
|
|
"source_identity": ORIGINAL_APK_SHA256, "model": "v1.2-fixed-clock-1",
|
|
"diagnostics": [], "ignored_mechanics": list(LIMITATIONS),
|
|
"anomalies": [], "battle_data": None}
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Stats:
|
|
hp: int
|
|
atk: int
|
|
defense: int
|
|
dex: int
|
|
attack_ms: float
|
|
move_speed: float
|
|
attack_range: float
|
|
element: int
|
|
crit: float = 0
|
|
damage_reduction: float = 0
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Skill:
|
|
id: int
|
|
level: int
|
|
cost: int
|
|
cooldown_ms: int
|
|
para: Mapping
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Unit:
|
|
key: str
|
|
species: int
|
|
team: int
|
|
stats: Stats
|
|
skills: tuple
|
|
attack_type: int
|
|
mode: int = 2
|
|
position: int = 1
|
|
join_time: int = -1
|
|
wave: int = 1
|
|
join_point: str = ""
|
|
count_unit: bool = True
|
|
is_object: bool = False
|
|
auto_target: bool = True
|
|
move_immune: bool = False
|
|
ai: int = 0
|
|
ai_search: int = 2
|
|
ap_recovery: bool = False
|
|
ap_cost: int = 0
|
|
boss_point: int = 0
|
|
effects: Mapping = field(default_factory=dict)
|
|
source_id: str = ""
|
|
attack_area: str = ""
|
|
|
|
|
|
@dataclass
|
|
class Actor:
|
|
unit: Unit
|
|
hp: int
|
|
x: float = 0
|
|
y: float = 0
|
|
state: str = "waiting"
|
|
joined_ms: int | None = None
|
|
died_ms: int | None = None
|
|
next_attack: int = 0
|
|
busy_until: int = 0
|
|
next_ai: int = 0
|
|
cooldowns: dict = field(default_factory=dict)
|
|
summon_of: str | None = None
|
|
total_hurt: int = 0
|
|
damage_dealt: int = 0
|
|
healed: int = 0
|
|
stunned_until: int = 0
|
|
poison_until: int = 0
|
|
poison_at: int = 0
|
|
poison_damage: int = 0
|
|
area_hit: bool = False
|
|
combo_hits: int = 0
|
|
|
|
|
|
def _skills(species_row, mon, tables, diagnostic, *, player):
|
|
tp = min(4, _int(mon.get("tpLevel", 0)))
|
|
ids = [int(species_row.get("skill_1", 0)), int(species_row.get("skill_2", 0))]
|
|
if player and _int(mon.get("upStar", 0)) > 0:
|
|
change = tables["upstar_info"].get(str(mon["typeId"]), {}).get("skill", {})
|
|
ids = [int(change.get(str(i + 1), v)) for i, v in enumerate(ids)]
|
|
if not player:
|
|
ids = [_int(mon.get(f"skill_{i + 1}", -1)) if _int(mon.get(f"skill_{i + 1}", -1)) != -1
|
|
else v for i, v in enumerate(ids)]
|
|
levels = [tp + 1 if ids[1] <= 0 else (1 if tp == 0 else 2 if tp <= 2 else 3),
|
|
1 if tp <= 1 else 2 if tp <= 3 else 3]
|
|
result = []
|
|
for i, skill_id in enumerate(ids):
|
|
if skill_id <= 0:
|
|
continue
|
|
level = levels[i]
|
|
if not player and _int(mon.get(f"skill_{i + 1}_lv", -1)) != -1:
|
|
level = _int(mon[f"skill_{i + 1}_lv"])
|
|
row = tables["monster_skill"].get(str(skill_id), {}).get(f"lv{level}")
|
|
if skill_id not in KNOWN_SKILLS or row is None:
|
|
diagnostic("unsupported_skill", f"Skill {skill_id} level {level} is omitted", ignored=True)
|
|
continue
|
|
result.append(Skill(skill_id, level, _int(row["cost"]), _int(row["cd"]), row["para"]))
|
|
return tuple(result)
|
|
|
|
|
|
def _player(mon, attributes, master, tables, key, position, diagnostic):
|
|
for name in ("id", "typeId", "level", "gAtk", "gDef", "gHp", "gDex"):
|
|
if name not in mon:
|
|
raise SimulationInputError(f"Full roster is missing monster field {name}")
|
|
species = _int(mon["typeId"])
|
|
row = tables["monster_info"].get(str(species))
|
|
if row is None:
|
|
raise SimulationInputError("Unknown original player species")
|
|
level = _int(mon["level"])
|
|
tp = min(4, _int(mon.get("tpLevel", 0)))
|
|
feel = min(200, max(0, _int(mon.get("feel", 0)))) / 2000
|
|
feel += _int(mon.get("upStar", 0)) * tables["game_setting"].get("upStarAdd", 0)
|
|
values = {}
|
|
for stat, suffix in (("hp", "Hp"), ("atk", "Atk"), ("def", "Def"), ("dex", "Dex")):
|
|
base = _number(row[stat]) + _number(mon["g" + suffix]) * (level + tp - 1)
|
|
base += _int(attributes.get(stat, 0)) + _int(mon.get("p" + suffix, 0))
|
|
base += _int(master.get("global" + suffix, 0))
|
|
values[stat] = int((1 + feel) * base)
|
|
stats = Stats(values["hp"], values["atk"], values["def"], values["dex"],
|
|
_number(row["spd_atk"]) + int(-values["dex"] * 3 / 4)
|
|
- 1600 * _int(attributes.get("atkSpd", 0)) / 100,
|
|
_number(row["spd_move"]) + math.floor(values["dex"] / 200 * 100 + .5) / 100,
|
|
_number(row["atk_dis"]), _int(row["element"]), _int(attributes.get("crit", 0)))
|
|
mode = _int(mon.get("mode", 2))
|
|
if level < 1 or mode not in (1, 2):
|
|
raise SimulationInputError("Only hatched, positive-level roster monsters can fight")
|
|
skills = _skills(row, mon, tables, diagnostic, player=True)
|
|
ap_costs = tables["game_setting"]["apCostByStar"]
|
|
ap_cost = max(0, _int(ap_costs[_int(row["star"]) - 1]) - _int(attributes.get("apCostSave", 0)))
|
|
return Unit(key, species, 1, stats, skills, _int(row[f"atk_type{mode}"]), mode=mode,
|
|
position=position, ai=1, ap_recovery=True, ap_cost=ap_cost,
|
|
effects=_freeze({k: _int(v, k) for k, v in attributes.items() if k != "monsterId"}),
|
|
source_id=str(mon["id"]))
|
|
|
|
|
|
def _enemy(mon, team, tables, key, battle, diagnostic, master):
|
|
species = _int(mon.get("type"))
|
|
row = tables["monster_info"].get(str(species))
|
|
if row is None:
|
|
raise SimulationInputError("Unknown original configured species")
|
|
mode = _int(mon.get("mode", 2))
|
|
auto = mon.get("autoValue") is True
|
|
level = _int(mon.get("level", 1))
|
|
stats = {}
|
|
for stat in ("hp", "atk", "def", "dex"):
|
|
if auto:
|
|
stats[stat] = int(_number(row[stat]) + (_number(row[stat + "_grow_min"])
|
|
+ _number(row[stat + "_grow_max"])) / 2 * (level - 1)
|
|
+ _int(master.get("global" + stat.capitalize(), 0)))
|
|
else:
|
|
if stat not in mon:
|
|
raise SimulationInputError(f"Configured enemy is missing {stat}")
|
|
stats[stat] = _int(mon[stat], stat)
|
|
ability = 1 if mon.get("abilityScaled") else _number(battle.get("scaleAbility", 1))
|
|
hp_scale = 1 if mon.get("abilityScaled") else _number(battle.get("scaleHp", 1))
|
|
# Authored battle scales are original configuration, never an invented boost.
|
|
hp = int(stats["hp"] * hp_scale)
|
|
move = _number(mon.get("spd_mov", -1))
|
|
attack = _number(mon.get("spd_atk", -1))
|
|
distance = _number(mon.get("atk_dis", -1))
|
|
if auto:
|
|
if move == -1:
|
|
move = _number(row["spd_move"]) + math.floor(stats["dex"] / 2 + .5) / 100
|
|
if attack == -1:
|
|
attack = _number(row["spd_atk"]) + int(-stats["dex"] * 3 / 4)
|
|
if distance == -1:
|
|
distance = _number(row["atk_dis"])
|
|
if min(move, distance) < 0 or attack <= 0:
|
|
raise SimulationInputError("Configured enemy movement/range/attack interval is incomplete")
|
|
effect_keys = ("atkVim", "atkStun", "defStun", "atkStunTime", "defStunTime", "atkPoi",
|
|
"atkPoiDmg", "thorns", "selfCure", "skillCooldown", "sunFire", "moonHeal", "deadBoom")
|
|
return Unit(key, species, _int(mon.get("team", team["team"])),
|
|
Stats(hp, int(stats["atk"] * ability), int(stats["def"] * ability),
|
|
int(stats["dex"] * ability), attack, move, distance, _int(row["element"]),
|
|
_number(mon.get("crit", 0)), _number(mon.get("defDama", 0))),
|
|
_skills(row, mon, tables, diagnostic, player=False),
|
|
_int(row.get(f"atk_type{mode}", row["atk_type1"])), mode=mode,
|
|
position=_int(mon.get("teamPos", 0)), join_time=_int(mon.get("joinTime", -1)),
|
|
wave=_int(mon.get("wave", 1)), join_point=str(mon.get("joinPoint", "")),
|
|
count_unit=mon.get("countUnit", True) is not False, is_object=bool(mon.get("isObject")),
|
|
auto_target=mon.get("autoTarget", True) is not False, move_immune=bool(mon.get("moveImmune")),
|
|
ai=_int(mon.get("ai", 0)) if _int(mon.get("ai", 0)) != -1 else _int(team.get("ai", 0)),
|
|
ai_search=_int(mon.get("ai_search", 2)) if _int(mon.get("ai_search", 2)) != -1 else _int(team.get("ai_search", 2)),
|
|
ap_recovery=bool(mon.get("apRecovery")), boss_point=_int(mon.get("bossPoint", 0)),
|
|
effects=_freeze({k: _number(mon[k], k) * (ability if k in ("deadBoom", "sunFire", "moonHeal", "selfCure") else 1)
|
|
for k in effect_keys if k in mon}),
|
|
source_id=str(mon.get("mid", "")), attack_area=str(mon.get("attackArea", "")))
|
|
|
|
|
|
@dataclass
|
|
class Scenario:
|
|
units: list
|
|
teams: dict
|
|
points: dict
|
|
areas: dict
|
|
duration_ms: int
|
|
seed: int
|
|
trace_limit: int
|
|
position: object
|
|
roster_ids: tuple
|
|
|
|
|
|
def _prepare(request, tables):
|
|
report = _envelope()
|
|
report.update(supported=False, reasons=[], implemented_skills=sorted(KNOWN_SKILLS))
|
|
|
|
def diagnostic(code, message, *, ignored=False, blocking=False):
|
|
record = {"code": code, "message": message}
|
|
if record not in report["diagnostics"]:
|
|
report["diagnostics"].append(record)
|
|
if ignored and message not in report["ignored_mechanics"]:
|
|
report["ignored_mechanics"].append(message)
|
|
if blocking and message not in report["reasons"]:
|
|
report["reasons"].append(message)
|
|
|
|
try:
|
|
if _get(request, "context") not in CONTEXTS:
|
|
raise SimulationInputError("Context must be ordinary_stage, task_battle or task_pass_stage")
|
|
original = _get(request, "original_data", {})
|
|
battle = _get(original, "battle")
|
|
if not isinstance(battle, Mapping) or not battle:
|
|
raise SimulationInputError("original_data.battle must contain the full original configuration")
|
|
if list(map(_int, battle.get("winType", (1,)))) != [1] or any(
|
|
_int(x) not in (1, 2) for x in battle.get("loseType", (1, 2))):
|
|
diagnostic("objective", "Non-elimination win/loss objective is unsupported", blocking=True)
|
|
for key in ("controller", "triggers"):
|
|
for entry in battle.get(key, ()) or ():
|
|
diagnostic(key, f"Unsupported battle {key}: {_get(entry, 'type', 'unknown')}", blocking=True)
|
|
raw = _get(request, "roster", _get(request, "snapshot"))
|
|
raw = _get(raw, "raw", raw)
|
|
if not isinstance(raw, Mapping) or not isinstance(raw.get("master"), Mapping):
|
|
raise SimulationInputError("roster must be a full raw snapshot including master")
|
|
team_name = _get(request, "team", "teamA")
|
|
if not isinstance(team_name, str):
|
|
raise SimulationInputError("team must be the original team name or an ordered comma-separated id string")
|
|
team = next((t for t in raw.get("teams", ()) if t.get("teamName") == team_name), None)
|
|
if team is None:
|
|
if not team_name or any(not part.strip().isdigit() for part in team_name.split(",")):
|
|
raise SimulationInputError("Selected team is absent from the raw snapshot")
|
|
ids = [part.strip() for part in team_name.split(",")]
|
|
else:
|
|
ids = team["monsters"]
|
|
ids = [str(i) for i in ids]
|
|
selected = [i for i in ids if _int(i) > 0]
|
|
if not selected or len(selected) != len(set(selected)):
|
|
raise SimulationInputError("Team must contain distinct original roster monsters")
|
|
roster = {str(m["id"]): m for m in raw.get("monsters", ())}
|
|
attributes = {str(m["monsterId"]): m for m in raw.get("monsterAttributes", ()) or ()}
|
|
master = raw["master"]
|
|
level = _int(master.get("level", 0), "master.level")
|
|
if level < 1:
|
|
raise SimulationInputError("Raw master.level must be positive")
|
|
slots = tables["team_info"]["battleTeam"]
|
|
capacity = min(4, sum(_int(s["level"]) <= level for s in slots.values()))
|
|
game = tables["game_setting"]
|
|
player_ap = _int(game["startAp"]) + (level - 1) * _int(game["addApByLevel"])
|
|
teams = {1: {"capacity": capacity, "initial": player_ap, "max": player_ap}}
|
|
units = []
|
|
positions = (1, 4, 2, 5, 6, 7, 8, 9)
|
|
for slot, mid in enumerate(ids):
|
|
if _int(mid) <= 0:
|
|
continue
|
|
if mid not in roster or slot >= len(positions):
|
|
raise SimulationInputError("Team references a missing monster or unsupported slot")
|
|
if str(slot) not in slots or level < _int(slots[str(slot)]["level"]):
|
|
raise SimulationInputError("Selected team uses a locked original team slot")
|
|
mon = roster[mid]
|
|
effects = attributes.get(mid, {})
|
|
units.append(_player(mon, effects, master, tables, f"player-{slot + 1}", positions[slot], diagnostic))
|
|
report["anomalies"].extend(_snapshot_anomalies(mon, units[-1], tables))
|
|
if any(mon.get(f"equip{i}", 0) for i in range(1, 6)) or mon.get("skin"):
|
|
diagnostic("equipment_words", "Equipment/skin numeric bonuses use monsterAttributes; special words and skin attack overrides are omitted", ignored=True)
|
|
if battle.get("hideTeamMon"):
|
|
units = [] # BattleCenter empties the master team before adding authored allies.
|
|
for ti, team in enumerate(battle.get("teams", ())):
|
|
team_id = _int(team.get("team", 2))
|
|
initial_ap = _int(team.get("ap", 0))
|
|
config = {"capacity": _int(team.get("numMax", 0)), "initial": initial_ap, "max": initial_ap * 2}
|
|
teams.setdefault(team_id, config)
|
|
for mi, mon in enumerate(team.get("mons", ())):
|
|
if mon is None:
|
|
continue
|
|
if not isinstance(mon, Mapping):
|
|
raise SimulationInputError("Enemy configuration contains a non-object monster")
|
|
for controller in mon.get("controller", ()) or ():
|
|
diagnostic("unit_controller", f"Unsupported monster controller: {_get(controller, 'type', 'unknown')}", blocking=True)
|
|
if mon.get("protectTarget") or mon.get("destroyTarget"):
|
|
diagnostic("unit_objective", "Protected/destroy objective units are unsupported", blocking=True)
|
|
unit = _enemy(mon, dict(team, team=team_id), tables, f"configured-{ti + 1}-{mi + 1}", battle, diagnostic, master)
|
|
teams.setdefault(unit.team, config.copy())
|
|
units.append(unit)
|
|
if not any(u.team != 1 and not u.is_object for u in units):
|
|
raise SimulationInputError("Elimination battle must contain configured enemies")
|
|
for team in teams.values():
|
|
if team["capacity"] <= 0 or team["initial"] < 0:
|
|
raise SimulationInputError("Original team capacity/AP is invalid")
|
|
field_config = battle.get("battleField")
|
|
if not isinstance(field_config, Mapping):
|
|
raise SimulationInputError("Full original battleField configuration is required")
|
|
if field_config.get("fieldMode"):
|
|
name = field_config.get("fieldName", "default")
|
|
original_field = tables["setting"]["defaultField"].get(name)
|
|
if original_field is None:
|
|
raise SimulationInputError("Unknown original default battlefield")
|
|
field_config = dict(original_field, mapObjects=field_config.get("mapObjects", ()),
|
|
mapAreas=tuple(original_field.get("mapAreas", ())) + tuple(field_config.get("mapAreas", ())))
|
|
points = {p["id"]: p for p in field_config.get("mapPoints", ())}
|
|
areas = {a["id"]: a for a in field_config.get("mapAreas", ())}
|
|
if "area_battlefield" not in areas or not points:
|
|
raise SimulationInputError("Battlefield needs original points and area_battlefield")
|
|
for area in areas.values():
|
|
if area.get("type", "none") != "none":
|
|
diagnostic("field_effect", f"Unsupported active field area: {area.get('type')}", blocking=True)
|
|
if field_config.get("mapObjects"):
|
|
diagnostic("ground_objects", "Battlefield ground object collision/decoration is omitted", ignored=True)
|
|
for u in units:
|
|
if u.stats.hp <= 0 or u.stats.atk < 0 or u.stats.defense < 0 or u.stats.dex < 0:
|
|
raise SimulationInputError("Original computed combat stats must be nonnegative with positive HP")
|
|
if u.stats.attack_ms <= 0:
|
|
raise SimulationInputError("Original computed attack interval is nonpositive; no clamping is applied")
|
|
if u.attack_type and str(u.attack_type) not in tables["attack_profiles"]:
|
|
diagnostic("attack_profile", f"Attack {u.attack_type} has no bundled source profile; original default AttackType1 is approximated", ignored=True)
|
|
if u.effects.get("sunFire") or u.effects.get("moonHeal") or u.effects.get("deadBoom"):
|
|
diagnostic("unimplemented_effect", "sunFire, moonHeal and deadBoom effects are omitted where present", ignored=True)
|
|
if u.attack_area and u.attack_area not in areas:
|
|
raise SimulationInputError("Configured attackArea is absent from original battlefield")
|
|
if u.join_point and not u.join_point.startswith("mon_") and u.join_point not in points:
|
|
raise SimulationInputError("Configured joinPoint is absent from original battlefield")
|
|
if not u.join_point:
|
|
default_point = f"point_team{u.team}_{'fore' if u.position < 3 else 'back'}{u.position + 1 if u.position < 3 else u.position - 2}"
|
|
if (u.position >= 6 or default_point not in points) and not any(
|
|
p.startswith(f"point_team{u.team}_wait") for p in points):
|
|
raise SimulationInputError("Original battlefield lacks a required team spawn point")
|
|
duration = _int(battle.get("time", -1))
|
|
duration = _int(game["normalBattleTime"]) if duration == -1 else duration
|
|
if duration <= 0:
|
|
raise SimulationInputError("Original battle clock must be positive")
|
|
seed = _int(_get(request, "seed", 0), "seed")
|
|
trace_limit = _int(_get(request, "trace_limit", 2000), "trace_limit")
|
|
if trace_limit < 0 or trace_limit > MAX_TRACE:
|
|
raise SimulationInputError(f"trace_limit must be in 0..{MAX_TRACE}")
|
|
if len(units) > MAX_UNITS:
|
|
diagnostic("resource_limit", "Initial configured unit count exceeds the model resource limit", blocking=True)
|
|
report["units"] = [_unit_preview(u) for u in units]
|
|
report["teams"] = _plain(teams)
|
|
report["duration_ms"] = duration * 1000
|
|
report["supported"] = not report["reasons"]
|
|
return Scenario(units, teams, points, areas, duration * 1000, seed, trace_limit,
|
|
_position(_get(request, "battle_position")),
|
|
tuple(_int(mid) for mid in selected) if not battle.get("hideTeamMon") else ()), report
|
|
except (SimulationInputError, KeyError, TypeError, AttributeError, IndexError) as exc:
|
|
message = str(exc) if isinstance(exc, SimulationInputError) else "Malformed original combat input"
|
|
diagnostic("input", message, blocking=True)
|
|
return None, report
|
|
|
|
|
|
def _unit_preview(unit):
|
|
return {"id": unit.key, "species": unit.species, "team": unit.team,
|
|
"stats": asdict(unit.stats), "attack_type": unit.attack_type, "mode": unit.mode,
|
|
"skills": [{"id": s.id, "level": s.level, "cost": s.cost,
|
|
"cooldown_ms": s.cooldown_ms, "para": _plain(s.para)} for s in unit.skills],
|
|
"wave": unit.wave, "join_time_seconds": unit.join_time, "position": unit.position,
|
|
"count_unit": unit.count_unit, "is_object": unit.is_object, "ap_cost": unit.ap_cost}
|
|
|
|
|
|
def _snapshot_anomalies(mon, unit, tables):
|
|
"""Port the observable input checks from BattlePanel.cheatCheck.
|
|
|
|
These are a subset of the final original checks, not a claim to have run
|
|
them all. Keep raw input values; never repair them to make checks pass.
|
|
"""
|
|
if _number(mon["id"]) < 99999: # Source exempts temporary/NPC ids.
|
|
return []
|
|
records = []
|
|
|
|
def add(code, points, **fields):
|
|
records.append({"at_ms": 0, "code": code, "source_cheat_points": points,
|
|
"target": unit.key, **fields})
|
|
|
|
row = tables["monster_info"][str(unit.species)]
|
|
potential_level = _int(mon.get("potentialLevel", 1))
|
|
tp = min(4, _int(mon.get("tpLevel", 0)))
|
|
if _number(mon.get("feel", 0)) > 200:
|
|
add("+15overfeel", 50, feel=mon["feel"])
|
|
potential = tables["potential_info"]["potential"].get(str(row["job"]), {}).get(str(row["star"]), {})
|
|
for stat, value in (("atk", unit.stats.atk), ("def", unit.stats.defense),
|
|
("hp", unit.stats.hp), ("dex", unit.stats.dex)):
|
|
maximum = row[stat] + row[stat + "_grow_max"] * (_int(mon["level"]) + potential_level) * 4
|
|
if value > maximum:
|
|
add("+15overgrow", 25, stat=stat, value=value, source_maximum=maximum)
|
|
max_potential = potential.get(stat, 0) + potential.get(stat + "TpAdd", 0) * tp
|
|
value_potential = _number(mon.get("p" + stat.capitalize(), 0))
|
|
if potential and value_potential > max_potential * 1.5:
|
|
add("+15overpoten", 30, stat=stat, value=value_potential, source_maximum=max_potential * 1.5)
|
|
maximum_level = potential_level * tables["potential_info"]["potentialLevelMaxAdd"]
|
|
if _int(mon["level"]) > maximum_level:
|
|
add("+50overlv", 50, level=mon["level"], source_maximum=maximum_level)
|
|
return records
|
|
|
|
|
|
def damage_roll(attack, attacker_dex, defender, game, rng):
|
|
"""GameMath.damage, including int stages and positive Math.round semantics."""
|
|
difference = min(80, max(-80, attacker_dex - defender.dex))
|
|
low = .8 + .3 * max(0, difference) / 80
|
|
high = 1.2 + .3 * min(0, difference) / 80
|
|
raw = attack * game["countDamagePerAtk"] * rng.uniform(low, high)
|
|
raw -= defender.defense * (game["countGuardPerDef"] * .75
|
|
+ rng.uniform(0, game["countGuardPerDef"] * .25))
|
|
return max(1, math.floor(raw + .5))
|
|
|
|
|
|
class _Battle:
|
|
def __init__(self, scenario, report, tables):
|
|
self.s = scenario
|
|
self.report = report
|
|
self.tables = tables
|
|
self.game = tables["game_setting"]
|
|
self.rng = random.Random(scenario.seed)
|
|
self.actors = [Actor(u, u.stats.hp) for u in scenario.units]
|
|
self.by_key = {a.unit.key: a for a in self.actors}
|
|
self.ap = {team: dict(initial=v["initial"], current=v["initial"], max=v["max"], spent=0, recovered=0)
|
|
for team, v in scenario.teams.items()}
|
|
self.wave = {team: 1 for team in scenario.teams}
|
|
self.wave_due = {}
|
|
self.queue = []
|
|
self.sequence = 0
|
|
self.now = 0
|
|
self.events = []
|
|
self.omitted_events = 0
|
|
self.anomalies = list(report["anomalies"])
|
|
self.kill_monster = Counter()
|
|
self.all_kills = Counter()
|
|
self.deaths = Counter()
|
|
self.hp_lost = Counter()
|
|
self.boss_points = 0
|
|
self.next_ap = _int(self.game["apCD"])
|
|
self.next_deploy = 0
|
|
self.complete_at = None
|
|
self.resource_limited = False
|
|
self.skill_used = False
|
|
|
|
def event(self, kind, **fields):
|
|
record = {"at_ms": self.now, "type": kind, **fields}
|
|
if len(self.events) < self.s.trace_limit:
|
|
self.events.append(record)
|
|
else:
|
|
self.omitted_events += 1
|
|
|
|
def anomaly(self, code, points=0, **fields):
|
|
# No score normalization, record removal, or threshold avoidance.
|
|
self.anomalies.append({"at_ms": self.now, "code": code, "source_cheat_points": points, **fields})
|
|
if len(self.anomalies) >= 10000:
|
|
self.resource_limited = True
|
|
|
|
def schedule(self, delay, kind, **fields):
|
|
self.sequence += 1
|
|
heapq.heappush(self.queue, (self.now + max(0, delay), self.sequence, kind, fields))
|
|
|
|
def active(self):
|
|
return [a for a in self.actors if a.state == "active" and a.hp > 0]
|
|
|
|
def living(self, team):
|
|
return [a for a in self.actors if a.unit.team == team and a.state != "dead" and not a.unit.is_object]
|
|
|
|
def terminal_team_size(self, team):
|
|
# BattleGround.checkGameOver counts objects differently from getAliveNum.
|
|
return sum(a.unit.team == team and a.state != "dead"
|
|
and (team == 1 or a.state == "active" or not a.unit.is_object) for a in self.actors)
|
|
|
|
def add_ap(self, team, amount, reason):
|
|
ap = self.ap[team]
|
|
before = ap["current"]
|
|
ap["current"] = min(ap["max"], int(ap["current"] + amount))
|
|
ap["recovered"] += ap["current"] - before
|
|
self.event("ap", team=team, amount=ap["current"] - before, current=ap["current"], reason=reason)
|
|
|
|
def spend_ap(self, team, amount, actor, skill):
|
|
ap = self.ap[team]
|
|
if ap["current"] < amount:
|
|
return False
|
|
ap["current"] -= amount
|
|
ap["spent"] += amount
|
|
self.event("ap", team=team, amount=-amount, current=ap["current"], reason="skill", actor=actor, skill=skill)
|
|
return True
|
|
|
|
def spawn_point(self, actor):
|
|
unit = actor.unit
|
|
point = unit.join_point
|
|
if point.startswith("mon_"):
|
|
original_id = point[4:]
|
|
target = next((a for a in self.actors if a.unit.source_id == original_id and a.joined_ms is not None), None)
|
|
if target:
|
|
return target.x, target.y
|
|
point = f"point_team{unit.team}_wait1"
|
|
if not point:
|
|
pos = unit.position
|
|
point = f"point_team{unit.team}_{'fore' if pos < 3 else 'back'}{pos + 1 if pos < 3 else pos - 2}"
|
|
if point not in self.s.points or pos >= 6:
|
|
names = sorted(p for p in self.s.points if p.startswith(f"point_team{unit.team}_wait"))
|
|
point = self.rng.choice(names) if names else ""
|
|
location = self.s.points.get(point)
|
|
if location is None:
|
|
raise SimulationInputError("Original battlefield lacks a required team spawn point")
|
|
return (_number(location["x"]) + self.rng.random() * _number(location.get("w", 0)),
|
|
_number(location["y"]) + self.rng.random() * _number(location.get("h", 0)))
|
|
|
|
def deploy(self):
|
|
for actor in self.actors:
|
|
u = actor.unit
|
|
if actor.state != "waiting" or u.wave > self.wave[u.team] or u.join_time * 1000 > self.now:
|
|
continue
|
|
count = sum(a.state == "active" and a.unit.team == u.team and a.unit.count_unit for a in self.actors)
|
|
if u.count_unit and count >= self.s.teams[u.team]["capacity"]:
|
|
continue
|
|
actor.x, actor.y = self.spawn_point(actor)
|
|
actor.state = "active"
|
|
actor.joined_ms = self.now
|
|
# Initial Cooldowner readiness is approximated as ready at deployment.
|
|
actor.next_attack = self.now
|
|
actor.next_ai = self.now + self.ai_interval(u)
|
|
for slot, skill in enumerate(u.skills):
|
|
actor.cooldowns[slot] = self.now + (2000 if u.team == 2 else 0)
|
|
if self.now > 1 and u.ap_recovery:
|
|
self.add_ap(u.team, self.ap[u.team]["max"] * self.game["addApByJoinMon"], "join")
|
|
self.event("deploy", actor=u.key, team=u.team, wave=u.wave, x=actor.x, y=actor.y,
|
|
count_unit=u.count_unit, ap_charged=0)
|
|
|
|
@staticmethod
|
|
def ai_interval(unit):
|
|
# BattleMon.setAutoSkill explicitly changes the player Jumper to 30.
|
|
frames = 30 if unit.team == 1 and unit.ai == 1 else 20 if unit.ai == 4 else 60 if unit.ai == 3 else 100
|
|
return frames * 1000 // FPS
|
|
|
|
def target(self, actor):
|
|
u = actor.unit
|
|
choices = [b for b in self.active() if b.unit.team != u.team]
|
|
if u.attack_area:
|
|
area = self.s.areas[u.attack_area]
|
|
choices = [b for b in choices if area["x"] <= b.x <= area["x"] + area["w"]
|
|
and area["y"] <= b.y <= area["y"] + area["h"]]
|
|
auto = [b for b in choices if b.unit.auto_target]
|
|
choices = auto or choices
|
|
if not choices:
|
|
return None
|
|
chosen = min(choices, key=lambda b: (math.hypot(b.x - actor.x, b.y - actor.y), b.unit.key))
|
|
if u.ai_search >= 3:
|
|
near = [b for b in choices if math.hypot(b.x - actor.x, b.y - actor.y) < u.stats.attack_range * 1.2]
|
|
if near:
|
|
chosen = max(near, key=lambda b: b.unit.stats.atk)
|
|
wounded = [b for b in near if b.hp / b.unit.stats.hp < .2]
|
|
if u.ai_search >= 4 and wounded:
|
|
chosen = min(wounded, key=lambda b: b.hp / b.unit.stats.hp)
|
|
return chosen
|
|
|
|
def in_range(self, actor, target):
|
|
distance = actor.unit.stats.attack_range
|
|
return abs(target.x - actor.x) < distance and abs(target.y - actor.y) < distance * .5
|
|
|
|
def profile(self, actor):
|
|
attack_type = 28 if actor.combo_hits else actor.unit.attack_type
|
|
return self.tables["attack_profiles"].get(str(attack_type), self.tables["attack_profiles"]["1"])
|
|
|
|
def cast(self, actor, target):
|
|
if self.skill_used or actor.summon_of or actor.next_ai > self.now or actor.unit.ai_search == 0:
|
|
return False
|
|
if actor.unit.team != 1 and actor.unit.ai < 1:
|
|
return False
|
|
actor.next_ai = self.now + self.ai_interval(actor.unit)
|
|
for slot, skill in enumerate(actor.unit.skills):
|
|
if actor.cooldowns[slot] > self.now:
|
|
continue
|
|
if skill.id == 5:
|
|
willing = target is not None and math.hypot(target.x - actor.x, target.y - actor.y) > actor.unit.stats.attack_range * 2
|
|
else:
|
|
willing = self.rng.random() < {3: .15, 7: .2, 9: .2, 38: .25}[skill.id]
|
|
if not willing or not self.spend_ap(actor.unit.team, skill.cost, actor.unit.key, skill.id):
|
|
continue
|
|
reduction = actor.unit.effects.get("skillCooldown", 0)
|
|
actor.cooldowns[slot] = self.now + max(0, int(skill.cooldown_ms / (1 + reduction / 100)))
|
|
self.event("skill", actor=actor.unit.key, skill=skill.id, level=skill.level)
|
|
self.skill_used = True
|
|
if skill.id in (3, 7):
|
|
self.summon(actor, skill)
|
|
elif skill.id == 5 and target is not None:
|
|
# Source impulse is one initial speed; approximate the impulse
|
|
# with a single displacement. No damage/stat adjustment.
|
|
dx, dy = target.x - actor.x, target.y - actor.y
|
|
distance = math.hypot(dx, dy)
|
|
step = min(distance, _number(skill.para["speed"]))
|
|
if distance:
|
|
actor.x += step * dx / distance
|
|
actor.y += step * dy / distance
|
|
removed = [e for e in self.queue if e[2] == "impact" and e[3].get("target") == actor.unit.key and e[3].get("projectile")]
|
|
self.queue = [e for e in self.queue if e not in removed]
|
|
heapq.heapify(self.queue)
|
|
for item in removed:
|
|
self.event("projectile_lost", actor=item[3]["attacker"], target=actor.unit.key, reason="skill5")
|
|
self.event("dash", actor=actor.unit.key, x=actor.x, y=actor.y, lost_projectiles=len(removed))
|
|
elif skill.id == 9:
|
|
actor.area_hit = True
|
|
actor.next_attack = self.now
|
|
elif skill.id == 38:
|
|
actor.combo_hits = 4
|
|
actor.next_attack = self.now
|
|
return True
|
|
return False
|
|
|
|
def summon(self, parent, skill):
|
|
for index in range(3 if skill.id == 7 else 1):
|
|
if len(self.actors) >= MAX_UNITS:
|
|
self.resource_limited = True
|
|
self.anomaly("unit_resource_limit", parent=parent.unit.key)
|
|
return
|
|
ability = _number(skill.para["ability"])
|
|
base = parent.unit.stats
|
|
# Skill3 uses current HP, Skill7 scaleAbility resets scaled max HP.
|
|
hp = max(1, int((parent.hp if skill.id == 3 else base.hp) * ability))
|
|
# BattleMonVo.clone rebuilds speed from the original MonsterVo,
|
|
# then overwrites only atk/def/dex/range/crit from the battle copy.
|
|
new_stats = replace(base, hp=hp, atk=int(base.atk * ability),
|
|
defense=int(base.defense * ability), dex=int(base.dex * ability))
|
|
key = f"summon-{len(self.actors) + 1}"
|
|
unit = replace(parent.unit, key=key, stats=new_stats, skills=(), count_unit=False,
|
|
ap_recovery=False, position=100, ap_cost=1 if skill.id == 7 else parent.unit.ap_cost,
|
|
effects=_freeze({"deadBoom": parent.unit.effects.get("deadBoom", 0)}))
|
|
actor = Actor(unit, hp, parent.x, parent.y + (index - 1) * 4, "active", self.now,
|
|
summon_of=parent.unit.key, next_ai=self.now + 2000)
|
|
self.actors.append(actor)
|
|
self.by_key[key] = actor
|
|
self.event("summon", actor=key, parent=parent.unit.key, skill=skill.id, hp=hp,
|
|
atk=new_stats.atk, defense=new_stats.defense, dex=new_stats.dex, count_unit=False)
|
|
|
|
def heal(self, actor, amount, reason):
|
|
if actor.state != "active":
|
|
return
|
|
if actor.unit.team == 1 and int(amount) > 20000:
|
|
self.anomaly("+15overcure", points=19, actor=actor.unit.key, cure=int(amount), reason=reason)
|
|
amount = max(0, min(int(amount), actor.unit.stats.hp - actor.hp))
|
|
actor.hp += amount
|
|
actor.healed += amount
|
|
if amount:
|
|
self.event("heal", actor=actor.unit.key, amount=amount, hp=actor.hp, reason=reason)
|
|
|
|
def hurt(self, actor, amount, attacker, reason):
|
|
if actor.state != "active":
|
|
return 0
|
|
amount = max(0, int(int(amount) * (1 - actor.unit.stats.damage_reduction)))
|
|
lost = min(actor.hp, amount)
|
|
actor.hp -= lost
|
|
actor.total_hurt += amount
|
|
self.hp_lost[actor.unit.team] += lost
|
|
if actor.unit.boss_point == -1:
|
|
self.boss_points += lost
|
|
if attacker:
|
|
attacker.damage_dealt += lost
|
|
self.event("damage", actor=attacker.unit.key if attacker else None, target=actor.unit.key,
|
|
damage=amount, hp_lost=lost, hp=actor.hp, reason=reason)
|
|
if amount > 80000: # BattleMon.beHurt original threshold, no cap.
|
|
self.anomaly("+10overdamage", points=10, damage=amount, hurt_team=actor.unit.team,
|
|
actor=attacker.unit.key if attacker else None, target=actor.unit.key)
|
|
if actor.hp == 0:
|
|
actor.state = "dead"
|
|
actor.died_ms = self.now
|
|
if actor.unit.boss_point > 0:
|
|
self.boss_points += actor.unit.boss_point
|
|
if not actor.unit.is_object:
|
|
self.deaths[actor.unit.team] += 1
|
|
if actor.unit.team != 1 and not actor.unit.is_object:
|
|
self.all_kills[str(actor.unit.species)] += 1
|
|
if actor.unit.mode == 2:
|
|
self.kill_monster[str(actor.unit.species)] += 1
|
|
if actor.total_hurt == 0:
|
|
self.anomaly("+1k_cheatDead", points=1000, target=actor.unit.key)
|
|
self.event("death", actor=actor.unit.key, team=actor.unit.team, summon=bool(actor.summon_of))
|
|
self.complete_at = self.now + 1000 # Original delayed checkGameOver.
|
|
return amount
|
|
|
|
def impact(self, fields):
|
|
attacker = self.by_key[fields["attacker"]]
|
|
target = self.by_key[fields["target"]]
|
|
if target.state != "active" or (attacker.state != "active" and not fields.get("projectile")):
|
|
self.event("miss", actor=attacker.unit.key, target=target.unit.key, reason="dead_target_or_attacker")
|
|
return
|
|
attack = fields["atk"]
|
|
dex = attacker.unit.stats.dex
|
|
quarters = int((dex - target.unit.stats.dex) / 4)
|
|
crit = .02 + attacker.unit.stats.crit / 100 + (quarters / (quarters + 120) if quarters >= 0 else 0)
|
|
critical = self.rng.random() < crit
|
|
if critical:
|
|
attack = int(attack * self.game["critAdd"])
|
|
if attacker.combo_hits > 0 and attacker.state == "active":
|
|
skill = next(s for s in attacker.unit.skills if s.id == 38)
|
|
attack = int(attack * self.rng.uniform(skill.para["min"], skill.para["max"]))
|
|
attacker.combo_hits -= 1
|
|
if attacker.combo_hits:
|
|
attacker.next_attack = self.now + 50
|
|
if attacker.area_hit:
|
|
attacker.area_hit = False
|
|
skill = next(s for s in attacker.unit.skills if s.id == 9)
|
|
for other in list(self.active()):
|
|
if other is target or other.unit.team == attacker.unit.team:
|
|
continue
|
|
# findMonsByMonNear expands +/- w,h into a 2w by 2h box.
|
|
if abs(other.x - target.x) <= 150 and abs(other.y - target.y) <= 91:
|
|
self.apply_damage(attacker, other, int(attacker.unit.stats.atk * skill.para["areahurt"]), "skill9_area")
|
|
self.apply_damage(attacker, target, attack, "attack", critical=critical)
|
|
|
|
def apply_damage(self, attacker, target, attack, reason, critical=False):
|
|
stats = attacker.unit.stats
|
|
counter = self.tables["monster_setting"]["element"].get(str(stats.element), {}).get("counter")
|
|
if counter == target.unit.stats.element:
|
|
attack = int(attack * self.game["counterAdd"])
|
|
amount = damage_roll(attack, stats.dex, target.unit.stats, self.game, self.rng)
|
|
amount = self.hurt(target, amount, attacker, reason)
|
|
if reason != "attack":
|
|
return
|
|
effects = attacker.unit.effects
|
|
if target.state == "active" and self.rng.random() < effects.get("atkStun", 0) / 100:
|
|
target.stunned_until = self.now + int(effects.get("atkStunTime", 2) * 1000)
|
|
self.event("stun", actor=target.unit.key, until_ms=target.stunned_until)
|
|
if target.state == "active" and self.rng.random() < effects.get("atkPoi", 0) / 100:
|
|
target.poison_until = self.now + 5000
|
|
target.poison_at = self.now + 1000
|
|
target.poison_damage = int(effects.get("atkPoiDmg", 0))
|
|
self.event("poison", actor=target.unit.key, until_ms=target.poison_until, damage=target.poison_damage)
|
|
if self.rng.random() < target.unit.effects.get("defStun", 0) / 100:
|
|
attacker.stunned_until = self.now + int(target.unit.effects.get("defStunTime", 2) * 1000)
|
|
self.event("stun", actor=attacker.unit.key, until_ms=attacker.stunned_until)
|
|
thorn = target.unit.effects.get("thorns", 0)
|
|
if thorn > 0:
|
|
self.hurt(attacker, max(1, int(amount * thorn / 100)), None, "thorns")
|
|
if effects.get("atkVim", 0) > 0:
|
|
self.heal(attacker, amount * effects["atkVim"] / 100, "lifesteal")
|
|
|
|
def advance_waves(self):
|
|
for team in self.s.teams:
|
|
if team in self.wave_due:
|
|
if self.now >= self.wave_due[team]:
|
|
self.wave[team] += 1
|
|
del self.wave_due[team]
|
|
self.event("wave", team=team, wave=self.wave[team])
|
|
continue
|
|
current = self.wave[team]
|
|
relevant = [a for a in self.actors if a.unit.team == team and a.state != "dead"]
|
|
if any(a.unit.wave == current for a in relevant):
|
|
continue
|
|
if any(a.unit.wave == current + 1 for a in relevant):
|
|
self.wave_due[team] = self.now + 700
|
|
self.event("wave_wait", team=team, next_wave=current + 1, until_ms=self.now + 700)
|
|
|
|
def tick(self):
|
|
self.skill_used = False
|
|
if self.now >= self.next_ap:
|
|
for team in self.ap:
|
|
if self.ap[team]["current"] < self.ap[team]["max"]:
|
|
self.add_ap(team, 1, "clock")
|
|
self.next_ap += _int(self.game["apCD"])
|
|
self.advance_waves()
|
|
if self.now >= self.next_deploy:
|
|
self.deploy()
|
|
self.next_deploy = (self.now // 1000 + 1) * 1000
|
|
while self.queue and self.queue[0][0] <= self.now:
|
|
_, _, kind, fields = heapq.heappop(self.queue)
|
|
if kind == "impact":
|
|
self.impact(fields)
|
|
elif kind == "launch":
|
|
actor, target = self.by_key[fields["attacker"]], self.by_key[fields["target"]]
|
|
if actor.state != "active" or target.state != "active":
|
|
continue
|
|
if fields["projectile"]:
|
|
distance = math.hypot(target.x - actor.x, target.y - actor.y)
|
|
travel = max(0, int((distance - 30) / fields.pop("speed") * 1000 / FPS))
|
|
self.event("projectile", actor=actor.unit.key, target=target.unit.key, travel_ms=travel)
|
|
self.schedule(travel, "impact", **fields)
|
|
else:
|
|
self.impact(fields)
|
|
for actor in list(self.active()):
|
|
u = actor.unit
|
|
if actor.poison_until >= self.now and actor.poison_at and actor.poison_at <= self.now:
|
|
self.hurt(actor, actor.poison_damage, None, "poison")
|
|
actor.poison_at += 1000
|
|
if actor.state != "active":
|
|
continue
|
|
if u.effects.get("selfCure", 0) > 0 and self.now > actor.joined_ms and (self.now - actor.joined_ms) % 5000 == 0:
|
|
self.heal(actor, u.effects["selfCure"], "selfCure")
|
|
if u.is_object or u.ai_search == 0 or self.now < actor.busy_until or self.now < actor.stunned_until:
|
|
continue
|
|
target = self.target(actor)
|
|
if self.cast(actor, target):
|
|
continue
|
|
if target is None:
|
|
continue
|
|
if self.in_range(actor, target):
|
|
if self.now < actor.next_attack:
|
|
continue
|
|
profile = self.profile(actor)
|
|
recovery = 150 if actor.combo_hits else 300
|
|
delay = profile["hit_delay_ms"]
|
|
actor.next_attack = self.now + max(1, int(u.stats.attack_ms))
|
|
actor.busy_until = self.now + delay + recovery
|
|
self.event("attack", actor=u.key, target=target.unit.key, hit_delay_ms=delay)
|
|
self.schedule(delay, "launch", attacker=u.key, target=target.unit.key,
|
|
atk=u.stats.atk, projectile=profile["projectile"], speed=profile["projectile_speed"])
|
|
elif not u.move_immune:
|
|
dx, dy = target.x - actor.x, target.y - actor.y
|
|
distance = math.hypot(dx, dy)
|
|
# Source Pointer.Point2Point uses spd_mov per frame.
|
|
step = min(distance, u.stats.move_speed)
|
|
if distance:
|
|
actor.x += step * dx / distance
|
|
actor.y += step * dy / distance
|
|
if self.now % 1000 == 0:
|
|
self.event("move", actor=u.key, target=target.unit.key, x=actor.x, y=actor.y)
|
|
|
|
def result(self, outcome, timeout_kind=None):
|
|
result = dict(self.report)
|
|
completed = outcome in ("win", "loss")
|
|
result.update(outcome=outcome, elapsed_ms=self.now, elapsed_seconds=self.now / 1000,
|
|
execution_status="completed" if completed else "cancelled" if outcome == "cancelled" else "error" if outcome == "error" else "timed_out",
|
|
terminal=completed, terminal_reason="elimination" if completed else timeout_kind or outcome,
|
|
units=[dict(_unit_preview(a.unit), hp=a.hp, x=a.x, y=a.y, state=a.state,
|
|
joined_ms=a.joined_ms, died_ms=a.died_ms, summon_of=a.summon_of,
|
|
damage_dealt=a.damage_dealt, total_hurt=a.total_hurt, healed=a.healed)
|
|
for a in self.actors],
|
|
events=self.events, trace_truncated=bool(self.omitted_events), omitted_events=self.omitted_events,
|
|
ap={str(k): v for k, v in self.ap.items()}, kills=sum(self.all_kills.values()),
|
|
all_kills=dict(self.all_kills), kill_monster=dict(self.kill_monster),
|
|
deaths={str(k): v for k, v in self.deaths.items()},
|
|
damage_hp_lost={str(k): v for k, v in self.hp_lost.items()},
|
|
anomalies=self.anomalies,
|
|
alive_num=len(self.living(1)), timeout_kind=timeout_kind,
|
|
source_field_notes={"killMonster": "non-player, non-object, mode==2 deaths (including summons)",
|
|
"aliveNum": "waiting plus active non-object player units, including summons",
|
|
"totalDamage": "declared AS3 int default 0; no source updates located",
|
|
"killNum": "declared AS3 int default 0; no source updates located",
|
|
"deadNum": "declared AS3 int default 0; no source updates located"})
|
|
if outcome in ("win", "loss"):
|
|
result["battle_data"] = {"win": outcome == "win", "leftTime": max(0, self.s.duration_ms - self.now),
|
|
"aliveNum": result["alive_num"], "apLeft": self.ap[1]["current"],
|
|
"battleMonIds": list(self.s.roster_ids),
|
|
"killMonster": dict(self.kill_monster), "killNum": 0, "deadNum": 0, "totalDamage": 0,
|
|
"bossDamage": self.boss_points,
|
|
"cheatNum": sum(r["source_cheat_points"] for r in self.anomalies),
|
|
"cheatRecords": _plain(self.anomalies)}
|
|
if self.s.position is not None:
|
|
result["battle_data"]["battlePosition"] = self.s.position
|
|
result["experimental_eligibility_reasons"] = []
|
|
if self.anomalies:
|
|
result["experimental_eligibility_reasons"].append("Detected model anomalies must be reviewed")
|
|
if not result["supported"] or result.get("reasons"):
|
|
result["experimental_eligibility_reasons"].append("Unresolved original combat inputs")
|
|
result["experimental_settlement_eligible"] = not result["experimental_eligibility_reasons"]
|
|
return result
|
|
|
|
|
|
def simulate(request, *, cancel_event=None, timeout=30.0, tables=None):
|
|
"""Execute a seeded offline model directly. Runtime.run isolates CPU work.
|
|
|
|
``timeout`` is wall-clock seconds; original ``battle.time`` independently
|
|
controls modeled battle expiry. Neither path synthesizes a win.
|
|
"""
|
|
started = time.monotonic()
|
|
timeout = _number(timeout, "timeout")
|
|
if timeout < 0:
|
|
raise SimulationInputError("timeout must be nonnegative")
|
|
tables = tables if tables is not None else combat_tables()
|
|
scenario, report = _prepare(request, tables)
|
|
if not report["supported"]:
|
|
return dict(report, outcome="unsupported", elapsed_ms=0, elapsed_seconds=0,
|
|
execution_status="unsupported", terminal=False, terminal_reason="unsupported_scenario",
|
|
events=[], units=report.get("units", []))
|
|
battle = _Battle(scenario, report, tables)
|
|
for tick in range(min(scenario.duration_ms // (1000 // FPS) + 1, 180001)):
|
|
battle.now = tick * 1000 // FPS
|
|
if cancel_event is not None and cancel_event.is_set():
|
|
return battle.result("cancelled")
|
|
if time.monotonic() - started >= timeout:
|
|
return battle.result("timeout", "wall_clock")
|
|
if battle.now >= scenario.duration_ms:
|
|
battle.event("complete", outcome="loss", reason="battle_time_limit")
|
|
result = battle.result("loss")
|
|
result["terminal_reason"] = "battle_time_limit"
|
|
return result
|
|
try:
|
|
battle.tick()
|
|
except Exception as exc:
|
|
result = battle.result("error")
|
|
result["terminal_reason"] = "model_execution_failure"
|
|
result["diagnostics"] = list(result["diagnostics"]) + [{"code": "execution", "message": type(exc).__name__}]
|
|
return result # Keep every anomaly and partial trajectory already observed.
|
|
if battle.resource_limited:
|
|
return battle.result("timeout", "resource_limit")
|
|
if battle.complete_at is not None and battle.now >= battle.complete_at:
|
|
if not battle.terminal_team_size(1):
|
|
battle.event("complete", outcome="loss")
|
|
return battle.result("loss")
|
|
if not any(battle.terminal_team_size(team) for team in scenario.teams if team != 1):
|
|
battle.event("complete", outcome="win")
|
|
return battle.result("win")
|
|
return battle.result("timeout", "resource_limit")
|
|
|
|
|
|
def _transport_request(request):
|
|
"""Send combat inputs only, not login credentials or the account envelope."""
|
|
raw = _get(request, "roster", _get(request, "snapshot"))
|
|
raw = _get(raw, "raw", raw)
|
|
if isinstance(raw, Mapping):
|
|
raw = {k: _plain(raw[k]) for k in ("master", "monsters", "teams", "monsterAttributes") if k in raw}
|
|
if isinstance(raw.get("master"), dict):
|
|
raw["master"] = {k: v for k, v in raw["master"].items()
|
|
if k in ("level", "globalAtk", "globalDef", "globalHp", "globalDex")}
|
|
original = _get(request, "original_data", {})
|
|
return {"context": _get(request, "context"), "original_data": {"battle": _plain(_get(original, "battle"))},
|
|
"roster": raw, "team": _get(request, "team", "teamA"),
|
|
"seed": _get(request, "seed", 0), "trace_limit": _get(request, "trace_limit", 2000),
|
|
"battle_position": _position(_get(request, "battle_position"))}
|
|
|
|
|
|
def _execution_failure(outcome, reason, *, supported=True):
|
|
return dict(_envelope(), supported=supported, outcome=outcome,
|
|
execution_status="cancelled" if outcome == "cancelled" else "timed_out" if outcome == "timeout" else "error",
|
|
terminal=False, terminal_reason=reason, timeout_kind="wall_clock" if outcome == "timeout" else None,
|
|
elapsed_ms=None, elapsed_seconds=None, events=[], units=[],
|
|
diagnostics=[{"code": "execution", "message": reason}])
|
|
|
|
|
|
class ExperimentalBattleRuntime:
|
|
"""Offline experimental adapter. run always executes a fixed worker module.
|
|
|
|
supported means this approximate model is runnable, not server settlement
|
|
eligibility. Calls do not mutate the request, cache, or input snapshot.
|
|
"""
|
|
|
|
def inspect(self, request):
|
|
try:
|
|
_, report = _prepare(request, combat_tables())
|
|
return report
|
|
except SimulationInputError as exc:
|
|
result = _envelope()
|
|
return dict(result, supported=False, reasons=[str(exc)],
|
|
diagnostics=[{"code": "static_data", "message": str(exc)}])
|
|
|
|
def run(self, request, *, cancel_event=None, timeout=30.0):
|
|
timeout = _number(timeout, "timeout")
|
|
if timeout < 0:
|
|
raise SimulationInputError("timeout must be nonnegative")
|
|
if cancel_event is not None and cancel_event.is_set():
|
|
return _execution_failure("cancelled", "cancelled_before_worker")
|
|
if timeout == 0:
|
|
return _execution_failure("timeout", "worker_wall_clock_limit")
|
|
try:
|
|
wire = json.dumps({"request": _transport_request(request), "timeout": timeout},
|
|
ensure_ascii=True, allow_nan=False, separators=(",", ":")).encode("utf-8")
|
|
except (TypeError, ValueError):
|
|
return _execution_failure("error", "request_is_not_serializable", supported=False)
|
|
if len(wire) > MAX_WIRE_BYTES:
|
|
return _execution_failure("error", "request_exceeds_worker_input_limit", supported=False)
|
|
started = time.monotonic()
|
|
process = None
|
|
try:
|
|
process = subprocess.Popen(
|
|
[sys.executable, "-m", "ranch_assistant.battle_simulator", "--worker"],
|
|
cwd=str(Path(__file__).resolve().parent.parent),
|
|
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
|
|
creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
|
|
)
|
|
pending_input = wire
|
|
while True:
|
|
if cancel_event is not None and cancel_event.is_set():
|
|
return _execution_failure("cancelled", "worker_cancelled")
|
|
left = timeout - (time.monotonic() - started)
|
|
if left <= 0:
|
|
return _execution_failure("timeout", "worker_wall_clock_limit")
|
|
try:
|
|
stdout, stderr = process.communicate(input=pending_input, timeout=min(.05, left))
|
|
break
|
|
except subprocess.TimeoutExpired:
|
|
pending_input = None
|
|
if len(stdout) > MAX_WIRE_BYTES or len(stderr) > 65536:
|
|
return _execution_failure("error", "worker_output_exceeds_limit")
|
|
result = json.loads(stdout)
|
|
if not isinstance(result, dict) or result.get("execution_mode") != "experimental" or result.get("faithful") is not False:
|
|
return _execution_failure("error", "invalid_worker_result")
|
|
if process.returncode != 0 and result.get("outcome") != "error":
|
|
return _execution_failure("error", "worker_exited_unsuccessfully")
|
|
return result
|
|
except KeyboardInterrupt:
|
|
return _execution_failure("cancelled", "worker_interrupted")
|
|
except (OSError, ValueError):
|
|
return _execution_failure("error", "worker_transport_failure")
|
|
finally:
|
|
if process is not None:
|
|
if process.poll() is None:
|
|
process.kill()
|
|
# communicate drains/joins the killed child and closes all pipes.
|
|
process.communicate()
|
|
|
|
|
|
def _offline_audit(event, args):
|
|
if event.startswith("socket.") or event == "urllib.Request":
|
|
raise PermissionError("Network access is forbidden in the combat worker")
|
|
|
|
|
|
def _worker():
|
|
sys.addaudithook(_offline_audit)
|
|
try:
|
|
wire = sys.stdin.buffer.read(MAX_WIRE_BYTES + 1)
|
|
if len(wire) > MAX_WIRE_BYTES:
|
|
raise SimulationInputError("Worker input exceeds limit")
|
|
payload = json.loads(wire)
|
|
result = simulate(payload["request"], timeout=payload.get("timeout", 30.0))
|
|
if result.get("outcome") == "unsupported":
|
|
result.update(execution_status="unsupported", terminal=False, terminal_reason="unsupported_scenario")
|
|
encoded = json.dumps(result, ensure_ascii=True, allow_nan=False,
|
|
separators=(",", ":")).encode("utf-8")
|
|
if len(encoded) > MAX_WIRE_BYTES:
|
|
# Do not discard anomaly records to fit a successful result.
|
|
raise SimulationInputError("Worker result exceeds transport limit")
|
|
sys.stdout.buffer.write(encoded)
|
|
return 0
|
|
except Exception as exc:
|
|
result = _execution_failure("error", f"worker_failure:{type(exc).__name__}")
|
|
sys.stdout.buffer.write(json.dumps(result, ensure_ascii=True).encode("utf-8"))
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
if sys.argv[1:] != ["--worker"]:
|
|
raise SystemExit("Use ExperimentalBattleRuntime or --worker (one JSON stdin request)")
|
|
raise SystemExit(_worker())
|