fix(web): finalize quick battle and commission procurement for 2.0.9
This commit is contained in:
@@ -0,0 +1,370 @@
|
||||
"""Fast, approximate HP/DPS budgets; no movement, animation or skill replay.
|
||||
|
||||
Inputs and the experimental result/settlement contract come from the existing
|
||||
simulator. One-second simultaneous damage budgets are not original-engine hits.
|
||||
"""
|
||||
from collections import Counter
|
||||
from dataclasses import replace
|
||||
import math
|
||||
import time
|
||||
|
||||
from . import battle_simulator as sim
|
||||
|
||||
|
||||
ASSUMPTIONS = (
|
||||
"Aggregate model: one-second simultaneous HP/DPS budgets, without movement or animation.",
|
||||
"Expected damage uses original attack, defense, dexterity, element and critical-hit formulas.",
|
||||
"Damage is shared equally among eligible opposing targets; explicit target locks take precedence.",
|
||||
"Team capacity, ordered waves, join times and death/time reinforcement gates use coarse numeric steps.",
|
||||
"Makers generate original-stat units at an averaged rate, bounded by 128 generated units per battle.",
|
||||
"Skills use bounded expected damage/healing contributions; other skill effects are omitted.",
|
||||
"HP controllers use averaged healing/damage rates; other control, movement and buff effects are omitted.",
|
||||
"This approximate model has not been validated against original AIR battle outcomes.",
|
||||
)
|
||||
MAX_GENERATED = 128
|
||||
MAX_STEPS = 7200
|
||||
|
||||
|
||||
class _MeanRoll:
|
||||
@staticmethod
|
||||
def uniform(low, high):
|
||||
return (low + high) / 2
|
||||
|
||||
|
||||
def prepare(request, tables=None):
|
||||
tables = tables if tables is not None else sim.combat_tables()
|
||||
scenario, report = sim._prepare(request, tables, quick=True)
|
||||
report.update(model="quick-v1-hp-dps", approximate=True, faithful=False,
|
||||
simulation_method="aggregate_hp_dps", implemented_skills=[],
|
||||
assumptions=list(ASSUMPTIONS), ignored_mechanics=list(ASSUMPTIONS))
|
||||
for d in report["diagnostics"]:
|
||||
if d["code"] == "unsupported_skill":
|
||||
d["code"] = "aggregate_skill"
|
||||
d["message"] = d["message"].replace("is omitted", "uses a bounded aggregate expectation where numeric parameters exist")
|
||||
elif d["code"] == "aggregate_approximation":
|
||||
d["message"] = d["message"].replace("unsupported", "approximated").replace("Unsupported", "Approximated")
|
||||
if scenario is not None:
|
||||
battle = sim._get(sim._get(request, "original_data", {}), "battle", {})
|
||||
kinds = sorted({str(c.get("type", "unknown")) for c in battle.get("controller", ()) or ()}
|
||||
| {str(c.get("type", "unknown")) for t in battle.get("teams", ()) for m in t.get("mons", ()) if m
|
||||
for c in m.get("controller", ()) or ()})
|
||||
report["aggregate_controllers"] = kinds
|
||||
report["assumptions"].append("Configured controllers: " + (", ".join(kinds) or "none") + "; only makers, HP rates and numeric target gates affect this model.")
|
||||
report["objective"] = {1: "elimination", 2: "survive_until_time", 3: "destroy_any", 4: "destroy_all"}.get(
|
||||
scenario.win_types[0] if scenario.win_types else 1, "elimination_approximation")
|
||||
for c in list(battle.get("controller", ()) or ()) + [c for t in battle.get("teams", ())
|
||||
for m in t.get("mons", ()) if m for c in m.get("controller", ()) or ()]:
|
||||
if c.get("type") == "monMaker":
|
||||
p = c.get("para", {})
|
||||
try:
|
||||
if str(sim._int(p.get("monType", 0))) not in tables["monster_info"]:
|
||||
raise sim.SimulationInputError("Generated monster species has no original attributes")
|
||||
if sim._int(p.get("team", 2)) not in scenario.teams:
|
||||
# Standalone controllers can be the only source of enemies.
|
||||
scenario.teams[sim._int(p.get("team", 2))] = {"capacity": 4, "initial": 0, "max": 0}
|
||||
for name in ("interval", "hp", "hpMax", "atk", "level"):
|
||||
if p.get(name) is not None:
|
||||
sim._number(p[name])
|
||||
except sim.SimulationInputError as exc:
|
||||
report["reasons"].append(str(exc))
|
||||
report["supported"] = False
|
||||
report["teams"] = sim._plain(scenario.teams)
|
||||
return scenario, report
|
||||
|
||||
|
||||
class _QuickBattle(sim._Battle):
|
||||
def __init__(self, scenario, report, tables, request):
|
||||
super().__init__(scenario, report, tables)
|
||||
self.pending_triggers = [] # Triggers below affect budgets, never a detailed replay.
|
||||
self.raw = sim._get(sim._get(request, "original_data", {}), "battle", {})
|
||||
self.raw_mons = {f"configured-{ti + 1}-{mi + 1}": m for ti, t in enumerate(self.raw.get("teams", ()))
|
||||
for mi, m in enumerate(t.get("mons", ())) if m}
|
||||
roster = sim._get(request, "roster", sim._get(request, "snapshot", {}))
|
||||
roster = sim._get(roster, "raw", roster)
|
||||
players = {str(m["id"]): m for m in roster.get("monsters", ())}
|
||||
self.raw_mons.update({a.unit.key: players[a.unit.source_id] for a in self.actors
|
||||
if a.unit.key.startswith("player-")})
|
||||
self.triggers = list(self.raw.get("triggers", ()) or ())
|
||||
self.gated = set()
|
||||
self.join_gates = set()
|
||||
for t in self.triggers:
|
||||
for e in t.get("effects", ()):
|
||||
p = e.get("para", {})
|
||||
if e.get("type") == "unlockWave":
|
||||
self.gated.add((sim._int(p.get("team", 2)), sim._int(p.get("wave", 1))))
|
||||
if e.get("type") == "monJoin":
|
||||
self.join_gates.add(str(p.get("mid", "")))
|
||||
self.next_wave = {}
|
||||
self.generated = 0
|
||||
self.damage_checks = set()
|
||||
self.peak_dps = Counter()
|
||||
self.expectations = {}
|
||||
self.hp_rates = {}
|
||||
self.makers = []
|
||||
for a in self.actors:
|
||||
self.configure(a, self.raw_mons.get(a.unit.key, {}))
|
||||
for c in self.raw.get("controller", ()) or ():
|
||||
if c.get("type") == "monMaker":
|
||||
self.makers.append({"vo": c, "owner": None, "credit": 0.,
|
||||
"active": c.get("para", {}).get("activited", True) is not False})
|
||||
|
||||
def configure(self, actor, mon):
|
||||
u, row = actor.unit, self.tables["monster_info"][str(actor.unit.species)]
|
||||
damage, healing = 1., 0.
|
||||
player = u.key.startswith("player-")
|
||||
for slot in (1, 2):
|
||||
sid = sim._int(mon.get(f"skill_{slot}", -1)) if not player else -1
|
||||
sid = sim._int(row.get(f"skill_{slot}", 0)) if sid == -1 else sid
|
||||
if player and sim._int(mon.get("upStar", 0)) > 0:
|
||||
sid = sim._int(self.tables["upstar_info"].get(str(u.species), {}).get("skill", {}).get(str(slot), sid))
|
||||
tp = min(4, sim._int(mon.get("tpLevel", 0)))
|
||||
level = sim._int(mon.get(f"skill_{slot}_lv", -1))
|
||||
level = max(1, tp + 1 if slot == 1 and not sim._int(row.get("skill_2", 0)) else 1) if level < 1 else level
|
||||
skill = self.tables["monster_skill"].get(str(sid), {}).get(f"lv{level}", {})
|
||||
p = skill.get("para", {})
|
||||
cooldown = max(1., sim._number(skill.get("cd", 10000)) / 1000)
|
||||
# At most 25% total expected damage gain, never a stat multiplier.
|
||||
extra = max(0., sim._number(p.get("damage", p.get("hurt", 1))) - 1)
|
||||
damage += min(.125, extra / cooldown)
|
||||
healing += max(0., sim._number(p.get("cure", 0)) + u.stats.atk * sim._number(p.get("cureAtkAdd", 0))) / cooldown
|
||||
self.expectations[u.key] = (min(1.25, damage), healing)
|
||||
rates = []
|
||||
for c in mon.get("controller", ()) or ():
|
||||
kind, p = c.get("type"), c.get("para", {})
|
||||
if kind == "monMaker":
|
||||
self.makers.append({"vo": c, "owner": u.key, "credit": 0., "active": True})
|
||||
if kind in ("hp", "hpArea"):
|
||||
rates.append((kind, sim._number(p.get("hp", 0)) / max(1., sim._number(p.get("interval", 1000)) / 1000),
|
||||
str(p.get("mid", -1))))
|
||||
for name, kind in (("selfCure", "hp"), ("sunFire", "enemy"), ("moonHeal", "hpArea")):
|
||||
amount = u.effects.get(name, 0)
|
||||
if amount:
|
||||
rates.append((kind, (-amount if name == "sunFire" else amount) / 5, "-1"))
|
||||
self.hp_rates[u.key] = rates
|
||||
|
||||
def gates(self):
|
||||
for trigger in list(self.triggers):
|
||||
p, kind = trigger.get("para", {}), trigger.get("type")
|
||||
source = self.by_source_id.get(str(p.get("mid", "")))
|
||||
ready = kind == "time" and self.now >= sim._number(p.get("time", 0)) * 1000
|
||||
ready |= kind == "monDead" and source is not None and source.state == "dead"
|
||||
ready |= kind == "waveStart" and self.wave.get(sim._int(p.get("team", 2)), 1) >= sim._int(p.get("wave", 1))
|
||||
if not ready:
|
||||
continue
|
||||
self.triggers.remove(trigger)
|
||||
self.event("aggregate_trigger", trigger_kind=kind)
|
||||
for effect in trigger.get("effects", ()):
|
||||
ep, ek = effect.get("para", {}), effect.get("type")
|
||||
if ek == "unlockWave":
|
||||
self.unlocked_waves[sim._int(ep.get("team", 2))].add(sim._int(ep.get("wave", 1)))
|
||||
elif ek == "monJoin":
|
||||
a = self.by_source_id.get(str(ep.get("mid", "")))
|
||||
if a:
|
||||
a.force_join = True
|
||||
elif ek in ("startController", "stopController"):
|
||||
for maker in self.makers:
|
||||
if str(maker["vo"].get("id", "")) == str(ep.get("id", "")):
|
||||
maker["active"] = ek == "startController"
|
||||
|
||||
def recruit(self):
|
||||
self.gates()
|
||||
for team in self.s.teams:
|
||||
waiting = [a for a in self.actors if a.unit.team == team and a.state == "waiting"]
|
||||
active = [a for a in self.actors if a.unit.team == team and a.state == "active" and not a.unit.is_object]
|
||||
if waiting and not active:
|
||||
wave = min(a.unit.wave for a in waiting)
|
||||
if (team, wave) not in self.gated:
|
||||
due = self.next_wave.setdefault((team, wave), self.now + (0 if wave <= 1 else 700))
|
||||
if self.now >= due:
|
||||
self.unlocked_waves[team].add(wave)
|
||||
self.wave[team] = wave
|
||||
counts = Counter(a.unit.team for a in self.active() if a.unit.count_unit)
|
||||
for a in self.actors:
|
||||
u = a.unit
|
||||
if a.state != "waiting" or (not a.force_join and (
|
||||
u.wave not in self.unlocked_waves[u.team] or self.now < max(0, u.join_time) * 1000
|
||||
or u.source_id in self.join_gates)):
|
||||
continue
|
||||
if u.count_unit and counts[u.team] >= self.s.teams[u.team]["capacity"]:
|
||||
continue
|
||||
a.state, a.joined_ms = "active", self.now
|
||||
counts[u.team] += int(u.count_unit)
|
||||
self.event("deploy", actor=u.key, team=u.team, wave=u.wave, count_unit=u.count_unit, ap_charged=0)
|
||||
|
||||
def generate(self, seconds):
|
||||
for maker in self.makers:
|
||||
p = maker["vo"].get("para", {})
|
||||
parent = self.by_key.get(maker["owner"])
|
||||
if not maker["active"] or parent is not None and parent.state != "active":
|
||||
continue
|
||||
after = sim._number(p.get("afterTime", 0))
|
||||
before = sim._number(p.get("beforeTime", 0))
|
||||
after = after * 1000 if after < 1000 else after
|
||||
before = before * 1000 if before < 1000 else before
|
||||
if self.now < after or before > 0 and self.now > before:
|
||||
continue
|
||||
maker["credit"] += seconds / max(1., sim._number(p.get("interval", 1000)) / 1000)
|
||||
count = min(int(maker["credit"]), MAX_GENERATED - self.generated)
|
||||
maker["credit"] -= count
|
||||
for _ in range(count):
|
||||
if len(self.actors) >= sim.MAX_UNITS:
|
||||
self.resource_limited = True
|
||||
return
|
||||
spec = {"type": p.get("monType"), "autoValue": True, "level": p.get("level", 1),
|
||||
"team": p.get("team", parent.unit.team if parent else 2), "mode": p.get("mode", 2),
|
||||
"skill_1": 0, "skill_2": 0, "countUnit": False}
|
||||
unit = sim._enemy(spec, {"team": spec["team"]}, self.tables, f"generated-{self.generated + 1}",
|
||||
{}, lambda *a, **k: None, {})
|
||||
hp = sim._int(p.get("hpMax") if p.get("hpMax") is not None else p.get("hp") if p.get("hp") is not None else unit.stats.hp)
|
||||
unit = replace(unit, stats=replace(unit.stats, hp=hp, atk=sim._int(p.get("atk") if p.get("atk") is not None else unit.stats.atk)),
|
||||
is_object=p.get("isObject", False) is True, source_id=f"-{self.generated + 1}")
|
||||
if hp <= 0 or unit.stats.atk < 0 or unit.team not in self.s.teams:
|
||||
raise sim.SimulationInputError("Generated monster attributes/team are invalid")
|
||||
a = sim.Actor(unit, min(hp, sim._int(p.get("hp") if p.get("hp") is not None else hp)), state="active", joined_ms=self.now)
|
||||
self.actors.append(a)
|
||||
self.by_key[unit.key], self.by_source_id[unit.source_id] = a, a
|
||||
self.expectations[unit.key], self.hp_rates[unit.key] = (1., 0.), []
|
||||
self.generated += 1
|
||||
self.event("aggregate_spawn", actor=unit.key, team=unit.team, hp=a.hp)
|
||||
|
||||
def budgets(self, seconds):
|
||||
active = self.active()
|
||||
damage, healing, dealt = Counter(), Counter(), Counter()
|
||||
team_rates = Counter()
|
||||
for a in active:
|
||||
u = a.unit
|
||||
locked = self.by_source_id.get(u.lock_target)
|
||||
targets = [locked] if locked and locked.state == "active" else [b for b in active if b.unit.team != u.team]
|
||||
if not locked:
|
||||
targets = [b for b in targets if b.unit.auto_target] or targets
|
||||
if not u.is_object and targets and u.ai_search != 0:
|
||||
for b in targets:
|
||||
attack = u.stats.atk
|
||||
counter = self.tables["monster_setting"]["element"].get(str(u.stats.element), {}).get("counter")
|
||||
if counter == b.unit.stats.element:
|
||||
attack = int(attack * self.game["counterAdd"])
|
||||
hit = sim.damage_roll(attack, u.stats.dex, b.unit.stats, self.game, _MeanRoll())
|
||||
quarter = int((u.stats.dex - b.unit.stats.dex) / 4)
|
||||
crit = min(1., .02 + u.stats.crit / 100 + (quarter / (quarter + 120) if quarter >= 0 else 0))
|
||||
hit *= 1 + crit * (self.game["critAdd"] - 1)
|
||||
element = str(u.stats.element)
|
||||
if element in b.unit.hurt_types and element in b.unit.hurt_elements:
|
||||
hit *= b.unit.hurt_elements[element]
|
||||
elif str(u.species) in b.unit.hurt_types:
|
||||
hit *= b.unit.hurt_types[str(u.species)]
|
||||
hit = max(0, int(hit * (1 - b.unit.stats.damage_reduction) * self.expectations[u.key][0]))
|
||||
hit = self.final_damage(hit, a, b)
|
||||
# Apply the desktop cap per expected hit, before summing DPS.
|
||||
amount = hit * 1000 / u.stats.attack_ms * seconds / len(targets)
|
||||
damage[b.unit.key] += amount
|
||||
dealt[u.key] += amount
|
||||
team_rates[u.team] += amount / seconds
|
||||
if hit > 80000 and (u.key, b.unit.key) not in self.damage_checks:
|
||||
self.damage_checks.add((u.key, b.unit.key))
|
||||
self.anomaly("+10overdamage", points=10, damage=hit, hurt_team=b.unit.team,
|
||||
actor=u.key, target=b.unit.key, approximate=True)
|
||||
healing[u.key] += self.expectations[u.key][1] * seconds
|
||||
for kind, rate, mid in self.hp_rates[u.key]:
|
||||
if kind == "hp":
|
||||
target = a if mid == "-1" else self.by_source_id.get(mid)
|
||||
targets = [target] if target and target.state == "active" else []
|
||||
else:
|
||||
targets = [b for b in active if (b.unit.team == u.team) == (rate >= 0)]
|
||||
for b in targets:
|
||||
(healing if rate >= 0 else damage)[b.unit.key] += abs(rate) * seconds
|
||||
for team, rate in team_rates.items():
|
||||
self.peak_dps[team] = max(self.peak_dps[team], rate)
|
||||
self.now += int(seconds * 1000)
|
||||
for a in active:
|
||||
key = a.unit.key
|
||||
lost = min(a.hp, damage[key])
|
||||
a.hp -= lost
|
||||
a.total_hurt += damage[key]
|
||||
self.hp_lost[a.unit.team] += lost
|
||||
a.damage_dealt += dealt[key]
|
||||
if a.unit.boss_point == -1:
|
||||
self.boss_points += int(lost)
|
||||
if lost:
|
||||
self.event("damage", actor=None, target=key, damage=round(damage[key], 3),
|
||||
hp_lost=round(lost, 3), hp=round(a.hp, 3), reason="aggregate_dps")
|
||||
# Healing is a simultaneous sustain budget; it cannot resurrect.
|
||||
if a.hp > 0:
|
||||
gained = min(a.unit.stats.hp - a.hp, healing[key])
|
||||
a.hp += gained
|
||||
a.healed += gained
|
||||
if gained:
|
||||
self.event("heal", actor=key, amount=round(gained, 3), hp=round(a.hp, 3), reason="aggregate_sustain")
|
||||
else:
|
||||
a.hp = 0
|
||||
self.finish_death(a)
|
||||
|
||||
def objectives(self):
|
||||
if self.now >= self.s.duration_ms:
|
||||
return "win" if 2 in self.s.win_types else "loss"
|
||||
if not any(a.unit.team == 1 and a.state != "dead" for a in self.actors):
|
||||
return "loss"
|
||||
# A still-running generator represents a future enemy HP/DPS budget,
|
||||
# including when its effective population bound has been reached.
|
||||
future = any(m["active"] and (m["owner"] is None or self.by_key[m["owner"]].state != "dead")
|
||||
and sim._int(m["vo"].get("para", {}).get("team", 2)) != 1
|
||||
and (not sim._number(m["vo"].get("para", {}).get("beforeTime", 0)) or
|
||||
self.now < (sim._number(m["vo"]["para"]["beforeTime"]) *
|
||||
(1000 if sim._number(m["vo"]["para"]["beforeTime"]) < 1000 else 1)))
|
||||
for m in self.makers)
|
||||
if 1 in self.s.win_types and not future and not any(a.unit.team != 1 and a.state != "dead"
|
||||
and (a.state == "active" or not a.unit.is_object) for a in self.actors):
|
||||
return "win"
|
||||
protected = [a for a in self.actors if a.unit.protect_target]
|
||||
destroyed = [a for a in self.actors if a.unit.destroy_target]
|
||||
if protected and (3 in self.s.lose_types and any(a.state == "dead" for a in protected)
|
||||
or 4 in self.s.lose_types and all(a.state == "dead" for a in protected)):
|
||||
return "loss"
|
||||
if destroyed and (3 in self.s.win_types and any(a.state == "dead" for a in destroyed)
|
||||
or 4 in self.s.win_types and all(a.state == "dead" for a in destroyed)):
|
||||
return "win"
|
||||
return None
|
||||
|
||||
def result(self, outcome, timeout_kind=None):
|
||||
result = super().result(outcome, timeout_kind)
|
||||
result["team_budgets"] = {str(team): {
|
||||
"initial_hp": sum(u.stats.hp for u in self.s.units if u.team == team),
|
||||
"remaining_hp": round(sum(a.hp for a in self.actors if a.unit.team == team), 3),
|
||||
"peak_expected_dps": round(self.peak_dps[team], 3)} for team in self.s.teams}
|
||||
result["generated_units"] = self.generated
|
||||
result["spawn_bound_reached"] = self.generated >= MAX_GENERATED
|
||||
return result
|
||||
|
||||
|
||||
def simulate_quick(request, *, cancel_event=None, timeout=30., tables=None):
|
||||
started = time.monotonic()
|
||||
timeout = sim._number(timeout, "timeout")
|
||||
if timeout < 0:
|
||||
raise sim.SimulationInputError("timeout must be nonnegative")
|
||||
tables = tables if tables is not None else sim.combat_tables()
|
||||
scenario, report = prepare(request, tables)
|
||||
if not report["supported"]:
|
||||
return dict(report, outcome="unsupported", execution_status="unsupported", terminal=False,
|
||||
terminal_reason="unsupported_scenario", elapsed_ms=0, elapsed_seconds=0, events=[])
|
||||
try:
|
||||
battle = _QuickBattle(scenario, report, tables, request)
|
||||
for step in range(min(MAX_STEPS, scenario.duration_ms // 1000 + 1)):
|
||||
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")
|
||||
battle.recruit()
|
||||
battle.generate(min(1., (scenario.duration_ms - battle.now) / 1000))
|
||||
outcome = battle.objectives()
|
||||
if outcome:
|
||||
reason = "battle_time_limit" if battle.now >= scenario.duration_ms else "elimination" if 1 in scenario.win_types else "objective"
|
||||
battle.event("complete", outcome=outcome, reason=reason)
|
||||
return dict(battle.result(outcome), terminal_reason=reason)
|
||||
if battle.resource_limited:
|
||||
return battle.result("timeout", "resource_limit")
|
||||
battle.budgets(min(1., (scenario.duration_ms - battle.now) / 1000))
|
||||
return battle.result("timeout", "resource_limit")
|
||||
except (sim.SimulationInputError, KeyError, TypeError, ValueError, ZeroDivisionError):
|
||||
# Do not include account material or arbitrary parameter values in errors.
|
||||
return dict(report, supported=False, outcome="unsupported", execution_status="unsupported", terminal=False,
|
||||
terminal_reason="invalid_numeric_battle_data", elapsed_ms=0, elapsed_seconds=0, events=[],
|
||||
reasons=list(report["reasons"]) + ["Missing or invalid original numeric combat/controller data"])
|
||||
Reference in New Issue
Block a user