798 lines
34 KiB
Python
798 lines
34 KiB
Python
"""The fight engine: a party against a pack, stepped in fixed slices of time.
|
|
|
|
A fight is one JSON-able dict. It only ever moves forward through `advance`, which
|
|
replays the slices between its last step and now; each slice draws from a random
|
|
seeded by the fight and the slice number, so the same presses give the same fight.
|
|
|
|
Every ability is either on auto (a rule decides when, on a longer cooldown) or in
|
|
the player's hands. A player's hands only count while they're watching: once they
|
|
look away, everything they hold falls back to auto.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import random
|
|
|
|
from content import ABILITIES, BOSS_DMG, BOSS_HP, ELITE_DMG, ELITE_HP, ENEMY_ABILITIES, MOBS
|
|
|
|
STEP = 0.25 # seconds per slice
|
|
GCD = 1.5
|
|
ENERGY_GCD = 1.0 # rogues
|
|
AUTO_DELAY = 0.5 # auto waits this long after it could act
|
|
AUTO_CD = 1.5 # ...and runs cooldowns this much slower
|
|
AUTO_REACT = 1.0 # seconds into a cast before auto interrupts it
|
|
WATCH = 12 # seconds since a player last looked that their manual choices still hold
|
|
QUEUE = 1.5 # a press waits this long for the global cooldown before it's dropped
|
|
CRIT, CRIT_MULT = 0.05, 1.5
|
|
SPREAD = 0.1
|
|
HEAL_THREAT = 0.5
|
|
STICKY = 1.1 # a mob only turns when someone has 10% more threat than its target
|
|
TANK_THREAT = 1.8
|
|
PET_THREAT = 0.5
|
|
PET_TANK_THREAT = 3.0
|
|
MANA_REGEN = 0.02 # share of max mana per second
|
|
ENERGY_REGEN = 10
|
|
RAGE_PER_SWING = 7
|
|
RAGE_TAKEN = 40 # rage for taking a whole health bar of damage
|
|
MAX_TIME = 300
|
|
LOG = 40
|
|
EVENTS = 60
|
|
|
|
|
|
def mob_hp(level: int) -> float:
|
|
return 35 + 15 * level + 0.8 * level * level
|
|
|
|
|
|
def mob_swing(level: int) -> float:
|
|
"""Damage of an ordinary mob's 2s swing at this level."""
|
|
return 3 + 1.5 * level
|
|
|
|
|
|
# --- building a fight ------------------------------------------------------
|
|
|
|
def mob_unit(uid: str, mob_id: str, level: int, hp_scale: float = 1.0, dmg_scale: float = 1.0) -> dict:
|
|
mob = MOBS[mob_id]
|
|
hp = mob_hp(level) * mob.get("hp", 1)
|
|
swing = mob_swing(level) * mob.get("dmg", 1)
|
|
if mob.get("elite"):
|
|
hp, swing = hp * ELITE_HP, swing * ELITE_DMG
|
|
if mob.get("boss"):
|
|
hp, swing = hp * BOSS_HP, swing * BOSS_DMG
|
|
hp = max(1, round(hp * hp_scale))
|
|
return {
|
|
"id": uid, "mob": mob_id, "name": mob["name"], "side": "enemy", "kind": mob["kind"], "level": level,
|
|
"hp": hp, "max_hp": hp, "power": 0, "armor": 0,
|
|
"swing": {"dmg": swing * dmg_scale, "every": 2.0, "next": 0.5, "school": "phys"},
|
|
"auras": [], "cast": None, "threat": {}, "target": None, "taunt": None,
|
|
"stun": 0, "cc": 0, "root": 0, "dead": False,
|
|
"boss": bool(mob.get("boss")), "elite": bool(mob.get("elite")), "rare": bool(mob.get("rare")),
|
|
"abil": [{"id": a, "next": ENEMY_ABILITIES[a]["first"]} for a in mob.get("abilities", [])],
|
|
"phases": [{**phase, "done": False} for phase in mob.get("phases", [])],
|
|
}
|
|
|
|
|
|
def new_fight(fid: str, seed: int, at: float, party: list[dict], enemies: list[dict], kind: str,
|
|
name: str = "", scale: tuple = (1.0, 1.0)) -> dict:
|
|
fight = {"id": fid, "seed": seed, "at": at, "t": 0.0, "n": 0, "state": "on", "kind": kind, "name": name,
|
|
"units": {}, "log": [], "ev": [], "kills": [], "next": 0, "scale": list(scale), "ended": None}
|
|
for unit in party + enemies:
|
|
fight["units"][unit["id"]] = unit
|
|
for enemy in enemies:
|
|
_engage(fight, enemy)
|
|
return fight
|
|
|
|
|
|
def _engage(fight: dict, enemy: dict) -> None:
|
|
"""Who a fresh mob starts on: the tank, else the first one in."""
|
|
party = alive(fight, "party")
|
|
for unit in party:
|
|
enemy["threat"][unit["id"]] = 10.0 if _tanks(unit) else 0.0
|
|
if party and not any(enemy["threat"].values()):
|
|
enemy["threat"][party[0]["id"]] = 1.0
|
|
|
|
|
|
def _tanks(unit: dict) -> bool:
|
|
return unit.get("role") == "tank" or unit.get("pet_tank", False)
|
|
|
|
|
|
def alive(fight: dict, side: str) -> list[dict]:
|
|
return [u for u in fight["units"].values() if u["side"] == side and not u["dead"]]
|
|
|
|
|
|
def players(fight: dict) -> list[dict]:
|
|
return [u for u in fight["units"].values() if u.get("kind") == "player"]
|
|
|
|
|
|
# --- the outside world's handles ------------------------------------------
|
|
|
|
def advance(fight: dict, now: float, watch: dict | None = None) -> None:
|
|
"""Run every slice up to `now` (game time)."""
|
|
end = now - fight["at"]
|
|
watch = watch or {}
|
|
while fight["state"] == "on" and fight["t"] + STEP <= end + 1e-9:
|
|
_step(fight, watch)
|
|
|
|
|
|
def end_time(fight: dict) -> float:
|
|
return fight["at"] + fight["t"]
|
|
|
|
|
|
def press(fight: dict, uid: str, ability: str, now: float, target: str | None = None) -> str | None:
|
|
unit = fight["units"].get(uid)
|
|
if fight["state"] != "on" or not unit or unit["dead"]:
|
|
return "You're not fighting"
|
|
if ability not in unit["abilities"]:
|
|
return "You don't know that"
|
|
unit["queued"] = {"ab": ability, "target": target, "at": now - fight["at"]}
|
|
return None
|
|
|
|
|
|
def set_target(fight: dict, uid: str, target: str) -> str | None:
|
|
unit, other = fight["units"].get(uid), fight["units"].get(target)
|
|
if not unit or not other or other["dead"]:
|
|
return "No such target"
|
|
if other["side"] == "enemy":
|
|
unit["target"], unit["picked"] = target, True
|
|
else:
|
|
unit["ftarget"] = target
|
|
return None
|
|
|
|
|
|
# --- a slice ---------------------------------------------------------------
|
|
|
|
def _step(fight: dict, watch: dict) -> None:
|
|
fight["t"] = t = round(fight["t"] + STEP, 4)
|
|
rng = random.Random(f"{fight['seed']}:{fight['n']}")
|
|
fight["n"] += 1
|
|
now = fight["at"] + t
|
|
units = list(fight["units"].values())
|
|
for unit in units:
|
|
if not unit["dead"]:
|
|
_tick(fight, unit, t, rng)
|
|
for unit in units:
|
|
if not unit["dead"] and unit["cast"] and unit["cast"]["end"] <= t + 1e-9:
|
|
_finish_cast(fight, unit, t, rng)
|
|
for unit in units:
|
|
if not unit["dead"] and unit["side"] == "party":
|
|
seen = watch.get(unit.get("owner") or unit["id"])
|
|
_think(fight, unit, t, rng, seen is not None and now - seen < WATCH)
|
|
for unit in units:
|
|
if not unit["dead"] and unit["side"] == "enemy":
|
|
_enemy_think(fight, unit, t, rng)
|
|
for unit in units:
|
|
if not unit["dead"]:
|
|
_swing(fight, unit, t, rng)
|
|
_phases(fight, t, rng)
|
|
_check_end(fight, t)
|
|
|
|
|
|
def _tick(fight: dict, unit: dict, t: float, rng: random.Random) -> None:
|
|
res = unit.get("res")
|
|
if res and res["type"] == "mana":
|
|
res["cur"] = min(res["max"], res["cur"] + res["max"] * MANA_REGEN * STEP)
|
|
elif res and res["type"] == "energy":
|
|
res["cur"] = min(res["max"], res["cur"] + ENERGY_REGEN * STEP)
|
|
for aura in list(unit["auras"]):
|
|
if aura["kind"] in ("dot", "hot", "ground") and t >= aura["next"] - 1e-9:
|
|
aura["next"] += aura["every"]
|
|
source = fight["units"].get(aura["by"])
|
|
if aura["kind"] == "dot":
|
|
_damage(fight, source, unit, aura["amount"], aura["school"], t, rng, crit=False)
|
|
elif aura["kind"] == "hot":
|
|
_heal(fight, source, unit, aura["amount"], t, rng, crit=False)
|
|
else:
|
|
for enemy in alive(fight, "enemy"):
|
|
if enemy["cc"] <= t:
|
|
_damage(fight, unit, enemy, aura["amount"], aura["school"], t, rng, crit=False,
|
|
threat=aura.get("threat", 1))
|
|
if unit["dead"]:
|
|
return
|
|
if t >= aura["until"] - 1e-9 and aura in unit["auras"]:
|
|
unit["auras"].remove(aura)
|
|
if aura["kind"] == "enrage":
|
|
unit["swing"]["dmg"] /= aura["mult"]
|
|
|
|
|
|
# --- player side -----------------------------------------------------------
|
|
|
|
def _think(fight: dict, unit: dict, t: float, rng: random.Random, watching: bool) -> None:
|
|
if unit["stun"] > t or unit["cast"]:
|
|
return
|
|
_pick_target(fight, unit, t)
|
|
if unit["kind"] == "pet":
|
|
return
|
|
queued = unit.get("queued")
|
|
if queued and watching:
|
|
if t - queued["at"] > QUEUE:
|
|
unit["queued"] = None
|
|
else:
|
|
why = _not_ready(unit, queued["ab"], t, manual=True)
|
|
if why is None:
|
|
target = _manual_target(fight, unit, queued["ab"], queued["target"], t)
|
|
unit["queued"] = None
|
|
if target is not False:
|
|
_use(fight, unit, queued["ab"], target, t, rng, manual=True)
|
|
if unit["cast"] or not ABILITIES[queued["ab"]].get("offgcd"):
|
|
return
|
|
elif why == "mana":
|
|
unit["queued"] = None
|
|
_event(fight, t, unit["id"], 0, "oom")
|
|
elif queued:
|
|
unit["queued"] = None
|
|
for ab_id in unit["priority"]:
|
|
if ab_id not in unit["abilities"] or (watching and ab_id in unit["manual"]):
|
|
continue
|
|
if _not_ready(unit, ab_id, t, manual=False):
|
|
continue
|
|
target = _rule(fight, unit, ab_id, t)
|
|
if target is False:
|
|
continue
|
|
_use(fight, unit, ab_id, target, t, rng, manual=False)
|
|
if unit["cast"] or not ABILITIES[ab_id].get("offgcd"):
|
|
return
|
|
|
|
|
|
def _not_ready(unit: dict, ab_id: str, t: float, manual: bool) -> str | None:
|
|
ab = ABILITIES[ab_id]
|
|
if unit["cds"].get(ab_id, 0) > t + 1e-9:
|
|
return "cooldown"
|
|
if not ab.get("offgcd") and unit["busy"] + (0 if manual else AUTO_DELAY) > t + 1e-9:
|
|
return "gcd"
|
|
cost = _cost(unit, ab)
|
|
if cost and unit["res"]["cur"] < cost:
|
|
return unit["res"]["type"]
|
|
return None
|
|
|
|
|
|
def _cost(unit: dict, ab: dict) -> float:
|
|
cost = ab.get("cost", 0)
|
|
if cost and cost < 1:
|
|
return cost * unit["res"]["max"]
|
|
return cost
|
|
|
|
|
|
def _use(fight: dict, unit: dict, ab_id: str, target, t: float, rng: random.Random, manual: bool) -> None:
|
|
ab = ABILITIES[ab_id]
|
|
cost = _cost(unit, ab)
|
|
if cost:
|
|
unit["res"]["cur"] -= cost
|
|
unit["cds"][ab_id] = t + ab.get("cd", 0) * (1 if manual else AUTO_CD)
|
|
cast = ab.get("cast", 0)
|
|
if not ab.get("offgcd"):
|
|
gcd = ENERGY_GCD if unit["res"] and unit["res"]["type"] == "energy" else GCD
|
|
unit["busy"] = t + max(gcd, cast)
|
|
if cast:
|
|
unit["cast"] = {"ab": ab_id, "name": ab["name"], "icon": ab["icon"], "target": target,
|
|
"start": t, "end": t + cast}
|
|
else:
|
|
_apply(fight, unit, ab_id, target, t, rng)
|
|
|
|
|
|
def _finish_cast(fight: dict, unit: dict, t: float, rng: random.Random) -> None:
|
|
cast, unit["cast"] = unit["cast"], None
|
|
if unit["side"] == "party":
|
|
_apply(fight, unit, cast["ab"], cast["target"], t, rng)
|
|
else:
|
|
_enemy_effect(fight, unit, cast["ab"], cast["target"], t, rng)
|
|
|
|
|
|
def _apply(fight: dict, unit: dict, ab_id: str, target_id, t: float, rng: random.Random) -> None:
|
|
ab = ABILITIES[ab_id]
|
|
units = fight["units"]
|
|
target = units.get(target_id) if target_id else None
|
|
if ab["target"] in ("enemy", "ally", "pet") and (not target or target["dead"]):
|
|
return
|
|
power = unit["power"]
|
|
threat = ab.get("threat", 1)
|
|
on = f" on {target['name']}" if target and target is not unit else ""
|
|
if ab["target"] != "enemy" or any(e["t"] in ("cc", "interrupt", "stun", "taunt") for e in ab["effects"]):
|
|
_log(fight, t, f"{unit['name']} · {ab['name']}{on}", "cast", unit["id"])
|
|
for eff in ab["effects"]:
|
|
kind = eff["t"]
|
|
if kind == "dmg":
|
|
_damage(fight, unit, target, eff["c"] * power, eff["school"], t, rng, threat=threat, label=ab["name"])
|
|
elif kind == "aoe":
|
|
for enemy in alive(fight, "enemy"):
|
|
if enemy["cc"] <= t:
|
|
_damage(fight, unit, enemy, eff["c"] * power, eff["school"], t, rng, threat=threat,
|
|
label=ab["name"])
|
|
elif kind in ("dot", "hot"):
|
|
_add_aura(target, {"id": ab_id, "kind": kind, "by": unit["id"], "amount": eff["c"] * power,
|
|
"every": eff["every"], "next": t + eff["every"], "until": t + eff["dur"] + 1e-6,
|
|
"school": eff.get("school"), "name": ab["name"], "icon": ab["icon"]})
|
|
elif kind == "ground":
|
|
_add_aura(unit, {"id": ab_id, "kind": "ground", "by": unit["id"], "amount": eff["c"] * power,
|
|
"every": eff["every"], "next": t + eff["every"], "until": t + eff["dur"] + 1e-6,
|
|
"school": eff["school"], "threat": threat, "name": ab["name"], "icon": ab["icon"]})
|
|
elif kind == "heal":
|
|
_heal(fight, unit, target, eff["c"] * power, t, rng, label=ab["name"])
|
|
elif kind == "shield":
|
|
if any(a["kind"] == "weakened" for a in target["auras"]):
|
|
continue
|
|
_add_aura(target, {"id": ab_id, "kind": "shield", "by": unit["id"], "amount": eff["c"] * power,
|
|
"until": t + eff["dur"], "name": ab["name"], "icon": ab["icon"]})
|
|
_add_aura(target, {"id": "weakened_soul", "kind": "weakened", "by": unit["id"], "until": t + 15,
|
|
"name": "Weakened Soul", "icon": "🩹"})
|
|
_heal_threat(fight, unit, eff["c"] * power * 0.5)
|
|
elif kind == "aura":
|
|
holder = target or unit
|
|
spec = {k: v for k, v in eff.items() if k not in ("t", "dur")}
|
|
_add_aura(holder, {**spec, "id": ab_id, "by": unit["id"], "until": t + eff["dur"]})
|
|
elif kind == "taunt":
|
|
top = max(target["threat"].values(), default=0)
|
|
target["threat"][unit["id"]] = top * STICKY + 1
|
|
target["taunt"] = {"by": unit["id"], "until": t + eff["dur"]}
|
|
target["target"] = unit["id"]
|
|
elif kind == "stun":
|
|
_stop_cast(fight, target, unit, t, force=not target["boss"])
|
|
if not target["boss"]:
|
|
target["stun"] = t + eff["dur"]
|
|
elif kind == "interrupt":
|
|
_stop_cast(fight, target, unit, t)
|
|
elif kind == "cc":
|
|
if target["boss"]:
|
|
_log(fight, t, f"{target['name']} is immune", "miss")
|
|
continue
|
|
_stop_cast(fight, target, unit, t, force=True, quiet=True)
|
|
target["cc"] = t + eff["dur"]
|
|
target["cc_icon"] = ab["icon"]
|
|
for other in alive(fight, "party"):
|
|
if other["target"] == target["id"] and not other.get("picked"):
|
|
other["target"] = None
|
|
elif kind == "freeze":
|
|
for enemy in alive(fight, "enemy"):
|
|
if not enemy["boss"]:
|
|
enemy["root"] = t + eff["dur"]
|
|
elif kind == "combo":
|
|
unit["combo"] = min(5, unit["combo"] + eff["n"])
|
|
elif kind == "finisher":
|
|
points, unit["combo"] = unit["combo"], 0
|
|
if points:
|
|
_damage(fight, unit, target, eff["c"] * power * points, "phys", t, rng, threat=threat,
|
|
label=ab["name"])
|
|
elif kind == "drain":
|
|
dealt = _damage(fight, unit, target, eff["c"] * power, eff["school"], t, rng, label=ab["name"])
|
|
_heal(fight, unit, unit, dealt, t, rng, crit=False)
|
|
|
|
|
|
def _stop_cast(fight: dict, enemy: dict, by: dict, t: float, force: bool = False, quiet: bool = False) -> None:
|
|
cast = enemy.get("cast")
|
|
if not cast:
|
|
return
|
|
if not force and not ENEMY_ABILITIES[cast["ab"]]["interrupt"]:
|
|
return
|
|
enemy["cast"] = None
|
|
if not quiet:
|
|
_log(fight, t, f"{by['name']} interrupts {enemy['name']}'s {cast['name']}", "interrupt", by["id"])
|
|
_event(fight, t, enemy["id"], 0, "interrupt")
|
|
|
|
|
|
def _add_aura(unit: dict, aura: dict) -> None:
|
|
unit["auras"] = [a for a in unit["auras"] if not (a["id"] == aura["id"] and a["by"] == aura["by"])]
|
|
unit["auras"].append(aura)
|
|
|
|
|
|
def _pet_of(fight: dict, unit: dict) -> dict | None:
|
|
return next((u for u in alive(fight, "party") if u.get("owner") == unit["id"]), None)
|
|
|
|
|
|
def _pick_target(fight: dict, unit: dict, t: float) -> None:
|
|
current = fight["units"].get(unit.get("target") or "")
|
|
if current and not current["dead"] and (unit.get("picked") or current["cc"] <= t):
|
|
return
|
|
unit["picked"] = False
|
|
enemies = alive(fight, "enemy")
|
|
free = [e for e in enemies if e["cc"] <= t] or enemies
|
|
if not free:
|
|
unit["target"] = None
|
|
return
|
|
owner = fight["units"].get(unit.get("owner") or "")
|
|
if unit["kind"] == "pet" and not unit.get("pet_tank") and owner and not owner["dead"] and owner.get("target"):
|
|
unit["target"] = owner["target"]
|
|
return
|
|
if _tanks(unit):
|
|
tanks = {u["id"] for u in alive(fight, "party") if _tanks(u)}
|
|
loose = [e for e in free if e["target"] not in tanks]
|
|
unit["target"] = (loose or sorted(free, key=lambda e: e["hp"] / e["max_hp"]))[0]["id"]
|
|
return
|
|
tank = next((u for u in alive(fight, "party") if _tanks(u) and u.get("target")), None)
|
|
focus = fight["units"].get(tank["target"]) if tank else None
|
|
if focus and not focus["dead"] and focus["cc"] <= t:
|
|
unit["target"] = focus["id"]
|
|
else:
|
|
unit["target"] = min(free, key=lambda e: e["hp"] / e["max_hp"])["id"]
|
|
|
|
|
|
def _hurt(unit: dict) -> float:
|
|
return unit["hp"] / unit["max_hp"]
|
|
|
|
|
|
def _has(unit: dict, ab_id: str, by: str | None = None) -> bool:
|
|
return any(a["id"] == ab_id and (by is None or a["by"] == by) for a in unit["auras"])
|
|
|
|
|
|
def _rule(fight: dict, unit: dict, ab_id: str, t: float):
|
|
"""Auto's decision: the target to use this on, None for no target, False for not now."""
|
|
ab = ABILITIES[ab_id]
|
|
rule = ab["auto"]
|
|
r = rule["r"]
|
|
enemies = alive(fight, "enemy")
|
|
party = alive(fight, "party")
|
|
target = fight["units"].get(unit.get("target") or "")
|
|
if target and target["dead"]:
|
|
target = None
|
|
on_me = [e for e in enemies if e["target"] == unit["id"] and e["cc"] <= t]
|
|
if rule.get("save") and unit.get("role") == "healer" and len(players(fight)) > 1 and \
|
|
unit["res"]["cur"] < rule["save"] * unit["res"]["max"]:
|
|
return False # a group's healer keeps their mana for healing
|
|
if r == "always":
|
|
if ab["target"] == "enemy":
|
|
return target["id"] if target else False
|
|
return None
|
|
if r == "dot":
|
|
return target["id"] if target and not _has(target, ab_id, unit["id"]) and _hurt(target) > 0.2 else False
|
|
if r == "heal":
|
|
low = min(party, key=_hurt, default=None)
|
|
return low["id"] if low and _hurt(low) < rule["pct"] else False
|
|
if r == "hot":
|
|
hurt = sorted((u for u in party if _hurt(u) < rule["pct"] and not _has(u, ab_id, unit["id"])), key=_hurt)
|
|
return hurt[0]["id"] if hurt else False
|
|
if r == "shield":
|
|
targeted = {e["target"] for e in enemies}
|
|
hurt = [u for u in party if not any(a["kind"] in ("shield", "weakened") for a in u["auras"])
|
|
and (u["id"] in targeted and _hurt(u) < 0.95 or _hurt(u) < rule["pct"])]
|
|
return min(hurt, key=_hurt)["id"] if hurt else False
|
|
if r == "self_below":
|
|
return target["id"] if target and _hurt(unit) < rule["pct"] else False
|
|
if r == "taunt":
|
|
if not _tanks(unit):
|
|
return False
|
|
loose = [e for e in enemies if e["cc"] <= t and e["target"] and e["target"] != unit["id"]
|
|
and not _tanks(fight["units"][e["target"]]) and t - e.get("since", 0) >= AUTO_REACT]
|
|
return loose[0]["id"] if loose else False
|
|
if r == "aoe":
|
|
return None if sum(1 for e in enemies if e["cc"] <= t) >= rule["n"] else False
|
|
if r == "interrupt":
|
|
casting = [e for e in enemies if e["cast"] and ENEMY_ABILITIES[e["cast"]["ab"]]["interrupt"]
|
|
and t - e["cast"]["start"] >= AUTO_REACT]
|
|
return casting[0]["id"] if casting else False
|
|
if r == "combo":
|
|
return target["id"] if target and unit["combo"] >= rule["n"] else False
|
|
if r == "cc":
|
|
free = [e for e in enemies if e["cc"] <= t]
|
|
if len(free) < 2:
|
|
return False
|
|
focus = {u.get("target") for u in party if _tanks(u)} | {unit.get("target")}
|
|
spare = [e for e in free if not e["boss"] and e["id"] not in focus and _hurt(e) > 0.5]
|
|
return max(spare, key=lambda e: e["hp"])["id"] if spare else False
|
|
if r == "peel":
|
|
return None if on_me and not _tanks(unit) and any(not e["boss"] for e in on_me) else False
|
|
if r == "tanking":
|
|
return None if on_me and (any(e["boss"] or e["elite"] for e in on_me) or _hurt(unit) < rule["pct"]) else False
|
|
if r == "danger":
|
|
return None if on_me and _hurt(unit) < rule["pct"] else False
|
|
if r == "buff":
|
|
return None if not _has(unit, ab_id) else False
|
|
if r == "boss":
|
|
pet = _pet_of(fight, unit)
|
|
if not pet or not target:
|
|
return False
|
|
return pet["id"] if target["boss"] or target["elite"] or target["rare"] else False
|
|
return False
|
|
|
|
|
|
def _manual_target(fight: dict, unit: dict, ab_id: str, given: str | None, t: float):
|
|
ab = ABILITIES[ab_id]
|
|
units = fight["units"]
|
|
kind = ab["target"]
|
|
if kind in ("self", "aoe"):
|
|
return None
|
|
if kind == "pet":
|
|
pet = _pet_of(fight, unit)
|
|
return pet["id"] if pet else False
|
|
if kind == "ally":
|
|
for choice in (given, unit.get("ftarget")):
|
|
other = units.get(choice or "")
|
|
if other and not other["dead"] and other["side"] == "party":
|
|
return other["id"]
|
|
return min(alive(fight, "party"), key=_hurt)["id"]
|
|
other = units.get(given or "")
|
|
if other and not other["dead"] and other["side"] == "enemy":
|
|
return other["id"]
|
|
smart = _rule(fight, unit, ab_id, t) if ab["auto"]["r"] in ("interrupt", "cc", "taunt") else False
|
|
if smart:
|
|
return smart
|
|
target = units.get(unit.get("target") or "")
|
|
return target["id"] if target and not target["dead"] else False
|
|
|
|
|
|
# --- enemy side ------------------------------------------------------------
|
|
|
|
def _enemy_think(fight: dict, enemy: dict, t: float, rng: random.Random) -> None:
|
|
if enemy["stun"] > t or enemy["cc"] > t:
|
|
enemy["cast"] = None
|
|
return
|
|
_enemy_target(fight, enemy, t)
|
|
if enemy["cast"] or not enemy["target"]:
|
|
return
|
|
for slot in enemy["abil"]:
|
|
if t < slot["next"]:
|
|
continue
|
|
spec = ENEMY_ABILITIES[slot["id"]]
|
|
target = _enemy_ability_target(fight, enemy, spec, rng)
|
|
if target is False:
|
|
slot["next"] = t + 2
|
|
continue
|
|
slot["next"] = t + spec["every"]
|
|
if spec["cast"]:
|
|
enemy["cast"] = {"ab": slot["id"], "name": spec["name"], "icon": spec["icon"], "target": target,
|
|
"start": t, "end": t + spec["cast"], "interrupt": spec["interrupt"]}
|
|
else:
|
|
_enemy_effect(fight, enemy, slot["id"], target, t, rng)
|
|
return
|
|
|
|
|
|
def _enemy_target(fight: dict, enemy: dict, t: float) -> None:
|
|
units = fight["units"]
|
|
taunt = enemy.get("taunt")
|
|
if taunt and taunt["until"] > t and not units[taunt["by"]]["dead"]:
|
|
enemy["target"] = taunt["by"]
|
|
return
|
|
table = {uid: v for uid, v in enemy["threat"].items() if not units[uid]["dead"]}
|
|
if not table:
|
|
party = alive(fight, "party")
|
|
enemy["target"] = party[0]["id"] if party else None
|
|
if party:
|
|
enemy["threat"][party[0]["id"]] = 1.0
|
|
return
|
|
top = max(table, key=table.get)
|
|
current = enemy.get("target")
|
|
if current in table and table[top] <= table[current] * STICKY:
|
|
return
|
|
enemy["target"], enemy["since"] = top, t
|
|
|
|
|
|
def _enemy_ability_target(fight: dict, enemy: dict, spec: dict, rng: random.Random):
|
|
kind = spec["target"]
|
|
if kind == "target":
|
|
return enemy["target"]
|
|
if kind == "all":
|
|
return None
|
|
if kind == "hurt_ally":
|
|
hurt = [e for e in alive(fight, "enemy") if _hurt(e) < 0.7]
|
|
return min(hurt, key=_hurt)["id"] if hurt else False
|
|
if kind == "random_soft":
|
|
soft = [u for u in alive(fight, "party") if u["kind"] == "player" and not _tanks(u)]
|
|
return rng.choice(soft)["id"] if soft else enemy["target"]
|
|
return False
|
|
|
|
|
|
def _enemy_effect(fight: dict, enemy: dict, ab_id: str, target_id, t: float, rng: random.Random) -> None:
|
|
spec = ENEMY_ABILITIES[ab_id]
|
|
kind, amount, school = spec["effect"]
|
|
target = fight["units"].get(target_id or "")
|
|
swing = enemy["swing"]["dmg"]
|
|
if kind == "hit":
|
|
if target and not target["dead"]:
|
|
_log(fight, t, f"{enemy['name']} · {spec['name']} on {target['name']}", "enemy", enemy["id"])
|
|
_damage(fight, enemy, target, swing * amount, school, t, rng, label=spec["name"])
|
|
elif kind == "aoe":
|
|
_log(fight, t, f"{enemy['name']} · {spec['name']}", "enemy", enemy["id"])
|
|
for unit in alive(fight, "party"):
|
|
_damage(fight, enemy, unit, swing * amount, school, t, rng, label=spec["name"])
|
|
elif kind == "heal":
|
|
if target and not target["dead"]:
|
|
_log(fight, t, f"{enemy['name']} · {spec['name']} on {target['name']}", "enemy", enemy["id"])
|
|
gain = min(target["max_hp"] - target["hp"], round(target["max_hp"] * amount))
|
|
target["hp"] += gain
|
|
_event(fight, t, target["id"], gain, "heal")
|
|
elif kind == "disarm":
|
|
if target and not target["dead"]:
|
|
_log(fight, t, f"{enemy['name']} disarms {target['name']}", "enemy", enemy["id"])
|
|
_add_aura(target, {"id": "disarm", "kind": "disarm", "by": enemy["id"], "until": t + amount,
|
|
"name": "Disarmed", "icon": "🫳"})
|
|
|
|
|
|
def _phases(fight: dict, t: float, rng: random.Random) -> None:
|
|
for enemy in alive(fight, "enemy"):
|
|
for phase in enemy["phases"]:
|
|
if phase["done"] or _hurt(enemy) > phase["at"]:
|
|
continue
|
|
phase["done"] = True
|
|
_log(fight, t, f"{enemy['name']} yells: {phase['say']}", "yell", enemy["id"])
|
|
for what, arg in phase["do"]:
|
|
if what == "stun_all":
|
|
for unit in alive(fight, "party"):
|
|
unit["stun"] = t + arg
|
|
unit["cast"] = None
|
|
elif what == "enrage":
|
|
enemy["swing"]["dmg"] *= arg
|
|
enemy["auras"].append({"id": f"enrage{t}", "kind": "enrage", "by": enemy["id"], "mult": arg,
|
|
"until": t + MAX_TIME, "name": "Enraged", "icon": "😡"})
|
|
elif what == "summon":
|
|
_summon(fight, enemy, arg, t)
|
|
|
|
|
|
def _summon(fight: dict, by: dict, mobs: list, t: float) -> None:
|
|
hp_scale, dmg_scale = fight["scale"]
|
|
for mob_id in mobs:
|
|
fight["next"] += 1
|
|
unit = mob_unit(f"s{fight['next']}", mob_id, MOBS[mob_id]["lv"][1], hp_scale, dmg_scale)
|
|
unit["swing"]["next"] = t + 1.0
|
|
fight["units"][unit["id"]] = unit
|
|
_engage(fight, unit)
|
|
_log(fight, t, f"{unit['name']} joins the fight", "enemy", unit["id"])
|
|
|
|
|
|
# --- shared mechanics ------------------------------------------------------
|
|
|
|
def _swing(fight: dict, unit: dict, t: float, rng: random.Random) -> None:
|
|
swing = unit.get("swing")
|
|
if not swing or t < swing["next"] - 1e-9 or unit["cast"] or unit["stun"] > t or unit["cc"] > t:
|
|
return
|
|
if unit["side"] == "enemy" and unit["root"] > t:
|
|
return
|
|
target = fight["units"].get(unit.get("target") or "")
|
|
if not target or target["dead"]:
|
|
return
|
|
swing["next"] = t + swing["every"]
|
|
amount = swing["dmg"]
|
|
if any(a["kind"] == "disarm" for a in unit["auras"]):
|
|
amount *= 0.5
|
|
_damage(fight, unit, target, amount, swing["school"], t, rng, swing=True)
|
|
res = unit.get("res")
|
|
if res and res["type"] == "rage":
|
|
res["cur"] = min(res["max"], res["cur"] + RAGE_PER_SWING)
|
|
|
|
|
|
def _damage(fight: dict, source: dict | None, target: dict, amount: float, school: str, t: float,
|
|
rng: random.Random, threat: float = 1.0, crit: bool = True, swing: bool = False,
|
|
label: str = "") -> int:
|
|
if target["dead"] or amount <= 0:
|
|
return 0
|
|
critted = crit and source is not None and source["side"] == "party" and rng.random() < CRIT
|
|
if critted:
|
|
amount *= CRIT_MULT
|
|
amount *= 1 + rng.uniform(-SPREAD, SPREAD)
|
|
if source:
|
|
for aura in source["auras"]:
|
|
if aura["kind"] == "done":
|
|
amount *= aura["mult"]
|
|
for aura in target["auras"]:
|
|
if aura["kind"] == "vuln" and aura["school"] == school:
|
|
amount *= aura["mult"]
|
|
elif aura["kind"] == "taken" and aura["school"] in (school, "all"):
|
|
amount *= aura["mult"]
|
|
if school == "phys" and target["side"] == "party" and source:
|
|
armor = target["armor"]
|
|
amount *= 1 - armor / (armor + 400 + 85 * source["level"])
|
|
amount = max(1, round(amount))
|
|
dealt = amount
|
|
for aura in list(target["auras"]):
|
|
if aura["kind"] == "shield" and amount:
|
|
soak = min(amount, round(aura["amount"]))
|
|
aura["amount"] -= soak
|
|
amount -= soak
|
|
if aura["amount"] < 1:
|
|
target["auras"].remove(aura)
|
|
target["hp"] -= amount
|
|
_event(fight, t, target["id"], dealt, "crit" if critted else ("absorb" if not amount else "dmg"),
|
|
source["id"] if source else None, label)
|
|
if target["side"] == "enemy" and source:
|
|
target["threat"][source["id"]] = target["threat"].get(source["id"], 0) + \
|
|
dealt * threat * source.get("threat_mult", 1)
|
|
if target["cc"] > t:
|
|
target["cc"] = 0
|
|
_log(fight, t, f"{target['name']} breaks free", "miss", target["id"])
|
|
res = target.get("res")
|
|
if res and res["type"] == "rage" and amount:
|
|
res["cur"] = min(res["max"], res["cur"] + amount / target["max_hp"] * RAGE_TAKEN)
|
|
if swing and source and source["side"] == "enemy":
|
|
for aura in list(target["auras"]):
|
|
if aura["kind"] == "reflect":
|
|
aura["charges"] -= 1
|
|
if aura["charges"] <= 0:
|
|
target["auras"].remove(aura)
|
|
_damage(fight, target, source, aura["c"] * target["power"], aura["school"], t, rng,
|
|
threat=2.0, label=aura["name"])
|
|
break
|
|
if target["hp"] <= 0:
|
|
_die(fight, target, t)
|
|
return dealt
|
|
|
|
|
|
def _heal(fight: dict, source: dict | None, target: dict, amount: float, t: float, rng: random.Random,
|
|
crit: bool = True, label: str = "") -> int:
|
|
if target["dead"] or amount <= 0:
|
|
return 0
|
|
critted = crit and rng.random() < CRIT
|
|
if critted:
|
|
amount *= CRIT_MULT
|
|
amount = round(amount * (1 + rng.uniform(-SPREAD, SPREAD)))
|
|
gain = max(0, min(amount, target["max_hp"] - target["hp"]))
|
|
target["hp"] += gain
|
|
_event(fight, t, target["id"], amount, "heal", source["id"] if source else None, label)
|
|
if source and gain:
|
|
_heal_threat(fight, source, gain)
|
|
return gain
|
|
|
|
|
|
def _heal_threat(fight: dict, source: dict, amount: float) -> None:
|
|
enemies = alive(fight, "enemy")
|
|
for enemy in enemies:
|
|
enemy["threat"][source["id"]] = enemy["threat"].get(source["id"], 0) + amount * HEAL_THREAT / len(enemies)
|
|
|
|
|
|
def _die(fight: dict, unit: dict, t: float) -> None:
|
|
unit["dead"], unit["hp"], unit["cast"], unit["auras"] = True, 0, None, []
|
|
_log(fight, t, f"{unit['name']} dies", "death", unit["id"])
|
|
if unit["side"] == "enemy":
|
|
fight["kills"].append(unit["mob"])
|
|
for other in alive(fight, "party"):
|
|
if other.get("target") == unit["id"]:
|
|
other["target"], other["picked"] = None, False
|
|
for mob_id in MOBS[unit["mob"]].get("on_death", []):
|
|
_summon(fight, unit, [mob_id], t)
|
|
else:
|
|
for enemy in alive(fight, "enemy"):
|
|
enemy["threat"].pop(unit["id"], None)
|
|
if enemy["target"] == unit["id"]:
|
|
enemy["target"] = None
|
|
|
|
|
|
def _check_end(fight: dict, t: float) -> None:
|
|
if not alive(fight, "enemy"):
|
|
fight["state"] = "won"
|
|
elif not any(not u["dead"] for u in players(fight)):
|
|
fight["state"] = "lost"
|
|
elif t >= MAX_TIME:
|
|
fight["state"] = "lost"
|
|
_log(fight, t, "The fight drags on too long. You fall back.", "death")
|
|
if fight["state"] != "on":
|
|
fight["ended"] = fight["at"] + t
|
|
|
|
|
|
def _log(fight: dict, t: float, text: str, kind: str, who: str | None = None) -> None:
|
|
fight["log"].append({"t": t, "text": text, "kind": kind, "who": who})
|
|
del fight["log"][:-LOG]
|
|
|
|
|
|
def _event(fight: dict, t: float, uid: str, amount: float, kind: str, source: str | None = None,
|
|
label: str = "") -> None:
|
|
fight["ev"].append({"t": t, "u": uid, "n": round(amount), "k": kind, "s": source, "l": label})
|
|
del fight["ev"][:-EVENTS]
|
|
|
|
|
|
# --- what the client sees --------------------------------------------------
|
|
|
|
def view(fight: dict) -> dict:
|
|
units = []
|
|
for unit in fight["units"].values():
|
|
item = {key: unit.get(key) for key in ("id", "name", "side", "kind", "cls", "role", "level", "hp",
|
|
"max_hp", "target", "boss", "elite", "rare", "dead", "owner",
|
|
"combo", "busy", "icon", "mob")}
|
|
item["hp"] = max(0, round(unit["hp"]))
|
|
if unit.get("res"):
|
|
item["res"] = {"type": unit["res"]["type"], "cur": round(unit["res"]["cur"]), "max": unit["res"]["max"]}
|
|
if unit["cast"]:
|
|
item["cast"] = {k: unit["cast"].get(k) for k in ("name", "icon", "start", "end", "target", "interrupt")}
|
|
item["auras"] = [{"icon": a.get("icon"), "name": a.get("name"), "until": round(a["until"], 2),
|
|
"kind": a["kind"], "mine": a["by"]} for a in unit["auras"] if a.get("icon")]
|
|
t = fight["t"]
|
|
item["cc"] = unit.get("cc_icon") if unit["cc"] > t else None
|
|
item["stun"] = unit["stun"] > t
|
|
item["root"] = unit.get("root", 0) > t
|
|
if unit["side"] == "enemy":
|
|
table = {k: v for k, v in unit["threat"].items() if not fight["units"][k]["dead"]}
|
|
top = max(table.values(), default=0) or 1
|
|
item["threat"] = sorted(([k, round(v / top, 2)] for k, v in table.items() if v > 0),
|
|
key=lambda kv: -kv[1])[:4]
|
|
if unit.get("kind") == "player":
|
|
item["cds"] = {k: round(v, 2) for k, v in unit["cds"].items() if v > t}
|
|
item["manual"] = unit["manual"]
|
|
item["abilities"] = unit["abilities"]
|
|
item["ftarget"] = unit.get("ftarget")
|
|
item["queued"] = (unit.get("queued") or {}).get("ab")
|
|
units.append(item)
|
|
return {"id": fight["id"], "t": fight["t"], "at": fight["at"], "state": fight["state"], "kind": fight["kind"],
|
|
"name": fight["name"], "units": units, "log": fight["log"][-14:], "ev": fight["ev"][-30:]}
|