feedback5: merge O11 — 自选 kits for 薇薇安娜, 怒潮凛冬 and 赫德雷; engine: enemy projectile shots carry isProjectile, targeting priority 'elite'; golden: only diy moved

docs/SIM.md

@@ -657,7 +657,10 @@ HP left is refused (damage.js `hasHp`: a lethal hit's `damaged` hook runs before
 
 `battle.dealDamage(source, target, dmg)` → HP removed. `DamageInfo = { amount, type:'phys'|'arts'|'true'|'elemental'|'element',
 element?, defIgnoreFlat, defIgnorePct, resIgnoreFlat, resIgnorePct, mul=1, canDodge (phys/arts), isSkill, isSplash,
-isAttack, attackId, ignoreSleep, ignoreSelect, sourceless, tags[], cancel }` (`ignoreSelect`: no selection 无法选择
+isAttack, isProjectile, attackId, ignoreSleep, ignoreSelect, sourceless, tags[], cancel }` (`isProjectile`: 远程途径 — an
+enemy normal attack that flew as a projectile (ai.js enemyAttack; PRTS 作战机制 "有弹道的攻击固定为10，无弹道的攻击固定为01")
+and 怒潮凛冬's 高台 splash (PRTS "被视为远程途径伤害"); every other hit is 近战途径 — what only melee-path damage triggers
+reads it: 薇薇安娜's 散华 护盾, kits/ops/op-vvana.js; `ignoreSelect`: no selection 无法选择
 effects stop — an ability "无视无法选择", a direct pick such as a counter on the attacker, a flying unit's blast credited to
 a ground leader, the tick of a debuff already on the unit — it reaches an airborne 起飞 ally whatever its source;
 `sourceless`: 无来源 damage — the source's stats add nothing and the hooks get `source: null` plus `credit` = the source,
@@ -1170,7 +1173,8 @@ S3 未照耀的荣光 — its CUSTOM_RANGE trigger also counts flyers). A stun /
 instant, and so are `'beam'` hits (a 锁定攻击范围 AoE without a projectile — `rangeAoe` profiles: "在攻击前摇结束时选取范围内的全体目标，同时造成伤害", PRTS 作战机制). Kit-settable profile flags beyond the
 table: `hitSleep` (targets and damages sleeping enemies — "可以攻击沉睡的敌人"), `onEachHit(b, u, victim, hctx)`, `dmgMul`,
 `afterHit`, `afterAttack`, `canAttack`, `hitsFn`, `priority` (targeting.js PRIORITY_FNS — `'heaviest'`: the 攻城手 trait
-"优先攻击重量最重的敌人", the highest current 重量等级 first: 早露 / 提丰), `blockFly`, `noHeal`, `skipEnemy(e)` (an enemy the unit never
+"优先攻击重量最重的敌人", the highest current 重量等级 first: 早露 / 提丰; `'elite'`: "优先攻击精英或领袖敌人", an ELITE / BOSS
+rank enemy or a leader first: 薇薇安娜 S3), `blockFly`, `noHeal`, `skipEnemy(e)` (an enemy the unit never
 selects — its attacks, the enemies it blocks and its skill-trigger targets: targeting.js canTargetEnemy; 嵯峨 "不攻击重伤
 单位"), `boomerang` (the projectile stays
 `'boomerang'` whatever the data's generic ranged projectile says), `boomerangOnward(ctx)` (a boomerang's flight after its

server/sim/ai.js

@@ -713,12 +713,14 @@ function enemyAttack(b, e) {
   for (const t of targets) {
     b._ev(['atk', e.id, t.id, deferred ? (e.profile.shot || 'none') : rangedShot ? 'enemy' : 'none']);
     if (deferred) continue;
-    const hit = (tt) => {
+    // a shot that flies as a projectile is 远程途径 (DamageInfo `isProjectile`; PRTS 作战机制 "有弹道的攻击固定为10，无弹道的攻击
+    // 固定为01"): what only 近战途径 damage triggers skips it (薇薇安娜's 散华 护盾, kits/ops/op-vvana.js)
+    const hit = (tt, isProjectile = false) => {
       if (!tt || !tt.alive || !e.alive && !rangedShot) return;
-      b.dealDamage(e, tt, { amount: e.s.atk * (e.profile?.atkScale ?? 1), type, isAttack: true, attackId });
+      b.dealDamage(e, tt, { amount: e.s.atk * (e.profile?.atkScale ?? 1), type, isAttack: true, attackId, isProjectile });
     };
     if (rangedShot && Math.hypot(t.x - e.x, t.y - e.y) > 0.75) {
-      b.addProjectile({ from: e, target: t, speed: PROJECTILE_SPEEDS.enemy, visual: 'enemy', source: e, onHit: (c) => hit(c.target) });
+      b.addProjectile({ from: e, target: t, speed: PROJECTILE_SPEEDS.enemy, visual: 'enemy', source: e, onHit: (c) => hit(c.target, true) });
     } else hit(t);
   }
   if (b._hooks.attack) b.emit('attack', { attacker: e, targets, isSkill: false });

server/sim/content/kits/index.js

@@ -118,6 +118,9 @@ export const OPERATOR_KIT_FILES = Object.freeze([
   'op-thorns.js',
   'op-chen3.js',
   'op-leizi2.js',
+  'op-vvana.js',
+  'op-headb2.js',
+  'op-hodrer.js',
 ]);
 
 /**

server/sim/content/kits/ops/op-headb2.js

@@ -0,0 +1,281 @@
+// server/sim/content/kits/ops/op-headb2.js — 怒潮凛冬 (char_1051_headb2) 自选 operator kit: 6★ 撼地者 (近卫), an owned-6★ pick
+// of the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and the module at every form.
+// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)").
+//
+// Forms (data/backups.json units.char_1051_headb2, the DIY slot statuses): normal = E2 Lv1, skills at rank 4, no module;
+// elite = E2 Lv60, rank 7, HAM-X at stage 1 (tier 5) or 3 (tier 6) when picked. Potential 0 [ASSUMED: no account].
+// Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json; teamId `student`); PRTS
+// 怒潮凛冬 (备注 of 汹涌怒火, 绝不罢休 and 无可抵挡); gamedata_const ba.sluggish 停顿, ba.root 束缚; the client's battle data read
+// from the local install — charpack char_1051_headb2, battle/prefabs [uc]skills skchr_headb2_3 and [uc]equips headb2_equip_*,
+// buff_template_data headb2_* (named below) — and the battle skeleton's Skill_3 clip events.
+// - Trait (撼地者) "攻击使目标周围的其他敌人受到相当于攻击力50%的群体物理伤害": the profession splash (radius 1.0, 50 %, others only,
+//   ground enemies — the trait bb).
+// - Module HAM-X 迟到的勋章: trait "溅射范围内有大于或等于3个敌人时，使当次攻击力提升至115%" (trait bb cnt / atk_scale_e;
+//   headb2_e_002_trait: ON_CALCULATE_DAMAGE, CheckEnemyCountWhenAttackDoCast ≥ cnt — the enemies the attack, or S3's ability,
+//   strikes — then AtkScaleUp): an attack whose target and splash victims (radius 1.0 around the target, ground) number at least
+//   cnt deals ×atk_scale_e on each of its damage instances (an ATK scale: before DEF); an S3 hammer counts its own 1.5 range,
+//   every 高台 splash its own x-5 (PRTS "每个溅射效果独立计算X模组特性加成"). Stage 3: 汹涌怒火 +40 % (below).
+// - T1 汹涌怒火 "特性溅射造成的物理伤害提升24%，且溅射到的每个高台对周围四格所有地面敌人造成相当于攻击力24%的物理伤害和0.5秒停顿"
+//   (damage_scale; HAM-X stage 3 1.4 — attack@splash_atk_scale, attack@sluggish): the trait splash ×damage_scale
+//   (headb2_t_1[damage_scale]: ON_OUTPUT_DAMAGE on the APPLY_TO_HAMMER_SUBCLASS_SPLASH_TARGET damage, PHYSICAL — PRTS "伤害倍率提升
+//   而非攻击倍率提升，且不对特性主目标生效": dmg.mul, splash victims only). 高台 splash (PRTS "独立于攻击的效果，其以该次攻击中心为中心，
+//   选择1.0半径内的地块触发溅射（重叠判定），伤害溅射范围为周围4格+本格x-5（格子判定），造成物理溅射伤害" / "伤害会被视为远程途径伤害…
+//   由此伤害击倒的敌人会被视为无来源击杀"; the charpack's highland AoE: radius 1.0, x-5, targetMotion ground, physical, `_attackType`
+//   ranged, sluggish from the blackboard, `_intervalTime` 0.1, SP via headb2_s_2[sp]): after each attack, every 高台 (a HIGH
+//   tile of the field rect: walls and forbidden blocks) whose square the circle of radius 1.0 around the target touches
+//   triggers; 0.1 s later the ground enemies she could select on its x-5 take attack@splash_atk_scale × her ATK at the trigger
+//   (physical 溅射伤害: no dodge; 无来源 credited to her, 远程途径 — DamageInfo isProjectile) and 停顿 attack@sluggish s.
+// - T2 万众巨潮 "技能期间所有场上干员攻击力和防御力+14%，【乌萨斯学生自治团】干员获得加成效果翻倍" (atk / def, scale_bonus; the aura's
+//   validator: ally operators of every profession, herself included; headb2_skill_judge switches it with her skill's start /
+//   finish; headb2_t_2[filter_tag]: CheckCharacterGroupTag `student` ⇒ ×scale_bonus, MULTIPLIER attributes): while a skill of
+//   hers runs, every operator of the field (teammates' in a shared field — the kits' field-wide convention) ATK / DEF
+//   +atk / +def, ×scale_bonus for the 【乌萨斯学生自治团】 (character_table teamId `student`) — given at the cast, renewed every
+//   TIDE_IV s (operators deployed meanwhile) and taken back at the end; two sources keep the strongest.
+// - S1 誓不低头 (MANUAL, data DEFAULT, 30 s): ATK +atk, ASPD +attack_speed.
+// - S2 绝不罢休 (AUTO): "被动效果：每次有高台触发第一天赋的效果时，获得1点技力" (sp_per_highland; PRTS 备注 "根据单次天赋触发的高台
+//   数量提供相应的sp") — +sp per 高台 that triggers, none while a skill runs (AK). "自动开启：攻击范围扩大，攻击力+60%，防御力+40%" —
+//   a self buff, so it fires at full SP (`trigger: 'SP_FULL'`, the owner's AUTO rule, kits/README.md checklist 5): the 2-5
+//   range, ATK / DEF for 16 s; "第二次及以后使用时能力加成变为最初的两倍，且持续时间无限" (headb2_s_2[second].atk / .def): from
+//   the second cast of a deployment [ASSUMED: counted per deployment, as 提丰's S2] the doubled values until she leaves (a
+//   toggle the kit ends after `duration` s on its first cast, as op-typhon.js).
+// - S3 无可抵挡 (MANUAL, data CUSTOM_RANGE on its trigger grid; the ability headb2_s3: `_additionalTimes` 4, each hit on its
+//   clip's attack event, not affected by ASPD — PRTS 备注 "锤击间隔1.8s…不受攻击速度影响"): ATK +atk_base; five hammers at the
+//   Skill_3 clip's OnAttack events (HAMMER_FRAMES at 30 fps: 1.1 … 7.77 s after the cast) and the skill over with the clip
+//   (SKILL3_FRAMES, 9.23 s); she makes no normal attack meanwhile. headb2_s_3: spell_times from −1, +1 at each hammer's spell
+//   ⇒ hammer k at ATK +atk_base + atk_step × (k − 1). Each hammer is centred 1.0 ahead (备注 "每次锤击以正前方1.0距离位置为中心"):
+//   an enemy on the tile ahead is its main target (her order; usually none), atk_scale × ATK physical; every other ground enemy
+//   within HAMMER_SPLASH ("主攻击拥有1.5的溅射半径") takes the trait's splash share (`_splashAtkScaleKey` atk_scale_2 — × atk_scale
+//   as well, the kits' 撼地者 convention, 佩佩 S1 [ASSUMED] — ×汹涌怒火) — skill damage, not a normal attack [ASSUMED]. Each hammer
+//   runs 汹涌怒火's 高台 round at its centre with the skill's change "伤害效果提升至3.5倍，控制效果变为1秒束缚" (the skill's AoE:
+//   splash_atk_scale_base × splash_atk_scale_bonus, headb2_s_3[unmovable] for `unmovable` s instead of 停顿, `_firstIntervalTime`
+//   0.1 then `_intervalTime` 0.125 per step) and the spread (备注 "第二次锤击起，所有本次锤击触发第一天赋的高台生效时将令相邻的未受
+//   影响的高台触发第一天赋（即扩散），最大扩散次数等同于当前已完成锤击次数；不论如何，一轮锤击中每个高台只会触发一次天赋效果" / "离场时，
+//   未完成的天赋效果扩散将立刻终止"): hammer k spreads up to k − 1 steps to the four tiles next to each affected 高台 [ASSUMED:
+//   "相邻" = the 4 neighbours]. A hammer due while she cannot act is lost [ASSUMED].
+
+import { num, talentBb, traitBb, skillRec, up, giveSp } from '../shared/tier1.js';
+import { COLS } from '../../../constants.js';
+import { sortEnemyTargets } from '../../../targeting.js';
+
+const S1 = 'skchr_headb2_1';
+const S2 = 'skchr_headb2_2';
+const S3 = 'skchr_headb2_3';
+/** PRTS 汹涌怒火 备注: "选择1.0半径内的地块触发溅射（重叠判定）". */
+const HIGHLAND_PICK_RADIUS = 1.0;
+/** PRTS 汹涌怒火 备注: "伤害溅射范围为周围4格+本格x-5（格子判定）" (symmetric: no rotation). */
+const X5 = Object.freeze([[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]);
+/** 汹涌怒火's 高台 AoE: `_intervalTime` 0.1 (PRTS "高台溅射效果从触发/被扩散到生效具有0.1秒内置延迟"); S3's own AoE: `_firstIntervalTime`
+ *  0.1, then `_intervalTime` 0.125 per spread step. */
+const HIGHLAND_DELAY = 0.1, S3_SPREAD_STEP = 0.125;
+/** The battle skeleton's Skill_3 clip (30 fps): 277 frames, OnAttack at frames 33, 84, 133, 182 and 233 (PRTS "锤击间隔1.8s"). */
+const FPS = 30, SKILL3_FRAMES = 277, HAMMER_FRAMES = Object.freeze([33, 84, 133, 182, 233]);
+/** PRTS 无可抵挡 备注: "每次锤击以正前方1.0距离位置为中心" / "主攻击拥有1.5的溅射半径". */
+const HAMMER_REACH = 1.0, HAMMER_SPLASH = 1.5;
+/** 【乌萨斯学生自治团】: character_table teamId `student` (古米, 凛冬, 烈夏, 苦艾, 真理, 早露, 怒潮凛冬; as op-poca.js). */
+const STUDENTS = new Set(['char_196_sunbr', 'char_115_headbr', 'char_194_leto', 'char_405_absin', 'char_195_glassb',
+  'char_197_poca', 'char_1051_headb2']);
+/** 万众巨潮: the renewal of the aura while a skill of hers runs. */
+const TIDE_IV = 0.25;
+const TIDE_KEY = 'talent:headb2:tide';
+const S2_KEY = 'skill:headb2:s2';
+const STEP_KEY = 'skill:headb2:step';
+const HAMMER_TAG = 'headb2Hammer';
+const HIGHLAND_TAG = 'headb2Highland';
+const GROUND = Object.freeze({ canHitFly: false });
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+const tagged = (d, tag) => !!d && Array.isArray(d.tags) && d.tags.includes(tag);
+const isOp = (a) => !!a && a.kind === 'op';
+
+/** Tile keys of the 高台 (HIGH tiles of the field rect) whose square the circle of radius `r` around (x, y) touches. */
+function highlandsAround(battle, x, y, r = HIGHLAND_PICK_RADIUS) {
+  const g = battle.grid, out = [];
+  for (let row = Math.floor(y - r); row <= Math.ceil(y + r); row++) {
+    for (let col = Math.floor(x - r); col <= Math.ceil(x + r); col++) {
+      if (!g.inRect(row, col) || g.tile(row, col).height !== 'HIGH') continue;
+      const dx = Math.max(Math.abs(x - col) - 0.5, 0), dy = Math.max(Math.abs(y - row) - 0.5, 0);
+      if (dx * dx + dy * dy <= r * r + 1e-9) out.push(row * COLS + col);
+    }
+  }
+  return out;
+}
+/** The 高台 next to tile key `k` (the spread of S3). */
+function highlandNeighbours(battle, k) {
+  const r = Math.floor(k / COLS), c = k % COLS, g = battle.grid, out = [];
+  for (const [dr, dc] of X5) {
+    if (!dr && !dc) continue;
+    const rr = r + dr, cc = c + dc;
+    if (g.inRect(rr, cc) && g.tile(rr, cc).height === 'HIGH') out.push(rr * COLS + cc);
+  }
+  return out;
+}
+
+export default {
+  char_1051_headb2: (bb, chess) => {
+    const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
+    const tb = traitBb(chess);
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    const s2 = skillRec(chess, S2);
+    const splashMul = num(t0.damage_scale, 1);
+    const hxScale = num(tb.atk_scale_e, 1), hxCnt = num(tb.cnt, Infinity);
+    const hamx = (n) => (hxScale !== 1 && n >= hxCnt ? hxScale : 1);
+    const traitShare = num(tb['attack@atk_scale_2'], 0.5);
+
+    /** One 高台 taking effect: its x-5 ground enemies take the splash and 停顿 (束缚 during S3). */
+    const highlandStrike = (battle, unit, k, atk, s3) => {
+      const r = Math.floor(k / COLS), c = k % COLS;
+      const keys = [];
+      for (const [dr, dc] of X5) if (battle.grid.inRect(r + dr, c + dc)) keys.push((r + dr) * COLS + c + dc);
+      const foes = battle.enemiesInKeys(keys, unit, GROUND);
+      battle.fx('aoe', { x: c, y: r, radius: 1, id: unit.id, skill: 'headb2:highland' });
+      if (!foes.length) return;
+      const amount = atk * num(t0['attack@splash_atk_scale']) * (s3 ? num(b3.splash_atk_scale_bonus, 1) : 1) * hamx(foes.length);
+      for (const e of foes) {
+        if (!e.alive) continue;
+        battle.dealDamage(unit, e, { amount, type: 'phys', isSplash: true, canDodge: false, sourceless: true, isProjectile: true, tags: [HIGHLAND_TAG] });
+        if (!e.alive) continue;
+        if (s3) battle.applyStatus(e, 'bind', { duration: num(b3.unmovable, 1), source: unit });
+        else if (num(t0['attack@sluggish']) > 0) battle.applyStatus(e, 'sluggish', { duration: num(t0['attack@sluggish']), source: unit });
+      }
+    };
+    /**
+     * A round of 汹涌怒火's 高台 splashes centred on (x, y): every 高台 within 1.0 triggers now and takes effect
+     * HIGHLAND_DELAY s later; with `depth` > 0 (S3) each one that takes effect makes the 高台 next to it that this round has
+     * not touched yet trigger — S3_SPREAD_STEP s later —, up to `depth` steps. S2's passive: +sp per 高台 that triggers.
+     */
+    const highlandRound = (battle, unit, x, y, depth = 0) => {
+      const tiles = highlandsAround(battle, x, y);
+      if (!tiles.length) return;
+      const seq = unit.deploySeq, atk = unit.s.atk;
+      const s3 = !!(unit.skill?.active && unit.skill.id === S3);
+      const sp = unit.skill?.id === S2 ? num(b2.sp_per_highland) : 0;
+      const seen = new Set(tiles);
+      const trigger = (k, step) => {
+        if (sp > 0) giveSp(unit, sp);
+        battle.after(step > 0 && s3 ? S3_SPREAD_STEP : HIGHLAND_DELAY, () => {
+          if (!(unit.alive && unit.deployed && unit.deploySeq === seq)) return;   // 离场: the round stops
+          highlandStrike(battle, unit, k, atk, s3);
+          if (step >= depth) return;
+          for (const nb of highlandNeighbours(battle, k)) if (!seen.has(nb)) { seen.add(nb); trigger(nb, step + 1); }
+        }, { owner: unit });
+      };
+      for (const k of tiles) trigger(k, 0);
+    };
+    /** S3 hammer `k` (1-based): centred 1.0 ahead, a main target on the tile ahead if any, the 1.5 splash, the 高台 round. */
+    const hammer = (battle, unit, k) => {
+      const [fr, fc] = unit.fwd;
+      const cx = unit.x + fc * HAMMER_REACH, cy = unit.y + fr * HAMMER_REACH;
+      const tr = unit.tileR + fr, tc = unit.tileC + fc;
+      let main = null;
+      if (battle.grid.inRect(tr, tc)) {
+        const cands = battle.enemiesInKeys([tr * COLS + tc], unit, unit.profile);
+        sortEnemyTargets(battle, unit, cands, unit.profile?.priority ?? null);
+        main = cands[0] ?? null;
+      }
+      const around = battle.foesInRadius(cx, cy, HAMMER_SPLASH, true).filter((e) => e !== main && !e.isFlying);
+      const atk = unit.s.atk, scale = num(b3.atk_scale, 1) * hamx((main ? 1 : 0) + around.length);
+      battle.fx('aoe', { x: cx, y: cy, radius: HAMMER_SPLASH, id: unit.id, skill: 'headb2:hammer' });
+      if (main && main.alive) battle.dealDamage(unit, main, { amount: atk * scale, type: 'phys', isSkill: true, tags: ['skill', HAMMER_TAG] });
+      for (const e of around) {
+        if (!e.alive) continue;
+        battle.dealDamage(unit, e, { amount: atk * scale * traitShare, type: 'phys', isSkill: true, isSplash: true, mul: splashMul, tags: ['skill', HAMMER_TAG] });
+      }
+      highlandRound(battle, unit, cx, cy, k - 1);
+    };
+
+    return {
+      skills: {
+        [S1]: { kind: 'duration', mods: { atkPct: num(b1.atk), aspd: num(b1.attack_speed) } },
+        [S2]: {
+          kind: 'toggle',
+          trigger: { rule: 'SP_FULL' },
+          targeting: { rangeGrid: s2?.rangeGrid ?? null },
+          onStart({ battle, unit, skill }) {
+            const later = (unit.mem.headb2S2Casts ?? 0) >= 1;
+            unit.mem.headb2S2Casts = (unit.mem.headb2S2Casts ?? 0) + 1;
+            const atk = later ? num(b2['headb2_s_2[second].atk']) : num(b2.atk);
+            const def = later ? num(b2['headb2_s_2[second].def']) : num(b2.def);
+            battle.addBuff(unit, { key: S2_KEY, mods: { atkPct: atk, defPct: def }, tags: ['skill'] });
+            skill.timeLeft = later ? Infinity : Math.max(0.01, skill.duration);
+          },
+          onTick({ skill, dt }) {
+            if (!Number.isFinite(skill.timeLeft)) return;
+            skill.timeLeft -= dt;
+            if (skill.timeLeft <= 1e-9) skill.end('duration');
+          },
+          onEnd({ battle, unit }) { battle.removeBuff(unit, S2_KEY); },
+        },
+        [S3]: {
+          kind: 'duration',
+          duration: SKILL3_FRAMES / FPS,
+          mods: { atkPct: num(b3.atk_base) },
+          attack: { noAttack: true },
+          onStart({ battle, unit, skill }) {
+            const n0 = skill.activations, seq = unit.deploySeq, step = num(b3.atk_step);
+            let done = 0;
+            for (const f of HAMMER_FRAMES) {
+              battle.after(f / FPS, () => {
+                if (!(unit.alive && unit.deployed && unit.deploySeq === seq && skill.active && skill.activations === n0)) return;
+                if (!unit.canAct) return;   // a hammer due while she cannot act is lost [ASSUMED]
+                hammer(battle, unit, done + 1);
+                done++;
+                if (step) battle.addBuff(unit, { key: STEP_KEY, mods: { atkPct: step * done }, tags: ['skill'] });
+              }, { owner: unit });
+            }
+          },
+          onEnd({ battle, unit }) { battle.removeBuff(unit, STEP_KEY); },
+        },
+      },
+      talents: [
+        { install(battle, unit) { // 汹涌怒火: the trait splash ×damage_scale (the 高台 rounds: trait.afterHit and the hammers)
+          if (splashMul === 1) return;
+          battle.on('hit', (c) => {
+            const d = c.dmg;
+            if (c.source === unit && d.isAttack && d.isSplash && !tagged(d, HAMMER_TAG)) d.mul *= splashMul;
+          }, { owner: unit });
+        } },
+        { install(battle, unit) { // 万众巨潮: every operator of the field ATK / DEF + while a skill of hers runs (students ×)
+          const a = num(t1.atk), d = num(t1.def), x = num(t1.scale_bonus, 1);
+          if (!a && !d) return;
+          const inSkill = () => !!(unit.skill && unit.skill.active && unit.skill.kind !== 'passive');
+          const give = () => {
+            if (!up(unit) || !inSkill()) return;
+            for (const o of battle.alliesFor(unit)) {
+              if (!isOp(o)) continue;
+              const k = STUDENTS.has(o.def?.charId) ? x : 1;
+              const cur = o.findBuff(TIDE_KEY);
+              if (cur && cur.source !== unit && (cur.data?.v ?? 0) > a * k && cur.timeLeft > 0.05) continue;
+              battle.addBuff(o, { key: TIDE_KEY, duration: TIDE_IV + 0.1, mods: { atkPct: a * k, defPct: d * k }, source: unit, data: { v: a * k }, tags: ['aura'] });
+            }
+          };
+          battle.every(TIDE_IV, give, { owner: unit });
+          battle.on('skillStart', (c) => { if (c.unit === unit) give(); }, { owner: unit });
+          battle.on('skillEnd', (c) => {
+            if (c.unit !== unit) return;
+            for (const o of battle.allyUnits) { const b = o.findBuff(TIDE_KEY); if (b && b.source === unit) battle.removeBuff(o, b); }
+          }, { owner: unit });
+        } },
+      ],
+      // 汹涌怒火's 高台 round after each attack, centred on its target
+      trait: { afterHit: (battle, unit, target, hctx) => { if (unit.alive && unit.deployed) highlandRound(battle, unit, hctx.x, hctx.y); } },
+      install(battle, unit) {
+        // S2: the cast count of a deployment [ASSUMED per deployment]
+        battle.on('deploy', (c) => { if (c.unit === unit) unit.mem.headb2S2Casts = 0; }, { owner: unit });
+        // HAM-X: ≥ cnt ground enemies in the splash range of the attack's target ⇒ ×atk_scale_e on each of its instances
+        if (hxScale === 1) return;
+        battle.on('hit', (c) => {
+          const d = c.dmg;
+          if (c.source !== unit || !d.isAttack || !d.attackId || tagged(d, HAMMER_TAG)) return;
+          const m = unit.mem;
+          if (m.headb2HamxId !== d.attackId) {
+            // the first instance of an attack is its target's (ai.js resolveHit: the main hit, then the splash)
+            const t = c.target;
+            m.headb2HamxId = d.attackId;
+            m.headb2HamxMul = hamx(1 + battle.foesInRadius(t.x, t.y, unit.profile?.splashRadius || 1, true).filter((e) => e !== t && !e.isFlying).length);
+          }
+          d.amount *= m.headb2HamxMul ?? 1;
+        }, { owner: unit, priority: 5 });
+      },
+    };
+  },
+};

server/sim/content/kits/ops/op-hodrer.js

@@ -0,0 +1,176 @@
+// server/sim/content/kits/ops/op-hodrer.js — 赫德雷 (char_4088_hodrer) 自选 operator kit: 6★ 重剑手 (近卫), an owned-6★ pick of
+// the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and both modules at every form.
+// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)").
+//
+// Forms (data/backups.json units.char_4088_hodrer, the DIY slot statuses): normal = E2 Lv1, skills at rank 4, no module;
+// elite = E2 Lv60, rank 7, the picked module at stage 1 (tier 5) or 3 (tier 6). Potential 0 [ASSUMED: no account].
+// Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json); PRTS 赫德雷 (备注 of 及锋而试
+// and 死境硝烟); PRTS 卫戍协议/帮助 §技能操作 ("携带状态切换类技能的干员…每次部署后仅开启一次技能"); gamedata_const ba.protect 庇护,
+// ba.stun 晕眩, ba.root 束缚; PRTS 伤害分类 (无来源真实持续伤害); the client's battle data read from the local install —
+// charpack char_4088_hodrer, battle/prefabs [uc]skills skchr_hodrer_1/2/3 and [uc]equips hodrer_equip_*, buff_template_data
+// hodrer_* (named below).
+// - Trait (重剑手) "同时攻击阻挡的所有敌人": the profession (melee physical, ground only, block 2, 2.5 s).
+// - Module CRU-X 新的生活: trait "受到的治疗效果提升20%" (trait bb heal_scale; equip_heal_scale_up): healingTakenMul ×heal_scale —
+//   his own S1 / S3 heals included. Stage 3: 余火之氅 28 % and 物理伤害 +10 % (below).
+// - Module CRU-Y 笔迹: trait "对被阻挡的敌人伤害提升至110%" (trait bb damage_scale; hodrer_e_003_tr: ON_OUTPUT_DAMAGE, CheckBlocked
+//   by the buff's source — him): ×damage_scale (a damage multiplier) on every damage of his on an enemy HE blocks. Stage 3:
+//   及锋而试 130 % / 160 % and its first-hit stun (below).
+// - T1 及锋而试 "攻击敌人时攻击力提升至110%，若目标处于晕眩、束缚则改为提升至140%" (atk_scale_2 / atk_scale; hodrer_t_1:
+//   ON_CALCULATE_DAMAGE, abnormal flags STUNNED / UNMOVABLE → AtkScaleUp): each damage instance of his attacks ×atk_scale_2, or
+//   ×atk_scale on a target under a 晕眩 or 束缚 status (冻结 is neither) — an ATK scale, before DEF. PRTS 备注 "本天赋于每次攻击的
+//   附加效果后、计算伤害前判断并生效": the attack's riders come first, in the same `hit` step — S2's stun and S3's stun roll (the
+//   attacks' `_activeBuffs`), then CRU-Y stage 3's "且对阻挡的敌人首次造成伤害时对其造成2.5秒晕眩效果" (hodrer_e_003_t, event
+//   priority 2000 — before 及锋而试: an enemy he blocks without his mark gets it and stuns `stun` s; the marks are derived from
+//   the module talent's buff, so they go when he leaves the field and a redeployed 赫德雷 stuns anew) — so a hit that stuns
+//   counts as on a stunned target; a rider lands when the hit is then dodged [ASSUMED: the client applies them in the attack's
+//   damage calculation].
+// - T2 余火之氅 "使自身与身后一格的友军获得18%的庇护" (damage_resistance, talent grid b-1: his tile and the one behind; CRU-X
+//   stage 3 "28%…且造成的物理伤害提升10%" — hodrer_equip_1_3_p2 gives damage_resistance[inf] and hodrer_equip[damage_scale_up]
+//   (ON_OUTPUT_DAMAGE PHYSICAL ×damage_scale) to the same targets, ally side, any motion, removed when they leave): 庇护
+//   (ba.protect "受到的物理和法术伤害降低相应比例（同名效果取最高）") = phys / artsTakenMul 1 − value as one instance per ally
+//   (applyStrongest) with physDealtMul ×damage_scale, renewed every PROTECT_IV s on the allies of the grid while he is deployed.
+// - S1 重锋不熄 (AUTO, hit SP: INCREASE_WHEN_ATTACK, data DEFAULT): the next attack (every enemy he blocks) at atk_scale × ATK;
+//   hodrer_s[heal] (ON_ABILITY_SPELL_ON, HealViaMaxHpRatio) heals hp_ratio of his max HP once for that attack.
+// - S2 余烬重荷 (MANUAL, data DEFAULT): "被动效果：攻击力+16%" (atk; the skill's extra ability hodrer_s_2[passive]) while it is
+//   his skill; "主动触发可以在下列状态和初始状态间切换" — a 状态切换类 skill, switched on once per deployment and kept (the official
+//   auto-battle rule, `toggle`): attack interval +base_attack_time s (flat), block +block_cnt, every attack stuns its targets
+//   attack@stun s.
+// - S3 死境硝烟 (MANUAL, data ACTIVE_RANGE on its running range, 70 / 70 s): max HP +max_hp, ATK +atk, 攻击距离
+//   +ability_range_forward_extend; each attack heals attack@hp_ratio of his max HP (hodrer_s[heal], once per attack) and stuns
+//   each target attack@stun s with attack@buff_prob. hodrer_s_3[damage] (triggerInterval 1 s, the first after 1 s): he loses
+//   attack@value HP every second (FixedValueDamage that skips the damage events: a 流失 here [ASSUMED: it may knock him out —
+//   no floor is named]); every damage he outputs on an enemy, and every damage an enemy deals him, marks that enemy if it is
+//   not 无敌 (one hodrer_s_3[burn] per enemy and 赫德雷, PRTS 备注 "仅判定本次技能期间满足条件的非无敌敌方单位…不可叠加"): from
+//   then on it takes attack@damage 无来源 true damage (NoSourceDamage PURE: damage.js periodicDamage, credited to him) every
+//   second of its own (triggerInterval 1 s from its mark) until the skill ends (a derived buff of the skill's).
+
+import { num, talentBb, talentGrid, moduleBb, traitBb, skillRec, statBuff, up, batMod, alliesInGridOf } from '../shared/tier1.js';
+import { periodicDamage } from '../../../damage.js';
+
+const S1 = 'skchr_hodrer_1';
+const S2 = 'skchr_hodrer_2';
+const S3 = 'skchr_hodrer_3';
+/** 余火之氅's grid when the data carries none: his tile and the one behind him (range b-1). */
+const BEHIND = Object.freeze([Object.freeze([0, -1]), Object.freeze([0, 0])]);
+const PROTECT_IV = 0.25;
+const PROTECT_KEY = 'talent:hodrer:protect';
+const S2_PASSIVE_KEY = 'skill:hodrer:s2passive';
+/** hodrer_s_3[damage] / hodrer_s_3[burn]: triggerInterval 1 s, waitFirstTriggerInterval. */
+const SMOKE_IV = 1;
+/** The riders and 及锋而试 before the other `hit` handlers read the hit. */
+const T1_PRIORITY = 10;
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+/** Under a 晕眩 or 束缚 status (及锋而试: abnormal flags STUNNED / UNMOVABLE). */
+const held = (e) => e.buffs.some((b) => (b.status ?? b.key) === 'stun' || (b.status ?? b.key) === 'bind');
+/** The S3 burn of one 赫德雷 on an enemy (independentCharacterSource: one per source). */
+const smokeKey = (unit) => `skill:hodrer:smoke:${unit.id}`;
+
+export default {
+  char_4088_hodrer: (bb, chess) => {
+    const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
+    const hidden = moduleBb(chess);   // CRU-Y stage 3: stun (the first-hit stun on an enemy he blocks)
+    const tb = traitBb(chess);
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    const selfHeal = (battle, unit, ratio) => { if (ratio > 0) battle.heal(unit, unit, unit.s.maxHp * ratio, { self: true }); };
+    /** S3: mark `e` (not 无敌) for this cast — its own 1 s burn until the skill ends. */
+    const mark = (battle, unit, e) => {
+      const marks = unit.mem.hodrerMarks;
+      if (!marks || marks.has(e) || !e.alive || e.s.flags.invulnerable) return;
+      marks.add(e);
+      const dmg = num(b3['attack@damage']);
+      battle.addBuff(e, {
+        key: smokeKey(unit), interval: SMOKE_IV, source: unit, tags: ['skill'],
+        onTick: ({ battle: b, unit: target }) => { if (dmg > 0) b.dealDamage(unit, target, periodicDamage(dmg)); },
+      });
+    };
+    return {
+      skills: {
+        [S1]: {
+          kind: 'instant',
+          attack: { atkScale: num(b1.atk_scale, 1) },
+          onAttack({ battle, unit }) { selfHeal(battle, unit, num(b1.hp_ratio)); },
+        },
+        [S2]: {
+          kind: 'toggle',
+          mods: { batPct: batMod(b2.base_attack_time, chess), blockCnt: num(b2.block_cnt) },
+        },
+        [S3]: {
+          kind: 'duration',
+          mods: { hpPct: num(b3.max_hp), atkPct: num(b3.atk) },
+          targeting: { rangeExtend: num(b3.ability_range_forward_extend) },
+          onStart({ battle, unit, skill }) {
+            const n0 = skill.activations;
+            unit.mem.hodrerMarks = new Set();
+            unit.mem.hodrerSmoke = battle.every(SMOKE_IV, (b, sc) => {
+              if (!skill.active || skill.activations !== n0 || !up(unit)) { sc.cancel(); return; }
+              battle.loseHp(unit, num(b3['attack@value']), { source: unit, tags: ['hodrer:smoke'] });
+            }, { owner: unit });
+          },
+          onAttack({ battle, unit }) { selfHeal(battle, unit, num(b3['attack@hp_ratio'])); },
+          onEnd({ battle, unit }) {
+            unit.mem.hodrerSmoke?.cancel();
+            unit.mem.hodrerSmoke = null;
+            for (const e of unit.mem.hodrerMarks ?? []) battle.removeBuff(e, smokeKey(unit));
+            unit.mem.hodrerMarks = null;
+          },
+        },
+      },
+      talents: [
+        { install(battle, unit) { // 及锋而试 (+ the riders that precede it): ×atk_scale_2, ×atk_scale on a stunned / bound target
+          const firstStun = num(hidden.stun);
+          let stunnedOnce = new WeakSet();   // CRU-Y stage 3's marks, gone with his deployment
+          battle.on('deploy', (c) => { if (c.unit === unit) stunnedOnce = new WeakSet(); }, { owner: unit });
+          battle.on('hit', (c) => {
+            const d = c.dmg, e = c.target;
+            if (c.source !== unit || !d.isAttack || d.cancel || !e || e.side !== 'enemy') return;
+            const sk = unit.skill;
+            if (sk?.active && sk.id === S2) battle.applyStatus(e, 'stun', { duration: num(b2['attack@stun']), source: unit });
+            if (sk?.active && sk.id === S3 && e.alive && battle.rng.chance(num(b3['attack@buff_prob']))) {
+              battle.applyStatus(e, 'stun', { duration: num(b3['attack@stun']), source: unit });
+            }
+            if (firstStun > 0 && e.alive && e.blockedBy === unit && !stunnedOnce.has(e)) {
+              stunnedOnce.add(e);
+              battle.applyStatus(e, 'stun', { duration: firstStun, source: unit });
+            }
+            d.amount *= held(e) ? num(t0.atk_scale, 1) : num(t0.atk_scale_2, 1);
+          }, { owner: unit, priority: T1_PRIORITY });
+        } },
+        { install(battle, unit) { // 余火之氅: 庇护 (and CRU-X stage 3 物理伤害 +) on his tile and the one behind
+          const dr = num(t1.damage_resistance), ds = num(t1.damage_scale, 1);
+          const grid = talentGrid(chess, 1) ?? BEHIND;
+          if (!(dr > 0) && ds === 1) return;
+          const mods = (v) => ({ physTakenMul: 1 - v, artsTakenMul: 1 - v, ...(ds !== 1 ? { physDealtMul: ds } : {}) });
+          const give = () => {
+            if (!up(unit)) return;
+            for (const a of alliesInGridOf(battle, unit, grid)) battle.applyStrongest(a, PROTECT_KEY, { duration: PROTECT_IV + 0.1, value: dr, mods, source: unit });
+          };
+          battle.every(PROTECT_IV, give, { owner: unit });
+          battle.on('battleStart', give, { owner: unit });
+          battle.on('deploy', (c) => { if (c.unit === unit && battle.started) give(); }, { owner: unit });
+        } },
+      ],
+      install(battle, unit) {
+        // CRU-X: 受到的治疗效果提升20%
+        statBuff(battle, unit, 'trait:hodrer:heal', { healingTakenMul: num(tb.heal_scale, 1) });
+        // CRU-Y: 对被（自身）阻挡的敌人伤害提升至110%
+        const vs = num(tb.damage_scale, 1);
+        if (vs !== 1) {
+          battle.on('hit', (c) => {
+            if (c.source === unit && c.target && c.target.side === 'enemy' && c.target.blockedBy === unit) c.dmg.mul *= vs;
+          }, { owner: unit });
+        }
+        // S2's passive part: 攻击力+16% while 余烬重荷 is his skill
+        if (unit.skill?.id === S2) statBuff(battle, unit, S2_PASSIVE_KEY, { atkPct: num(b2.atk) });
+        // S3: every damage either way between him and an enemy marks the enemy for the running cast
+        if (unit.skill?.id === S3) {
+          battle.on('hit', (c) => {
+            if (!unit.mem.hodrerMarks) return;
+            if (c.source === unit && c.target && c.target.side === 'enemy') mark(battle, unit, c.target);
+            else if (c.target === unit && c.source && c.source.side === 'enemy') mark(battle, unit, c.source);
+          }, { owner: unit });
+        }
+      },
+    };
+  },
+};

server/sim/content/kits/ops/op-vvana.js

@@ -0,0 +1,283 @@
+// server/sim/content/kits/ops/op-vvana.js — 薇薇安娜 (char_4098_vvana) 自选 operator kit: 6★ 术战者 (近卫), an owned-6★ pick
+// of the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and both modules at every form.
+// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)").
+//
+// Forms (data/backups.json units.char_4098_vvana, the DIY slot statuses): normal = E2 Lv1, skills at rank 4, no module;
+// elite = E2 Lv60, rank 7, the picked module at stage 1 (tier 5) or 3 (tier 6). Potential 0 [ASSUMED: no account].
+// Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json); PRTS 薇薇安娜 (备注 of
+// 散华, 光影迅捷剑 and “明灭”, the AFT-Δ trait note); gamedata_const ba.charged 蓄力, ba.shield 护盾, ba.steal 偷取,
+// ba.magicfragile 法术脆弱; PRTS 作战机制 (伤害流程, 远近途径 "有弹道的攻击固定为10，无弹道的攻击固定为01"); range_table 3-2; the
+// client's battle data read from the local install — charpack char_4098_vvana, battle/prefabs [uc]skills skchr_vvana_1/2/3
+// and [uc]equips vvana_equip_*, buff_template_data vvana_* (the templates are named below).
+// - Trait (术战者) "攻击造成法术伤害": the profession (melee arts, ground only, block 1, 1.25 s).
+// - Module AFT-D 目不能及之处: trait "攻击灼燃损伤爆发期间的目标时额外造成攻击力15%的元素伤害" (trait bb ep_damage_ratio; PRTS
+//   "※于任意非本模组特性的伤害的输出伤害时触发"; vvana_e_002_trait: ON_OUTPUT_DAMAGE, not its own damage, the target in its FIRE
+//   爆发冷却 → ELEMENT damage ep_damage_ratio × ATK): every damage instance she outputs on an enemy holding the `burnBurst` lock
+//   (docs/SIM.md §3) — at the output (the `hit` step, before the target's dodge / cancel) — adds ep_damage_ratio × ATK
+//   元素伤害. Stage 3: 燃烛施明's 灼燃损伤 (below).
+// - Module AFT-Y “最后一行”: trait "自身阻挡的敌人受到10%的法术脆弱效果" (trait bb damage_scale 1.1; vvana_equip_2_*: weak[magic]
+//   to every blockee): the 法术脆弱 status (同名效果取最高) on each enemy she blocks, renewed every 0.2 s for 0.3 s (as 史尔特尔's
+//   AFT-Y). Stage 3: 散华 25 %, 2 layers (below).
+// - T1 燃烛施明 "造成的法术伤害+8%，受到的物理和法术伤害-8%。攻击范围内存在精英或领袖敌人时，该效果提升至2倍" (damage_scale_m,
+//   damage_resistance_pm, super_scale; vvana_t_1[self] / [aura] / [super]: an aura on the enemies of her current range —
+//   targetMotion ALL, flyers too, no untargetable one — and on those she blocks; an ELITE / BOSS one swaps [self] for [super],
+//   ×super_scale): artsDealtMul 1 + 0.08 f, phys / artsTakenMul 1 − 0.08 f, f = super_scale while such an enemy is there, else
+//   1 — re-read every tick and before every hit she deals or takes. AFT-D stage 3 "攻击附带相当于9%伤害的灼燃损伤"
+//   (ep_damage_ratio_m; the templates' ON_AFTER_OUTPUT_DAMAGE on her non-continuous arts damage, ApplyElementDamageBasedOnDamageValue
+//   FIRE): each arts damage instance of hers that removes HP carries ep × f × that damage as 灼燃损伤.
+// - T2 散华 "攻击精英或领袖敌人时，有18%概率获得一层仅抵挡近战攻击的护盾（最多1层）" (prob; AFT-Y stage 3: 25 %, max_stack_cnt 2;
+//   S3: × talent_scale; vvana_t_2: ON_OUTPUT_DAMAGE on an ELITE_AND_BOSS target, Dice prob, CreateBuff vvana_t_2[block_melee] —
+//   UNIQUE without max_stack_cnt, STACK up to it with — so a roll at the cap changes nothing, PRTS "※自身未存在本天赋的护盾时，每对
+//   符合条件的目标造成一次伤害判定一次本天赋"): one roll per damage instance she outputs on an elite / leader (any damage — the AFT-D
+//   rider too — at the output, before the target's dodge / cancel). vvana_t_2[block_melee]: ON_TAKE_DAMAGE from an ENEMY source
+//   with apply way MELEE → BlockDamage, one layer spent (ba.shield "每层护盾可以抵挡一次伤害"; PRTS "※仅来源于敌方单位的近战途径伤害
+//   可触发本天赋的护盾"): an enemy's damage that did not fly as a projectile (DamageInfo `isProjectile`, ai.js enemyAttack) is
+//   negated whole in a late `hit` handler (cancel, as the enemies' 护盾 layers in content/enemies.js); 无来源 damage has no enemy
+//   source. The enemy content's own projectiles (invisible / leaders / fly kits) are not marked and count as melee [ASSUMED].
+// - S1 光影迅捷剑 (AUTO, 2 charges, data DEFAULT — a "next attack" waits for her attack): the next attack at atk_scale × ATK,
+//   S1_HITS hits (S1_Attack2, `_additionalTimes` 1). 蓄力 (ba.charged "回复至上限2倍时进入蓄力状态…任何时候开启均消耗全部技力"; PRTS
+//   备注 "未满足蓄力所需技力时…仅消耗技能最低所需技力" / "“蓄力”模式将在下一次技能结束时结束" / "“蓄力”模式期间…攻击范围变为3-2";
+//   the skill's toggle at SP ratio 1 puts vvana_s_1[mode] — mode 1, range 3-2 — whose ON_SKILL_START clears the SP and
+//   ON_SKILL_FINISH ends it; S1_Attack, `_additionalTimes` 2 on 3-2, needs its mark): with both charges stored her own range is
+//   3-2 (the DEFAULT trigger's initial range and the card follow it) until the next end of the skill; a cast then hits
+//   S1_CHARGED_HITS times and spends every charge, a cast below that spends one charge.
+// - S2 烛燃影息 (MANUAL, data DEFAULT, 28 / 30 s; mode 2): ATK +atk, DEF +def, block +block_cnt, every attack hits all the
+//   enemies she blocks; each attack picks Attack_Once / Attack_Twice (attack@prob_once / attack@prob_twice: one roll per
+//   attack), the double hit at attack@atk_scale_twice × ATK carrying vvana_s_2[steal] (ON_BEFORE_TARGET_APPLY_MODIFIER of each
+//   damage → vvana_steal_attack_speed: ba.steal "减少目标的基础属性作为自身加成，目标减少和自身加成的属性不超过指定上限（同类属性取最高）"):
+//   each enemy it hits loses attack@steal_atk_speed ASPD (at most attack@steal_atk_speed_max per enemy, the largest of several
+//   thieves) and she gains as much (at most the max in all) — "持续至技能结束或薇薇安娜离场"; a dodged hit steals too (the step
+//   comes before the target's checks).
+// - S3 “明灭” (MANUAL, data DEFAULT, 15 s): attack interval +base_attack_time s (flat), ATK +atk, DEF +def, RES
+//   +magic_resistance, S3_HITS hits per attack, 散华 × talent_scale, elite / leader enemies first (targeting priority 'elite',
+//   after the enemies she blocks — the engine's order). "第二次及以后使用时，攻击距离+2，攻击变为三连击，持续时间延长至25秒" (PRTS
+//   备注 "每次部署薇薇安娜时，重新计算该技能的使用次数" / "首次技能结束后，本技能的技能范围永久扩大至3-2"; vvana_s_3[check]: a
+//   skill triggered before ⇒ the enhance mark and duration_plus = enhance_duration, vvana_s_3: mode 4 instead of 3): from her
+//   second cast of a deployment the skill runs enhance_duration s with S3_LATER_HITS hits on the 3-2 range (her own grid while
+//   it runs: the card shows it). The trigger stays the data's DEFAULT on her own range for every cast — the later casts'
+//   larger running range is no data range (reported, not changed: kits/README.md checklist 5).
+
+import { num, talentBb, traitBb, skillRec, up, batMod } from '../shared/tier1.js';
+import { isElite, elementDmg, enemiesIn } from '../shared/tier6.js';
+import { hasHp } from '../../../damage.js';
+
+const S1 = 'skchr_vvana_1';
+const S2 = 'skchr_vvana_2';
+const S3 = 'skchr_vvana_3';
+/** range_table 3-2: the 蓄力 range (PRTS S1 备注) and S3's range from its second cast (PRTS S3 备注). */
+const RANGE_3_2 = Object.freeze([[0, 0], [0, 1], [0, 2], [0, 3]].map((p) => Object.freeze(p)));
+/** S1 "并连续攻击两次" / 蓄力 "改为连续攻击三次"; S2 "二连击"; S3 "攻击变为二连击" / later "攻击变为三连击" — text only. */
+const S1_HITS = 2, S1_CHARGED_HITS = 3, S2_TWICE_HITS = 2, S3_HITS = 2, S3_LATER_HITS = 3;
+/** AFT-Y: the 法术脆弱 renewal (as 史尔特尔's AFT-Y, kits/ops/chess_char_5_07-surtr.js). */
+const FRAGILE_IV = 0.2, FRAGILE_DUR = 0.3;
+const AFTD_TAG = 'vvanaAftD';
+const CANDLE_KEY = 'talent:vvana:candle';
+const SHIELD_KEY = 'talent:vvana:shield';
+const LOOT_KEY = 'skill:vvana:loot';
+const STOLEN_KEY = 'skill:vvana:stolen';
+/** `hit` order: 燃烛施明 re-reads its factor first; the output effects (AFT-D, 散华's roll) come before the target-side
+ *  handlers (priority 0: the enemies' own 护盾, guards); 散华's 护盾 itself last (a guard that cancelled first spends none). */
+const CANDLE_PRIORITY = 100, OUTPUT_PRIORITY = 50, SHIELD_PRIORITY = -500;
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+const tagged = (d, tag) => !!d && Array.isArray(d.tags) && d.tags.includes(tag);
+/** Her own range grid (the form's 1-1), or the range she switches to. */
+function setGrid(battle, unit, grid) {
+  if (!grid || unit.rangeGrid === grid) return;
+  unit.rangeGrid = grid;
+  battle.refreshRange(unit);
+}
+
+// ---- S2 偷取: the losses of the enemies, one battle-wide table (同类属性取最高 over several thieves) ---------------------
+/** battle → Map(enemy → Map(thief id → ASPD stolen)). */
+const STOLEN = new WeakMap();
+const stolenOf = (battle) => { let m = STOLEN.get(battle); if (!m) STOLEN.set(battle, (m = new Map())); return m; };
+function applyLoss(battle, e, per) {
+  let a = 0;
+  for (const v of per.values()) a = Math.max(a, v);
+  if (!(a > 0)) { battle.removeBuff(e, STOLEN_KEY); return; }
+  battle.addBuff(e, { key: STOLEN_KEY, mods: { aspd: -a }, tags: ['steal'] });
+}
+function steal(battle, unit, e, n, cap) {
+  if (!(n > 0) || !e || !e.alive || e.side !== 'enemy') return;
+  const losses = stolenOf(battle);
+  let per = losses.get(e);
+  if (!per) losses.set(e, (per = new Map()));
+  per.set(unit.id, Math.min(cap, (per.get(unit.id) ?? 0) + n));
+  applyLoss(battle, e, per);
+  (unit.mem.vvanaVictims ??= new Set()).add(e);
+  unit.mem.vvanaLoot = Math.min(cap, (unit.mem.vvanaLoot ?? 0) + n);
+  battle.addBuff(unit, { key: LOOT_KEY, mods: { aspd: unit.mem.vvanaLoot }, tags: ['skill'] });
+}
+/** "持续至技能结束或薇薇安娜离场": she gives everything back. */
+function returnLoot(battle, unit) {
+  battle.removeBuff(unit, LOOT_KEY);
+  unit.mem.vvanaLoot = 0;
+  const losses = stolenOf(battle);
+  for (const e of unit.mem.vvanaVictims ?? []) {
+    const per = losses.get(e);
+    if (!per || !per.delete(unit.id)) continue;
+    if (e.alive) applyLoss(battle, e, per);
+  }
+  unit.mem.vvanaVictims = new Set();
+}
+
+export default {
+  char_4098_vvana: (bb, chess) => {
+    const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
+    const tb = traitBb(chess);
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    const twice = num(b2['attack@atk_scale_twice'], 1);
+    return {
+      skills: {
+        [S1]: {
+          kind: 'charges',
+          attack: { atkScale: num(b1.atk_scale, 1), hitsFn: (b, u) => (u.mem.vvanaCast === 'charged' ? S1_CHARGED_HITS : S1_HITS) },
+          onStart({ unit, skill }) {
+            // after activate's one charge: still ≥ max − 1 ⇒ every charge was stored (蓄力) — a charged cast spends them all
+            const charged = !!unit.mem.vvanaCharged || (skill.maxCharges > 1 && skill.charges >= skill.maxCharges - 1);
+            unit.mem.vvanaCast = charged ? 'charged' : 'plain';
+            if (charged) { skill.charges = 0; skill.sp = 0; }
+          },
+          onEnd({ unit }) { unit.mem.vvanaCast = null; },
+        },
+        [S2]: {
+          kind: 'duration',
+          mods: { atkPct: num(b2.atk), defPct: num(b2.def), blockCnt: num(b2.block_cnt) },
+          attack: {
+            hitAllBlocked: true,
+            hitsFn: (b, u) => (u.mem.vvanaTwice ? S2_TWICE_HITS : 1),
+            dmgMul: (b, u) => (u.mem.vvanaTwice ? twice : 1),
+            onEachHit({ battle, unit, target, kind }) {
+              if (unit.mem.vvanaTwice && kind === 'main') steal(battle, unit, target, num(b2['attack@steal_atk_speed']), num(b2['attack@steal_atk_speed_max'], Infinity));
+            },
+          },
+          onStart({ battle, unit }) { returnLoot(battle, unit); },
+          onEnd({ battle, unit }) { unit.mem.vvanaTwice = false; returnLoot(battle, unit); },
+        },
+        [S3]: {
+          kind: 'duration',
+          mods: { batPct: batMod(b3.base_attack_time, chess), atkPct: num(b3.atk), defPct: num(b3.def), resFlat: num(b3.magic_resistance) },
+          targeting: { priority: 'elite' },
+          attack: { hitsFn: (b, u) => (u.mem.vvanaS3Later ? S3_LATER_HITS : S3_HITS) },
+          onStart({ battle, unit, skill }) {
+            const later = (unit.mem.vvanaS3Casts ?? 0) >= 1;
+            unit.mem.vvanaS3Casts = (unit.mem.vvanaS3Casts ?? 0) + 1;
+            unit.mem.vvanaS3Later = later;
+            if (!later) return;
+            skill.timeLeft = Math.max(0.01, num(b3.enhance_duration, skill.duration));
+            setGrid(battle, unit, RANGE_3_2);
+          },
+          onEnd({ battle, unit }) {
+            if (unit.mem.vvanaS3Later) setGrid(battle, unit, unit.def?.rangeGrid);
+            unit.mem.vvanaS3Later = false;
+          },
+        },
+      },
+      talents: [
+        { install(battle, unit) { // 燃烛施明: arts dealt +, phys / arts taken −, ×super_scale with an elite / leader there
+          const dsm = num(t0.damage_scale_m), drp = num(t0.damage_resistance_pm), sup = num(t0.super_scale, 1), ep = num(t0.ep_damage_ratio_m);
+          const factor = () => (enemiesIn(battle, unit, unit.rangeKeys).some(isElite) || unit.blocking.some(isElite) ? sup : 1);
+          const check = () => {
+            if (!up(unit)) return;
+            const f = factor();
+            if (unit.mem.vvanaCandle === f && unit.findBuff(CANDLE_KEY)) return;
+            unit.mem.vvanaCandle = f;
+            battle.addBuff(unit, { key: CANDLE_KEY, mods: { artsDealtMul: 1 + dsm * f, physTakenMul: 1 - drp * f, artsTakenMul: 1 - drp * f }, data: { f }, tags: ['talent'] });
+          };
+          battle.on('tick', check, { owner: unit });
+          battle.on('battleStart', check, { owner: unit });
+          battle.on('deploy', (c) => { if (c.unit === unit) { unit.mem.vvanaCandle = null; check(); } }, { owner: unit });
+          // exact at the damage: re-read before any hit she deals or takes is resolved (the pipeline reads both units'
+          // stats after the `hit` hook)
+          battle.on('hit', (c) => { if (c.source === unit || c.target === unit) check(); }, { owner: unit, priority: CANDLE_PRIORITY });
+          if (!(ep > 0)) return;
+          // AFT-D stage 3: 攻击附带相当于9%伤害的灼燃损伤 (× the same factor) — her arts damage that removed HP
+          battle.on('damaged', (c) => {
+            const d = c.dmg;
+            if (c.source !== unit || c.type !== 'arts' || tagged(d, 'dot') || !(c.amount > 0) || !c.target || c.target.side !== 'enemy') return;
+            elementDmg(battle, unit, c.target, 'burn', c.amount * ep * (unit.mem.vvanaCandle ?? 1), ['talent']);
+          }, { owner: unit });
+        } },
+        { install(battle, unit) { // 散华: a melee-only 护盾 layer from her damage on elite / leader enemies
+          const p = num(t1.prob), max = Math.max(1, Math.floor(num(t1.max_stack_cnt, 1)));
+          const s3Scale = num(b3.talent_scale, 1);
+          const layers = () => unit.findBuff(SHIELD_KEY)?.data?.n ?? 0;
+          const setLayers = (n) => {
+            if (n > 0) battle.addBuff(unit, { key: SHIELD_KEY, data: { n }, visible: true, tags: ['talent'] });
+            else battle.removeBuff(unit, SHIELD_KEY);
+          };
+          battle.on('hit', (c) => {
+            if (c.source !== unit || !isElite(c.target) || !up(unit)) return;
+            const have = layers();
+            if (have >= max) return;
+            const prob = p * (unit.skill?.active && unit.skill.id === S3 ? s3Scale : 1);
+            if (!(prob > 0) || !battle.rng.chance(prob)) return;
+            setLayers(have + 1);
+            battle.fx('shield', { x: unit.x, y: unit.y, id: unit.id });
+          }, { owner: unit, priority: OUTPUT_PRIORITY });
+          battle.on('hit', (c) => {
+            if (c.target !== unit || c.dmg.cancel) return;
+            const s = c.source;
+            if (!s || s.side !== 'enemy' || c.dmg.isProjectile) return;
+            const have = layers();
+            if (!(have > 0)) return;
+            c.dmg.cancel = true;
+            setLayers(have - 1);
+            battle.fx('shieldBreak', { x: unit.x, y: unit.y, id: unit.id });
+          }, { owner: unit, priority: SHIELD_PRIORITY });
+        } },
+      ],
+      install(battle, unit) {
+        const own = unit.def?.rangeGrid;
+        // S1's 蓄力 mode: both charges stored ⇒ her range is 3-2 until the next end of the skill
+        if (unit.skill?.id === S1) {
+          const leave = () => { unit.mem.vvanaCharged = false; setGrid(battle, unit, own); };
+          battle.on('tick', () => {
+            const sk = unit.skill;
+            if (!up(unit) || unit.mem.vvanaCharged || !sk || !(sk.maxCharges > 1) || sk.charges < sk.maxCharges) return;
+            unit.mem.vvanaCharged = true;
+            setGrid(battle, unit, RANGE_3_2);
+          }, { owner: unit });
+          battle.on('skillEnd', (c) => { if (c.unit === unit && c.skill.id === S1 && unit.mem.vvanaCharged) leave(); }, { owner: unit });
+          battle.on('deploy', (c) => { if (c.unit === unit) leave(); }, { owner: unit });
+        }
+        // S2: one Attack_Once / Attack_Twice pick per attack while it runs
+        if (unit.skill?.id === S2) {
+          const prob = num(b2['attack@prob_twice']);
+          battle.on('beforeAttack', (c) => {
+            if (c.attacker !== unit) return;
+            unit.mem.vvanaTwice = !!(unit.skill?.active && unit.skill.id === S2) && prob > 0 && battle.rng.chance(prob);
+          }, { owner: unit });
+          battle.on('death', (c) => { if (c.unit === unit) returnLoot(battle, unit); }, { owner: unit });
+        }
+        // S3: the cast count of a deployment ("每次部署…重新计算"), her own range back
+        if (unit.skill?.id === S3) {
+          battle.on('deploy', (c) => {
+            if (c.unit !== unit) return;
+            unit.mem.vvanaS3Casts = 0;
+            unit.mem.vvanaS3Later = false;
+            setGrid(battle, unit, own);
+          }, { owner: unit });
+        }
+        // AFT-D: 元素伤害 at the output of every damage of hers on an enemy in its 灼燃 爆发冷却 (not on this rider's own)
+        const er = num(tb.ep_damage_ratio);
+        if (er > 0) {
+          battle.on('hit', (c) => {
+            const t = c.target;
+            if (c.source !== unit || !t || t.side !== 'enemy' || tagged(c.dmg, AFTD_TAG) || !hasHp(t) || !t.findBuff('burnBurst')) return;
+            battle.dealDamage(unit, t, { amount: unit.s.atk * er, type: 'elemental', element: 'burn', canDodge: false, tags: [AFTD_TAG, 'dot'] });
+          }, { owner: unit, priority: OUTPUT_PRIORITY });
+        }
+        // AFT-Y: 自身阻挡的敌人受到10%的法术脆弱效果
+        const fragile = num(tb.damage_scale, 1) - 1;
+        if (fragile > 0) {
+          battle.every(FRAGILE_IV, () => {
+            if (!up(unit)) return;
+            for (const e of unit.blocking) if (e.alive) battle.applyStatus(e, 'artsFragile', { duration: FRAGILE_DUR, value: fragile, source: unit });
+          }, { owner: unit });
+        }
+      },
+    };
+  },
+};

server/sim/targeting.js

@@ -181,6 +181,8 @@ const PRIORITY_FNS = {
   lowestHpRatio: (e) => e.hpRatio,
   highestAtk: (e) => -e.s.atk,
   boss: (e) => (e.isBoss ? 0 : 1),
+  // "优先攻击精英或领袖敌人" (薇薇安娜 S3: kits/ops/op-vvana.js): an ELITE / BOSS rank enemy or a leader first
+  elite: (e) => (e.isBoss || e.def?.rank === 'ELITE' || e.def?.rank === 'BOSS' ? 0 : 1),
   notBurst: (e) => (e.s.flags.burstLock ? 1 : 0),
   ground: (e) => (e.isFlying ? 1 : 0),
   // 攻城手 trait "优先攻击重量最重的敌人" (早露 / 提丰: kits/ops/op-poca.js, op-typhon.js): the highest current 重量等级

test/content/op_headb2.test.js

@@ -0,0 +1,323 @@
+// test/content/op_headb2.test.js — the 自选 operator kit of 怒潮凛冬 (char_1051_headb2, 6★ 撼地者; kit
+// server/sim/content/kits/ops/op-headb2.js), fielded the production way (a DIY slot + its `diy` pick, simdata getDiy) in every
+// form: tiers 5 / 6, normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module or HAM-X 迟到的勋章 at
+// stage 1 (tier 5) / 3 (tier 6). Every number is read back from data/backups.json (the form of that slot status); the
+// fidelity checklist of kits/README.md item by item. The 高台 of 汹涌怒火 are HIGH tiles of the field rect: the tests put
+// forbidden blocks ('#') next to the lane of the flat stage.
+// Run: node --test test/content/op_headb2.test.js
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
+import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js';
+import { diyPool, validateDiyPicks } from '../../shared/diy.js';
+
+const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
+const CHESS = load('chess');
+const BACKUPS = load('backups');
+const ZIMA = 'char_1051_headb2';
+const FORMS = BACKUPS.units[ZIMA].forms;
+const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
+const HAMX = 'uniequip_002_headb2';
+const S1 = 'skchr_headb2_1', S2 = 'skchr_headb2_2', S3 = 'skchr_headb2_3';
+const TIDE = 'talent:headb2:tide';
+/** The Skill_3 clip of the battle skeleton (30 fps): OnAttack at frames 33 / 84 / 133 / 182 / 233, 277 frames long. */
+const HAMMER_T = [33, 84, 133, 182, 233].map((f) => f / 30), SKILL3_T = 277 / 30;
+/** Row 11 of the flat stage with one 高台 at (11, 7) — diagonal to the tile ahead of her (10, 6) — or a row of four. */
+const ONE_HIGH = { 11: '##hrrrr#rrfrrrrrrrf##' };
+const FOUR_HIGH = { 11: '##hrrrr####rrrrrrrf##' };
+const formOf = (tier, elite) => FORMS[elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0'];
+const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id);
+const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null);
+const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`);
+const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o });
+const ENEMIES = { enemy_dummy: dummy('enemy_dummy'), enemy_fly: dummy('enemy_fly', { motion: 'FLY' }) };
+const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, HAMX].map((m) => [t, true, m]))];
+
+/** A battle with 怒潮凛冬 as uid 1 at (row, col) facing RIGHT, plus `others`. */
+function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 5, others = [], seed = 5, rows = null, noSp = false } = {}) {
+  const h = makeBattle({
+    defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed, flat: rows ? { rows } : undefined,
+    flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied', 'spGain', 'attack'], captureNoisy: true,
+    units: [{ uid: 1, diy: { slot: SLOT[tier], charId: ZIMA, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others],
+  });
+  h.step();
+  const u = h.unit(1);
+  if (noSp) h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; });
+  return { h, u };
+}
+const dmgOn = (h, e, pred = () => true) => h.hooksOf('damaged').filter((c) => c.target === e && pred(c));
+const highland = (c) => (c.dmg?.tags ?? []).includes('headb2Highland');
+const hammerHit = (c) => (c.dmg?.tags ?? []).includes('headb2Hammer');
+function done(h) {
+  checkInvariants(h.b);
+  assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
+}
+const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
+const t0Of = (u) => u.def.raw.talents.find((t) => t.index === 0).bb;
+
+test('怒潮凛冬 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + HAM-X attributes, 1-1, blocks 2, melee physical ground-only with the 撼地者 splash, no bond, no 特质', () => {
+  assert.equal(OPERATOR_KITS[ZIMA], KITS[ZIMA]);
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    for (const skill of [0, 1, 2]) {
+      const { h, u } = field({ tier, elite, mod, skill });
+      const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null;
+      assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [ZIMA, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
+      assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0)], `${label(f)}: stats`);
+      assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.base.bat], [2, 'melee', 'phys', false, 1.8], `${label(f)}: 撼地者`);
+      assert.deepEqual([u.profile.splashRadius, u.profile.splashScale, u.profile.splashOthersOnly], [1, 0.5, true], `${label(f)}: the trait splash`);
+      assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 1-1`);
+      assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [['emptyShip'], []], `${label(f)}: bonds / 特质`);
+      assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target her`);
+      done(h);
+    }
+  }
+  // zh_CN: E2 Lv1 2301 / 1060 / 346, E2 Lv60 2731 / 1194 / 387; HAM-X +250 / +63 / +21 → +380 / +83 / +30
+  assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk], [2301, 1060, 2731, 1194]);
+  assert.deepEqual([modOf(5, HAMX).attr, modOf(6, HAMX).attr], [{ maxHp: 250, atk: 63, def: 21 }, { maxHp: 380, atk: 83, def: 30 }]);
+});
+
+test('a 自选 pick: 怒潮凛冬 is offered at tiers 5 and 6 (she has a kit) and a roster with her passes validateDiyPicks', () => {
+  const data = { chess: CHESS, backups: BACKUPS };
+  assert.ok(KITTED_CHARS.includes(ZIMA));
+  for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(ZIMA), `tier ${t}`);
+  assert.deepEqual(validateDiyPicks({ [SLOT[5]]: { charId: ZIMA, skillIndex: 2, uniEquipId: HAMX } }, { data, kitted: KITTED_CHARS }),
+    { ok: true, picks: { [SLOT[5]]: { charId: ZIMA, skillIndex: 2, uniEquipId: HAMX } } });
+});
+
+test('trait + T1 汹涌怒火 + HAM-X: the target takes ATK, the others within 1.0 the 50 % splash ×1.24 (HAM-X stage 3 ×1.4) — not flyers; with 3 enemies in the splash range HAM-X lifts the attack to 115 %', () => {
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 0, noSp: true });
+    const ds = t0Of(u).damage_scale;
+    assert.equal(ds, elite && tier === 6 && mod === HAMX ? 1.4 : 1.24, `${label(f)}: damage_scale`);
+    const a = h.spawn('enemy_dummy', { pos: [10, 6] });
+    const c = h.spawn('enemy_dummy', { pos: [9, 6] });
+    const fly = h.spawn('enemy_fly', { pos: [11, 6] });
+    h.run(0.1);
+    const ma = dmgOn(h, a), mc = dmgOn(h, c);
+    assert.ok(ma.length === 1 && mc.length === 1, `${label(f)}: one attack (${ma.length} / ${mc.length})`);
+    approx(ma[0].amount, u.s.atk, `${label(f)}: the target 100 % (no ×${ds})`);
+    approx(mc[0].amount, u.s.atk * 0.5 * ds, `${label(f)}: splash 50 % × ${ds}`);
+    assert.deepEqual([mc[0].dmg.isSplash, mc[0].type], [true, 'phys']);
+    assert.equal(dmgOn(h, fly).length, 0, `${label(f)}: no flyer`);
+    // a third enemy in the splash range: HAM-X ×1.15 on the attack
+    h.spawn('enemy_dummy', { pos: [10, 7] });
+    h.run(u.s.interval);
+    const hx = elite && mod === HAMX ? 1.15 : 1;
+    const ma2 = dmgOn(h, a).slice(1), mc2 = dmgOn(h, c).slice(1);
+    assert.ok(ma2.length >= 1 && mc2.length >= 1, `${label(f)}: the next attack`);
+    approx(ma2[0].amount, u.s.atk * hx, `${label(f)}: the target ×${hx}`);
+    approx(mc2[0].amount, u.s.atk * 0.5 * ds * hx, `${label(f)}: the splash ×${hx}`);
+    done(h);
+  }
+});
+
+test('T1 汹涌怒火 高台: every 高台 the 1.0 circle around her target touches hits the ground enemies of its x-5 0.1 s later — 24 % ATK physical 溅射 (no dodge, 无来源, 远程途径) + 停顿 0.5 s; HAM-X: ×1.15 with 3 there', () => {
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 0, noSp: true, rows: ONE_HIGH });
+    const t0 = t0Of(u);
+    assert.deepEqual([t0['attack@splash_atk_scale'], t0['attack@sluggish']], [0.24, 0.5], label(f));
+    assert.equal(h.b.grid.tile(11, 7).height, 'HIGH');
+    const a = h.spawn('enemy_dummy', { pos: [10, 6] });
+    const b = h.spawn('enemy_dummy', { pos: [12, 7] });        // only on (11, 7)'s x-5
+    const far = h.spawn('enemy_dummy', { pos: [12, 9] });      // on no 高台's x-5
+    const fly = h.spawn('enemy_fly', { pos: [11, 8] });         // an air unit on the x-5
+    h.step();
+    const atkT = h.b.time, atk = u.s.atk;
+    assert.equal(dmgOn(h, a).length, 1, `${label(f)}: her attack`);
+    h.run(0.05);
+    assert.equal(dmgOn(h, b).length, 0, `${label(f)}: not before 0.1 s`);
+    h.run(0.1);
+    const hb = dmgOn(h, b);
+    assert.equal(hb.length, 1, `${label(f)}: the 高台 splash`);
+    const d = hb[0];
+    approx(d.t - atkT, 0.1, `${label(f)}: 0.1 s after the attack`, 0.4);
+    approx(d.amount, atk * 0.24, `${label(f)}: 24 % ATK`);
+    assert.deepEqual([d.type, d.source, d.credit, d.dmg.isSplash, d.dmg.canDodge, d.dmg.sourceless, d.dmg.isProjectile], ['phys', null, u, true, false, true, true], `${label(f)}: physical 溅射, 无来源 credited to her, 远程途径`);
+    const st = h.hooksOf('statusApplied').filter((s) => s.target === b && s.status === 'sluggish');
+    assert.ok(st.length === 1 && Math.abs(st[0].duration - 0.5) < 1e-9, `${label(f)}: 停顿 0.5 s`);
+    assert.ok(dmgOn(h, far).length === 0 && dmgOn(h, fly).length === 0, `${label(f)}: off the x-5 / air: nothing`);
+    assert.equal(dmgOn(h, a, highland).length, 0, `${label(f)}: the target is diagonal to the 高台 — not on its x-5`);
+    // three ground enemies on the x-5: HAM-X ×1.15 on that splash
+    h.spawn('enemy_dummy', { pos: [11, 6] });
+    h.spawn('enemy_dummy', { pos: [11, 8] });
+    const n0 = dmgOn(h, b, highland).length;
+    h.run(u.s.interval + 0.2);
+    const next = dmgOn(h, b, highland).slice(n0);
+    assert.ok(next.length >= 1, `${label(f)}: the next attack's 高台 splash`);
+    approx(next[0].amount, u.s.atk * 0.24 * (elite && mod === HAMX ? 1.15 : 1), `${label(f)}: ×${elite && mod === HAMX ? 1.15 : 1} with 3 on the x-5`);
+    done(h);
+  }
+});
+
+test('S2 绝不罢休\'s passive: +1 SP per 高台 that triggers 汹涌怒火 (none without one, none while the skill runs)', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S2);
+    assert.equal(sk.bb.sp_per_highland, 1);
+    const { h, u } = field({ tier, elite, skill: 1, rows: FOUR_HIGH, seed: 9 });
+    h.spawn('enemy_dummy', { pos: [10, 6] });               // (11, 7) only
+    const talentSp = () => h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'talent');
+    const attacks = () => h.hooksOf('attack').filter((c) => c.attacker === u).length;
+    h.run(5);
+    assert.ok(attacks() >= 2 && talentSp().length === attacks(), `T${tier}: ${talentSp().length} SP gifts for ${attacks()} attacks (one 高台 each)`);
+    assert.ok(talentSp().every((c) => c.amount === 1));
+    assert.ok(h.runUntil(() => u.skill.active, 60), `T${tier}: S2 casts`);
+    const n = talentSp().length;
+    h.run(5);
+    assert.equal(talentSp().length, n, `T${tier}: none while it runs`);
+    done(h);
+  }
+  // no 高台 around her target: no gift
+  const { h, u } = field({ tier: 5, skill: 1, seed: 9 });
+  h.spawn('enemy_dummy', { pos: [10, 6] });
+  h.run(5);
+  assert.equal(h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'talent').length, 0);
+  done(h);
+});
+
+test('T2 万众巨潮: while a skill of hers runs every operator of the field ATK / DEF +14 % — 【乌萨斯学生自治团】 (her, 古米) +28 % — and nothing before or after it', () => {
+  for (const [tier, elite, skill] of [[5, false, 0], [6, true, 1]]) {
+    const others = [{ uid: 2, chessId: 'chess_char_1_10_a', row: 11, col: 3 }, { uid: 3, chessId: 'chess_char_1_08_a', row: 12, col: 3 }];
+    const { h, u } = field({ tier, elite, skill, others });
+    const gummy = h.unit(2), texas = h.unit(3);
+    const t1 = u.def.raw.talents.find((t) => t.index === 1).bb;
+    assert.deepEqual([t1.atk, t1.def, t1.scale_bonus], [0.14, 0.14, 2]);
+    h.run(0.5);
+    for (const o of [u, gummy, texas]) assert.equal(o.findBuff(TIDE), null, `T${tier}: nothing before her skill (${o.def.charId})`);
+    u.skill.gainSp(999);
+    if (skill === 0) { h.spawn('enemy_dummy', { pos: [10, 6] }); assert.ok(h.runUntil(() => u.skill.active, 3)); } else assert.ok(h.runUntil(() => u.skill.active, 1), 'S2 at full SP');
+    for (const [o, v] of [[u, 0.28], [gummy, 0.28], [texas, 0.14]]) {
+      const m = o.findBuff(TIDE)?.mods;
+      assert.ok(m, `T${tier}: ${o.def.charId} in her skill`);
+      approx(m.atkPct, v, `T${tier}: ${o.def.charId} ATK`);
+      approx(m.defPct, v, `T${tier}: ${o.def.charId} DEF`);
+    }
+    h.run(3);
+    assert.ok(texas.findBuff(TIDE), `T${tier}: kept while it runs`);
+    u.skill.end('test');
+    for (const o of [u, gummy, texas]) assert.equal(o.findBuff(TIDE), null, `T${tier}: gone at its end (${o.def.charId})`);
+    done(h);
+  }
+});
+
+test('S1 誓不低头 (MANUAL, DEFAULT): 30 s, ATK +32 % / 39 %, ASPD +35 / 40 (her own 万众巨潮 +28 % on top); all back after', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S1);
+    const { h, u } = field({ tier, elite, skill: 0 });
+    assert.deepEqual([u.skill.rule, sk.duration, sk.bb.atk, sk.bb.attack_speed], ['DEFAULT', 30, elite ? 0.39 : 0.32, elite ? 40 : 35], `T${tier}`);
+    u.skill.gainSp(999);
+    h.run(1);
+    assert.equal(u.skill.activations, 0, `T${tier}: no enemy, no cast`);
+    h.spawn('enemy_dummy', { pos: [10, 6] });
+    assert.ok(h.runUntil(() => u.skill.active, 3), `T${tier}: cast with an enemy in range`);
+    approx(u.skill.timeLeft, 30, `T${tier}: 30 s`, 0.01);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk + 0.28), `T${tier}: ATK`);
+    approx(u.s.aspd, 100 + sk.bb.attack_speed, `T${tier}: ASPD`);
+    h.runUntil(() => !u.skill.active, 40);
+    approx(u.s.atk, u.base.atk, `T${tier}: ATK back`);
+    done(h);
+  }
+});
+
+test('S2 绝不罢休 (AUTO, SP_FULL — a self buff): at full SP with no enemy, 2-5, ATK +60 / 75 %, DEF +40 / 50 % for 16 s; the second cast of a deployment doubles them for good; a redeploy counts again', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S2);
+    const { h, u } = field({ tier, elite, skill: 1 });
+    assert.deepEqual([u.skill.rule, sk.skillType, sk.duration, sk.spCost, sk.initSp, sk.rangeId], ['SP_FULL', 'AUTO', 16, elite ? 53 : 57, elite ? 24 : 20, '2-5'], `T${tier}`);
+    h.run(sk.spCost - sk.initSp - 0.5);
+    assert.equal(u.skill.activations, 0, `T${tier}: not before full SP`);
+    assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: at full SP, no enemy on the field`);
+    assert.deepEqual(u.liveRangeGrid, sk.rangeGrid, `T${tier}: 2-5 while it runs`);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk + 0.28), `T${tier}: ATK (+ her 万众巨潮)`);
+    approx(u.s.def, u.base.def * (1 + sk.bb.def + 0.28), `T${tier}: DEF`);
+    h.run(15.9);
+    assert.ok(u.skill.active, `T${tier}: 16 s`);
+    h.run(0.2);
+    assert.ok(!u.skill.active, `T${tier}: over after 16 s`);
+    assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 1-1 again`);
+    u.skill.gainSp(999);
+    assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: the second cast`);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb['headb2_s_2[second].atk'] + 0.28), `T${tier}: ATK doubled`);
+    approx(u.s.def, u.base.def * (1 + sk.bb['headb2_s_2[second].def'] + 0.28), `T${tier}: DEF doubled`);
+    h.run(200);
+    assert.ok(u.skill.active, `T${tier}: 持续时间无限`);
+    h.b.retreat(u);
+    h.b.redeploy(u);
+    h.step();
+    u.skill.gainSp(999);
+    assert.ok(h.runUntil(() => u.skill.active, 1));
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk + 0.28), `T${tier}: a new deployment's first cast`);
+    done(h);
+  }
+});
+
+test('S3 无可抵挡 (MANUAL, data CUSTOM_RANGE): five hammers on the Skill_3 clip\'s attack events (1.1 … 7.77 s), no normal attack, 9.23 s; the target ahead atk_scale × ATK, the others within 1.5 the splash; ATK +atk_base, +30 % per hammer; 高台 ×3.5 with 束缚, spreading k − 1 steps (0.1 s, then 0.125 s a step)', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [6, true, HAMX]]) {
+    const sk = skillOf(tier, elite, S3);
+    const { h, u } = field({ tier, elite, mod, skill: 2, rows: FOUR_HIGH, seed: 17 });
+    assert.deepEqual([u.skill.rule, sk.bb.atk_scale, sk.bb.atk_step, sk.bb.splash_atk_scale_bonus, sk.bb.unmovable, sk.bb.atk_base],
+      ['CUSTOM_RANGE', elite ? 2.1 : 1.9, 0.3, 3.5, elite ? 1.5 : 1, elite ? 0.8 : 0.65], `T${tier}`);
+    const ds = t0Of(u).damage_scale;
+    // the 高台 at (11, 7)…(11, 10); a dummy on each one's own x-5 tile below it
+    const under = [7, 8, 9, 10].map((c) => h.spawn('enemy_dummy', { pos: [12, c] }));
+    const side = h.spawn('enemy_dummy', { pos: [9, 7] });     // in the hammer's 1.5, not the 1.0 of the trait
+    u.skill.gainSp(999);
+    h.run(1);
+    assert.equal(u.skill.activations, 0, `T${tier}: nothing in the trigger grid`);
+    const main = h.spawn('enemy_dummy', { pos: [10, 6] });
+    assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: an enemy in the trigger grid`);
+    const t0 = h.hooksOf('skillStart').find((c) => c.unit === u).t;
+    approx(u.skill.timeLeft, SKILL3_T - (h.b.time - t0), `T${tier}: the clip's 277 frames`, 0.01);
+    h.runUntil(() => !u.skill.active, 12);
+    approx(h.b.time - t0, SKILL3_T, `T${tier}: over with the clip`, 0.02);
+    assert.equal(h.hooksOf('attack').filter((c) => c.attacker === u && c.t > t0 && c.t < t0 + SKILL3_T - 0.1).length, 0, `T${tier}: no normal attack`);
+    const atkK = (k) => u.base.atk * (1 + sk.bb.atk_base + 0.28 + sk.bb.atk_step * (k - 1));
+    const mh = dmgOn(h, main, (c) => c.t >= t0 && hammerHit(c));
+    assert.equal(mh.length, 5, `T${tier}: five hammers on the target ahead`);
+    mh.forEach((c, i) => { approx(c.t - t0, HAMMER_T[i], `T${tier}: hammer ${i + 1} at ${HAMMER_T[i].toFixed(3)} s`, 0.02); approx(c.amount, atkK(i + 1) * sk.bb.atk_scale, `T${tier}: hammer ${i + 1} ${sk.bb.atk_scale * 100} %`); });
+    const sh = dmgOn(h, side, (c) => c.t >= t0 && hammerHit(c));
+    assert.equal(sh.length, 5, `T${tier}: the splash within 1.5`);
+    sh.forEach((c, i) => approx(c.amount, atkK(i + 1) * sk.bb.atk_scale * 0.5 * ds, `T${tier}: splash ${i + 1}`));
+    // the 高台 rounds: hammer k reaches k − 1 steps along the row
+    const counts = under.map((e) => dmgOn(h, e, (c) => c.t >= t0 && highland(c)).length);
+    assert.deepEqual(counts, [5, 4, 3, 2], `T${tier}: (11, 7) every hammer, (11, 8) from the 2nd, (11, 9) the 3rd, (11, 10) the 4th`);
+    const first = dmgOn(h, under[0], (c) => c.t >= t0 && highland(c));
+    first.forEach((c, i) => approx(c.amount, atkK(i + 1) * 0.24 * 3.5, `T${tier}: 高台 ×3.5 at hammer ${i + 1}`));
+    const last = dmgOn(h, under[3], (c) => c.t >= t0 && highland(c));
+    approx(last[0].t - (t0 + HAMMER_T[3]), 0.1 + 3 * 0.125, `T${tier}: 0.1 s, then three spread steps of 0.125 s after the 4th hammer`, 0.03);
+    const binds = h.hooksOf('statusApplied').filter((s) => s.target === under[0] && s.status === 'bind' && s.t >= t0);
+    assert.ok(binds.length === 5 && binds.every((s) => Math.abs(s.duration - sk.bb.unmovable) < 1e-9), `T${tier}: 束缚 ${sk.bb.unmovable} s (${binds.length})`);
+    assert.equal(h.hooksOf('statusApplied').filter((s) => s.target === under[0] && s.status === 'sluggish' && s.t >= t0).length, 0, `T${tier}: no 停顿 in the skill`);
+    approx(u.s.atk, u.base.atk, `T${tier}: ATK back`);
+    done(h);
+  }
+});
+
+test('S3: leaving the field stops the 高台 spread at once; a hammer due while she is stunned is lost', () => {
+  const { h, u } = field({ tier: 6, elite: true, skill: 2, rows: FOUR_HIGH, seed: 17 });
+  const under = [7, 8, 9, 10].map((c) => h.spawn('enemy_dummy', { pos: [12, c] }));
+  h.spawn('enemy_dummy', { pos: [10, 6] });
+  u.skill.gainSp(999);
+  assert.ok(h.runUntil(() => u.skill.active, 1));
+  const t0 = h.hooksOf('skillStart').find((c) => c.unit === u).t;
+  h.run(HAMMER_T[3] + 0.15 - (h.b.time - t0));   // the 4th hammer: (11, 7) at +0.1, (11, 8) due at +0.225
+  h.b.retreat(u);
+  h.run(2);
+  const counts = under.map((e) => dmgOn(h, e, (c) => c.t >= t0 && highland(c)).length);
+  assert.deepEqual(counts, [4, 2, 1, 0], 'the 4th round stopped after its first step: (11, 8) / (11, 9) / (11, 10) keep the earlier rounds only');
+  done(h);
+  // stunned through the 1st hammer (1.1 s)
+  const s = field({ tier: 5, skill: 2, seed: 17 });
+  const main = s.h.spawn('enemy_dummy', { pos: [10, 6] });
+  s.u.skill.gainSp(999);
+  assert.ok(s.h.runUntil(() => s.u.skill.active, 1));
+  s.h.run(1.0);
+  s.h.b.applyStatus(s.u, 'stun', { duration: 1.5, source: null });
+  s.h.runUntil(() => !s.u.skill.active, 12);
+  assert.equal(dmgOn(s.h, main, hammerHit).length, 4, 'four hammers landed');
+  done(s.h);
+});

test/content/op_hodrer.test.js

@@ -0,0 +1,288 @@
+// test/content/op_hodrer.test.js — the 自选 operator kit of 赫德雷 (char_4088_hodrer, 6★ 重剑手; kit
+// server/sim/content/kits/ops/op-hodrer.js), fielded the production way (a DIY slot + its `diy` pick, simdata getDiy) in every
+// form: tiers 5 / 6, normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module, CRU-X 新的生活 or
+// CRU-Y 笔迹 at stage 1 (tier 5) / 3 (tier 6). Every number is read back from data/backups.json (the form of that slot status);
+// the fidelity checklist of kits/README.md item by item.
+// Run: node --test test/content/op_hodrer.test.js
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
+import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js';
+import { diyPool, validateDiyPicks } from '../../shared/diy.js';
+
+const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
+const CHESS = load('chess');
+const BACKUPS = load('backups');
+const HOD = 'char_4088_hodrer';
+const FORMS = BACKUPS.units[HOD].forms;
+const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
+const CRUX = 'uniequip_002_hodrer', CRUY = 'uniequip_003_hodrer';
+const S1 = 'skchr_hodrer_1', S2 = 'skchr_hodrer_2', S3 = 'skchr_hodrer_3';
+const PROTECT = 'talent:hodrer:protect';
+const formOf = (tier, elite) => FORMS[elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0'];
+const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id);
+const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null);
+const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`);
+const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o });
+const ENEMIES = {
+  enemy_dummy: dummy('enemy_dummy'),
+  enemy_fly: dummy('enemy_fly', { motion: 'FLY' }),
+  enemy_walk: enemyRec({ key: 'enemy_walk', hp: 1e9, speed: 0.6, mass: 0 }),
+  enemy_brute: enemyRec({ key: 'enemy_brute', hp: 1e9, speed: 0.6, mass: 0, atk: 300, bat: 1 }),
+};
+const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, CRUX, CRUY].map((m) => [t, true, m]))];
+
+/** A battle with 赫德雷 as uid 1 at (row, col) facing RIGHT, plus `others`. */
+function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 5, others = [], seed = 5, noSp = false } = {}) {
+  const h = makeBattle({
+    defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed,
+    flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'heal', 'skillStart', 'skillEnd', 'statusApplied', 'attack'], captureNoisy: true,
+    units: [{ uid: 1, diy: { slot: SLOT[tier], charId: HOD, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others],
+  });
+  h.step();
+  const u = h.unit(1);
+  if (noSp) h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; });
+  return { h, u };
+}
+const atkHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.isAttack);
+const byAttack = (hits) => { const m = new Map(); for (const c of hits) { const k = c.dmg.attackId; if (!m.has(k)) m.set(k, []); m.get(k).push(c); } return [...m.values()]; };
+function done(h) {
+  checkInvariants(h.b);
+  assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
+}
+const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
+const t0Of = (u) => u.def.raw.talents.find((t) => t.index === 0).bb;
+const t1Of = (u) => u.def.raw.talents.find((t) => t.index === 1).bb;
+/** 余火之氅 on his own tile: CRU-X stage 3 "造成的物理伤害提升10%" (damage_scale) — 1 otherwise. */
+const ownPhys = (u) => t1Of(u).damage_scale ?? 1;
+
+test('赫德雷 in every 自选 form: his operator kit (all three skills authored), the form\'s stats + module attributes, 1-1, blocks 2, melee physical ground-only hitting all he blocks, no bond, no 特质', () => {
+  assert.equal(OPERATOR_KITS[HOD], KITS[HOD]);
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    for (const skill of [0, 1, 2]) {
+      const { h, u } = field({ tier, elite, mod, skill });
+      const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null;
+      assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [HOD, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
+      assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def], `${label(f)}: stats`);
+      assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.profile.hitAllBlocked, u.base.bat], [2, 'melee', 'phys', false, true, 2.5], `${label(f)}: 重剑手`);
+      assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 1-1`);
+      assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [['emptyShip'], []], `${label(f)}: bonds / 特质`);
+      assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target him`);
+      done(h);
+    }
+  }
+  // zh_CN: E2 Lv1 4670 / 1323 / 0, E2 Lv60 5544 / 1491 / 0; CRU-X +290 / +92 → +450 / +130, CRU-Y +300 / +110 → +400 / +160
+  assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk], [4670, 1323, 5544, 1491]);
+  assert.deepEqual([modOf(5, CRUX).attr, modOf(6, CRUX).attr, modOf(5, CRUY).attr, modOf(6, CRUY).attr], [{ maxHp: 290, atk: 92 }, { maxHp: 450, atk: 130 }, { maxHp: 300, atk: 110 }, { maxHp: 400, atk: 160 }]);
+});
+
+test('a 自选 pick: 赫德雷 is offered at tiers 5 and 6 (he has a kit) and a roster with him passes validateDiyPicks', () => {
+  const data = { chess: CHESS, backups: BACKUPS };
+  assert.ok(KITTED_CHARS.includes(HOD));
+  for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(HOD), `tier ${t}`);
+  assert.deepEqual(validateDiyPicks({ [SLOT[6]]: { charId: HOD, skillIndex: 0, uniEquipId: CRUY } }, { data, kitted: KITTED_CHARS }),
+    { ok: true, picks: { [SLOT[6]]: { charId: HOD, skillIndex: 0, uniEquipId: CRUY } } });
+});
+
+test('trait + T1 及锋而试: every attack hits all he blocks; ×1.1 (CRU-Y stage 3 ×1.3), ×1.4 (×1.6) on a stunned or bound target — not a frozen one, never a flyer', () => {
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 0, noSp: true });
+    const t0 = t0Of(u);
+    const y3 = elite && tier === 6 && mod === CRUY;
+    assert.deepEqual([t0.atk_scale_2, t0.atk_scale], y3 ? [1.3, 1.6] : [1.1, 1.4], label(f));
+    const e = h.spawn('enemy_dummy', { pos: [10, 6] });
+    h.spawn('enemy_fly', { pos: [10, 6] });
+    const hitOn = () => { const n = atkHits(h, u).length; h.runUntil(() => atkHits(h, u).length > n, 3); return atkHits(h, u).slice(n); };
+    let hs = hitOn();
+    assert.ok(hs.length === 1 && hs[0].target === e, `${label(f)}: the ground dummy only`);
+    approx(hs[0].amount, u.s.atk * t0.atk_scale_2 * ownPhys(u), `${label(f)}: ×${t0.atk_scale_2}`);
+    for (const [st, mul] of [['stun', t0.atk_scale], ['bind', t0.atk_scale], ['freeze', t0.atk_scale_2]]) {
+      h.b.applyStatus(e, st, { duration: 60, source: null });
+      hs = hitOn();
+      approx(hs[0].amount, u.s.atk * mul * ownPhys(u), `${label(f)}: ${st} ×${mul}`);
+      h.b.removeStatus(e, st);
+    }
+    done(h);
+  }
+  // all he blocks, at once
+  const { h, u } = field({ tier: 6, elite: true, skill: 0, row: 9, col: 5, noSp: true });
+  h.spawn('enemy_walk', { routeIndex: 0 });
+  h.spawn('enemy_walk', { routeIndex: 0, time: 0 });
+  assert.ok(h.runUntil(() => u.blocking.length === 2, 40), 'blocks two');
+  const n = atkHits(h, u).length;
+  h.run(6);
+  const att = byAttack(atkHits(h, u).slice(n));
+  assert.ok(att.length >= 2 && att.every((a) => a.length === 2 && new Set(a.map((c) => c.target)).size === 2), '同时攻击阻挡的所有敌人');
+  done(h);
+});
+
+test('CRU-Y stage 3: his first damage on an enemy he blocks stuns it 2.5 s — before 及锋而试 reads it (×1.6) — once per enemy and deployment; CRU-Y ×1.1 on the enemies he blocks (stages 1 and 3), not on others', () => {
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 0, row: 9, col: 5, noSp: true });
+    const y = elite && mod === CRUY, y3 = y && tier === 6;
+    const w = h.spawn('enemy_walk', { routeIndex: 0 });
+    assert.ok(h.runUntil(() => u.blocking.includes(w), 40), `${label(f)}: blocked`);
+    const n = atkHits(h, u).length;
+    h.runUntil(() => atkHits(h, u).length > n, 4);
+    const first = atkHits(h, u).slice(n)[0];
+    const stuns = () => h.hooksOf('statusApplied').filter((s) => s.target === w && s.status === 'stun' && s.source === u);
+    const t0 = t0Of(u);
+    assert.equal(stuns().length, y3 ? 1 : 0, `${label(f)}: the first-hit stun`);
+    if (y3) assert.equal(stuns()[0].duration, 2.5);
+    approx(first.amount, u.s.atk * (y3 ? t0.atk_scale : t0.atk_scale_2) * (y ? 1.1 : 1) * ownPhys(u), `${label(f)}: the first hit`);
+    h.run(8);
+    assert.equal(stuns().length, y3 ? 1 : 0, `${label(f)}: once per enemy`);
+    if (y3) {
+      // the marks go with his deployment (derived from the module talent's buff): a redeployed 赫德雷 stuns it anew
+      h.b.retreat(u);
+      h.b.redeploy(u);
+      assert.ok(h.runUntil(() => stuns().length === 2, 20), `${label(f)}: stunned again after a redeploy`);
+    }
+    done(h);
+  }
+  // an enemy another operator blocks: no CRU-Y ×1.1 (hodrer_e_003_tr: CheckBlocked by him)
+  for (const [tier, mod] of [[5, CRUY], [6, CRUY]]) {
+    const { h, u } = field({ tier, elite: true, mod, skill: 0, noSp: true, others: [{ uid: 2, chessId: 'chess_char_1_02_a', row: 10, col: 6 }] });
+    const e = h.spawn('enemy_dummy', { pos: [10, 6] });
+    assert.ok(h.runUntil(() => e.blockedBy === h.unit(2), 3), `T${tier}: blocked by 角峰`);
+    const n = atkHits(h, u).length;
+    h.runUntil(() => atkHits(h, u).filter((c) => c.target === e).length > 0 && atkHits(h, u).length > n, 6);
+    const c = atkHits(h, u).filter((x) => x.target === e).pop();
+    approx(c.amount, u.s.atk * t0Of(u).atk_scale_2, `T${tier}: ×${t0Of(u).atk_scale_2} only`);
+    done(h);
+  }
+});
+
+test('T2 余火之氅: he and the ally on the tile behind him get 18 % 庇护 (CRU-X stage 3: 28 % and 物理伤害 +10 %); not the ally beside him; gone once he leaves', () => {
+  const others = [{ uid: 2, chessId: 'chess_char_1_08_a', row: 10, col: 4 }, { uid: 3, chessId: 'chess_char_1_10_a', row: 11, col: 5 }];
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 0, others });
+    const behind = h.unit(2), beside = h.unit(3);
+    h.run(0.5);
+    const x3 = elite && tier === 6 && mod === CRUX;
+    const dr = t1Of(u).damage_resistance;
+    assert.equal(dr, x3 ? 0.28 : 0.18, label(f));
+    for (const a of [u, behind]) {
+      const m = a.findBuff(PROTECT)?.mods;
+      assert.ok(m, `${label(f)}: ${a.def.charId} protected`);
+      approx(m.physTakenMul, 1 - dr, `${label(f)}: phys`);
+      approx(m.artsTakenMul, 1 - dr, `${label(f)}: arts`);
+      assert.equal(m.physDealtMul ?? 1, x3 ? 1.1 : 1, `${label(f)}: 物理伤害`);
+    }
+    assert.equal(beside.findBuff(PROTECT), null, `${label(f)}: not beside him`);
+    const hp = behind.hp;
+    h.b.dealDamage(null, behind, { amount: 1000, type: 'arts' });
+    approx(hp - behind.hp, 1000 * (1 - behind.s.res / 100) * (1 - dr), `${label(f)}: arts taken behind him`);
+    h.b.retreat(u);
+    h.run(0.5);
+    assert.equal(behind.findBuff(PROTECT), null, `${label(f)}: gone with him`);
+    done(h);
+  }
+});
+
+test('S1 重锋不熄 (AUTO, hit SP 3, DEFAULT): every 4th attack hits all he blocks at 180 % / 200 % (× 及锋而试) and heals 15 % / 20 % of his max HP once (CRU-X: ×1.2 受到的治疗)', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [6, true, null], [6, true, CRUX]]) {
+    const sk = skillOf(tier, elite, S1);
+    const { h, u } = field({ tier, elite, mod, skill: 0, row: 9, col: 5 });
+    assert.deepEqual([u.skill.rule, u.skill.spType, u.skill.spCost, sk.bb.atk_scale, sk.bb.hp_ratio], ['DEFAULT', 'attack', 3, elite ? 2 : 1.8, elite ? 0.2 : 0.15], `T${tier}`);
+    h.spawn('enemy_walk', { routeIndex: 0 });
+    h.spawn('enemy_walk', { routeIndex: 0, time: 0 });
+    assert.ok(h.runUntil(() => u.blocking.length === 2, 40));
+    u.hp = u.s.maxHp * 0.3;
+    const n0 = atkHits(h, u).length;
+    h.run(2.5 * 8 + 0.1);
+    const att = byAttack(atkHits(h, u).slice(n0));
+    const sk1 = att.filter((a) => a[0].dmg.isSkill);
+    assert.ok(sk1.length >= 2, `T${tier}: casts (${sk1.length} in ${att.length} attacks)`);
+    const idx = att.map((a, i) => (a[0].dmg.isSkill ? i : -1)).filter((i) => i >= 0);
+    for (let i = 1; i < idx.length; i++) assert.equal(idx[i] - idx[i - 1], 4, `T${tier}: one cast every 4 attacks`);
+    for (const c of sk1[0]) approx(c.amount, u.s.atk * sk.bb.atk_scale * 1.1 * ownPhys(u), `T${tier}: ${sk.bb.atk_scale * 100} % × 1.1`);
+    assert.equal(sk1[0].length, 2, `T${tier}: both blocked enemies`);
+    const heals = h.hooksOf('heal').filter((c) => c.target === u && c.source === u);
+    assert.equal(heals.length, sk1.length, `T${tier}: one heal per cast`);
+    approx(heals[0].amount, u.s.maxHp * sk.bb.hp_ratio * (mod === CRUX ? 1.2 : 1), `T${tier}: ${sk.bb.hp_ratio * 100} % max HP${mod === CRUX ? ' × 1.2' : ''}`);
+    done(h);
+  }
+});
+
+test('S2 余烬重荷 (MANUAL, DEFAULT, a 状态切换 toggle): ATK +16 % / 28 % from the deployment on; switched on once and kept — interval 2.5 + 0.5 s, block 3, every attack stuns its targets 1 s before 及锋而试 reads them (×1.4)', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S2);
+    const { h, u } = field({ tier, elite, skill: 1, row: 9, col: 5 });
+    assert.deepEqual([u.skill.rule, u.skill.kind, sk.spCost, sk.initSp, sk.bb.atk, sk.bb.base_attack_time, sk.bb.block_cnt, sk.bb['attack@stun']], ['DEFAULT', 'toggle', elite ? 8 : 9, 0, elite ? 0.28 : 0.16, 0.5, 1, 1], `T${tier}`);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: the passive ATK`);
+    for (let i = 0; i < 3; i++) h.spawn('enemy_walk', { routeIndex: 0, time: 0 });
+    assert.ok(h.runUntil(() => u.skill.active, 30), `T${tier}: switched on with an enemy`);
+    approx(u.s.interval, 3.0, `T${tier}: 攻击间隔略微增大(+0.5)`);
+    assert.equal(u.s.blockCnt, 3, `T${tier}: 阻挡数+1`);
+    assert.ok(h.runUntil(() => u.blocking.length === 3, 30), `T${tier}: blocks three`);
+    const n0 = atkHits(h, u).length;
+    h.run(9.1);
+    const att = byAttack(atkHits(h, u).slice(n0));
+    assert.ok(att.length >= 3 && att.every((a) => a.length === 3), `T${tier}: all three each attack`);
+    for (const a of att) for (const c of a) approx(c.amount, u.s.atk * 1.4, `T${tier}: stunned first ⇒ ×1.4`);
+    const stuns = h.hooksOf('statusApplied').filter((s) => s.source === u && s.status === 'stun');
+    assert.ok(stuns.length >= 9 && stuns.every((s) => s.duration === 1), `T${tier}: 晕眩1秒 on every target`);
+    h.run(60);
+    assert.ok(u.skill.active, `T${tier}: kept on`);
+    assert.equal(u.skill.activations, 1, `T${tier}: switched on once`);
+    done(h);
+  }
+});
+
+test('S3 死境硝烟 (MANUAL, data ACTIVE_RANGE): cast with an enemy 2 tiles ahead; 70 s, max HP +30 / 45 %, ATK +60 / 90 %, range +1; heals 5 % per attack, 25 % stuns 3 / 4 s; −100 HP / s and 200 无来源 true / s on the enemies he attacked or that attacked him', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S3);
+    const { h, u } = field({ tier, elite, skill: 2, seed: 19 });
+    assert.deepEqual([u.skill.rule, sk.duration, sk.bb.max_hp, sk.bb.atk, sk.bb['attack@hp_ratio'], sk.bb['attack@buff_prob'], sk.bb['attack@stun'], sk.bb.ability_range_forward_extend, sk.bb['attack@value'], sk.bb['attack@damage']],
+      ['ACTIVE_RANGE', 70, elite ? 0.45 : 0.3, elite ? 0.9 : 0.6, 0.05, 0.25, elite ? 4 : 3, 1, 100, 200], `T${tier}`);
+    assert.deepEqual(sk.trigger.customRangeGrid, [[0, 0], [0, 1], [0, 2]], `T${tier}: the running range`);
+    u.skill.gainSp(999);
+    const near = h.spawn('enemy_dummy', { pos: [9, 6] });        // beside his range: never attacked
+    h.run(1);
+    assert.equal(u.skill.activations, 0, `T${tier}: nothing in his range`);
+    const far = h.spawn('enemy_dummy', { pos: [10, 7] });
+    assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: an enemy 2 tiles ahead (the running range)`);
+    assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1], [0, 2]], `T${tier}: 攻击距离+1`);
+    approx(u.skill.timeLeft, 70, `T${tier}: 70 s`, 0.01);
+    approx(u.s.maxHp, u.base.maxHp * (1 + sk.bb.max_hp), `T${tier}: max HP`);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
+    const t0 = h.hooksOf('skillStart').find((c) => c.unit === u).t;
+    h.run(10);
+    const ticks = (e) => h.hooksOf('damaged').filter((c) => c.target === e && c.credit === u && c.source === null && (c.dmg?.tags ?? []).includes('periodic'));
+    const onFar = ticks(far);
+    assert.ok(onFar.length >= 8 && onFar.every((c) => c.amount === 200 && c.type === 'true'), `T${tier}: 200 无来源 true / s on the enemy he attacked (${onFar.length})`);
+    assert.equal(ticks(near).length, 0, `T${tier}: none on an enemy he never attacked`);
+    const losses = h.hooksOf('damaged').filter((c) => c.target === u && (c.dmg?.tags ?? []).includes('hpLoss') && c.t >= t0);
+    assert.ok(losses.length >= 9 && losses.every((c) => c.amount === 100), `T${tier}: 每秒流失100点生命 (${losses.length})`);
+    const heals = h.hooksOf('heal').filter((c) => c.target === u && c.source === u && c.t >= t0);
+    const attacks = h.hooksOf('attack').filter((c) => c.attacker === u && c.t >= t0);
+    assert.ok(heals.length >= 2 && Math.abs(heals.length - attacks.length) <= 1, `T${tier}: one heal per attack (${heals.length} / ${attacks.length})`);
+    // an enemy that attacks him joins
+    const brute = h.spawn('enemy_brute', { routeIndex: 1 });
+    assert.ok(h.runUntil(() => ticks(brute).length >= 2, 40), `T${tier}: the brute that hit him burns too`);
+    h.b.kill(brute, null);
+    u.hp = u.s.maxHp;
+    // the stun roll over many attacks ≈ 25 %
+    u.skill.extend(600);
+    const s0 = h.hooksOf('statusApplied').filter((s) => s.source === u && s.status === 'stun' && s.target === far).length;
+    const a0 = atkHits(h, u).filter((c) => c.target === far).length;
+    h.run(500);
+    const sN = h.hooksOf('statusApplied').filter((s) => s.source === u && s.status === 'stun' && s.target === far);
+    const aN = atkHits(h, u).filter((c) => c.target === far).length - a0;
+    const rate = (sN.length - s0) / aN;
+    assert.ok(rate > 0.17 && rate < 0.33 && sN.every((s) => s.duration === sk.bb['attack@stun']), `T${tier}: stun ${(rate * 100).toFixed(1)} % ≈ 25 %, ${sk.bb['attack@stun']} s`);
+    u.skill.end('test');
+    const n = ticks(far).length;
+    h.run(3);
+    assert.equal(ticks(far).length, n, `T${tier}: no tick after the skill`);
+    assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 1-1 again`);
+    done(h);
+  }
+});

test/content/op_vvana.test.js

@@ -0,0 +1,419 @@
+// test/content/op_vvana.test.js — the 自选 operator kit of 薇薇安娜 (char_4098_vvana, 6★ 术战者; kit
+// server/sim/content/kits/ops/op-vvana.js), fielded the production way (a DIY slot + its `diy` pick, simdata getDiy) in every
+// form: tiers 5 / 6, normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module, AFT-D 目不能及之处 or
+// AFT-Y “最后一行” at stage 1 (tier 5) / 3 (tier 6). Every number is read back from data/backups.json (the form of that slot
+// status); the fidelity checklist of kits/README.md item by item.
+// Run: node --test test/content/op_vvana.test.js
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
+import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js';
+import { sortEnemyTargets } from '../../server/sim/targeting.js';
+import { diyPool, validateDiyPicks } from '../../shared/diy.js';
+
+const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
+const CHESS = load('chess');
+const BACKUPS = load('backups');
+const VVANA = 'char_4098_vvana';
+const FORMS = BACKUPS.units[VVANA].forms;
+const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
+const AFTD = 'uniequip_002_vvana', AFTY = 'uniequip_003_vvana';
+const S1 = 'skchr_vvana_1', S2 = 'skchr_vvana_2', S3 = 'skchr_vvana_3';
+const SHIELD = 'talent:vvana:shield', CANDLE = 'talent:vvana:candle';
+const RANGE_3_2 = [[0, 0], [0, 1], [0, 2], [0, 3]];
+/** The unit form of a slot (tier, normal / elite). */
+const formOf = (tier, elite) => FORMS[elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0'];
+const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id);
+const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null);
+const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`);
+const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o });
+const ENEMIES = {
+  enemy_dummy: dummy('enemy_dummy'),
+  enemy_elite: dummy('enemy_elite', { rank: 'ELITE' }),
+  enemy_fly: dummy('enemy_fly', { motion: 'FLY' }),
+  enemy_walk: enemyRec({ key: 'enemy_walk', hp: 1e9, speed: 0.6, mass: 0 }),
+  enemy_brute: enemyRec({ key: 'enemy_brute', hp: 1e9, speed: 0.6, mass: 0, atk: 500, bat: 1 }),
+  enemy_shooter: dummy('enemy_shooter', { atk: 300, range: 3, bat: 1 }),
+};
+/** Every 自选 form: [tier, elite, module]. */
+const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, AFTD, AFTY].map((m) => [t, true, m]))];
+
+/** A battle with 薇薇安娜 as uid 1 at (row, col) facing RIGHT, plus `others`. */
+function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 5, others = [], seed = 5 } = {}) {
+  const h = makeBattle({
+    defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed,
+    flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'hit', 'skillStart', 'skillEnd', 'statusApplied'], captureNoisy: true,
+    units: [{ uid: 1, diy: { slot: SLOT[tier], charId: VVANA, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others],
+  });
+  h.step();
+  return { h, u: h.unit(1) };
+}
+const atkHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.isAttack);
+const byAttack = (hits) => { const m = new Map(); for (const c of hits) { const k = c.dmg.attackId; if (!m.has(k)) m.set(k, []); m.get(k).push(c); } return [...m.values()]; };
+function done(h) {
+  checkInvariants(h.b);
+  assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
+}
+const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
+const keysOf = (u, grid) => grid.map(([dr, dc]) => (u.tileR + dr) * 21 + u.tileC + dc).sort((a, b) => a - b);
+
+test('薇薇安娜 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + module attributes, 1-1 range, blocks 1, melee arts ground-only, 卡西米尔, no 特质', () => {
+  assert.equal(OPERATOR_KITS[VVANA], KITS[VVANA]);
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    for (const skill of [0, 1, 2]) {
+      const { h, u } = field({ tier, elite, mod, skill });
+      const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null;
+      assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [VVANA, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
+      assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def, u.base.res], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0), form.stats.res], `${label(f)}: stats`);
+      assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.base.bat], [1, 'melee', 'arts', false, 1.25], `${label(f)}: 术战者`);
+      assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 1-1`);
+      assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [['kazimierzShip'], []], `${label(f)}: bonds / 特质`);
+      assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target her`);
+      done(h);
+    }
+  }
+  // zh_CN: E2 Lv1 2219 / 523 / 371, E2 Lv60 2684 / 605 / 421; AFT-D +240 / +30 → +420 / +60 HP / ATK, AFT-Y +240 / +30 / +30 → +300 / +45 / +45
+  assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk], [2219, 523, 2684, 605]);
+  assert.deepEqual([modOf(5, AFTD).attr, modOf(6, AFTD).attr, modOf(5, AFTY).attr, modOf(6, AFTY).attr], [{ maxHp: 240, atk: 30 }, { maxHp: 420, atk: 60 }, { maxHp: 240, atk: 30, def: 30 }, { maxHp: 300, atk: 45, def: 45 }]);
+});
+
+test('a 自选 pick: 薇薇安娜 is offered at tiers 5 and 6 (she has a kit) and a roster with her passes validateDiyPicks', () => {
+  const data = { chess: CHESS, backups: BACKUPS };
+  assert.ok(KITTED_CHARS.includes(VVANA));
+  for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(VVANA), `tier ${t}`);
+  assert.deepEqual(validateDiyPicks({ [SLOT[6]]: { charId: VVANA, skillIndex: 2, uniEquipId: AFTY } }, { data, kitted: KITTED_CHARS }),
+    { ok: true, picks: { [SLOT[6]]: { charId: VVANA, skillIndex: 2, uniEquipId: AFTY } } });
+});
+
+test('S1 光影迅捷剑 (AUTO, DEFAULT, 2 charges): with one charge the next attack hits twice at 155 % / 170 % ATK (arts) and spends one charge; the range stays 1-1', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S1);
+    const { h, u } = field({ tier, elite, skill: 0 });
+    assert.deepEqual([u.skill.rule, u.skill.maxCharges, u.skill.spCost, sk.initSp, sk.bb.atk_scale], ['DEFAULT', 2, elite ? 4 : 5, 0, elite ? 1.7 : 1.55], `T${tier}`);
+    const e = h.spawn('enemy_dummy', { pos: [10, 6] });
+    const fly = h.spawn('enemy_fly', { pos: [10, 6] });
+    assert.ok(h.runUntil(() => u.skill.activations === 1, sk.spCost + 2), `T${tier}: cast once a charge is stored`);
+    assert.equal(h.hooksOf('damaged').filter((c) => c.target === fly).length, 0, `T${tier}: a melee 术战者 never hits the flyer`);
+    h.run(0.1);
+    const skillAtk = byAttack(atkHits(h, u).filter((c) => c.dmg.isSkill));
+    assert.equal(skillAtk.length, 1, `T${tier}: one skill attack`);
+    assert.equal(skillAtk[0].length, 2, `T${tier}: 连续攻击两次`);
+    for (const c of skillAtk[0]) {
+      assert.deepEqual([c.target, c.type], [e, 'arts'], `T${tier}: the target, arts`);
+      approx(c.amount, u.s.atk * sk.bb.atk_scale * 1.08, `T${tier}: ${sk.bb.atk_scale * 100} % ATK (× 燃烛施明 1.08)`);
+    }
+    assert.ok(u.skill.charges < 1 && !u.mem.vvanaCharged, `T${tier}: one charge spent, no 蓄力`);
+    assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 1-1`);
+    // plain attacks hit once at 100 %
+    const plain = byAttack(atkHits(h, u).filter((c) => !c.dmg.isSkill));
+    assert.ok(plain.length > 0 && plain.every((a) => a.length === 1), `T${tier}: plain attacks hit once`);
+    done(h);
+  }
+});
+
+test('S1 蓄力: both charges stored ⇒ the 3-2 range (card and trigger), the cast spends every charge and hits three times from 3 tiles away; the range is 1-1 again after it', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S1);
+    const { h, u } = field({ tier, elite, skill: 0 });
+    h.run(sk.spCost * 2 - 0.5);
+    assert.equal(u.skill.charges, 1, `T${tier}: one charge after ${sk.spCost * 2 - 0.5} s`);
+    assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: not yet`);
+    h.run(0.6);
+    assert.equal(u.skill.charges, 2, `T${tier}: both charges`);
+    assert.deepEqual(u.liveRangeGrid, RANGE_3_2, `T${tier}: 蓄力 — 3-2`);
+    assert.deepEqual([...u.baseRangeKeys].sort((a, b) => a - b), keysOf(u, RANGE_3_2), `T${tier}: the DEFAULT trigger range follows`);
+    const e = h.spawn('enemy_dummy', { pos: [10, 8] });
+    assert.ok(h.runUntil(() => u.skill.activations === 1, 2), `T${tier}: cast on the enemy 3 tiles ahead`);
+    h.step();
+    const skillAtk = byAttack(atkHits(h, u).filter((c) => c.dmg.isSkill));
+    assert.equal(skillAtk.length, 1);
+    assert.equal(skillAtk[0].length, 3, `T${tier}: 改为连续攻击三次`);
+    for (const c of skillAtk[0]) { assert.equal(c.target, e); approx(c.amount, u.s.atk * sk.bb.atk_scale * 1.08, `T${tier}: ${sk.bb.atk_scale * 100} %`); }
+    assert.ok(u.skill.charges === 0 && u.skill.sp < 0.2, `T${tier}: 任何时候开启均消耗全部技力 (${u.skill.charges} / ${u.skill.sp})`);
+    assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 蓄力 over with the skill`);
+    const n = atkHits(h, u).length;
+    h.run(3);
+    assert.equal(atkHits(h, u).length, n, `T${tier}: the enemy 3 tiles ahead is out of her 1-1 again`);
+    done(h);
+  }
+});
+
+test('S1 蓄力 mode stays until the next end of the skill: silenced with both charges she attacks with the 3-2 range (plain attacks); a redeploy clears it', () => {
+  const { h, u } = field({ tier: 6, elite: true, skill: 0 });
+  h.run(9);
+  assert.equal(u.skill.charges, 2);
+  h.b.applyStatus(u, 'silence', { duration: 4, source: null });
+  const e = h.spawn('enemy_dummy', { pos: [10, 8] });
+  h.run(3);
+  const hits = atkHits(h, u).filter((c) => c.target === e);
+  assert.ok(hits.length >= 2 && hits.every((c) => !c.dmg.isSkill), `plain attacks from the 3-2 range: ${hits.length}`);
+  assert.deepEqual(u.liveRangeGrid, RANGE_3_2);
+  h.b.retreat(u);
+  h.b.redeploy(u);
+  h.step();
+  assert.deepEqual([u.liveRangeGrid, !!u.mem.vvanaCharged], [[[0, 0], [0, 1]], false], 'a new deployment: 1-1, SP from 0');
+  done(h);
+});
+
+test('S2 烛燃影息 (MANUAL, DEFAULT): 28 / 30 s, ATK +20 / 30 %, DEF +80 / 110 %, block 2, every attack hits all she blocks; 20 % double hits at 130 / 140 % that steal 25 / 30 ASPD (capped), given back at the end', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [6, true, AFTD]]) {
+    const sk = skillOf(tier, elite, S2);
+    const { h, u } = field({ tier, elite, mod, skill: 1, row: 9, col: 5, seed: 13 });
+    assert.deepEqual([u.skill.rule, sk.duration, sk.bb.atk, sk.bb.def, sk.bb.block_cnt, sk.bb['attack@prob_twice'], sk.bb['attack@atk_scale_twice'], sk.bb['attack@steal_atk_speed'], sk.bb['attack@steal_atk_speed_max']],
+      ['DEFAULT', elite ? 30 : 28, elite ? 0.3 : 0.2, elite ? 1.1 : 0.8, 1, 0.2, elite ? 1.4 : 1.3, elite ? 30 : 25, elite ? 30 : 25], `T${tier}`);
+    h.spawn('enemy_walk', { routeIndex: 0 });
+    h.spawn('enemy_walk', { routeIndex: 0, time: 0 });
+    assert.ok(h.runUntil(() => u.blocking.length === 1, 30), `T${tier}: blocks one`);
+    h.run(2);
+    assert.equal(u.blocking.length, 1, `T${tier}: block 1 before the skill`);
+    u.skill.gainSp(999);
+    assert.ok(h.runUntil(() => u.skill.active, 3), `T${tier}: cast with an enemy blocked`);
+    approx(u.skill.timeLeft, sk.duration, `T${tier}: ${sk.duration} s`, 0.01);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
+    approx(u.s.def, u.base.def * (1 + sk.bb.def), `T${tier}: DEF`);
+    assert.ok(h.runUntil(() => u.blocking.length === 2, 10), `T${tier}: block 2 (阻挡数+1)`);
+    const n0 = atkHits(h, u).length;
+    u.skill.extend(300);
+    h.run(300);
+    const attacks = byAttack(atkHits(h, u).slice(n0));
+    const both = attacks.filter((a) => new Set(a.map((c) => c.target)).size === 2);
+    assert.ok(both.length > attacks.length * 0.9, `T${tier}: ${both.length} / ${attacks.length} attacks hit both blocked enemies`);
+    const twice = attacks.filter((a) => a.length === 4);
+    const once = attacks.filter((a) => a.length === 2);
+    assert.equal(twice.length + once.length, attacks.length, `T${tier}: one or two hits per target`);
+    const rate = twice.length / attacks.length;
+    assert.ok(rate > 0.13 && rate < 0.27, `T${tier}: double hits ${twice.length} / ${attacks.length} ≈ 20 %`);
+    for (const c of once[0]) approx(c.amount, u.s.atk * 1.08, `T${tier}: a plain hit 100 %`, 1e-3);
+    for (const c of twice[0]) approx(c.amount, u.s.atk * sk.bb['attack@atk_scale_twice'] * 1.08, `T${tier}: a double hit ${sk.bb['attack@atk_scale_twice'] * 100} %`, 1e-3);
+    // 偷取: capped on both sides
+    const steal = sk.bb['attack@steal_atk_speed'];
+    assert.equal(u.findBuff('skill:vvana:loot')?.mods.aspd, steal, `T${tier}: her +${steal} ASPD (max ${steal})`);
+    for (const e of u.blocking) assert.equal(e.findBuff('skill:vvana:stolen')?.mods.aspd, -steal, `T${tier}: each target −${steal}`);
+    approx(u.s.aspd, 100 + steal, `T${tier}: her ASPD`);
+    const victims = u.blocking.slice();
+    u.skill.end('test');
+    assert.equal(u.findBuff('skill:vvana:loot'), null, `T${tier}: given back at the end`);
+    for (const e of victims) assert.equal(e.findBuff('skill:vvana:stolen'), null, `T${tier}: the enemies get theirs back`);
+    approx(u.s.atk, u.base.atk, `T${tier}: ATK back`);
+    done(h);
+  }
+});
+
+test('S3 “明灭” (MANUAL, DEFAULT): 15 s, interval 1.25 + 0.5 s, ATK / DEF / RES up, double hits, 1-1; from the second cast of a deployment 25 s, triple hits on 3-2, elite / leader enemies first; a redeploy counts again', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S3);
+    const { h, u } = field({ tier, elite, skill: 2, seed: 3 });
+    assert.deepEqual([u.skill.rule, sk.duration, sk.bb.base_attack_time, sk.bb.atk, sk.bb.def, sk.bb.magic_resistance, sk.bb.enhance_duration, sk.bb.talent_scale, sk.rangeId],
+      ['DEFAULT', 15, 0.5, elite ? 0.75 : 0.55, elite ? 0.6 : 0.4, elite ? 20 : 15, 25, elite ? 2 : 1.8, '1-1'], `T${tier}`);
+    u.skill.gainSp(999);
+    h.run(2);
+    assert.equal(u.skill.activations, 0, `T${tier}: no enemy, no cast`);
+    const front = h.spawn('enemy_dummy', { pos: [10, 6] });
+    assert.ok(h.runUntil(() => u.skill.active, 3), `T${tier}: cast with an enemy in her range`);
+    approx(u.skill.timeLeft, 15, `T${tier}: 15 s`, 0.01);
+    approx(u.s.interval, 1.75, `T${tier}: 攻击间隔延长(+0.5)`);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
+    approx(u.s.def, u.base.def * (1 + sk.bb.def), `T${tier}: DEF`);
+    approx(u.s.res, u.base.res + sk.bb.magic_resistance, `T${tier}: RES`);
+    assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: the first cast keeps 1-1`);
+    const n0 = atkHits(h, u).length;
+    h.runUntil(() => !u.skill.active, 20);
+    const first = byAttack(atkHits(h, u).slice(n0).filter((c) => c.dmg.isSkill));
+    assert.ok(first.length >= 7 && first.every((a) => a.length === 2), `T${tier}: ${first.length} double hits`);
+    approx(u.s.interval, 1.25, `T${tier}: interval back`);
+    // the second cast: 25 s, 3-2, triple hits, the elite first
+    h.b.kill(front, null);
+    const normal = h.spawn('enemy_dummy', { pos: [10, 7] });
+    const eliteE = h.spawn('enemy_elite', { pos: [10, 8] });
+    assert.deepEqual(sortEnemyTargets(h.b, u, [eliteE, normal], null).map((e) => e.defId), ['enemy_dummy', 'enemy_elite'], `T${tier}: her usual order takes the one nearer the goal`);
+    assert.deepEqual(sortEnemyTargets(h.b, u, [normal, eliteE], 'elite').map((e) => e.defId), ['enemy_elite', 'enemy_dummy'], `T${tier}: the 'elite' priority (targeting.js)`);
+    u.skill.gainSp(999);
+    u.skill.activate('test');
+    approx(u.skill.timeLeft, 25, `T${tier}: 持续时间延长至25秒`, 0.01);
+    assert.deepEqual(u.liveRangeGrid, RANGE_3_2, `T${tier}: 3-2 while it runs`);
+    const n1 = atkHits(h, u).length;
+    h.run(10);
+    const second = byAttack(atkHits(h, u).slice(n1).filter((c) => c.dmg.isSkill));
+    assert.ok(second.length >= 5 && second.every((a) => a.length === 3 && a.every((c) => c.target === eliteE)), `T${tier}: triple hits on the elite (${second.length})`);
+    h.runUntil(() => !u.skill.active, 20);
+    assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 1-1 after it`);
+    // a new deployment counts from one again
+    h.b.retreat(u);
+    h.b.redeploy(u);
+    h.step();
+    u.skill.gainSp(999);
+    u.skill.activate('test');
+    assert.deepEqual([Math.round(u.skill.timeLeft), u.liveRangeGrid], [15, [[0, 0], [0, 1]]], `T${tier}: the first cast of the new deployment`);
+    done(h);
+  }
+});
+
+test('T1 燃烛施明: arts dealt ×1.08, physical / arts taken ×0.92 — ×1.16 / ×0.84 while an elite / leader enemy is in her range; AFT-D stage 3: 9 % (18 %) of her attack damage as 灼燃损伤', () => {
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 2 });
+    const t0 = u.def.raw.talents.find((t) => t.index === 0).bb;
+    assert.deepEqual([t0.damage_scale_m, t0.damage_resistance_pm, t0.super_scale], [0.08, 0.08, 2], label(f));
+    assert.deepEqual(u.findBuff(CANDLE)?.mods, { artsDealtMul: 1.08, physTakenMul: 0.92, artsTakenMul: 0.92 }, `${label(f)}: no elite`);
+    const taken = (type) => { const hp = u.hp; h.b.dealDamage(null, u, { amount: 1000, type }); const d = hp - u.hp; u.hp = u.s.maxHp; return d; };
+    approx(taken('arts'), 1000 * (1 - u.s.res / 100) * 0.92, `${label(f)}: arts taken −8 %`);
+    approx(taken('true'), 1000, `${label(f)}: true damage untouched`);
+    const el = h.spawn('enemy_elite', { pos: [10, 6] });
+    h.step();
+    approx(taken('arts'), 1000 * (1 - u.s.res / 100) * 0.84, `${label(f)}: −16 % with the elite in her range`);
+    const m = u.findBuff(CANDLE).mods;
+    approx(m.artsDealtMul, 1.16, `${label(f)}: elite in range — arts dealt`);
+    approx(m.physTakenMul, 0.84, `${label(f)}: phys taken`);
+    approx(m.artsTakenMul, 0.84, `${label(f)}: arts taken`);
+    const ep = elite && tier === 6 && mod === AFTD ? 0.09 : 0;
+    assert.equal(t0.ep_damage_ratio_m ?? 0, ep, `${label(f)}: the AFT-D stage-3 灼燃损伤`);
+    h.run(1.3);
+    const hit = atkHits(h, u).find((c) => c.target === el);
+    assert.ok(hit, `${label(f)}: she hits the elite`);
+    approx(el.elem.burn, ep * 2 * atkHits(h, u).filter((c) => c.target === el).reduce((s, c) => s + c.amount, 0), `${label(f)}: 灼燃损伤 ×2 next to an elite`);
+    h.b.kill(el, null);
+    h.step();
+    approx(u.findBuff(CANDLE).mods.artsDealtMul, 1.08, `${label(f)}: back without the elite`);
+    if (ep) {
+      const e = h.spawn('enemy_dummy', { pos: [10, 6] });
+      h.run(1.3);
+      approx(e.elem.burn, ep * atkHits(h, u).filter((c) => c.target === e).reduce((s, c) => s + c.amount, 0), `${label(f)}: 9 % next to no elite`);
+    }
+    done(h);
+  }
+});
+
+test('T2 散华: hits on elite / leader enemies give a 护盾 layer at 18 % (AFT-Y stage 3: 25 %, 2 layers; × talent_scale while S3 runs) — only on elites, never above the cap', () => {
+  const rateOf = (tier, elite, mod, s3) => {
+    const { h, u } = field({ tier, elite, mod, skill: s3 ? 2 : 1, seed: 21 });
+    if (!s3) h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; });
+    const el = h.spawn('enemy_elite', { pos: [10, 6] });
+    if (s3) { u.skill.gainSp(999); u.skill.activate('test'); u.skill.extend(600); }
+    let gains = 0, rolls = 0;
+    const cap = mod === AFTY && tier === 6 ? 2 : 1;
+    h.b.on('damaged', (c) => {
+      if (c.source !== u || c.target !== el || !c.dmg.isAttack) return;
+      rolls++;
+      const n = u.findBuff(SHIELD)?.data.n ?? 0;
+      assert.ok(n <= cap, `never above ${cap}`);
+      if (n > 0) { gains++; h.b.removeBuff(u, SHIELD); }
+    }, { priority: -100 });
+    h.run(400);
+    done(h);
+    return gains / rolls;
+  };
+  for (const [tier, elite, mod, p] of [[5, false, null, 0.18], [6, true, AFTY, 0.25], [5, true, AFTY, 0.18]]) {
+    const r = rateOf(tier, elite, mod, false);
+    assert.ok(Math.abs(r - p) < 0.06, `T${tier} ${mod ?? 'none'}: ${r.toFixed(3)} ≈ ${p}`);
+  }
+  for (const [tier, elite, mod, p] of [[5, false, null, 0.18 * 1.8], [6, true, AFTY, 0.25 * 2]]) {
+    const r = rateOf(tier, elite, mod, true);
+    assert.ok(Math.abs(r - p) < 0.08, `T${tier} ${mod ?? 'none'} under S3: ${r.toFixed(3)} ≈ ${p}`);
+  }
+  // a normal enemy gives none; AFT-Y stage 3 holds two layers
+  const { h, u } = field({ tier: 6, elite: true, mod: AFTY, skill: 1, seed: 2 });
+  h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; });
+  const e = h.spawn('enemy_dummy', { pos: [10, 6] });
+  h.run(60);
+  assert.equal(u.findBuff(SHIELD), null, 'no layer from a normal enemy');
+  h.b.kill(e, null);
+  h.spawn('enemy_elite', { pos: [10, 6] });
+  assert.ok(h.runUntil(() => (u.findBuff(SHIELD)?.data.n ?? 0) === 2, 120), 'two layers (AFT-Y stage 3)');
+  h.run(30);
+  assert.equal(u.findBuff(SHIELD).data.n, 2, 'no third');
+  done(h);
+});
+
+test('T2 散华\'s 护盾 negates one whole enemy melee-path damage per layer — not an enemy shot that flew as a projectile, not 无来源 damage', () => {
+  const { h, u } = field({ tier: 6, elite: true, mod: AFTY, skill: 1, seed: 4 });
+  h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; });
+  const el = h.spawn('enemy_elite', { pos: [10, 6] });
+  assert.ok(h.runUntil(() => (u.findBuff(SHIELD)?.data.n ?? 0) === 2, 120), 'two layers');
+  h.b.kill(el, null);
+  const brute = h.spawn('enemy_dummy', { pos: [11, 9] });
+  const hp0 = u.hp;
+  // a projectile-borne hit and a 无来源 one pass
+  assert.ok(h.b.dealDamage(brute, u, { amount: 300, type: 'phys', isAttack: true, isProjectile: true }) > 0, 'a projectile hit lands');
+  assert.ok(h.b.dealDamage(brute, u, { amount: 300, type: 'true', sourceless: true }) > 0, 'a 无来源 hit lands');
+  assert.equal(u.findBuff(SHIELD).data.n, 2, 'both layers kept');
+  // a melee-path hit (an attack or an ability) is negated whole, one layer each
+  const hp1 = u.hp;
+  assert.equal(h.b.dealDamage(brute, u, { amount: 5000, type: 'phys', isAttack: true }), 0, 'a melee attack: negated');
+  assert.equal(u.findBuff(SHIELD).data.n, 1);
+  assert.equal(h.b.dealDamage(brute, u, { amount: 5000, type: 'arts' }), 0, 'a melee-path ability: negated');
+  assert.equal(u.findBuff(SHIELD), null, 'no layer left');
+  assert.equal(u.hp, hp1, 'no HP lost to them');
+  assert.ok(h.b.dealDamage(brute, u, { amount: 300, type: 'phys', isAttack: true }) > 0, 'without a layer the hit lands');
+  assert.ok(u.hp < hp0);
+  done(h);
+});
+
+test('T2 散华 in battle: an enemy shooter\'s projectile (ai.js: DamageInfo isProjectile) never spends a layer; a blocked brute\'s blow does', () => {
+  const { h, u } = field({ tier: 6, elite: true, mod: AFTY, skill: 1, row: 9, col: 5, seed: 4 });
+  h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; });
+  const el = h.spawn('enemy_elite', { pos: [9, 6] });
+  assert.ok(h.runUntil(() => (u.findBuff(SHIELD)?.data.n ?? 0) === 2, 120), 'two layers');
+  h.b.kill(el, null);
+  const shooter = h.spawn('enemy_shooter', { pos: [11, 6] });
+  const hits0 = h.hooksOf('hit').length;
+  assert.ok(h.runUntil(() => h.hooksOf('hit').slice(hits0).some((c) => c.source === shooter && c.target === u), 10), 'the shooter hits her');
+  const shot = h.hooksOf('hit').slice(hits0).find((c) => c.source === shooter && c.target === u);
+  assert.deepEqual([shot.dmg.isProjectile, shot.dmg.cancel], [true, false], 'a projectile, not negated');
+  assert.equal(u.findBuff(SHIELD).data.n, 2, 'the layers stay');
+  h.b.kill(shooter, null);
+  h.spawn('enemy_brute', { routeIndex: 0 });
+  assert.ok(h.runUntil(() => (u.findBuff(SHIELD)?.data.n ?? 0) < 2, 60), 'the brute\'s blow spends one');
+  const blow = h.hooksOf('hit').filter((c) => c.source?.defId === 'enemy_brute' && c.target === u)[0];
+  assert.deepEqual([blow.dmg.isProjectile, blow.dmg.cancel], [false, true], 'a melee blow, negated');
+  done(h);
+});
+
+test('AFT-D 目不能及之处 trait: her damage on an enemy in its 灼燃 爆发冷却 is followed by 15 % ATK 元素伤害 (stages 1 and 3) — once per instance, never otherwise', () => {
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 1, seed: 8 });
+    h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; });
+    const e = h.spawn('enemy_dummy', { pos: [10, 6] });
+    h.run(3);
+    const rider = () => h.hooksOf('damaged').filter((c) => c.source === u && c.type === 'elemental');
+    assert.equal(rider().length, 0, `${label(f)}: no rider without a burst`);
+    h.b.dealDamage(null, e, { type: 'element', element: 'burn', amount: 2000 });
+    assert.ok(e.findBuff('burnBurst'), `${label(f)}: 灼燃 burst`);
+    const n0 = atkHits(h, u).length;
+    h.run(4);
+    const hits = atkHits(h, u).slice(n0);
+    const aftd = elite && mod === AFTD;
+    assert.equal(rider().length, aftd ? hits.length : 0, `${label(f)}: one rider per hit (${hits.length})`);
+    if (aftd) {
+      assert.equal(u.def.raw.trait.bb.ep_damage_ratio, 0.15);
+      for (const c of rider()) approx(c.amount, u.s.atk * 0.15, `${label(f)}: 15 % ATK 元素伤害`);
+    }
+    done(h);
+  }
+});
+
+test('AFT-Y “最后一行” trait: the enemies she blocks take 10 % 法术脆弱 (her arts hits ×1.1); not an enemy she does not block, none without the module', () => {
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 1, row: 9, col: 5, seed: 6 });
+    h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; });
+    const far = h.spawn('enemy_dummy', { pos: [10, 6] });
+    const w = h.spawn('enemy_walk', { routeIndex: 0 });
+    assert.ok(h.runUntil(() => u.blocking.includes(w), 30), `${label(f)}: blocks the walker`);
+    h.run(0.5);
+    const afty = elite && mod === AFTY;
+    const fv = w.findBuff('artsFragile')?.data?.value ?? null;
+    if (afty) approx(fv, 0.1, `${label(f)}: 法术脆弱 on the blocked one`); else assert.equal(fv, null, `${label(f)}: no 法术脆弱`);
+    assert.equal(far.findBuff('artsFragile'), null, `${label(f)}: none on the unblocked one`);
+    if (afty) {
+      const n0 = atkHits(h, u).length;
+      h.run(2);
+      const c = atkHits(h, u).slice(n0).find((x) => x.target === w);
+      approx(c.amount, u.s.atk * 1.08 * 1.1, `${label(f)}: ×1.1 arts`);
+    }
+    done(h);
+  }
+});

test/golden/diy.json

@@ -3246,132 +3246,132 @@
       "snaps": "279180c1 ec59986c 8724f011 2c0b4ef4 0ef558f2 84e4a729 66364554 c0b920f3 6e7185e5 79a82568 49b6ed9f 7493c0a1 f161d189 3b2e9b0a 7a7d89d9 3cf87903 b2fb1d51 9322cda8 bdcbf5e7"
     },
     "diy-076": {
-      "about": "6_diy1_b=leizi2/S1 6_diy2_b=leizi2/S2 6_diy1_b=leizi2/S3 6_diy2_b=leizi2/S1/002_leizi2 6_diy1_b=leizi2/S2/002_leizi2 6_diy2_b=leizi2/S3/002_leizi2 5_diy1_a=cdfend 5_diy2_b=cdfend 5_diy1_a=cguard 5_diy2_b=cguard 5_diy1_a=csnipe 5_diy2_b=csnipe",
-      "fast": true,
+      "about": "6_diy1_b=leizi2/S1 6_diy2_b=leizi2/S2 6_diy1_b=leizi2/S3 6_diy2_b=leizi2/S1/002_leizi2 6_diy1_b=leizi2/S2/002_leizi2 6_diy2_b=leizi2/S3/002_leizi2 5_diy1_a=vvana/S1 5_diy2_a=vvana/S2 5_diy1_a=vvana/S3 5_diy2_b=vvana/S1 5_diy1_b=vvana/S2 5_diy2_b=vvana/S3",
+      "fast": false,
       "kind": "normal",
       "stageId": "act2autochess_m03",
       "modeId": "mode_multi_abyss",
       "round": 13,
       "seed": 1116500759,
       "waveId": "act1autochess_h06",
-      "time": 221.37,
-      "ticks": 6641,
+      "time": 211.93,
+      "ticks": 6358,
       "reason": "cleared",
-      "killed": 8,
+      "killed": 9,
       "total": 144,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 704,
+      "rngDraws": 731,
       "errors": {"count":0,"kinds":[]},
-      "players": {"p1":{"killed":8,"total":144,"perfect":false,"leaks":136,"leaksUncounted":0,"coins":0,"dmg":682344,"bossDmg":0,"heal":0,"deaths":26,"layerGains":{}}},
+      "players": {"p1":{"killed":9,"total":144,"perfect":false,"leaks":135,"leaksUncounted":0,"coins":0,"dmg":730931,"bossDmg":0,"heal":0,"deaths":24,"layerGains":{}}},
       "units": [
-        ["p1",1,"op","chess_char_6_diy1_b",0,"none",2232.16,1,175,1,100633,8694,0,0,7],
-        ["p1",2,"op","chess_char_6_diy2_b",1,"none",0,0,114,1,49891,7284,0,10,2],
-        ["p1",3,"op","chess_char_6_diy1_b",2,"none",3642,1,176,1,91439,7284,0,7,2],
-        ["p1",4,"op","chess_char_6_diy2_b",0,"uniequip_002_leizi2",0,0,133,0,102305,8004,0,0,7],
-        ["p1",5,"op","chess_char_6_diy1_b",1,"uniequip_002_leizi2",0,0,145,0,63113,8004,0,8,2],
-        ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_leizi2",0,0,165,5,251964,8004,0,9,2],
-        ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,90,0,1356,4256,0,6,0],
-        ["p1",8,"op","chess_char_5_diy2_b",2,"none",0,0,81,0,647,5816,0,9,0],
-        ["p1",9,"op","chess_char_5_diy1_a",2,null,2564,1,174,0,5994,5128,0,12,0],
-        ["p1",10,"op","chess_char_5_diy2_b",2,"none",0,0,95,0,6114,6668,0,8,0],
-        ["p1",11,"op","chess_char_5_diy1_a",2,null,0,0,158,0,4551,3813,0,14,0],
-        ["p1",12,"op","chess_char_5_diy2_b",2,"none",0,0,152,0,4336,4530,0,14,0],
+        ["p1",1,"op","chess_char_6_diy1_b",0,"none",0,0,114,1,110644,7284,0,0,7],
+        ["p1",2,"op","chess_char_6_diy2_b",1,"none",0,0,106,2,71535,7284,0,11,2],
+        ["p1",3,"op","chess_char_6_diy1_b",2,"none",3642,1,172,0,61978,7284,0,5,2],
+        ["p1",4,"op","chess_char_6_diy2_b",0,"uniequip_002_leizi2",0,0,136,0,76696,8004,0,0,7],
+        ["p1",5,"op","chess_char_6_diy1_b",1,"uniequip_002_leizi2",0,0,98,1,56986,8004,0,6,2],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_leizi2",0,0,144,4,301469,8004,0,7,2],
+        ["p1",7,"op","chess_char_5_diy1_a",0,null,0,0,157,0,7018,6657,0,17,3],
+        ["p1",8,"op","chess_char_5_diy2_a",1,null,0,0,170,0,2406,6657,0,9,0],
+        ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,5,0,8162,2219,0,10,1],
+        ["p1",10,"op","chess_char_5_diy2_b",0,"none",0,0,102,0,10886,5368,0,16,6],
+        ["p1",11,"op","chess_char_5_diy1_b",1,"none",0,0,9,1,19388,2684,0,23,1],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"none",0,0,88,0,3764,5368,0,12,0],
         ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null],
         ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null],
         ["-","~3","device","trap_1105_accrate",null,null,100,1,3,0,0,0,0,0,null]
       ],
-      "enemies": {"enemy_1251_lysyta_2":[51,8,43,10477,247839],"enemy_1252_lysytb_2":[54,0,54,37950,262303],"enemy_1329_cbshld_2":[39,0,39,29059,172202]},
-      "hooks": [1,176,6641,280,280,1112,1112,0,34,170,22,22,0,13611,164,65,144,136,1,34,0,0,0],
-      "events": {"atk":316,"deploy":29,"die":34,"dmg":1112,"fx":293,"leak":136,"skill":44,"spawn":159,"status":227},
-      "fx": {"aoe":11,"lightning":266,"pulse":16},
-      "snaps": "b6e40abe f0db8570 c90e6e20 e302c918 dfa05526 3d4b8649 85bc75bd 172418e4 a05afe46 4e4a8c54 12204c69 9175c57b 23f62e93 06bc7066 fee8a47b 9f03d8c8 094d031e 1727f1eb 90766837 fc7af1c2 7af0403b 904c6c85 74a2d458"
+      "enemies": {"enemy_1251_lysyta_2":[51,7,44,7556,239546],"enemy_1252_lysytb_2":[54,1,53,35570,238862],"enemy_1329_cbshld_2":[39,1,38,31691,252523]},
+      "hooks": [1,172,6358,308,308,1222,1222,0,33,168,33,33,0,13780,177,59,144,135,1,33,0,0,0],
+      "events": {"atk":357,"deploy":25,"die":33,"dmg":1222,"fx":291,"leak":135,"skill":66,"spawn":159,"status":231},
+      "fx": {"aoe":11,"lightning":268,"pulse":12},
+      "snaps": "e5aa4eaa d6ba5ad4 c3fc9920 0c0694c3 3c2d6768 2db18b72 fccb9cf5 9c7c8a5d e08870ed 2e2ef124 df9e1088 43c28882 5e429444 dcc0d460 b4d0311b afe5d2f9 0bfacbe2 4001646e 5a8d03c7 03fea703 00210b83 84c9c000"
     },
     "diy-077": {
-      "about": "5_diy1_a=acfend 5_diy2_b=acfend 5_diy1_a=acpion 5_diy2_b=acpion 5_diy1_a=acguad 5_diy2_b=acguad 5_diy1_a=ccast 5_diy2_b=ccast 5_diy1_a=cmedic 5_diy2_b=cmedic 5_diy1_a=csuppo 5_diy2_b=csuppo",
+      "about": "5_diy1_b=vvana/S1/002_vvana 5_diy2_b=vvana/S2/002_vvana 5_diy1_b=vvana/S3/002_vvana 5_diy2_b=vvana/S1/003_vvana 5_diy1_b=vvana/S2/003_vvana 5_diy2_b=vvana/S3/003_vvana 6_diy1_a=vvana/S1 6_diy2_a=vvana/S2 6_diy1_a=vvana/S3 6_diy2_b=vvana/S1 6_diy1_b=vvana/S2 6_diy2_b=vvana/S3",
       "fast": false,
       "kind": "normal",
       "stageId": "act2autochess_m04",
       "modeId": "mode_multi_funny",
-      "round": 12,
+      "round": 13,
       "seed": 489962961,
-      "waveId": "act1autochess_h05",
-      "time": 216.43,
-      "ticks": 6493,
-      "reason": "cleared",
-      "killed": 28,
-      "total": 114,
+      "waveId": "act1autochess_h06",
+      "time": 230,
+      "ticks": 6900,
+      "reason": "timeout",
+      "killed": 0,
+      "total": 93,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 119,
+      "rngDraws": 0,
       "errors": {"count":0,"kinds":[]},
-      "players": {"p1":{"killed":28,"total":114,"perfect":false,"leaks":86,"leaksUncounted":0,"coins":0,"dmg":155075,"bossDmg":0,"heal":4683,"deaths":26,"layerGains":{}}},
+      "players": {"p1":{"killed":0,"total":93,"perfect":false,"leaks":93,"leaksUncounted":0,"coins":0,"dmg":0,"bossDmg":0,"heal":0,"deaths":11,"layerGains":{}}},
       "units": [
-        ["p1",1,"op","chess_char_5_diy1_a",2,null,0,0,131,3,15003,5208,0,69,1],
-        ["p1",2,"op","chess_char_5_diy2_b",2,"uniequip_002_acfend",0,0,124,1,24440,6742,0,66,2],
-        ["p1",3,"op","chess_char_5_diy1_a",2,null,0,0,132,4,18564,3058,0,18,2],
-        ["p1",4,"op","chess_char_5_diy2_b",2,"uniequip_002_acpion",0,0,141,1,5622,5712,0,13,2],
-        ["p1",5,"op","chess_char_5_diy1_a",2,null,0,0,96,0,2043,5276,0,4,0],
-        ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_002_acguad",0,0,90,4,29193,6822,0,23,1],
-        ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,3,6,13608,1133,0,37,1],
-        ["p1",8,"op","chess_char_5_diy2_b",2,"none",0,0,4,4,26194,1360,0,54,2],
-        ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,128,0,0,5310,3125,8,1],
-        ["p1",10,"op","chess_char_5_diy2_b",2,"none",0,0,125,0,0,7149,1558,6,0],
-        ["p1",11,"op","chess_char_5_diy1_a",2,null,0,0,140,4,12459,1864,0,36,1],
-        ["p1",12,"op","chess_char_5_diy2_b",2,"none",0,0,142,1,7948,3393,0,19,1],
+        ["p1",1,"op","chess_char_5_diy1_b",0,"uniequip_002_vvana",857.48,1,5,0,0,2067,0,0,0],
+        ["p1",2,"op","chess_char_5_diy2_b",1,"uniequip_002_vvana",1957.37,1,116,0,0,3891,0,0,0],
+        ["p1",3,"op","chess_char_5_diy1_b",2,"uniequip_002_vvana",2392.37,1,3,0,0,532,0,0,0],
+        ["p1",4,"op","chess_char_5_diy2_b",0,"uniequip_003_vvana",1302.37,1,115,0,0,4546,0,0,0],
+        ["p1",5,"op","chess_char_5_diy1_b",1,"uniequip_003_vvana",1366.7,1,105,0,0,4481,0,0,0],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_003_vvana",1443.24,1,108,0,0,4405,0,0,0],
+        ["p1",7,"op","chess_char_6_diy1_a",0,null,2201.19,1,117,0,0,4456,0,0,0],
+        ["p1",8,"op","chess_char_6_diy2_a",1,null,0,0,75,0,0,4438,0,0,0],
+        ["p1",9,"op","chess_char_6_diy1_a",2,null,1473.07,1,69,0,0,2965,0,0,0],
+        ["p1",10,"op","chess_char_6_diy2_b",0,"none",2639.47,1,4,0,0,45,0,0,0],
+        ["p1",11,"op","chess_char_6_diy1_b",1,"none",1668.47,1,114,0,0,3700,0,0,0],
+        ["p1",12,"op","chess_char_6_diy2_b",2,"none",608.26,1,103,0,0,4760,0,0,0],
         ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null],
         ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null]
       ],
-      "enemies": {"enemy_1019_jshoot_2":[51,14,37,7067,50822],"enemy_1381_winman":[27,11,16,343,68509],"enemy_1389_winbab_2":[36,3,33,45616,71345]},
-      "hooks": [1,142,6493,1168,1168,2271,2234,14,54,140,14,14,0,15903,50,49,114,86,1,71,0,0,37],
-      "events": {"atk":1168,"deploy":26,"die":54,"dmg":2234,"fx":125,"heal":14,"leak":86,"skill":28,"spawn":128,"status":104},
-      "fx": {"aoe":67,"dodge":37,"dp":9,"slash":12},
-      "snaps": "a8ebaa0a c7a3f563 86d849aa c41775ad 4cd063ec 661332c4 3a9b60a3 6c16de62 51354213 50776bdd 1fcc01fb a21d8b42 d9ca94c1 1bd48914 49095136 084282f3 de456c61 1d5569a8 88d801e3 38867e16 f557042a 2ccda668"
+      "enemies": {"enemy_1005_yokai":[33,0,33,0,0],"enemy_1005_yokai_2":[48,0,43,9033,0],"enemy_1005_yokai_3":[12,0,12,31250,0]},
+      "hooks": [1,117,6900,1260,1260,1256,1256,0,11,99,0,0,0,10506,0,0,93,88,1,11,0,0,0],
+      "events": {"atk":1260,"deploy":22,"die":11,"dmg":1256,"leak":88,"spawn":107},
+      "fx": {},
+      "snaps": "56b58330 a3448e9a 5b5154a3 bc6d5e8d 1487c2e5 fd30305d 36c9eef7 2434a616 5de090ea 112fbed7 df72eb10 13673563 bf9f3597 50abc9fb bfa725af 196b93b7 3f8794ee 9db0276c c02baf4d 840ba560 dc668320 8d0e0e8e b3d49138"
     },
     "diy-078": {
-      "about": "5_diy1_a=sharp2 5_diy2_b=sharp2 5_diy1_a=acspec 5_diy2_b=acspec 5_diy1_a=acnipe 5_diy2_b=acnipe 5_diy1_a=accast 5_diy2_b=accast 5_diy1_a=acmedc 5_diy2_b=acmedc 5_diy1_a=acsupo 5_diy2_b=acsupo",
+      "about": "5_diy1_a=headb2/S1 5_diy2_a=headb2/S2 5_diy1_a=headb2/S3 5_diy2_b=headb2/S1 5_diy1_b=headb2/S2 5_diy2_b=headb2/S3 6_diy1_b=vvana/S1/002_vvana 6_diy2_b=vvana/S2/002_vvana 6_diy1_b=vvana/S3/002_vvana 6_diy2_b=vvana/S1/003_vvana 6_diy1_b=vvana/S2/003_vvana 6_diy2_b=vvana/S3/003_vvana",
       "fast": false,
       "kind": "normal",
       "stageId": "act1autochess_m01",
       "modeId": "mode_single_hard",
-      "round": 12,
+      "round": 13,
       "seed": 2130619692,
-      "waveId": "act1autochess_h05",
-      "time": 211.13,
-      "ticks": 6334,
+      "waveId": "act1autochess_h06",
+      "time": 227.33,
+      "ticks": 6820,
       "reason": "cleared",
-      "killed": 7,
-      "total": 114,
+      "killed": 67,
+      "total": 123,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 48,
+      "rngDraws": 140,
       "errors": {"count":0,"kinds":[]},
-      "players": {"p1":{"killed":7,"total":114,"perfect":false,"leaks":107,"leaksUncounted":0,"coins":0,"dmg":64050,"bossDmg":0,"heal":2112,"deaths":32,"layerGains":{}}},
+      "players": {"p1":{"killed":67,"total":123,"perfect":false,"leaks":56,"leaksUncounted":0,"coins":0,"dmg":560136,"bossDmg":0,"heal":0,"deaths":21,"layerGains":{}}},
       "units": [
-        ["p1",1,"op","chess_char_5_diy1_a",0,null,0,0,7,0,5325,2016,0,7,1],
-        ["p1",2,"op","chess_char_5_diy2_b",0,"uniequip_002_sharp2",0,0,9,4,22936,2374,0,14,1],
-        ["p1",3,"op","chess_char_5_diy1_a",2,null,1154,1,151,0,7836,11540,0,12,0],
-        ["p1",4,"op","chess_char_5_diy2_b",2,"uniequip_002_acspec",1448,1,150,1,16367,13032,0,22,0],
-        ["p1",5,"op","chess_char_5_diy1_a",2,null,0,0,97,0,1239,2544,0,5,0],
-        ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_002_acnipe",0,0,5,2,3182,1765,0,5,1],
-        ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,11,0,1663,1608,0,1,0],
-        ["p1",8,"op","chess_char_5_diy2_b",2,"uniequip_002_accast",0,0,13,0,3986,1749,0,4,0],
-        ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,6,0,0,1224,777,3,1],
-        ["p1",10,"op","chess_char_5_diy2_b",2,"uniequip_002_acmedc",0,0,78,0,0,4163,1335,3,0],
-        ["p1",11,"op","chess_char_5_diy1_a",2,null,0,0,71,0,789,2320,0,2,0],
-        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_002_acsupo",0,0,8,0,727,1642,0,1,1],
+        ["p1",1,"op","chess_char_5_diy1_a",0,null,1429.57,1,148,6,34877,5473,0,24,2],
+        ["p1",2,"op","chess_char_5_diy2_a",1,null,0,0,119,7,64136,4602,0,31,1],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,2301,1,149,4,56279,4602,0,3,1],
+        ["p1",4,"op","chess_char_5_diy2_b",0,"none",0,0,139,5,32666,8193,0,14,1],
+        ["p1",5,"op","chess_char_5_diy1_b",1,"none",0,0,84,1,25901,5462,0,12,1],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"none",0,0,130,8,55992,5462,0,15,2],
+        ["p1",7,"op","chess_char_6_diy1_b",0,"uniequip_002_vvana",0,0,7,10,60122,3104,0,53,19],
+        ["p1",8,"op","chess_char_6_diy2_b",1,"uniequip_002_vvana",0,0,4,2,25528,3104,0,15,1],
+        ["p1",9,"op","chess_char_6_diy1_b",2,"uniequip_002_vvana",0,0,8,9,63404,3104,0,47,2],
+        ["p1",10,"op","chess_char_6_diy2_b",0,"uniequip_003_vvana",0,0,82,11,70354,5968,0,76,24],
+        ["p1",11,"op","chess_char_6_diy1_b",1,"uniequip_003_vvana",0,0,14,4,50097,2984,0,30,1],
+        ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_003_vvana",0,0,81,0,20780,5968,0,24,1],
         ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null],
         ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null],
         ["-","~3","device","trap_1105_accrate",null,null,100,1,3,0,0,0,0,0,null]
       ],
-      "enemies": {"enemy_1019_jshoot_2":[51,3,48,6735,13561],"enemy_1381_winman":[27,4,23,274,48141],"enemy_1389_winbab_2":[36,0,36,38969,2348]},
-      "hooks": [1,151,6334,389,389,313,328,8,39,146,5,24,0,6349,19,23,114,107,1,39,0,0,0],
-      "events": {"atk":393,"deploy":34,"die":39,"dmg":314,"fx":8,"heal":7,"leak":107,"skill":36,"spawn":129,"status":35},
-      "fx": {"displace":6,"spGain":2},
-      "snaps": "cbc574c2 514473e2 75591f1c cfb07d82 a78b7245 8f48f6aa be3b725d 921fad95 439e2f43 d25dc3db 519fe02f f01841f2 1a6f7d56 55197d41 f972b250 b95a084c b5ed1052 522fa670 7e2846cd df5e04a5 17e0c749 a7b2c538"
+      "enemies": {"enemy_1019_jshoot_2":[57,41,16,9154,183638],"enemy_1299_ymkilr_2":[27,10,17,47487,203959],"enemy_1422_lrsldr_2":[39,16,23,1386,172539]},
+      "hooks": [1,149,6820,1026,1026,1315,1436,0,88,144,56,55,0,17849,892,94,123,56,1,88,0,6,0],
+      "events": {"atk":1056,"deploy":23,"die":88,"dmg":1436,"fx":74,"leak":56,"skill":111,"spawn":138,"status":71},
+      "fx": {"aoe":20,"burst":6,"shield":24,"shieldBreak":24},
+      "snaps": "45ecc41c 880ee0dd b36699bc 992f1255 23143b3d 3ba40a64 ead1143c 29b600b7 60ec6974 eff36649 bbaee861 b11de034 d58d5c37 63232bfe 4e305d69 848a4366 cd76bd35 ad1f8c0f 8e3f9ba5 2b3b69eb 71bc494b 17b62c2a 2f3b24a4"
     },
     "diy-079": {
-      "about": "6_diy1_a=acfend 6_diy2_b=acfend 6_diy1_a=acpion 6_diy2_b=acpion 6_diy1_a=acguad 6_diy2_b=acguad 6_diy1_a=acnipe 6_diy2_b=acnipe 6_diy1_a=accast 6_diy2_b=accast 6_diy1_a=acmedc 6_diy2_b=acmedc",
+      "about": "5_diy1_b=headb2/S1/002_headb2 5_diy2_b=headb2/S2/002_headb2 5_diy1_b=headb2/S3/002_headb2 6_diy1_a=headb2/S1 6_diy2_a=headb2/S2 6_diy1_a=headb2/S3 6_diy2_b=headb2/S1 6_diy1_b=headb2/S2 6_diy2_b=headb2/S3 6_diy1_b=headb2/S1/002_headb2 6_diy2_b=headb2/S2/002_headb2 6_diy1_b=headb2/S3/002_headb2",
       "fast": false,
       "kind": "normal",
       "stageId": "act1autochess_m02",
@@ -3379,71 +3379,284 @@
       "round": 13,
       "seed": 1503726279,
       "waveId": "act1autochess_h06",
-      "time": 220.87,
-      "ticks": 6626,
+      "time": 221.23,
+      "ticks": 6637,
       "reason": "cleared",
-      "killed": 18,
+      "killed": 30,
       "total": 111,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 741,
+      "rngDraws": 0,
       "errors": {"count":0,"kinds":[]},
-      "players": {"p1":{"killed":18,"total":111,"perfect":false,"leaks":93,"leaksUncounted":0,"coins":0,"dmg":1112925,"bossDmg":0,"heal":16745,"deaths":12,"layerGains":{}}},
+      "players": {"p1":{"killed":30,"total":111,"perfect":false,"leaks":81,"leaksUncounted":0,"coins":0,"dmg":1164508,"bossDmg":0,"heal":0,"deaths":17,"layerGains":{}}},
       "units": [
-        ["p1",1,"op","chess_char_6_diy1_a",2,null,0,0,124,0,403,7812,0,12,0],
-        ["p1",2,"op","chess_char_6_diy2_b",2,"uniequip_002_acfend",0,0,91,0,9431,7244,0,46,2],
-        ["p1",3,"op","chess_char_6_diy1_a",2,null,1529,1,117,0,20345,1529,0,41,4],
-        ["p1",4,"op","chess_char_6_diy2_b",2,"uniequip_002_acpion",1904,1,113,3,123004,5991,0,33,7],
-        ["p1",5,"op","chess_char_6_diy1_a",2,null,1249.23,1,10,5,61613,8772,0,61,3],
-        ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acguad",3531,1,132,3,65671,6743,0,39,2],
-        ["p1",7,"op","chess_char_6_diy1_a",2,null,1272,1,5,1,34182,0,0,89,2],
-        ["p1",8,"op","chess_char_6_diy2_b",2,"uniequip_002_acnipe",1643,1,8,0,236086,0,0,194,3],
-        ["p1",9,"op","chess_char_6_diy1_a",2,null,1372,1,6,4,232286,0,0,79,2],
-        ["p1",10,"op","chess_char_6_diy2_b",2,"uniequip_002_accast",1819,1,9,2,329906,0,0,84,3],
-        ["p1",11,"op","chess_char_6_diy1_a",2,null,1224,1,114,0,0,4128,1680,4,0],
-        ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_002_acmedc",0,0,77,0,0,2928,15065,20,2]
+        ["p1",1,"op","chess_char_5_diy1_b",0,"uniequip_002_headb2",0,0,115,3,98506,5962,0,28,1],
+        ["p1",2,"op","chess_char_5_diy2_b",1,"uniequip_002_headb2",180.12,1,1,2,57414,2801,0,21,2],
+        ["p1",3,"op","chess_char_5_diy1_b",2,"uniequip_002_headb2",2981,1,122,5,84558,2981,0,9,2],
+        ["p1",4,"op","chess_char_6_diy1_a",0,null,726.61,1,111,1,20541,3875,0,17,1],
+        ["p1",5,"op","chess_char_6_diy2_a",1,null,0,0,75,1,47122,4602,0,13,1],
+        ["p1",6,"op","chess_char_6_diy1_a",2,null,2301,1,134,1,62802,4602,0,8,1],
+        ["p1",7,"op","chess_char_6_diy2_b",0,"none",0,0,68,0,37939,5462,0,14,1],
+        ["p1",8,"op","chess_char_6_diy1_b",1,"none",2731,1,2,3,55873,0,0,18,2],
+        ["p1",9,"op","chess_char_6_diy2_b",2,"none",2731,1,3,1,180570,0,0,5,5],
+        ["p1",10,"op","chess_char_6_diy1_b",0,"uniequip_002_headb2",0,0,101,2,135690,6222,0,34,1],
+        ["p1",11,"op","chess_char_6_diy2_b",1,"uniequip_002_headb2",0,0,87,1,87183,6222,0,28,1],
+        ["p1",12,"op","chess_char_6_diy1_b",2,"uniequip_002_headb2",0,0,132,10,296311,9333,0,25,1]
       ],
-      "enemies": {"enemy_1010_demon":[54,8,46,28411,532284],"enemy_1320_wdrrl_2":[18,0,18,14717,193787],"enemy_1422_lrsldr_2":[39,10,29,2019,386854]},
-      "hooks": [1,132,6626,818,818,2133,2113,42,30,123,30,28,0,37558,0,25,111,93,1,34,0,0,20],
-      "events": {"atk":1045,"deploy":21,"die":30,"dmg":2113,"fx":194,"heal":36,"leak":93,"skill":58,"spawn":123,"status":22},
-      "fx": {"aoe":68,"dodge":20,"dp":14,"explode":4,"slash":88},
-      "snaps": "a44439af 086db0a0 a68e4f3a 84f700cd 7a9ed117 7e3f7e4f 35f4764e 45919dbf 8d33b48a 809ac470 2a21b044 0d9e3e70 4aff1df9 12c0a2e9 19050d4e ecd037c6 cf2f56ed 4dc0e234 f974bf40 2bcc5e1a 38d67c2c 029d3b9d"
+      "enemies": {"enemy_1010_demon":[54,16,38,50373,545260],"enemy_1320_wdrrl_2":[18,0,18,0,277787],"enemy_1422_lrsldr_2":[39,14,25,1689,341462]},
+      "hooks": [1,134,6637,368,368,1305,1305,0,47,128,19,17,0,24434,527,50,111,81,1,47,0,0,0],
+      "events": {"atk":368,"deploy":23,"die":47,"dmg":1305,"fx":302,"leak":81,"skill":36,"spawn":123,"status":903},
+      "fx": {"aoe":302},
+      "snaps": "a43aa2ec 7ae1f2c9 13f07bb1 5f453175 ab0bd68f 60782fe7 3ca2f642 e772d677 9ba25d19 c9e1b218 d80aba95 5055465a 5f296d73 a338b0fb a699f6e6 f73d7f6e 79530136 7f95e25d ce966d84 17b6a1dc 866a5c57 38b805a5 f043e9a1"
     },
     "diy-080": {
-      "about": "6_diy1_a=sharp2 6_diy2_b=sharp2 6_diy1_a=acspec 6_diy2_b=acspec 6_diy1_a=acsupo 6_diy2_b=acsupo",
+      "about": "5_diy1_a=hodrer/S1 5_diy2_a=hodrer/S2 5_diy1_a=hodrer/S3 5_diy2_b=hodrer/S1 5_diy1_b=hodrer/S2 5_diy2_b=hodrer/S3 5_diy1_b=hodrer/S1/002_hodrer 5_diy2_b=hodrer/S2/002_hodrer 5_diy1_b=hodrer/S3/002_hodrer 5_diy2_b=hodrer/S1/003_hodrer 5_diy1_b=hodrer/S2/003_hodrer 5_diy2_b=hodrer/S3/003_hodrer",
       "fast": false,
       "kind": "normal",
       "stageId": "act1autochess_m03",
       "modeId": "mode_multi_hard",
-      "round": 13,
+      "round": 12,
       "seed": 3144258890,
-      "waveId": "act1autochess_h06",
-      "time": 204.37,
-      "ticks": 6131,
-      "reason": "cleared",
-      "killed": 2,
-      "total": 109,
+      "waveId": "act1autochess_h05",
+      "time": 230,
+      "ticks": 6900,
+      "reason": "timeout",
+      "killed": 18,
+      "total": 42,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 107,
+      "rngDraws": 18,
       "errors": {"count":0,"kinds":[]},
-      "players": {"p1":{"killed":2,"total":109,"perfect":false,"leaks":107,"leaksUncounted":0,"coins":0,"dmg":252435,"bossDmg":0,"heal":0,"deaths":22,"layerGains":{}}},
+      "players": {"p1":{"killed":18,"total":42,"perfect":false,"leaks":24,"leaksUncounted":0,"coins":0,"dmg":0,"bossDmg":0,"heal":0,"deaths":21,"layerGains":{}}},
       "units": [
-        ["p1",1,"op","chess_char_6_diy1_a",0,null,0,0,136,0,12809,5595,0,27,1],
-        ["p1",2,"op","chess_char_6_diy2_b",0,"uniequip_002_sharp2",0,0,80,2,35608,4988,0,25,1],
-        ["p1",3,"op","chess_char_6_diy1_a",2,null,0,0,134,0,27421,10386,0,46,0],
-        ["p1",4,"op","chess_char_6_diy2_b",2,"uniequip_002_acspec",1484,1,137,0,54545,11872,0,58,0],
-        ["p1",5,"op","chess_char_6_diy1_a",2,null,1160,1,6,0,43256,0,0,80,2],
-        ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acsupo",1450,1,9,0,78795,0,0,108,2],
+        ["p1",1,"op","chess_char_5_diy1_a",0,null,0,0,63,0,0,9340,0,0,0],
+        ["p1",2,"op","chess_char_5_diy2_a",1,null,0,0,65,0,0,9340,0,0,0],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,0,0,66,0,0,14010,0,0,0],
+        ["p1",4,"op","chess_char_5_diy2_b",0,"none",0,0,48,0,0,11088,0,0,0],
+        ["p1",5,"op","chess_char_5_diy1_b",1,"none",0,0,46,0,0,11088,0,0,0],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"none",0,0,44,0,0,11088,0,0,0],
+        ["p1",7,"op","chess_char_5_diy1_b",0,"uniequip_002_hodrer",0,0,42,0,0,11668,0,0,0],
+        ["p1",8,"op","chess_char_5_diy2_b",1,"uniequip_002_hodrer",0,0,7,0,0,5834,0,0,0],
+        ["p1",9,"op","chess_char_5_diy1_b",2,"uniequip_002_hodrer",0,0,11,0,0,5834,0,0,0],
+        ["p1",10,"op","chess_char_5_diy2_b",0,"uniequip_003_hodrer",0,0,41,0,0,11688,0,0,0],
+        ["p1",11,"op","chess_char_5_diy1_b",1,"uniequip_003_hodrer",0,0,8,0,0,5844,0,0,0],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_003_hodrer",0,0,9,0,0,5844,0,0,0],
         ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null],
         ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null],
         ["-","~3","device","trap_1105_accrate",null,null,100,1,3,0,0,0,0,0,null]
       ],
-      "enemies": {"enemy_1195_sfyin":[39,2,37,9962,63124],"enemy_1196_msfyin":[4,0,4,0,0],"enemy_1197_sfshu":[48,0,48,16642,92959],"enemy_1199_sfjin":[18,0,18,6237,96351]},
-      "hooks": [1,137,6131,461,461,559,589,0,24,131,6,23,0,10394,3192,29,109,107,1,24,0,0,0],
-      "events": {"atk":470,"deploy":25,"die":24,"dmg":553,"fx":16,"leak":107,"skill":48,"spawn":118,"status":562},
-      "fx": {"displace":13,"dodge":1,"summon":2},
-      "snaps": "40212f08 7ee7edf5 4e04eafe 1553e3a7 99a50525 30be47aa 60aae4c8 e173c070 f9824ca4 6f4c6d3e a164bbd5 974997f8 450b5a36 a6a2e8fa 582b939d 71eab21c e8b519ac 7bfb7ce5 da5081ed f7ada234 fcc66ab5"
+      "enemies": {"enemy_1005_yokai_2":[18,18,0,4527,0],"enemy_1005_yokai_3":[12,0,11,44142,0],"enemy_9009_acfort":[12,0,12,63998,0]},
+      "hooks": [1,66,6900,154,154,155,155,0,39,62,0,0,0,3951,0,0,42,23,1,21,0,0,0],
+      "events": {"atk":154,"deploy":21,"die":39,"dmg":155,"fx":51,"leak":23,"spawn":57,"status":35},
+      "fx": {"beam":51},
+      "snaps": "474e954e c7444490 661e618e 4133690f d5251e8f 73cf99f9 8712495a 564bea60 bc133cde a2df01d8 badc4fd0 58702ede a725aa93 79fc9602 6072c42d 75049c0f d84798ea d35a3811 7d2c4067 a1f62e75 1b62044c 46a7bee1 a7e23789"
+    },
+    "diy-081": {
+      "about": "6_diy1_a=hodrer/S1 6_diy2_a=hodrer/S2 6_diy1_a=hodrer/S3 6_diy2_b=hodrer/S1 6_diy1_b=hodrer/S2 6_diy2_b=hodrer/S3 6_diy1_b=hodrer/S1/002_hodrer 6_diy2_b=hodrer/S2/002_hodrer 6_diy1_b=hodrer/S3/002_hodrer 6_diy2_b=hodrer/S1/003_hodrer 6_diy1_b=hodrer/S2/003_hodrer 6_diy2_b=hodrer/S3/003_hodrer",
+      "fast": false,
+      "kind": "normal",
+      "stageId": "act1autochess_m04",
+      "modeId": "mode_single_normal",
+      "round": 13,
+      "seed": 636597004,
+      "waveId": "act1autochess_h06",
+      "time": 229.47,
+      "ticks": 6884,
+      "reason": "cleared",
+      "killed": 0,
+      "total": 66,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 0,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":0,"total":66,"perfect":false,"leaks":66,"leaksUncounted":0,"coins":0,"dmg":0,"bossDmg":0,"heal":0,"deaths":19,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_6_diy1_a",0,null,0,0,74,0,0,9340,0,0,0],
+        ["p1",2,"op","chess_char_6_diy2_a",1,null,0,0,84,0,0,9340,0,0,0],
+        ["p1",3,"op","chess_char_6_diy1_a",2,null,1933.68,1,89,0,0,7406,0,0,0],
+        ["p1",4,"op","chess_char_6_diy2_b",0,"none",4527.12,1,90,0,0,6561,0,0,0],
+        ["p1",5,"op","chess_char_6_diy1_b",1,"none",0,0,62,0,0,11088,0,0,0],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"none",0,0,58,0,0,11088,0,0,0],
+        ["p1",7,"op","chess_char_6_diy1_b",0,"uniequip_002_hodrer",0,0,57,0,0,11988,0,0,0],
+        ["p1",8,"op","chess_char_6_diy2_b",1,"uniequip_002_hodrer",0,0,55,0,0,11988,0,0,0],
+        ["p1",9,"op","chess_char_6_diy1_b",2,"uniequip_002_hodrer",0,0,5,0,0,5994,0,0,0],
+        ["p1",10,"op","chess_char_6_diy2_b",0,"uniequip_003_hodrer",0,0,8,0,0,5944,0,0,0],
+        ["p1",11,"op","chess_char_6_diy1_b",1,"uniequip_003_hodrer",0,0,10,0,0,5944,0,0,0],
+        ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_003_hodrer",0,0,60,0,0,11888,0,0,0],
+        ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null],
+        ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null],
+        ["-","~3","device","trap_1105_accrate",null,null,100,1,3,0,0,0,0,0,null]
+      ],
+      "enemies": {"enemy_1005_yokai_2":[12,0,12,22157,0],"enemy_1041_lazerd_2":[24,0,24,79958,0],"enemy_1042_frostd":[30,0,30,0,0]},
+      "hooks": [1,90,6884,281,281,366,366,0,19,85,0,0,0,6275,0,0,66,66,1,19,0,0,0],
+      "events": {"atk":281,"deploy":21,"die":19,"dmg":366,"leak":66,"spawn":81,"status":47},
+      "fx": {},
+      "snaps": "8afdfc31 0919a7ee 8de4aed1 6337fba4 567daf76 56008522 ec4ade74 73f019c2 7e5f5d33 2c4fea9c 6074f502 52883b9c b11a8d89 5c9bbd0b 5babd404 d5a091cc 22cdfd3a 1aeaf56c 45dd6b18 201ffd65 edb008bd 576be1b9 345d52ba"
+    },
+    "diy-082": {
+      "about": "5_diy1_a=cdfend 5_diy2_b=cdfend 5_diy1_a=cguard 5_diy2_b=cguard 5_diy1_a=csnipe 5_diy2_b=csnipe 5_diy1_a=ccast 5_diy2_b=ccast 5_diy1_a=cmedic 5_diy2_b=cmedic 5_diy1_a=csuppo 5_diy2_b=csuppo",
+      "fast": true,
+      "kind": "normal",
+      "stageId": "act1autochess_m05",
+      "modeId": "mode_multi_abyss",
+      "round": 12,
+      "seed": 3291363193,
+      "waveId": "act1autochess_h05",
+      "time": 213.67,
+      "ticks": 6410,
+      "reason": "cleared",
+      "killed": 1,
+      "total": 72,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 0,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":1,"total":72,"perfect":false,"leaks":71,"leaksUncounted":0,"coins":0,"dmg":15090,"bossDmg":0,"heal":5294,"deaths":24,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_5_diy1_a",2,null,0,0,2,0,0,2128,0,0,0],
+        ["p1",2,"op","chess_char_5_diy2_b",2,"none",0,0,4,0,0,2908,0,0,0],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,2564,1,99,0,0,5128,0,0,0],
+        ["p1",4,"op","chess_char_5_diy2_b",2,"none",0,0,60,0,0,8365,0,0,0],
+        ["p1",5,"op","chess_char_5_diy1_a",2,null,0,0,94,0,4022,3813,0,13,0],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"none",634.77,1,97,0,5094,5062,0,16,0],
+        ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,70,0,163,2266,0,1,0],
+        ["p1",8,"op","chess_char_5_diy2_b",2,"none",0,0,82,1,2820,2720,0,10,1],
+        ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,66,0,0,2436,2522,7,1],
+        ["p1",10,"op","chess_char_5_diy2_b",2,"none",0,0,61,0,0,4297,2772,6,1],
+        ["p1",11,"op","chess_char_5_diy1_a",2,null,624.26,1,98,0,1738,2172,0,7,0],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"none",0,0,90,0,1253,4274,0,4,0]
+      ],
+      "enemies": {"enemy_1005_yokai_2":[18,1,17,8907,11354],"enemy_1041_lazerd_2":[24,0,24,36662,3237],"enemy_1042_frostd":[30,0,30,0,499]},
+      "hooks": [1,99,6410,184,184,131,131,13,25,96,3,3,0,9470,11,0,72,71,1,25,0,0,0],
+      "events": {"atk":184,"deploy":27,"die":25,"dmg":131,"heal":13,"leak":71,"skill":6,"spawn":84,"status":60},
+      "fx": {},
+      "snaps": "929e7b64 23c44cc9 f9252009 fe8442bd fe2f4a74 46603554 138850b1 2e57b138 4c54f6c2 583bdb0a 16733ff1 7968a95b 2db4dc91 bfcdfe79 68dbe05a 9fa96f3c 851092ff d2516ce2 0f10acbb 1a19f09e be4a61b4 792ae5fa"
+    },
+    "diy-083": {
+      "about": "5_diy1_a=acfend 5_diy2_b=acfend 5_diy1_a=acpion 5_diy2_b=acpion 5_diy1_a=acguad 5_diy2_b=acguad 5_diy1_a=acnipe 5_diy2_b=acnipe 5_diy1_a=accast 5_diy2_b=accast 5_diy1_a=acmedc 5_diy2_b=acmedc",
+      "fast": false,
+      "kind": "normal",
+      "stageId": "act1autochess_m06",
+      "modeId": "mode_multi_funny",
+      "round": 12,
+      "seed": 1650236694,
+      "waveId": "act1autochess_h05",
+      "time": 187.97,
+      "ticks": 5639,
+      "reason": "cleared",
+      "killed": 315,
+      "total": 315,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 223,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":315,"total":315,"perfect":true,"leaks":0,"leaksUncounted":0,"coins":0,"dmg":255771,"bossDmg":0,"heal":13009,"deaths":0,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_5_diy1_a",2,null,2604,1,3,1,3,0,0,3,1],
+        ["p1",2,"op","chess_char_5_diy2_b",2,"uniequip_002_acfend",3371,1,6,0,0,0,0,0,0],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,1529,1,9,15,5082,0,0,0,6],
+        ["p1",4,"op","chess_char_5_diy2_b",2,"uniequip_002_acpion",1904,1,12,211,186089,6902,0,139,20],
+        ["p1",5,"op","chess_char_5_diy1_a",2,null,2638,1,7,7,7128,81,0,51,3],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_002_acguad",3411,1,10,21,40776,2208,0,65,3],
+        ["p1",7,"op","chess_char_5_diy1_a",2,null,1272,1,1,4,17,0,0,9,1],
+        ["p1",8,"op","chess_char_5_diy2_b",2,"uniequip_002_acnipe",1587,1,4,33,2253,0,0,124,2],
+        ["p1",9,"op","chess_char_5_diy1_a",2,null,1372,1,5,20,13384,0,0,52,2],
+        ["p1",10,"op","chess_char_5_diy2_b",2,"uniequip_002_accast",1749,1,2,3,1039,0,0,32,2],
+        ["p1",11,"op","chess_char_5_diy1_a",2,null,1224,1,8,0,0,0,7253,57,2],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_002_acmedc",1414,1,11,0,0,3818,5756,53,2]
+      ],
+      "enemies": {
+        "enemy_1195_sfyin": [45,45,0,1536,86400],
+        "enemy_1196_msfyin": [90,90,0,0,180],
+        "enemy_1197_sfshu": [39,39,0,1301,93600],
+        "enemy_1198_msfshu": [117,117,0,0,351],
+        "enemy_1199_sfjin": [12,12,0,10172,74880],
+        "enemy_1200_msfjin": [12,12,0,0,360]
+      },
+      "hooks": [1,327,5639,737,737,1468,1463,169,315,315,44,44,0,42253,0,66,315,0,1,315,0,0,5],
+      "events": {"atk":777,"deploy":12,"die":315,"dmg":1463,"fx":542,"heal":119,"skill":88,"spawn":327,"status":51},
+      "fx": {"aoe":8,"dodge":5,"dp":252,"slash":181,"summon":96},
+      "snaps": "b9de20f5 cd6b3efb 09eb57b5 24bfc0e3 e829b26a e73faaa5 5fd0fd4c c8657af0 44a29020 72515532 09743957 f2340a46 7d119e5c 1cad876f b2bf2c88 1853453d 2b9e79cd 8732b534 6fac7895"
+    },
+    "diy-084": {
+      "about": "6_diy1_a=acfend 6_diy2_b=acfend 5_diy1_a=sharp2 5_diy2_b=sharp2 6_diy1_a=acpion 6_diy2_b=acpion 5_diy1_a=acspec 5_diy2_b=acspec 6_diy1_a=acguad 6_diy2_b=acguad 5_diy1_a=acsupo 5_diy2_b=acsupo",
+      "fast": false,
+      "kind": "normal",
+      "stageId": "act1autochess_m07",
+      "modeId": "mode_single_hard",
+      "round": 13,
+      "seed": 9899299,
+      "waveId": "act1autochess_h06",
+      "time": 219.17,
+      "ticks": 6575,
+      "reason": "cleared",
+      "killed": 19,
+      "total": 135,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 292,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":19,"total":135,"perfect":false,"leaks":116,"leaksUncounted":0,"coins":0,"dmg":386697,"bossDmg":0,"heal":0,"deaths":27,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_6_diy1_a",2,null,0,0,128,0,1435,5208,0,12,1],
+        ["p1",2,"op","chess_char_6_diy2_b",2,"uniequip_002_acfend",0,0,122,2,6526,6862,0,22,1],
+        ["p1",3,"op","chess_char_5_diy1_a",0,null,0,0,10,2,41674,1865,0,45,1],
+        ["p1",4,"op","chess_char_5_diy2_b",0,"uniequip_002_sharp2",0,0,109,7,89912,4748,0,50,1],
+        ["p1",5,"op","chess_char_6_diy1_a",2,null,0,0,162,0,27523,4587,0,17,1],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acpion",849.85,1,167,1,23161,4862,0,31,2],
+        ["p1",7,"op","chess_char_5_diy1_a",2,null,1154,1,169,0,33022,9232,0,77,0],
+        ["p1",8,"op","chess_char_5_diy2_b",2,"uniequip_002_acspec",1448,1,168,1,13917,5792,0,71,0],
+        ["p1",9,"op","chess_char_6_diy1_a",2,null,0,0,144,2,45083,5276,0,62,2],
+        ["p1",10,"op","chess_char_6_diy2_b",2,"uniequip_002_acguad",0,0,8,2,40848,3531,0,40,1],
+        ["p1",11,"op","chess_char_5_diy1_a",2,null,1160,1,6,1,27511,0,0,135,2],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_002_acsupo",1430,1,9,1,36084,0,0,136,3],
+        ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null],
+        ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null]
+      ],
+      "enemies": {"enemy_1288_duskls":[27,5,22,4153,64716],"enemy_1288_duskls_2":[57,10,47,12855,138844],"enemy_1292_duskld":[51,4,47,34955,183138]},
+      "hooks": [1,169,6575,908,908,1164,1227,0,46,162,15,26,0,19726,9482,81,135,116,1,74,0,0,7],
+      "events": {"atk":971,"deploy":32,"die":46,"dmg":1192,"fx":87,"leak":116,"skill":56,"spawn":149,"status":933},
+      "fx": {"aoe":16,"displace":9,"dodge":14,"dp":4,"ember":23,"revive":3,"slash":18},
+      "snaps": "b6b0e787 40ce69f0 e4a600b5 03bcfb53 8d941860 105006e3 f43c01a7 d63ddd19 e0a0dd62 1f2e5509 75f4280a d8178e83 94b30053 eb92be4e 488e3693 891784a7 9c6773ef d70c22dc ba6886ac a4f41448 8e4e2e3d f580b25a"
+    },
+    "diy-085": {
+      "about": "6_diy1_a=sharp2 6_diy2_b=sharp2 6_diy1_a=acspec 6_diy2_b=acspec 6_diy1_a=acnipe 6_diy2_b=acnipe 6_diy1_a=accast 6_diy2_b=accast 6_diy1_a=acmedc 6_diy2_b=acmedc 6_diy1_a=acsupo 6_diy2_b=acsupo",
+      "fast": false,
+      "kind": "normal",
+      "stageId": "act2autochess_m01",
+      "modeId": "mode_multi_normal",
+      "round": 13,
+      "seed": 2664068408,
+      "waveId": "act1autochess_h06",
+      "time": 230,
+      "ticks": 6900,
+      "reason": "timeout",
+      "killed": 2,
+      "total": 78,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 1111,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":2,"total":78,"perfect":false,"leaks":76,"leaksUncounted":0,"coins":0,"dmg":510505,"bossDmg":0,"heal":3151,"deaths":29,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_6_diy1_a",0,null,0,0,6,0,8366,1865,0,11,1],
+        ["p1",2,"op","chess_char_6_diy2_b",0,"uniequip_002_sharp2",0,0,9,0,20134,2494,0,18,1],
+        ["p1",3,"op","chess_char_6_diy1_a",2,null,1154,1,111,0,2051,11540,0,24,0],
+        ["p1",4,"op","chess_char_6_diy2_b",2,"uniequip_002_acspec",0,0,110,0,11183,13763,0,46,0],
+        ["p1",5,"op","chess_char_6_diy1_a",2,null,1272,1,2,0,15695,0,0,192,3],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acnipe",1643,1,3,0,39788,0,0,203,3],
+        ["p1",7,"op","chess_char_6_diy1_a",2,null,1372,1,4,1,315089,0,0,76,2],
+        ["p1",8,"op","chess_char_6_diy2_b",2,"uniequip_002_accast",0,0,61,0,68339,4898,0,11,1],
+        ["p1",9,"op","chess_char_6_diy1_a",2,null,0,0,8,0,0,1224,3151,6,1],
+        ["p1",10,"op","chess_char_6_diy2_b",2,"uniequip_002_acmedc",0,0,56,0,0,2928,0,0,0],
+        ["p1",11,"op","chess_char_6_diy1_a",2,null,0,0,108,1,7580,3480,0,12,1],
+        ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_002_acsupo",0,0,5,0,22280,1450,0,24,1]
+      ],
+      "enemies": {"enemy_1045_hammer_2":[18,0,18,13581,118358],"enemy_1061_zomshd":[60,2,57,30061,392147]},
+      "hooks": [1,111,6900,689,689,2072,2101,30363,31,106,14,30,0,17929,1574,31,78,75,1,31,0,0,0],
+      "events": {"atk":990,"deploy":33,"die":31,"dmg":2040,"fx":11,"heal":9,"leak":75,"skill":58,"spawn":90,"status":276},
+      "fx": {"aoe":8,"dodge":1,"spGain":2},
+      "snaps": "8ed3b18e a2013054 0f66a943 048beb0a a87e3d9e 4c545d47 607b10f5 e8c8ec5f e06c7c92 24fa68b9 b40e620b 37fafbe8 b101dc8e 3ab8e7cd a3b2aeda c75be2f7 4db80d53 0f84f660 bc5b8050 1a0d5e1f 5d5d3c03 6074a480 d12f4c03"
     }
   }
 }