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