feedback5: merge O13 — 自选 kits for 假日威龙陈, 莱伊 (with her 沙地兽) and 阿斯卡纶; golden: only diy moved

server/sim/content/kits/index.js

@@ -121,6 +121,9 @@ export const OPERATOR_KIT_FILES = Object.freeze([
   'op-vvana.js',
   'op-headb2.js',
   'op-hodrer.js',
+  'op-chen2.js',
+  'op-ray.js',
+  'op-ascln.js',
 ]);
 
 /**

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

@@ -0,0 +1,260 @@
+// server/sim/content/kits/ops/op-ascln.js — 阿斯卡纶 (char_4132_ascln) 自选 operator kit: 6★ 伏击客 (特种), an owned-6★ pick
+// of the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and both modules (AMB-X “无形，无情”, AMB-Y
+// “阿斯卡纶的眼睛”) at every form. Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)").
+//
+// Forms (data/backups.json units.char_4132_ascln): 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) — the owner's decision of 2026-10-05. Potential 0 [ASSUMED: no
+// account]. Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json) and PRTS
+// 阿斯卡纶 (死亡拘审 备注 and its {{**}} 最终乘算 (100−18×层数)%, S2 修正 / 备注, S3 备注, the AMB-X note), PRTS 分支特性信息
+// 伏击客 ("嘲讽等级为-1"), PRTS 命中率, Arknights Terra Wiki "Ascalon" (死亡拘审: "The MSPD reduction and Arts damage stack
+// additively"); the client's battle data read from the local install — buff_template_data ascln_t_1 / ascln_t_1[debuff]
+// (ON_OUTPUT_DAMAGE of NORMAL attacks; STACK, the duration refreshed; per trigger buff count × atk_ratio × ATK, MAGICAL,
+// attack type BUFF), ascln_t_2 (CheckHeightTypeInRange x-5 ≥ cnt), ascln_s_2[enemy] (ON_OWNER_KILLED of a WALK enemy:
+// the debuff in a circle of range_radius on the WALK_ONLY enemies but the dead one), ascln_s_3[self] (heal on
+// ON_EVADE_DAMAGE and on a HIT_FAILED damage), ascln_e_003_t_1[heal] (a heal when the enemy holding it finishes).
+// - Trait (伏击客) "对攻击范围内所有敌人造成伤害；拥有50%的物理和法术闪避且不容易成为敌人的攻击目标": the stalker profile — every
+//   enemy of her range at once, melee, ground only (no "可对空"), physical — and 50 % physical / arts dodge (trait bb prob;
+//   AMB-Y: 65 %). "不容易成为敌人的攻击目标" is her taunt level −1, which her data stats already carry (PRTS 伏击客 "嘲讽等级为
+//   -1"): the kit trait installs the dodge without the profile's own extra −1 (professions.js installStalker adds one on
+//   top of the data's — a double count reported for 水月, whose kit keeps the profile; not changed here).
+//   AMB-X adds "攻击范围内所有敌人移动速度-20%" (hidden talent move_speed): every enemy of her current range, air units too,
+//   moves ×(1 + move_speed); PRTS "多个伏击客X模组之间的减速效果可叠加" — one slow per 阿斯卡纶 (her own key).
+// - T1 死亡拘审 "攻击对敌人施加效果：移动速度降低18％，每秒受到10％阿斯卡纶当前攻击力的法术伤害，持续25秒，效果最多叠加三层"
+//   (bb move_speed / atk_ratio / max_stack_cnt / debuff_duration / interval): every damage instance of her attacks (S1's two
+//   strikes are two attacks) adds a layer (≤ max_stack_cnt) and resets the duration (PRTS 备注); the target moves
+//   ×(1 − 0.18 × layers) (PRTS 最终乘算 (100−18×层数)%) and takes layers × atk_ratio × her CURRENT ATK as arts damage every
+//   `interval` s (Terra Wiki: both parts stack additively; PRTS 伤害分类 法术持续伤害 — not dodgeable, tag 'dot'); "自身退场后，
+//   所有已施加的本天赋效果将立刻结束". One effect per 阿斯卡纶 [ASSUMED]. AMB-X stage 3: 11 %, 30 s (the talent change).
+//   AMB-Y stage 3 adds "拥有该效果的敌人被击倒时阿斯卡纶回复10%生命" (hp_ratio): a heal of hp_ratio × her max HP whoever knocks
+//   such an enemy out, while she is on the field.
+// - T2 噬光残影 "攻击速度+8，自身周围四格有高台时，攻击速度额外+6" (bb attack_speed / attack_speed_add / cnt): ASPD +8, +6 more
+//   while at least `cnt` of the four tiles next to her are 高台 (heightType HIGHLAND in the level files — the 高台 deploy
+//   tiles and the HIGHLAND forbidden tiles), judged at each deployment.
+// - S1 追袭 (AUTO, 2 / 3 charges, data DEFAULT — a "next attack" skill): the next attack at atk_scale × ATK and "连续攻击两
+//   次": every enemy of her range struck twice (bb cnt is the charge count, not the strikes).
+// - S2 恩赐 (MANUAL, 35 s, data DEFAULT): ATK +atk; PRTS 修正 (原因 "描述与游戏实际表现不符合"): "使攻击范围内所有敌人移动速度
+//   -N%" — every enemy of her range, air units too, moves ×(1 − |move_speed|) (refreshed every AURA_IV s, 同名 keeps the
+//   strongest — two 阿斯卡纶 do not stack [ASSUMED]) — and "在地面敌人被击倒时对周围地面敌人施加一层第一天赋效果": a ground
+//   enemy of her range knocked out (by anyone [ASSUMED]) gives one 死亡拘审 layer to every selectable ground enemy within
+//   range_radius (PRTS 备注 "尸爆半径1.3", a 中点判定 around it).
+// - S3 降临 (MANUAL, 45 s, data ACTIVE_RANGE on its y-10): range y-10, ATK +atk, base attack time + base_attack_time s
+//   (−1.2 / −1.5 on 3.5 s), taunt level +taunt_level (PRTS 备注 "从-1提升至1"); ground enemies of her range have their
+//   物理 / 法术命中率 −N % (PRTS 命中率: an attack of that damage type rolls once when it starts and misses as a whole —
+//   every target and hit of it; here one roll per enemy attack at its first damage instance, a battle-wide `hit` handler
+//   as 娜仁图亚's / Raidian's, the strongest of the 阿斯卡纶 whose range holds the attacker; several kinds of 命中率 cuts roll
+//   apart [ASSUMED]); "敌人未命中自身或自身闪避时回复5%最大生命值": attack@hp_ratio × her max HP for each enemy attack her cut
+//   makes miss her and each dodge of hers, while it runs (a heal: no 生命回复速度 note).
+
+import { num, talentBb, moduleBb, traitBb, skillRec, up, batMod } from '../shared/tier1.js';
+import { canTargetEnemy } from '../../../targeting.js';
+import { bodyInKeys } from '../../../body.js';
+import { hasHp } from '../../../damage.js';
+
+const S1 = 'skchr_ascln_1';
+const S2 = 'skchr_ascln_2';
+const S3 = 'skchr_ascln_3';
+/** Refresh period / length of the range auras (S2's slow, AMB-X's slow): the kits' non-stacking aura convention. */
+const AURA_IV = 0.25;
+const AURA_DUR = 0.4;
+/** S3's 命中率 handler runs before the enemy content's own hit riders (priority 200), after Raidian's / 娜仁图亚's (300). */
+const MISS_PRIORITY = 290;
+/** Tag of the 死亡拘审 ticks (法术持续伤害). */
+export const DREAD_TAG = 'ascln:dread';
+const ANY = Object.freeze({ canHitFly: true });
+/** The four tiles next to her (offsets: direction does not matter). */
+const ADJ4 = Object.freeze([[1, 0], [-1, 0], [0, 1], [0, -1]]);
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+/** Buff key of her 死亡拘审 on an enemy (one per 阿斯卡纶). */
+export const dreadKey = (src) => `ascln:dread#${src.id}`;
+
+/**
+ * One layer of 死亡拘审 from `src` on enemy `e` (talent blackboard `tb`): ≤ max_stack_cnt layers, the duration reset,
+ * move ×(1 − ms × layers), layers × atk_ratio × src's current ATK arts every interval s while src is on the field.
+ */
+export function addDread(battle, src, e, tb) {
+  if (!e || !e.alive || e.side !== 'enemy' || !hasHp(e)) return null;
+  const key = dreadKey(src);
+  const max = Math.max(1, Math.floor(num(tb.max_stack_cnt, 3)));
+  const ms = Math.abs(num(tb.move_speed)), dur = num(tb.debuff_duration, 25), iv = num(tb.interval, 1), ratio = num(tb.atk_ratio);
+  if (!(dur > 0)) return null;
+  const old = e.findBuff(key);
+  const n = Math.min(max, (old?.data?.n ?? 0) + 1);
+  const mods = { moveMul: Math.max(0, 1 - ms * n) };
+  if (old) {
+    old.data.n = n;
+    old.mods = mods;
+    old.timeLeft = dur;
+    old.duration = dur;
+    e.markDirty();
+    return old;
+  }
+  return battle.addBuff(e, {
+    key, duration: dur, mods, source: src, interval: iv > 0 ? iv : 1, data: { n }, tags: ['talent', 'dot'],
+    onTick: ({ battle: b, unit: t, buff }) => {
+      if (!up(src)) { b.removeBuff(t, buff); return; }
+      if (ratio > 0) b.dealDamage(src, t, { amount: src.s.atk * ratio * buff.data.n, type: 'arts', canDodge: false, tags: ['talent', 'dot', DREAD_TAG] });
+    },
+  });
+}
+
+// ---- S3 命中率: one battle-wide handler over every 阿斯卡纶 of the battle ---------------------------------------------------
+/** battle → { srcs: [{ unit, phys, arts, heal }], last: WeakMap(enemy → { id, miss }) }. */
+const MISS = new WeakMap();
+const s3On = (u) => !!(u.skill && u.skill.active && u.skill.id === S3);
+
+function missCut(st, e, type) {
+  let cut = 0;
+  for (const s of st.srcs) {
+    const v = type === 'arts' ? s.arts : s.phys;
+    if (v > cut && up(s.unit) && s3On(s.unit) && s.unit.rangeKeySet && bodyInKeys(e, s.unit.rangeKeySet)) cut = v;
+  }
+  return Math.min(1, cut);
+}
+
+function missHit(battle, st, ctx) {
+  const e = ctx.source, d = ctx.dmg;
+  if (!e || e.side !== 'enemy' || e.isFlying || !d || !d.isAttack || d.cancel || (d.type !== 'phys' && d.type !== 'arts')) return;
+  // one roll per attack: every damage instance of it shares the first instance's result
+  const prev = d.attackId ? st.last.get(e) : null;
+  let miss, first = false;
+  if (prev && prev.id === d.attackId) miss = prev.miss;
+  else {
+    first = true;
+    const cut = missCut(st, e, d.type);
+    miss = cut > 0 && battle.rng() < cut;
+    if (d.attackId) st.last.set(e, { id: d.attackId, miss });
+  }
+  if (!miss) return;
+  d.cancel = true;
+  ctx.stopPropagation = true;
+  const t = ctx.target;
+  if (t) battle.fx('dodge', { x: t.x, y: t.y, id: t.id });
+  // 敌人未命中自身: the 阿斯卡纶 it aimed at heals (once per missed attack)
+  if (first && t) for (const s of st.srcs) if (s.unit === t && up(t) && s3On(t) && s.heal > 0) battle.heal(t, t, t.s.maxHp * s.heal, { self: true });
+}
+
+function installMiss(battle, unit, phys, arts, heal) {
+  if (!(phys > 0) && !(arts > 0)) return;
+  let st = MISS.get(battle);
+  if (!st) {
+    st = { srcs: [], last: new WeakMap() };
+    MISS.set(battle, st);
+    // no owner: it serves every 阿斯卡纶 of the battle, whichever is on the field
+    battle.on('hit', (ctx) => missHit(battle, st, ctx), { priority: MISS_PRIORITY });
+  }
+  st.srcs.push({ unit, phys, arts, heal });
+}
+
+export default {
+  char_4132_ascln: (bb, chess) => {
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    const s3 = skillRec(chess, S3);
+    const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
+    const hidden = moduleBb(chess);
+    const dodge = num(traitBb(chess).prob, 0.5);
+    const picked = chess?.skill?.skillId ?? null;
+    return {
+      trait: {
+        // 伏击客: the dodge; the taunt level −1 is in her stats (no second −1)
+        install(battle, unit) {
+          const p = num(unit.profile?.dodge, dodge);
+          if (p > 0) battle.addBuff(unit, { key: 'trait:stalker', mods: { dodgePhys: p, dodgeArts: p }, persist: true, allowDead: true });
+        },
+      },
+      skills: {
+        [S1]: {
+          kind: num(skillRec(chess, S1)?.maxChargeTime, 1) > 1 ? 'charges' : 'instant',
+          attack: { atkScale: num(b1.atk_scale, 1), hits: 2 },
+        },
+        [S2]: {
+          kind: 'duration',
+          mods: { atkPct: num(b2.atk) },
+        },
+        [S3]: {
+          kind: 'duration',
+          mods: { atkPct: num(b3.atk), batPct: batMod(b3.base_attack_time, chess), taunt: num(b3.taunt_level) },
+          targeting: s3?.rangeGrid ? { rangeGrid: s3.rangeGrid.map((p) => [p[0], p[1]]) } : undefined,
+        },
+      },
+      talents: [
+        { install(battle, unit) { // 死亡拘审 (+ AMB-Y stage 3: a heal when an enemy carrying it is knocked out)
+          battle.on('damaged', (ctx) => {
+            const d = ctx.dmg, e = ctx.target;
+            if (ctx.source !== unit || !up(unit) || !d || !d.isAttack || !e || e.side !== 'enemy' || d.type === 'element') return;
+            addDread(battle, unit, e, t0);
+          }, { owner: unit });
+          const key = dreadKey(unit);
+          battle.on('death', (ctx) => {
+            const u = ctx.unit;
+            if (u === unit) { // 自身退场后，所有已施加的本天赋效果将立刻结束
+              for (const e of battle.enemies) if (e.findBuff(key)) battle.removeBuff(e, key);
+              return;
+            }
+            const hr = num(t0.hp_ratio);
+            if (hr > 0 && u.side === 'enemy' && ctx.reason === 'killed' && up(unit) && u.findBuff(key)) battle.heal(unit, unit, unit.s.maxHp * hr, { self: true });
+          }, { owner: unit });
+        } },
+        { install(battle, unit) { // 噬光残影: ASPD +8, +6 with 高台 among the four tiles next to her
+          const base = num(t1.attack_speed), add = num(t1.attack_speed_add), cnt = Math.max(1, Math.floor(num(t1.cnt, 1)));
+          const KEY = 'talent:ascln:shadow';
+          const apply = (r, c) => {
+            let n = 0;
+            for (const [dr, dc] of ADJ4) {
+              const rr = r + dr, cc = c + dc;
+              if (battle.grid.inBounds(rr, cc) && battle.grid.tile(rr, cc).height === 'HIGH') n++;
+            }
+            const v = base + (n >= cnt ? add : 0);
+            if (v) battle.addBuff(unit, { key: KEY, mods: { aspd: v }, persist: true, allowDead: true, tags: ['talent'], data: { high: n } });
+          };
+          apply(unit.homeR ?? unit.tileR, unit.homeC ?? unit.tileC);
+          battle.on('deploy', (ctx) => { if (ctx.unit === unit) apply(unit.tileR, unit.tileC); }, { owner: unit });
+        } },
+      ],
+      install(battle, unit) {
+        // AMB-X: every enemy of her range moves ×(1 + move_speed) (one slow per 阿斯卡纶: they stack — PRTS)
+        const mx = num(hidden.move_speed);
+        if (mx < 0) {
+          const key = `ascln:ambx#${unit.id}`;
+          battle.every(AURA_IV, () => {
+            if (!up(unit)) return;
+            for (const e of battle.enemiesInKeys(unit.rangeKeys, unit, ANY)) battle.addBuff(e, { key, duration: AURA_DUR, mods: { moveMul: Math.max(0, 1 + mx) }, source: unit, tags: ['module'] });
+          }, { owner: unit, immediate: true });
+        }
+        if (picked === S2) {
+          const ms = Math.abs(num(b2.move_speed)), radius = num(b2.range_radius, 1.3);
+          const slow = () => {
+            if (!up(unit) || !unit.skill?.active) return;
+            for (const e of battle.enemiesInKeys(unit.rangeKeys, unit, ANY)) {
+              battle.applyStrongest(e, 'ascln:s2slow', { duration: AURA_DUR, value: ms, mods: (v) => ({ moveMul: Math.max(0, 1 - v) }), source: unit });
+            }
+          };
+          if (ms > 0) {
+            battle.on('skillStart', (ctx) => { if (ctx.unit === unit) slow(); }, { owner: unit });
+            battle.every(AURA_IV, slow, { owner: unit });
+          }
+          // a ground enemy of her range knocked out ⇒ one 死亡拘审 layer on the selectable ground enemies within the radius
+          battle.on('death', (ctx) => {
+            const v = ctx.unit;
+            if (ctx.reason !== 'killed' || !v || v.side !== 'enemy' || v.isFlying || !up(unit) || !unit.skill?.active || !unit.rangeKeySet || !bodyInKeys(v, unit.rangeKeySet)) return;
+            battle.fx('aoe', { x: v.x, y: v.y, radius, id: unit.id, skill: 'ascln:endowment' });
+            for (const e of battle.foesInRadius(v.x, v.y, radius, true)) {
+              if (e !== v && !e.isFlying && canTargetEnemy(unit, e, ANY)) addDread(battle, unit, e, t0);
+            }
+          }, { owner: unit });
+        }
+        if (picked === S3) {
+          const heal = num(b3['attack@hp_ratio']);
+          installMiss(battle, unit, Math.abs(num(b3['attack@damage_hitrate_physical'])), Math.abs(num(b3['attack@damage_hitrate_magical'])), heal);
+          // 自身闪避时回复…最大生命值
+          if (heal > 0) {
+            battle.on('dodge', (ctx) => {
+              if (ctx.target !== unit || !up(unit) || !s3On(unit) || !ctx.source || ctx.source.side !== 'enemy') return;
+              battle.heal(unit, unit, unit.s.maxHp * heal, { self: true });
+            }, { owner: unit });
+          }
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,282 @@
+// server/sim/content/kits/ops/op-chen2.js — 假日威龙陈 (char_1013_chen2) 自选 operator kit: 6★ 散射手 (狙击), an owned-6★ pick
+// of the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and both modules (RPR-X 沙滩战斗套装, RPR-Y 假期的
+// 最后一天) at every form. Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)").
+//
+// Forms (data/backups.json units.char_1013_chen2): 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) — the owner's decision of 2026-10-05. Potential 0 [ASSUMED: no
+// account]. Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json); PRTS 假日威龙陈
+// (节约风气 修正 and 备注, 假日余韵 备注, S2 / S3 备注, the RPR-X stage-1 note); PRTS 作战机制 §地形TAG; PRTS 分支特性信息 散射手
+// ("可对空", the trait's 1-3 front grid); gamedata_const ba.charged (蓄力); the client's battle data read from the local
+// install — charpack char_1013_chen2 (the S2 / S3 modes: an attack plus a RangeAttack firing projectile_chr_chen2_s2 / _s3),
+// battle/prefabs [uc]projectiles projectile_chr_chen2_s2 / _s3, buff_template_data chen2_s_debuff, chen2_s_2_enhance_judge,
+// chen2_tr, chen2_t_002[spareShot], chen2_e_003_t[map_tag].
+// - Trait (散射手) "攻击范围内的所有敌人，对自己前方一横排的敌人攻击力提升至150%": the reaperrange profile — every enemy of
+//   her range, air units too, ×atk_scale (trait bb; chen2_tr AtkScaleUp) on the trait's front grid (her tile and the three
+//   ahead). RPR-X overrides it with atk_scale 1.6; RPR-Y adds "部署费用减少" (cost −8, in the stats: her redeploy after a
+//   knock-out costs 8 DP less). Ranged physical arrows; blocks 1; ground enemies target her (no flag).
+// - T1 节约风气 "在场时自身弹药类技能攻击时20%概率不消耗对应弹药，其他【狙击】干员的弹药类技能改为10%概率不消耗（同类效果取最
+//   高）": while she is on the field, an attack made by a running 弹药类技能 (PRTS 备注: a skill whose text says "攻击装有X发
+//   弹药 / 子弹" — never the 猎手 bullets) spends no ammo with that chance: hers spareshot_chen.prob, another 【狙击】
+//   operator's 20 % — PRTS 修正 (原因 "描述与游戏实际表现不符合", and the RPR-X stage-1 note "实际应为…其他【狙击】干员…20%"):
+//   the game gives the other snipers what she has, spareshot_chen.prob, not the text's / `prob`'s 10 % [the mechanism is
+//   ASSUMED; the 20 % is PRTS's]. RPR-X stage 3 (talent change; chen2_t_002[spareShot]: 【狙击】 profession ⇒ [sniper],
+//   else deploy class RANGED ⇒ [other]): herself e_spareshot_chen.prob 25 %, other 【狙击】 operators 20 %, other 远程
+//   operators 12 %. 同类效果取最高: the highest chance of every 假日威龙陈 on the field. One roll per attack ("一次性消耗多发弹药
+//   时仅进行一次判定"); a spared attack spends nothing of what it would ("强制改为实耗0发"), and every `ammoUsed` of it still
+//   fires ("不影响以'消耗弹药'为效果触发条件的侦测": the bullet is put back in that event, before the skill checks for its last
+//   bullet) — 拉特兰 / garrison counters see it.
+// - T2 假日余韵 "攻击速度+8，当场地中存在水地形时改为攻击速度+12" ([common].attack_speed 8, [map].attack_speed +4). 水地形 is
+//   a map TAG (PRTS 作战机制 §地形TAG): no level of this mode carries one (the act1 / act2 autochess level files' mapData.tags
+//   are null), so +8. RPR-Y stage 3 "攻击力+15%，攻击速度+12，当场地中存在水地形时改为攻击力+28%，攻击速度+20，技能开启时，场地
+//   视为水地形": +15 % / +12, and while her skill runs the field holds the water TAG (chen2_e_003_t[map_tag]: SetRuntimeMapTag
+//   water at ON_SKILL_START, cleared at ON_SKILL_FINISH / ON_OWNER_FINISH — one flag of the level, no count: the first
+//   holder whose skill ends clears it) — +28 % / +20 for every 假日威龙陈 of that field. The module row's [map] keys are the
+//   text's totals (20 / 0.28), the base row's [map] 4 the step over [common] 8 (8 + 4 = 12): read so.
+// - S1 高压冲击 (AUTO, attack SP, data DEFAULT — an attack skill): ATK +atk, 4 bullets (attack@trigger_time), every enemy of
+//   her range takes the trait's front-row multiplier ("对攻击范围内的所有敌人应用特性加成", as 送葬人 S1).
+// - S2 “堇青之夜” (MANUAL, data DEFAULT): ATK +atk, 8 bullets (attack@trigger_time); 蓄力 (maxChargeTime 2;
+//   chen2_s_2_enhance_judge: ≥ 2 charges at the cast ⇒ the enhanced mode, then ClearCharacterSp; ba.charged): cast with both
+//   charges stored ⇒ attack@another_trigger_time (20) bullets; every cast empties the SP. Every attack leaves slime (below).
+// - S3 “假日风暴” (MANUAL, data ACTIVE_RANGE on its 2-6): range 2-6 while it runs, ATK +atk, every attack strikes twice
+//   (MultiMeleeAttack _additionalTimes 1) and takes the trait multiplier on every enemy, leaves slime; 32 bullets, 2 per
+//   attack — PRTS 备注 "即使剩余弹药数小于2发仍可'消耗2发弹药'进行攻击；技能仅在弹药数归零后自动结束" (one `ammoUsed` per bullet).
+// - Slime (S2 / S3 "每次攻击在范围内生成持续5秒的粘液，地面敌人经过时移动速度-N%、防御力-M（不叠加）"): each attack's RangeAttack
+//   fires a projectile that lands at once on her own ground mount point in her direction and lives
+//   attack@projectile_life_time s; every 0.2 s its range selector (ground enemies, `_ignoreTargetFree`: PRTS 备注 "无视无法选
+//   择类效果（如隐匿与无敌）") gives chen2_slime for 0.25 s — move speed FINAL_SCALER ×(1 + attack@move_speed), DEF
+//   FINAL_ADDITION attack@def. Here: the tiles of her attack range at the attack hold slime for the life time (a later attack
+//   refreshes them) [ASSUMED: the projectile's selector range is her attack range — the prefab names no grid; its effect is
+//   "chen2_skill_02_range_01"], pulsed every 0.2 s; 不叠加 — one effect per 假日威龙陈 (independentCharacterSource: two of
+//   them each slow); the DEF cut is compensated for the target's DEF multipliers (a final addition). It outlives her: the
+//   projectiles are not hers to clear [ASSUMED]. Air units never (地面敌人). (Each struck ground enemy's own 0.1 s
+//   chen2_s_debuff from the attack is inside that range anyway.)
+
+import { num, talentBb, skillRec, up } from '../shared/tier1.js';
+import { bodyKeys } from '../../../body.js';
+import { aggregateMods } from '../../../buffs.js';
+
+const S1 = 'skchr_chen2_1';
+const S2 = 'skchr_chen2_2';
+const S3 = 'skchr_chen2_3';
+/** PRTS 节约风气 备注: a 弹药类技能 is one whose text says "攻击装有X发弹药" or "攻击装有X发子弹". */
+const AMMO_SKILL = /攻击装有\d+发(?:弹药|子弹)/;
+/** projectile_chr_chen2_s2 / _s3 `_interval` (the slime's selection period) and chen2_slime's lifeTime. */
+const SLIME_IV = 0.2;
+const SLIME_DUR = 0.25;
+/** Buff key of a 假日威龙陈's slime effect on an enemy (independentCharacterSource: one per source). */
+export const slimeKey = (src) => `chen2:slime#${src.id}`;
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+const count = (v, d) => Math.max(1, Math.floor(num(v, d)));
+
+// ---- T1 节约风气: one battle-wide pair of handlers over every 假日威龙陈 of the battle ------------------------------------
+/** battle → { srcs: Map(unit → { self, sniper, other }) }. */
+const SPARE = new WeakMap();
+
+/** The spare chance of `u`'s ammo-skill attack: the highest of the 假日威龙陈 on the field (同类效果取最高). */
+export function spareChance(battle, u) {
+  const st = SPARE.get(battle);
+  if (!st || !u) return 0;
+  const op = u.kind === 'op';
+  let p = 0;
+  for (const [s, v] of st.srcs) {
+    if (!up(s)) continue;
+    const q = u === s ? v.self : op && u.def?.profession === 'SNIPER' ? v.sniper : op && u.def?.position === 'RANGED' ? v.other : 0;
+    if (q > p) p = q;
+  }
+  return Math.min(1, p);
+}
+
+function installSpare(battle, unit, probs) {
+  let st = SPARE.get(battle);
+  if (!st) {
+    st = { srcs: new Map() };
+    SPARE.set(battle, st);
+    // the roll: when an attack is made by a running 弹药类技能, before its bullets are spent (skills.js onAttackPerformed
+    // runs after the `attack` hook); one roll per attack (no draw when nobody's chance applies)
+    battle.on('attack', (ctx) => {
+      const u = ctx.attacker, sk = u?.skill;
+      if (!u || u.side !== 'ally' || !sk || !sk.active || sk.kind !== 'ammo' || !AMMO_SKILL.test(String(sk.def?.description ?? ''))) return;
+      const p = spareChance(battle, u);
+      u.mem.chen2Spare = { t: battle.time, n: u.stats.attacks, proc: p > 0 && battle.rng.chance(p) };
+      if (u.mem.chen2Spare.proc) battle.fx('reload', { x: u.x, y: u.y, id: u.id });
+    }, { priority: -50 });
+    // the spared attack's every bullet goes back in its own ammoUsed event (the event itself still fires)
+    battle.on('ammoUsed', (ctx) => {
+      const u = ctx.unit, m = u?.mem?.chen2Spare, sk = ctx.skill;
+      if (!m || !m.proc || m.t !== battle.time || m.n !== u.stats.attacks || !sk || !sk.active || sk.kind !== 'ammo') return;
+      sk.ammoLeft += 1;
+    }, { priority: 100 });
+  }
+  st.srcs.set(unit, probs);
+}
+
+// ---- 水地形 TAG (RPR-Y stage 3): the level's one runtime flag ----------------------------------------------------------
+/** battle → { on } (SetRuntimeMapTag water: no count — the last set / clear wins). */
+const WATER = new WeakMap();
+/** Whether the field of `battle` counts as water terrain now (no level of the mode has the TAG of its own). */
+export const waterOn = (battle) => !!WATER.get(battle)?.on;
+function setWater(battle, on) {
+  let s = WATER.get(battle);
+  if (!s) WATER.set(battle, (s = { on: false }));
+  s.on = on;
+}
+
+/**
+ * 假日余韵's two lines: { common: { atkPct, aspd }, water: { atkPct, aspd } }. The base row's [map] value is the step over
+ * [common] (8 + 4 = the text's 12); a module row's [map] values are the text's totals (RPR-Y: 改为 +28 % / +20).
+ */
+export function holidayLines(t) {
+  const bb = t?.bb ?? {};
+  const ca = num(bb['chen2_t_2[common].atk']), cs = num(bb['chen2_t_2[common].attack_speed']);
+  const ma = num(bb['chen2_t_2[map].atk']), ms = num(bb['chen2_t_2[map].attack_speed']);
+  const total = !!t?.fromModule;
+  return { common: { atkPct: ca, aspd: cs }, water: total ? { atkPct: ma || ca, aspd: ms || cs } : { atkPct: ca + ma, aspd: cs + ms } };
+}
+
+// ---- slime (S2 / S3): one battle-wide pulse over every 假日威龙陈's slimed tiles ------------------------------------------
+/** battle → Map(source unit → Map(tileKey → { until, ms, def })). */
+const SLIME = new WeakMap();
+
+/** A source's slimed tiles (tile key → { until, ms, def }), for tests. */
+export const slimeOf = (battle, src) => SLIME.get(battle)?.get(src) ?? null;
+
+/** The enemy's DEF multiplier from every buff but `key`'s ((1 + Σ defPct) × Π defMul): a FINAL_ADDITION is divided by it. */
+function defFactor(e, key) {
+  const { add, mul } = aggregateMods(e.buffs.filter((b) => b.key !== key));
+  return Math.max(0, 1 + (add.defPct ?? 0)) * (mul.defMul ?? 1);
+}
+
+function slimeState(battle) {
+  let m = SLIME.get(battle);
+  if (m) return m;
+  m = new Map();
+  SLIME.set(battle, m);
+  // no owner: the slime outlives the unit that left it [ASSUMED]
+  battle.every(SLIME_IV, () => {
+    const now = battle.time;
+    for (const [src, tiles] of m) {
+      for (const [k, p] of tiles) if (p.until <= now + 1e-9) tiles.delete(k);
+      if (!tiles.size) continue;
+      const key = slimeKey(src);
+      for (const e of battle.enemies) {
+        // 地面敌人 only; 无视无法选择 — no targetability check (stealth, invulnerable)
+        if (!e.alive || e.hidden || !e.deployed || e.isFlying) continue;
+        let p = null;
+        for (const k of bodyKeys(e)) { p = tiles.get(k) ?? null; if (p) break; }
+        if (!p) continue;
+        const f = defFactor(e, key);
+        battle.addBuff(e, {
+          key, duration: SLIME_DUR, source: src, tags: ['skill', 'slime'],
+          mods: { moveMul: Math.max(0, 1 + p.ms), defFlat: f > 1e-6 ? p.def / f : p.def },
+        });
+      }
+    }
+  });
+  return m;
+}
+
+/** S2 / S3 onAttack: the tiles of her attack range hold her slime for life s (refreshed by every attack). */
+function leaveSlime(battle, unit, b) {
+  const life = num(b['attack@projectile_life_time'], 5), ms = num(b['attack@move_speed']), def = num(b['attack@def']);
+  if (!(life > 0) || (!ms && !def) || !unit.rangeKeys) return;
+  const m = slimeState(battle);
+  let tiles = m.get(unit);
+  if (!tiles) m.set(unit, (tiles = new Map()));
+  const fresh = !tiles.size;
+  const until = battle.time + life;
+  for (const k of unit.rangeKeys) tiles.set(k, { until, ms, def });
+  if (fresh) battle.fx('zone', { x: unit.x, y: unit.y, radius: 2, dur: life, id: unit.id, skill: 'chen2:slime' });
+}
+
+export default {
+  char_1013_chen2: (bb, chess) => {
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    const s3 = skillRec(chess, S3);
+    const t0 = talentBb(chess, 0);
+    const t1 = (chess?.talents ?? []).filter((t) => t && t.index !== -1)[1] ?? null;
+    const lines = holidayLines(t1);
+    const waterSkill = /技能开启时，场地视为水地形/.test(String(t1?.desc ?? ''));
+    const frontAll = (battle, u) => num(u.profile?.frontScale, 1.5);
+    const spare = {
+      self: num(t0['e_spareshot_chen.prob'], num(t0['spareshot_chen.prob'])),
+      sniper: num(t0['chen2_t_002[spareshot][sniper].prob'], num(t0['spareshot_chen.prob'])),
+      other: num(t0['chen2_t_002[spareshot][other].prob']),
+    };
+    const s2Charged = count(b2['attack@another_trigger_time'], 0);
+    return {
+      skills: {
+        [S1]: {
+          kind: 'ammo',
+          ammo: count(b1['attack@trigger_time'], 4),
+          mods: { atkPct: num(b1.atk) },
+          attack: { dmgMul: frontAll },
+        },
+        [S2]: {
+          kind: 'ammo',
+          ammo: count(b2['attack@trigger_time'], 8),
+          mods: { atkPct: num(b2.atk) },
+          attack: {},   // (its attacks are the skill's: isSkill)
+          onStart({ unit, skill }) {
+            // 蓄力: cast with every charge stored (activate took one) ⇒ the charged bullets; any cast spends all the SP
+            const charged = skill.maxCharges > 1 && skill.charges + 1 >= skill.maxCharges;
+            unit.mem.chen2Charged = charged;
+            if (charged && s2Charged > skill.ammoLeft) skill.addAmmo(s2Charged - skill.ammoLeft);
+            skill.charges = 0;
+            skill.sp = 0;
+          },
+          onAttack({ battle, unit }) { leaveSlime(battle, unit, b2); },
+          onEnd({ unit }) { unit.mem.chen2Charged = false; },
+        },
+        [S3]: {
+          kind: 'ammo',
+          ammo: count(b3['attack@trigger_time'], 32),
+          mods: { atkPct: num(b3.atk) },
+          targeting: s3?.rangeGrid ? { rangeGrid: s3.rangeGrid.map((p) => [p[0], p[1]]) } : undefined,
+          attack: { hits: 2, dmgMul: frontAll },
+          onAttack({ battle, unit, skill }) {
+            leaveSlime(battle, unit, b3);
+            // 每次攻击消耗2发: the second bullet (the engine spends the other one); with one left she still attacks
+            if (skill.ammoLeft > 1) {
+              skill.ammoLeft--;
+              battle.emit('ammoUsed', { unit, left: skill.ammoLeft, skill });
+            }
+          },
+        },
+      },
+      talents: [
+        { install(battle, unit) { // 节约风气
+          if (spare.self > 0 || spare.sniper > 0 || spare.other > 0) installSpare(battle, unit, spare);
+        } },
+        { install(battle, unit) { // 假日余韵: +ASPD (+ATK), the water line while the field counts as water
+          const KEY = 'talent:chen2:holiday';
+          const apply = () => {
+            const w = waterOn(battle);
+            if (unit.mem.chen2Water === w && unit.findBuff(KEY)) return;
+            unit.mem.chen2Water = w;
+            const l = w ? lines.water : lines.common;
+            const mods = {};
+            if (l.atkPct) mods.atkPct = l.atkPct;
+            if (l.aspd) mods.aspd = l.aspd;
+            if (Object.keys(mods).length) battle.addBuff(unit, { key: KEY, mods, persist: true, allowDead: true, tags: ['talent'] });
+            else battle.removeBuff(unit, KEY);
+          };
+          apply();
+          battle.on('tick', apply, { owner: unit });
+          if (!waterSkill) return;
+          // RPR-Y stage 3 "技能开启时，场地视为水地形" (chen2_e_003_t[map_tag]): set at her skill's start unless she holds it,
+          // cleared when her skill ends or she leaves — if she set it
+          const clear = () => { if (unit.mem.chen2WaterSet) { unit.mem.chen2WaterSet = false; setWater(battle, false); apply(); } };
+          battle.on('skillStart', (ctx) => {
+            if (ctx.unit !== unit || unit.mem.chen2WaterSet) return;
+            unit.mem.chen2WaterSet = true;
+            setWater(battle, true);
+            apply();
+          }, { owner: unit });
+          battle.on('skillEnd', (ctx) => { if (ctx.unit === unit) clear(); }, { owner: unit });
+          battle.on('death', (ctx) => { if (ctx.unit === unit) clear(); }, { owner: unit });
+        } },
+      ],
+    };
+  },
+};

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

@@ -0,0 +1,320 @@
+// server/sim/content/kits/ops/op-ray.js — 莱伊 (char_4117_ray) 自选 operator kit: 6★ 猎手 (狙击), an owned-6★ pick of the
+// tier-5 and tier-6 自选 slots; every skill, both talents, the trait, both modules (HUN-X 《跳舞的月光》, HUN-Y 证明什么？) at
+// every form, and the kit of her summon 沙地兽 (token_10034_ray_sndbst). Kit contract and the 自选 rules: ../README.md
+// ("How to add an operator (自选)").
+//
+// Forms (data/backups.json units.char_4117_ray): 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) — the owner's decision of 2026-10-05. Potential 0 [ASSUMED: no
+// account]. Sources: character_table / skill_table / battle_equip_table / the token's character_table row (zh_CN, as
+// built into backups.json) and PRTS 莱伊 (巡哨伙伴 / 入神 / S1 / S2 / S3 备注), PRTS 沙地兽 (备注 "持有禁疗、无敌", "退场时返还1
+// 个可部署的沙地兽", "莱伊退场时强制撤退场上的沙地兽"; its skill "仅在持有者携带技能2时才会携带"), PRTS 分支特性信息 猎手, BWIKI
+// 莱伊 ("装填间隔即为攻击间隔，初始子弹数即为最大子弹数"), PRTS 卫戍协议/帮助 (a placed summon that leaves is deployed again on
+// its tile "在满足条件后"); the client's battle data read from the local install — buff_template_data ray_tr / ray_tr_add /
+// ray_tr_sub (the magazine), ray_s_1[konckback] (Knockback _useSourceDirection, _decreaseForceLevelWhenNotInDirection 1),
+// ray_s_1[kill_add_bullet], ray_t_1[damage_scale] (PHYSICAL DamageScale on targets holding ray_sndbst_aura), ray_s_2[deck],
+// ray_s_3[reload] / [check_full] / [sp], ray_sndbst_tr / ray_sndbst_collect, and charpack char_4117_ray.
+// - Trait (猎手) "攻击时需要消耗子弹且攻击力提升至120%，不攻击时会缓慢地装填子弹（最多8发）" (trait bb value / atk_scale; the
+//   hunter profile's ×atk_scale on every bullet attack, skill attacks included). PRTS 分支特性信息 猎手: "入场时持有自身子弹上限
+//   数的子弹" — full at every deployment; "存在子弹且攻击范围内存在目标时进行攻击，不存在子弹/子弹未满且攻击范围内无目标时进行
+//   装弹，通常情况下每次装填1颗" and "装弹行为属于普通攻击行为，持续时间使用装填间隔，装填间隔默认为自身基础攻击间隔，不受攻速/
+//   攻击间隔变化影响": a reload is an action of her attack loop lasting her BASE attack time (1.6 s; ASPD never shortens it),
+//   loading one bullet when it ends — taken when the magazine is empty (targets or not) or not full with nobody to shoot.
+//   This kit's own reload (kit trait install / canAttack / afterAttack); the engine's hunter profile (1 bullet per second
+//   after 1 s without attacking) stays for 雪猎. Can hit air units (PRTS "可对空"), blocks 1, ground enemies target her.
+//   HUN-X adds "子弹数量为空时下次装填额外加装1发子弹" (trait bb extra_add): a reload begun on an empty magazine loads 1 + that.
+//   HUN-Y raises the trait to atk_scale 1.33 (and ASPD +5 / +7 in the stats).
+// - T1 巡哨伙伴 "可以在攻击范围内部署沙地兽于25秒内侦察一片区域延伸攻击范围，自身优先攻击该区域内的目标且对其造成的物理伤害提
+//   高15%" (bb damage_scale; HUN-X stage 3: 20 % and "沙地兽的再部署时间-10秒" — the token's module stats, respawn 20 s).
+//   PRTS 备注: "攻击范围内" of her attacks, talents and skills means "自己或自己的召唤物的攻击范围内" — while a 沙地兽 scouts,
+//   the enemies of its x-4 (3×3) are in her range (Battle.setExtraRange) and in her skills' trigger range
+//   (skill.addTriggerRange); she picks a target of that area before any other (after the ones she blocks); her physical
+//   damage on an enemy there ×(1 + damage_scale) ("伤害倍率提升": DamageInfo mul).
+//   The 沙地兽 is a hand piece the player places in her range (data ownerRange): it deploys with the board, scouts for the
+//   token talent's `duration` (25 s) and then leaves [ASSUMED: the scouting ends with its stay — PRTS "退场时返还1个可部署
+//   的沙地兽"]; it is untargetable (its trait text), 无敌 and 禁疗 (PRTS 备注), makes no attack (实体类型 装置) [ASSUMED], and
+//   is withdrawn when 莱伊 leaves the field (PRTS 备注). A 沙地兽 that left comes back on its tile once its redeploy time
+//   (×(1 + S2 respawn_time) while 广域警觉 runs) has passed, paying its cost (3 DP), while 莱伊 is on the field.
+// - T2 入神 "攻击相同目标时每次攻击提高自身攻击力8%，最多3层" (bb atk / max_stack_cnt; HUN-Y stage 3: 9 %, 4 layers). PRTS 备注:
+//   "每次攻击前：若目标与上次攻击目标不同，失去之前获得的增益；随后获得一层增益，持续时间无限" — before each attack (the special
+//   bullet of S1 too; never a reload), lost on a new target, gone when she leaves the field.
+// - S1 脱身矢 (MANUAL, 2 charges, data DEFAULT): "立即用额外特殊子弹攻击目标，造成相当于攻击力N%的物理伤害并将其中等力度地推开，
+//   若将其击倒则使下次装填额外加装1发子弹". PRTS 备注: "'额外特殊子弹'实际为无需消耗子弹的一次攻击，可受特性加成" — an attack
+//   at once (Battle.forceAttack; the cast's normal attack follows as usual) at atk_scale × ATK × the trait scale that takes no
+//   bullet; a 中力 (bb force) push along her facing, radial at 力度 −1 when the target is off it (PRTS "推动方向默认为自身朝
+//   向，因角度过大变为径向推力时，力度仅-1": the engine's directional rule with a −1 instead of −2); a kill adds bb cnt bullets
+//   to the next reload ("额外装填效果可叠加并于下1次装填时一同生效"). With an empty magazine (no attack to wait for) the cast
+//   comes as soon as an enemy is in range [ASSUMED, as 雪猎's special bullets]. The 地穴 clause has nothing to act on here.
+// - S2 广域警觉 (AUTO, attack SP; 持续时间无限 — a toggle): range 4-10, ATK +atk, the 沙地兽's redeploy time ×(1 +
+//   respawn_time). Self / summon effects only: it fires at full SP (`trigger: 'SP_FULL'`, the owner's AUTO rule).
+//   Passive "沙地兽撤退时回收命中该区域的子弹": while she carries S2, the bullets of her attacks that hit an enemy inside a
+//   scouting 沙地兽's area are counted (its own counter: ≤ its trait value 8 — ray_sndbst_tr) and come back to her magazine
+//   when it leaves, while she is on the field (ray_sndbst_collect → ray_tr_add: HUN-X's extra_add first on an empty
+//   magazine, capped at her maximum); S1's special bullet is no bullet. PRTS "装弹行为不触发攻击回复": no reload gives
+//   attack SP.
+// - S3 “得见光芒” (MANUAL, 16 s, data ACTIVE_RANGE on its 3-8): "立即停止攻击直至子弹装满，装填间隔大幅缩短(-1.2)": at the cast
+//   she stops attacking and reloads (a reload under way is cut to the new interval) until her magazine is full, every reload
+//   while it runs lasting base attack time + reload_interval (0.4 s); range 3-8; every attack attack@atk_scale × ATK
+//   (× the trait scale) and 束缚 (bind) attack@unmove_duration s; a kill of hers during it ⇒ +sp SP when it ends, through
+//   阻回 (PRTS 备注 "获得技力效果无视阻回").
+
+import { num, talentBb, traitBb, skillRec, up } from '../shared/tier1.js';
+import { acquireTargets, effectiveProfile } from '../../../ai.js';
+import { sortEnemyTargets } from '../../../targeting.js';
+import { bodyInKeys } from '../../../body.js';
+import { PUSH_DIRECTIONAL_MIN_DIST } from '../../../constants.js';
+
+const S1 = 'skchr_ray_1';
+const S2 = 'skchr_ray_2';
+const S3 = 'skchr_ray_3';
+export const SANDBEAST = 'token_10034_ray_sndbst';
+/** 巡哨伙伴 (E2): the 沙地兽's scouting when its def carries no duration (PRTS: "持续25秒"). */
+const LIFE_FALLBACK = 25;
+/** Seconds between two tries of a 沙地兽 that left to come back (tile busy, DP short, 莱伊 away). */
+const RETRY = 0.25;
+/** Tag of S1's special bullet (no bullet of the magazine). */
+export const SPECIAL_TAG = 'ray:special';
+const TRANCE_KEY = 'talent:ray:trance';
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+/** The magazine of the trait ("最多8发"). */
+const ammoMax = (unit) => Math.max(1, Math.floor(num(unit.profile?.ammoMax, 8)));
+/** First talent of a normalised token def holding `key` (token talents keep no index). */
+const tokTalent = (def, key) => (def?.talents ?? []).find((t) => t && t.bb && t.bb[key] != null) ?? null;
+
+/** The 沙地兽's kit: no attack, 无敌, 禁疗 (its untargetability comes from its trait text, simdata normalizeToken). */
+function sandbeastKit() {
+  return {
+    skill: null,
+    trait: { noAttack: true },
+    talents: [],
+    install(battle, t) {
+      battle.addBuff(t, { key: 'ray:sandbeast', flags: { invulnerable: true, noHeal: true }, persist: true, allowDead: true });
+    },
+  };
+}
+
+export default {
+  char_4117_ray: (bb, chess) => {
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    const s2 = skillRec(chess, S2), s3 = skillRec(chess, S3);
+    const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
+    const extraAdd = Math.max(0, Math.floor(num(traitBb(chess).extra_add)));
+    const picked = chess?.skill?.skillId ?? null;
+    const tokenId = (chess?.talents ?? []).find((t) => t && t.tokenKey)?.tokenKey ?? SANDBEAST;
+
+    /** One reload: her base attack time, S3's reload_interval while it runs (PRTS: ASPD never changes it). */
+    const reloadInterval = (unit) => {
+      const s3on = !!(unit.skill && unit.skill.active && unit.skill.id === S3);
+      return Math.max(0.05, num(unit.base?.bat, 1.6) + (s3on ? num(b3.reload_interval) : 0));
+    };
+    const startReload = (unit) => {
+      const m = unit.mem;
+      m.rayReloading = true;
+      if ((unit.trait.ammo ?? 0) <= 0 && extraAdd > 0) m.rayLoadExtra = (m.rayLoadExtra ?? 0) + extraAdd;   // HUN-X
+      unit.atkCd = reloadInterval(unit);
+    };
+    const finishReload = (unit) => {
+      const m = unit.mem;
+      m.rayReloading = false;
+      const add = 1 + Math.max(0, Math.floor(num(m.rayLoadExtra)));
+      m.rayLoadExtra = 0;
+      unit.trait.ammo = Math.min(ammoMax(unit), (unit.trait.ammo ?? 0) + add);
+    };
+    const resetTrait = (unit) => {
+      unit.trait.ammo = ammoMax(unit);
+      Object.assign(unit.mem, { rayReloading: false, rayLoadExtra: 0, rayFill: false });
+    };
+
+    return {
+      trait: {
+        // 猎手 (PRTS 分支特性信息): her own reload, an action of the attack loop (canAttack runs once the cooldown is over)
+        install(battle, unit) {
+          resetTrait(unit);
+          battle.on('deploy', (ctx) => { if (ctx.unit === unit) resetTrait(unit); }, { owner: unit });
+        },
+        canAttack(battle, unit) {
+          const m = unit.mem;
+          if (m.rayReloading) finishReload(unit);
+          const max = ammoMax(unit), ammo = unit.trait.ammo ?? 0;
+          if (m.rayFill) {   // S3: no attack until the magazine is full
+            if (ammo < max) { startReload(unit); return false; }
+            m.rayFill = false;
+          }
+          if (ammo <= 0 || (ammo < max && !acquireTargets(battle, unit, effectiveProfile(unit)).length)) { startReload(unit); return false; }
+          return true;
+        },
+        afterAttack(battle, unit) { unit.trait.ammo = Math.max(0, (unit.trait.ammo ?? 0) - 1); },
+      },
+      skills: {
+        [S1]: {
+          kind: num(skillRec(chess, S1)?.maxChargeTime, 1) > 1 ? 'charges' : 'instant',
+          // the special bullet: an attack that spends no bullet (its own afterAttack) and takes the trait scale
+          attack: {
+            atkScale: num(b1.atk_scale, 1),
+            tags: ['skill', SPECIAL_TAG],
+            afterAttack() {},
+            onHit({ battle, unit, target }) {
+              if (!target) return;
+              if (!target.alive) { unit.mem.rayLoadExtra = num(unit.mem.rayLoadExtra) + Math.max(0, Math.floor(num(b1.cnt, 1))); return; }
+              const force = num(b1.force, 1);
+              const [fr, fc] = unit.fwd;
+              const vx = target.x - unit.x, vy = target.y - unit.y, d = Math.hypot(vx, vy);
+              if (d >= PUSH_DIRECTIONAL_MIN_DIST && vx * fc + vy * fr >= d * Math.SQRT1_2) battle.push(target, force, { from: unit, dir: { x: fc, y: fr }, fixed: true });
+              else battle.push(target, force - 1, { from: unit });
+            },
+          },
+          onStart({ battle, skill, unit }) {
+            if (battle.forceAttack(unit)) return;
+            // nobody to shoot after all: no cast
+            skill.pending = false;
+            skill.addCharge(1);
+          },
+        },
+        [S2]: {
+          kind: 'toggle',
+          trigger: 'SP_FULL',
+          mods: { atkPct: num(b2.atk) },
+          targeting: s2?.rangeGrid ? { rangeGrid: s2.rangeGrid.map((p) => [p[0], p[1]]) } : undefined,
+        },
+        [S3]: {
+          kind: 'duration',
+          targeting: s3?.rangeGrid ? { rangeGrid: s3.rangeGrid.map((p) => [p[0], p[1]]) } : undefined,
+          attack: {
+            atkScale: num(b3['attack@atk_scale'], 1),
+            onHit({ battle, unit, target }) {
+              if (target && target.alive) battle.applyStatus(target, 'bind', { duration: num(b3['attack@unmove_duration'], 2), source: unit });
+            },
+          },
+          onStart({ unit }) {
+            const m = unit.mem;
+            m.rayFill = true;
+            m.rayKilled = false;
+            // 立即停止攻击: the reload starts now (one under way is cut to the new interval)
+            unit.atkCd = m.rayReloading ? Math.min(unit.atkCd, reloadInterval(unit)) : 0;
+          },
+          onEnd({ unit, reason }) {
+            const m = unit.mem;
+            m.rayFill = false;
+            if (m.rayKilled && reason !== 'death' && up(unit) && unit.skill) unit.skill.gainSp(num(b3.sp), 'init');   // 无视阻回
+            m.rayKilled = false;
+          },
+        },
+      },
+      talents: [
+        { install(battle, unit) { // 巡哨伙伴 + the 沙地兽 (and S2's bullet recovery)
+          const m = unit.mem;
+          const mine = (t) => !!t && t.kind === 'token' && t.defId === tokenId && t.ownerUnit === unit;
+          // her placed 沙地兽 pieces run the 沙地兽's kit (set up here, before the battle starts — as 鸿雪's 打字机)
+          for (const t of battle.allyUnits) {
+            if (!mine(t) || t.alive || t.deployed) continue;
+            if (t.kit) battle.offOwner(t);
+            battle._setupUnit(t, sandbeastKit());
+          }
+          const ds = num(t0.damage_scale);
+          m.rayArea = null;
+          m.rayBullets = 0;
+          if (unit.skill) unit.skill.addTriggerRange(() => (m.rayAreaKeys ? [m.rayAreaKeys] : []));
+          const endArea = () => { m.rayArea = null; m.rayAreaKeys = null; m.rayBeast = null; battle.setExtraRange(unit, null); };
+          battle.on('deploy', (ctx) => {
+            const t = ctx.unit;
+            if (!mine(t)) return;
+            const life = num(tokTalent(t.def, 'duration')?.bb?.duration, LIFE_FALLBACK);
+            m.rayBeast = t;
+            m.rayAreaKeys = [...t.rangeKeys];
+            m.rayArea = new Set(m.rayAreaKeys);
+            m.rayBullets = 0;
+            m.rayCounted = 0;
+            battle.setExtraRange(unit, m.rayAreaKeys);
+            const seq = t.deploySeq;
+            battle.after(life, () => { if (t.alive && t.deploySeq === seq) battle.retreat(t, { reason: 'expired', permanent: true }); }, { owner: unit });
+          }, { owner: unit });
+          battle.on('death', (ctx) => {
+            const t = ctx.unit;
+            if (t === unit) { // "莱伊退场时强制撤退场上的沙地兽"
+              for (const x of battle.allyUnits) if (mine(x) && x.alive) battle.retreat(x, { reason: 'retreat', permanent: true });
+              return;
+            }
+            if (!mine(t) || battle.finished) return;
+            t.removed = false; // the piece stays (Battle.redeploy needs it; its hooks are kept)
+            if (m.rayBeast === t) endArea();
+            // S2 passive: the bullets that hit in its area come back (ray_sndbst_collect → ray_tr_add: its count — ≤ its own
+            // trait value — onto her magazine, HUN-X's extra_add first when she is empty, capped at her maximum)
+            if (picked === S2 && m.rayBullets > 0 && up(unit)) {
+              const back = Math.min(m.rayBullets, Math.max(1, Math.floor(num(t.def?.traitBb?.value, ammoMax(unit)))));
+              const empty = (unit.trait.ammo ?? 0) <= 0 ? extraAdd : 0;
+              unit.trait.ammo = Math.min(ammoMax(unit), (unit.trait.ammo ?? 0) + empty + back);
+            }
+            m.rayBullets = 0;
+            const left = battle.time;
+            battle.every(RETRY, (b, sched) => {
+              if (t.alive || t.removed || b.finished) { sched.cancel(); return; }
+              const mul = unit.skill && unit.skill.active && unit.skill.id === S2 ? Math.max(0, 1 + num(b2.respawn_time)) : 1;
+              if (b.time + 1e-9 < left + Math.max(0, num(t.base.respawnTime)) * mul || !up(unit)) return;
+              if (b.redeploy(t, { free: false })) sched.cancel();
+            }, { owner: unit });
+          }, { owner: unit, priority: -10 });
+          // 自身优先攻击该区域内的目标 (after the enemies she blocks)
+          battle.on('beforeAttack', (ctx) => {
+            if (ctx.attacker !== unit || !m.rayArea || !ctx.targets.length) return;
+            const area = m.rayArea, prof = ctx.profile ?? unit.profile;
+            const all = battle.enemiesInKeys(unit.rangeKeys, unit, prof);
+            for (const e of battle.blockedTargets(unit, prof)) if (!all.includes(e)) all.push(e);
+            if (!all.some((e) => bodyInKeys(e, area))) return;
+            sortEnemyTargets(battle, unit, all, prof.priority ?? null);
+            const rank = (e) => (e.blockedBy === unit ? 0 : bodyInKeys(e, area) ? 1 : 2);
+            const order = all.map((e, i) => ({ e, i, r: rank(e) })).sort((a, b) => a.r - b.r || a.i - b.i).map((x) => x.e);
+            ctx.targets = order.slice(0, ctx.targets.length);
+          }, { owner: unit, priority: 10 });
+          // ×(1 + damage_scale) on her physical damage to an enemy of the area
+          if (ds > 0) {
+            battle.on('hit', (ctx) => {
+              if (ctx.source !== unit || !m.rayArea || !ctx.target || ctx.target.side !== 'enemy' || ctx.dmg.type !== 'phys') return;
+              if (bodyInKeys(ctx.target, m.rayArea)) ctx.dmg.mul *= 1 + ds;
+            }, { owner: unit });
+          }
+          // S2 passive: count the bullets of her attacks that hit an enemy of the area (one per attack)
+          if (picked === S2) {
+            battle.on('damaged', (ctx) => {
+              const d = ctx.dmg, e = ctx.target;
+              if (ctx.source !== unit || !m.rayArea || !d || !d.isAttack || !e || e.side !== 'enemy' || (d.tags && d.tags.includes(SPECIAL_TAG))) return;
+              if ((d.attackId && d.attackId === m.rayCounted) || !bodyInKeys(e, m.rayArea)) return;
+              m.rayCounted = d.attackId;
+              m.rayBullets++;
+            }, { owner: unit });
+          }
+        } },
+        { install(battle, unit) { // 入神: +atk per attack on the same target (≤ max_stack_cnt), lost on a new target
+          const atk = num(t1.atk), max = Math.max(1, Math.floor(num(t1.max_stack_cnt, 3)));
+          if (!(atk > 0)) return;
+          const m = unit.mem;
+          m.rayTrance = null;
+          m.rayStacks = 0;
+          battle.on('deploy', (ctx) => { if (ctx.unit === unit) { m.rayTrance = null; m.rayStacks = 0; } }, { owner: unit });
+          battle.on('beforeAttack', (ctx) => {
+            const t = ctx.attacker === unit ? ctx.targets[0] : null;
+            if (!t) return;
+            if (m.rayTrance !== t) { m.rayTrance = t; m.rayStacks = 0; }
+            m.rayStacks = Math.min(max, m.rayStacks + 1);
+            battle.addBuff(unit, { key: TRANCE_KEY, mods: { atkPct: atk * m.rayStacks }, tags: ['talent'] });
+          }, { owner: unit, priority: -10 });
+        } },
+      ],
+      install(battle, unit) {
+        // S3: 技能期间若击倒敌人 — a kill of hers while it runs
+        if (picked === S3) {
+          battle.on('kill', (ctx) => {
+            if (ctx.killer === unit && unit.skill && unit.skill.active && unit.skill.id === S3) unit.mem.rayKilled = true;
+          }, { owner: unit });
+        }
+        // S1 with an empty magazine (the attack loop only reloads then): cast once an enemy is in range [ASSUMED]
+        if (picked !== S1) return;
+        battle.on('tick', () => {
+          const sk = unit.skill;
+          if (!up(unit) || !unit.canAct || !sk || !sk.ready || sk.pending || sk.opCooling || unit.s.flags.silence || unit.s.flags.disarm) return;
+          if ((unit.trait.ammo ?? 1) > 0) return;
+          if (acquireTargets(battle, unit, effectiveProfile(unit)).length) sk.activate('DEFAULT');
+        }, { owner: unit });
+      },
+    };
+  },
+};

test/content/op_ascln.test.js

@@ -0,0 +1,311 @@
+// test/content/op_ascln.test.js — the 自选 operator kit of 阿斯卡纶 (char_4132_ascln, 6★ 伏击客; kit
+// server/sim/content/kits/ops/op-ascln.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, AMB-X
+// “无形，无情” or AMB-Y “阿斯卡纶的眼睛” at stage 1 (tier 5) / 3 (tier 6). Numbers from data/backups.json; the fidelity
+// checklist of kits/README.md.
+// Run: node --test test/content/op_ascln.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';
+import { dreadKey, DREAD_TAG } from '../../server/sim/content/kits/ops/op-ascln.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 ASC = 'char_4132_ascln';
+const FORMS = BACKUPS.units[ASC].forms;
+const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
+const AX = 'uniequip_002_ascln', AY = 'uniequip_003_ascln';
+const S1 = 'skchr_ascln_1', S2 = 'skchr_ascln_2', S3 = 'skchr_ascln_3';
+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_weak: dummy('enemy_weak', { hp: 10 }),
+  enemy_hitter: dummy('enemy_hitter', { atk: 200, range: 1.5, bat: 0.5 }),
+  enemy_walkslow: enemyRec({ key: 'enemy_walkslow', hp: 1e9, speed: 1, mass: 0 }),
+};
+const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, AX, AY].map((m) => [t, true, m]))];
+const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
+
+/** 阿斯卡纶 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', 'skillStart', 'skillEnd', 'statusApplied', 'death', 'attack', 'heal', 'dodge'], captureNoisy: true,
+    units: [{ uid: 1, diy: { slot: SLOT[tier], charId: ASC, 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);
+function done(h) {
+  checkInvariants(h.b);
+  assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
+}
+/** Keep her from casting (no SP). */
+function noSkill(h, u) {
+  u.skill.charges = 0; u.skill.sp = 0;
+  h.b.addBuff(u, { key: 'test:noSp', flags: { noSp: true } });
+}
+
+test('阿斯卡纶 in every 自选 form: her kit (all three skills authored), the form\'s stats + module attributes, y-1, 伏击客 (melee, every enemy in range, ground only, 50 % / AMB-Y 65 % dodge, taunt level −1 — not −2), blocks 0, the data triggers; offered as a pick', () => {
+  assert.equal(OPERATOR_KITS[ASC], KITS[ASC]);
+  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], [ASC, 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), 30], `${label(f)}: stats`);
+      assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.canHitFly, u.profile.dmgType, u.profile.allInRange, u.profile.sub, u.base.bat],
+        [0, 'melee', false, 'phys', true, 'stalker', 3.5], `${label(f)}: 伏击客`);
+      const p = mod === AY ? 0.65 : 0.5;
+      assert.deepEqual([u.s.dodgePhys, u.s.dodgeArts, u.s.taunt], [p, p, -1], `${label(f)}: dodge, taunt −1`);
+      assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: y-1`);
+      assert.equal(u.skill.rule, form.skills[skill].trigger.rule, `${label(f)}: the data's trigger`);
+      assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth && !u.s.flags.untargetable, `${label(f)}: ground enemies can target her`);
+      done(h);
+    }
+  }
+  assert.deepEqual(formOf(6, true).skills.map((s) => s.trigger.rule), ['DEFAULT', 'DEFAULT', 'ACTIVE_RANGE']);
+  assert.deepEqual([modOf(5, AX).attr, modOf(6, AX).attr, modOf(5, AY).attr, modOf(6, AY).attr],
+    [{ maxHp: 180, atk: 15 }, { maxHp: 270, atk: 53 }, { atk: 55, def: 25 }, { atk: 80, def: 60 }]);
+  const data = { chess: CHESS, backups: BACKUPS };
+  assert.ok(KITTED_CHARS.includes(ASC) && [5, 6].every((t) => diyPool(t, { data, kitted: KITTED_CHARS }).includes(ASC)));
+  assert.equal(validateDiyPicks({ [SLOT[6]]: { charId: ASC, skillIndex: 2, uniEquipId: AX } }, { data, kitted: KITTED_CHARS }).ok, true);
+});
+
+test('trait 伏击客: one attack strikes every ground enemy of her y-1 at once (physical), never a flyer; her dodge lets 50 % (AMB-Y 65 %) of the enemy hits through as dodges', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [6, true, AY]]) {
+    const { h, u } = field({ tier, elite, mod, skill: 1 });
+    noSkill(h, u);
+    const a = h.spawn('enemy_dummy', { pos: [10, 6] }), b = h.spawn('enemy_dummy', { pos: [11, 4] }), c = h.spawn('enemy_dummy', { pos: [10, 7] });
+    const fly = h.spawn('enemy_fly', { pos: [9, 5] });
+    assert.ok(h.runUntil(() => atkHits(h, u).length >= 3, 6));
+    const id = atkHits(h, u)[0].dmg.attackId;
+    const hit = atkHits(h, u).filter((x) => x.dmg.attackId === id);
+    assert.deepEqual(new Set(hit.map((x) => x.target)), new Set([a, b, c]), `T${tier}: every ground enemy of y-1 ([0,2] included)`);
+    for (const x of hit) assert.equal(x.type, 'phys');
+    assert.ok(!atkHits(h, u).some((x) => x.target === fly), 'never the flyer');
+    // her dodge
+    const hitter = h.spawn('enemy_hitter', { pos: [10, 6] });
+    h.b.addBuff(u, { key: 'test:inv', mods: { defFlat: 1e6 } });
+    h.run(200);
+    const dodged = h.hooksOf('dodge').filter((x) => x.target === u && x.source === hitter).length;
+    const landed = h.hooksOf('damaged').filter((x) => x.target === u && x.source === hitter).length;
+    const r = dodged / (dodged + landed);
+    assert.ok(dodged + landed > 200 && Math.abs(r - (mod === AY ? 0.65 : 0.5)) < 0.06, `T${tier}: dodge rate ${r}`);
+    done(h);
+  }
+});
+
+test('T1 死亡拘审: every hit of her attacks adds a layer (≤ 3, the duration reset): move ×(1 − 0.18 × layers), layers × 10 % of her current ATK as arts every second (法术持续伤害: not dodgeable) for 25 s; AMB-X stage 3: 11 %, 30 s; all of it ends the moment she leaves', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [5, true, AX], [6, true, AX], [6, true, AY]]) {
+    const x3 = tier === 6 && mod === AX;
+    const tb = (elite ? formOf(tier, true) : formOf(tier, elite)).talents.find((t) => t.index === 0).bb;
+    const [ratio, dur] = x3 ? [0.11, 30] : [0.1, 25];
+    if (!x3) assert.deepEqual(tb, { move_speed: -0.18, atk_ratio: 0.1, max_stack_cnt: 3, debuff_duration: 25, interval: 1 });
+    else assert.deepEqual(modOf(6, AX).talentChanges.find((t) => t.talentIndex === 0).bb, { move_speed: -0.18, atk_ratio: 0.11, max_stack_cnt: 3, debuff_duration: 30, interval: 1 });
+    const { h, u } = field({ tier, elite, mod, skill: 1 });
+    noSkill(h, u);
+    const e = h.spawn('enemy_dummy', { pos: [10, 6] });
+    h.b.addBuff(e, { key: 'test:dodge', mods: { dodgePhys: 1, dodgeArts: 1 } });
+    const key = dreadKey(u);
+    // a dodged attack lands nothing and adds nothing
+    h.run(4);
+    assert.equal(e.findBuff(key), null, `${label([tier, elite, mod])}: dodged hits add no layer`);
+    h.b.removeBuff(e, 'test:dodge');
+    const n0 = atkHits(h, u).length;
+    assert.ok(h.runUntil(() => atkHits(h, u).length > n0, 5));
+    let b = e.findBuff(key);
+    assert.deepEqual([b.data.n, b.duration], [1, dur], 'one layer');
+    approx(b.mods.moveMul, 0.82, 'move ×0.82');
+    // its ticks: 10 % × layers of her current ATK, arts, not dodgeable
+    const ticks = () => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg.tags?.includes(DREAD_TAG));
+    h.run(1.05);
+    const t1 = ticks();
+    assert.ok(t1.length >= 1, 'a tick');
+    approx(t1[0].amount, u.s.atk * ratio * 1, `${label([tier, elite, mod])}: ${ratio * 100} % ATK × 1`);
+    assert.deepEqual([t1[0].type, t1[0].dmg.canDodge, t1[0].dmg.isAttack], ['arts', false, false]);
+    assert.ok(h.runUntil(() => e.findBuff(key)?.data.n === 3, 15), 'three layers');
+    b = e.findBuff(key);
+    approx(b.mods.moveMul, 1 - 0.18 * 3, 'move ×0.46');
+    h.run(5);
+    assert.equal(e.findBuff(key).data.n, 3, '≤ 3 layers');
+    const last = ticks().slice(-1)[0];
+    approx(last.amount, u.s.atk * ratio * 3, 'three layers tick ×3');
+    approx(e.findBuff(key).timeLeft, dur, 'reset on each hit', 0.15);
+    // no more hits: it runs out after its duration
+    h.b.addBuff(u, { key: 'test:disarm', flags: { disarm: true } });
+    const tLast = atkHits(h, u).filter((c) => c.target === e).slice(-1)[0].t;
+    h.run(tLast + dur - 0.3 - h.b.time);
+    assert.ok(e.findBuff(key), 'still there');
+    h.run(0.6);
+    assert.equal(e.findBuff(key), null, `gone ${dur} s after the last hit`);
+    // she leaves: every layer of hers ends at once
+    h.b.removeBuff(u, 'test:disarm');
+    h.runUntil(() => e.findBuff(key), 5);
+    h.b.retreat(u);
+    assert.equal(e.findBuff(key), null, 'ends the moment she leaves');
+    done(h);
+  }
+});
+
+test('T2 噬光残影: ASPD +8; +6 more with 高台 (HIGHLAND) among the four tiles next to her — the ranged wall on her left, the forbidden rim below', () => {
+  for (const [row, col, high] of [[10, 5, false], [10, 3, true], [12, 6, true], [11, 5, false]]) {
+    const { h, u } = field({ tier: 6, elite: true, skill: 1, row, col });
+    approx(u.s.aspd, 100 + 8 + (high ? 6 : 0), `(${row},${col}): ASPD`);
+    approx(u.s.interval, 3.5 * 100 / u.s.aspd, 'interval');
+    done(h);
+  }
+  assert.deepEqual(FORMS['2/1/4/0'].talents.find((t) => t.index === 1).bb, { attack_speed: 8, attack_speed_add: 6, cnt: 1 });
+});
+
+test('S1 追袭 (AUTO, 2 / 3 charges, data DEFAULT): the next attack strikes every enemy of her range twice at 130 % / 170 % ATK — two 死亡拘审 layers', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S1);
+    assert.deepEqual([sk.spCost, sk.initSp, sk.maxChargeTime, sk.bb.atk_scale, sk.skillType], elite ? [8, 4, 3, 1.7, 'AUTO'] : [10, 2, 2, 1.3, 'AUTO'], `T${tier}`);
+    const { h, u } = field({ tier, elite, skill: 0 });
+    assert.deepEqual([u.skill.kind, u.skill.rule, u.skill.maxCharges], ['charges', 'DEFAULT', elite ? 3 : 2]);
+    const a = h.spawn('enemy_dummy', { pos: [10, 6] }), b = h.spawn('enemy_dummy', { pos: [11, 5] });
+    u.skill.gainSp(999);
+    assert.ok(h.runUntil(() => u.skill.activations === 1, 3), `T${tier}: cast on her next attack`);
+    h.step();
+    const hits = atkHits(h, u).filter((c) => c.dmg.isSkill);
+    assert.equal(hits.length, 4, `T${tier}: 2 enemies × 2 strikes`);
+    for (const c of hits) approx(c.amount, u.s.atk * sk.bb.atk_scale, `T${tier}: ×${sk.bb.atk_scale}`);
+    assert.deepEqual([a.findBuff(dreadKey(u)).data.n, b.findBuff(dreadKey(u)).data.n], [2, 2], `T${tier}: two layers each`);
+    assert.equal(u.skill.charges, u.skill.maxCharges - 1, 'one charge spent');
+    done(h);
+  }
+});
+
+test('S2 恩赐 (MANUAL, 35 s, data DEFAULT): ATK +50 % / +90 %; every enemy of her range — air units too (PRTS 修正) — moves ×0.7 / ×0.6; a ground enemy of her range knocked out gives one 死亡拘审 layer to the ground enemies within 1.3 of it (not flyers, not beyond)', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S2);
+    assert.deepEqual([sk.duration, sk.spCost, sk.initSp, sk.bb.atk, sk.bb.move_speed, sk.bb.range_radius], [35, elite ? 24 : 27, elite ? 10 : 5, elite ? 0.9 : 0.5, elite ? -0.4 : -0.3, 1.3], `T${tier}`);
+    const { h, u } = field({ tier, elite, skill: 1 });
+    assert.deepEqual([u.skill.kind, u.skill.rule], ['duration', 'DEFAULT']);
+    const weak = h.spawn('enemy_weak', { pos: [10, 6] });
+    h.b.addBuff(weak, { key: 'test:dodge', mods: { dodgePhys: 1 } });
+    const near = h.spawn('enemy_dummy', { pos: [11, 6] });   // 1 tile from it, in her range too
+    const fly = h.spawn('enemy_fly', { pos: [10, 7] });      // in her range (air), 1 tile from it
+    const out = h.spawn('enemy_dummy', { pos: [9, 8] });     // outside her range, √5 from it
+    h.b.addBuff(near, { key: 'test:dodge', mods: { dodgePhys: 1 } });
+    u.skill.gainSp(999);
+    assert.ok(h.runUntil(() => u.skill.active, 5), `T${tier}: cast`);
+    approx(u.skill.timeLeft, 35, '35 s', 0.01);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
+    h.run(0.3);
+    for (const e of [weak, near, fly]) approx(e.findBuff('ascln:s2slow')?.mods.moveMul ?? 1, 1 + sk.bb.move_speed, `T${tier}: ${e.defId} slowed`);
+    assert.equal(out.findBuff('ascln:s2slow'), null, 'not outside her range');
+    // the knock-out: one layer on the ground enemy next to it; the flyer and the far one get none
+    h.b.removeBuff(weak, 'test:dodge');
+    assert.ok(h.runUntil(() => !weak.alive, 10), 'knocked out');
+    assert.equal(near.findBuff(dreadKey(u))?.data.n, 1, `T${tier}: a layer on the ground enemy within 1.3`);
+    assert.equal(fly.findBuff(dreadKey(u)), null, 'never a flyer');
+    assert.equal(out.findBuff(dreadKey(u)), null, 'not beyond 1.3');
+    u.skill.extend(-999);
+    h.step(2);
+    h.run(0.5);
+    assert.equal(near.findBuff('ascln:s2slow'), null, `T${tier}: the slow ends with the skill`);
+    done(h);
+  }
+});
+
+test('S3 降临 (MANUAL, 45 s, data ACTIVE_RANGE on y-10): an enemy only on y-10 casts it; range y-10; ATK +20 %, interval 3.5 − 1.2 / 1.5 s, taunt level −1 → +1; ground enemies of her range miss 15 % / 30 % of their attacks (one roll per attack), and a miss on her or a dodge of hers heals 4 % / 5 % of her max HP', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S3);
+    assert.deepEqual([sk.duration, sk.spCost, sk.initSp, sk.bb.atk, sk.bb.base_attack_time, sk.bb.taunt_level, sk.bb['attack@hp_ratio'], sk.bb['attack@damage_hitrate_physical'], sk.rangeId],
+      [45, elite ? 49 : 53, elite ? 30 : 25, 0.2, elite ? -1.5 : -1.2, 2, elite ? 0.05 : 0.04, elite ? -0.3 : -0.15, 'y-10'], `T${tier}`);
+    const { h, u } = field({ tier, elite, skill: 2 });
+    assert.deepEqual([u.skill.kind, u.skill.rule], ['duration', 'ACTIVE_RANGE']);
+    u.skill.gainSp(999);
+    const far = h.spawn('enemy_dummy', { pos: [12, 5] });   // [2,0]: in y-10, not in y-1
+    assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: cast for [2,0]`);
+    assert.deepEqual(u.liveRangeGrid, sk.rangeGrid, `T${tier}: y-10 while it runs`);
+    approx(u.s.atk, u.base.atk * 1.2, 'ATK +20 %');
+    approx(u.s.interval, (3.5 + sk.bb.base_attack_time) * 100 / u.s.aspd, 'interval');
+    assert.equal(u.s.taunt, 1, 'taunt level +1');
+    h.b.kill(far, null);
+    // a ground hitter in her range: count its attacks before and after the 命中率 roll
+    const hitter = h.spawn('enemy_hitter', { pos: [10, 6] });
+    h.b.addBuff(hitter, { key: 'test:dodge', mods: { dodgePhys: 1 } });   // she never kills it
+    const seen = new Set(), passed = new Set();
+    h.b.on('hit', (c) => { if (c.source === hitter && c.dmg.isAttack) seen.add(c.dmg.attackId); }, { priority: 295 });
+    h.b.on('hit', (c) => { if (c.source === hitter && c.dmg.isAttack && !c.dmg.cancel) passed.add(c.dmg.attackId); }, { priority: 280 });
+    h.b.on('fatal', (c) => { if (c.unit === u) c.prevented = true; });
+    h.b.addBuff(u, { key: 'test:tough', mods: { defFlat: 1e6 } });
+    const heals0 = h.hooksOf('heal').filter((c) => c.target === u).length;
+    u.skill.extend(400);
+    h.run(300);
+    const r = 1 - passed.size / seen.size;
+    assert.ok(seen.size > 400 && Math.abs(r - Math.abs(sk.bb['attack@damage_hitrate_physical'])) < 0.05, `T${tier}: miss rate ${r} (${seen.size} attacks)`);
+    const dodges = h.hooksOf('dodge').filter((c) => c.target === u && c.source === hitter).length;
+    const heals = h.hooksOf('heal').filter((c) => c.target === u).length - heals0;
+    assert.equal(heals, (seen.size - passed.size) + dodges, `T${tier}: a heal per miss on her and per dodge`);
+    approx(h.hooksOf('heal').filter((c) => c.target === u).slice(-1)[0].amount, u.s.maxHp * sk.bb['attack@hp_ratio'], `T${tier}: ${sk.bb['attack@hp_ratio'] * 100} % max HP`, 1e-3);
+    u.skill.extend(-999);
+    h.step(2);
+    assert.deepEqual([u.s.taunt, u.liveRangeGrid], [-1, formOf(tier, elite).rangeGrid], `T${tier}: back`);
+    done(h);
+  }
+});
+
+test('AMB-X “无形，无情”: every enemy of her range (air too) moves ×0.8 (stages 1 and 3) — two 阿斯卡纶 with it: ×0.64 (PRTS: they stack); none without it', () => {
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const { h, u } = field({ tier, elite, mod, skill: 1 });
+    noSkill(h, u);
+    const e = h.spawn('enemy_dummy', { pos: [10, 6] }), fly = h.spawn('enemy_fly', { pos: [9, 5] });
+    h.b.addBuff(e, { key: 'test:dodge', mods: { dodgePhys: 1 } });
+    h.run(0.6);
+    const x = elite && mod === AX;
+    if (x) assert.deepEqual(formOf(tier, true).modules.find((m) => m.uniEquipId === AX).talentChanges.find((t) => t.talentIndex === -1).bb, { move_speed: -0.2 });
+    for (const t of [e, fly]) approx(t.findBuff(`ascln:ambx#${u.id}`)?.mods.moveMul ?? 1, x ? 0.8 : 1, `${label(f)}: ${t.defId}`);
+    done(h);
+  }
+  const h = makeBattle({
+    defs: { enemies: ENEMIES }, timeLimit: 60, autoFinish: false, seed: 3, flags: { dpPerSec: 0 },
+    units: [{ uid: 1, diy: { slot: 5, charId: ASC, skillIndex: 1, uniEquipId: AX }, elite: true, row: 10, col: 5 },
+      { uid: 2, diy: { slot: 6, charId: ASC, skillIndex: 1, uniEquipId: AX }, elite: true, row: 11, col: 5 }],
+  });
+  h.step();
+  const e = h.spawn('enemy_walkslow', { pos: [10, 6] });
+  h.b.addBuff(e, { key: 'test:dodge', mods: { dodgePhys: 1 } });
+  h.run(0.5);
+  approx(e.s.moveSpeed, e.base.moveSpeed * 0.8 * 0.8, 'two AMB-X slows multiply');
+  done(h);
+});
+
+test('AMB-Y “阿斯卡纶的眼睛”: 65 % dodge (stages 1 and 3); stage 3 adds "拥有该效果的敌人被击倒时阿斯卡纶回复10%生命" — a heal of 10 % of her max HP whoever knocks out an enemy carrying her 死亡拘审', () => {
+  for (const [tier, elite, mod] of [[5, true, AY], [6, true, AY], [6, true, AX], [6, false, null]]) {
+    const y3 = tier === 6 && mod === AY;
+    const { h, u } = field({ tier, elite, mod, skill: 1 });
+    noSkill(h, u);
+    if (y3) assert.equal(modOf(6, AY).talentChanges.find((t) => t.talentIndex === 0).bb.hp_ratio, 0.1);
+    const e = h.spawn('enemy_dummy', { pos: [10, 6] });
+    assert.ok(h.runUntil(() => e.findBuff(dreadKey(u)), 6), 'marked');
+    u.hp = 100;
+    const h0 = h.hooksOf('heal').filter((c) => c.target === u).length;
+    h.b.kill(e, null);   // knocked out by anybody
+    const heals = h.hooksOf('heal').filter((c) => c.target === u).slice(h0);
+    if (y3) {
+      assert.equal(heals.length, 1, 'one heal');
+      approx(heals[0].amount, u.s.maxHp * 0.1, '10 % of her max HP');
+    } else assert.equal(heals.length, 0, `${tier} ${mod}: no heal`);
+    // an unmarked enemy: nothing
+    const plain = h.spawn('enemy_dummy', { pos: [12, 8] });
+    h.b.kill(plain, null);
+    assert.equal(h.hooksOf('heal').filter((c) => c.target === u).length - h0, y3 ? 1 : 0);
+    done(h);
+  }
+});

test/content/op_chen2.test.js

@@ -0,0 +1,380 @@
+// test/content/op_chen2.test.js — the 自选 operator kit of 假日威龙陈 (char_1013_chen2, 6★ 散射手; kit
+// server/sim/content/kits/ops/op-chen2.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, RPR-X
+// 沙滩战斗套装 or RPR-Y 假期的最后一天 at stage 1 (tier 5) / 3 (tier 6). Numbers from data/backups.json; the fidelity checklist
+// of kits/README.md item by item.
+// Run: node --test test/content/op_chen2.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';
+import { spareChance, waterOn, holidayLines, slimeOf, slimeKey } from '../../server/sim/content/kits/ops/op-chen2.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 CHEN = 'char_1013_chen2';
+const FORMS = BACKUPS.units[CHEN].forms;
+const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
+const RX = 'uniequip_002_chen2', RY = 'uniequip_003_chen2';
+const S1 = 'skchr_chen2_1', S2 = 'skchr_chen2_2', S3 = 'skchr_chen2_3';
+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_armor: dummy('enemy_armor', { def: 500 }),
+  enemy_walk: enemyRec({ key: 'enemy_walk', hp: 1e9, speed: 0.5, mass: 0 }),
+};
+const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, RX, RY].map((m) => [t, true, m]))];
+const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
+
+/** 假日威龙陈 as uid 1 at (row, col) facing RIGHT, plus `others`. */
+function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 4, others = [], seed = 5, flags = {} } = {}) {
+  const h = makeBattle({
+    defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed,
+    flags: { dpPerSec: 0, dpMax: 999, ...flags }, hooks: ['damaged', 'skillStart', 'skillEnd', 'ammoUsed', 'attack', 'statusApplied'], captureNoisy: true,
+    units: [{ uid: 1, diy: { slot: SLOT[tier], charId: CHEN, 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);
+function done(h) {
+  checkInvariants(h.b);
+  assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
+}
+/** Give the skill its SP and run until it starts. */
+function cast(h, u, max = 5) {
+  u.skill.gainSp(999);
+  assert.ok(h.runUntil(() => u.skill.active, max), 'cast');
+}
+
+test('假日威龙陈 in every 自选 form: her kit (all three skills authored), the form\'s stats + module attributes (RPR-Y: cost −8), 2-5, 散射手 (every enemy in range, air too, ×1.5 / RPR-X ×1.6 on her front row), blocks 1, ground-targetable, the data triggers; offered as a pick', () => {
+  assert.equal(OPERATOR_KITS[CHEN], KITS[CHEN]);
+  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], [CHEN, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
+      assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def, u.base.cost],
+        [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0), form.stats.cost + (m?.attr.cost ?? 0)], `${label(f)}: stats`);
+      assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.canHitFly, u.profile.dmgType, u.profile.allInRange, u.profile.sub, u.base.bat],
+        [1, 'ranged', true, 'phys', true, 'reaperrange', 2.3], `${label(f)}: 散射手`);
+      assert.equal(u.profile.frontScale, mod === RX ? 1.6 : 1.5, `${label(f)}: front-row scale`);
+      assert.deepEqual(u.profile.frontGrid, [[1, 1], [0, 0], [0, 1], [-1, 1]], `${label(f)}: the trait's front grid`);
+      assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 2-5`);
+      assert.equal(u.skill.rule, form.skills[skill].trigger.rule, `${label(f)}: the data's trigger`);
+      assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth && !u.s.flags.untargetable, `${label(f)}: ground enemies target her`);
+      done(h);
+    }
+  }
+  assert.deepEqual(formOf(6, true).skills.map((s) => s.trigger.rule), ['DEFAULT', 'DEFAULT', 'ACTIVE_RANGE']);
+  assert.deepEqual([FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.atk, FORMS['2/1/4/0'].stats.cost], [649, 731, 32]);
+  assert.deepEqual([modOf(5, RX).attr, modOf(6, RX).attr, modOf(5, RY).attr, modOf(6, RY).attr],
+    [{ atk: 30, def: 37 }, { atk: 60, def: 45 }, { cost: -8, maxHp: 135, atk: 55 }, { cost: -8, maxHp: 180, atk: 100 }]);
+  const data = { chess: CHESS, backups: BACKUPS };
+  assert.ok(KITTED_CHARS.includes(CHEN) && [5, 6].every((t) => diyPool(t, { data, kitted: KITTED_CHARS }).includes(CHEN)));
+  assert.equal(validateDiyPicks({ [SLOT[6]]: { charId: CHEN, skillIndex: 2, uniEquipId: RY } }, { data, kitted: KITTED_CHARS }).ok, true);
+});
+
+test('trait 散射手: one attack strikes every enemy of her 2-5 (a flyer too) — ×1.5 (RPR-X ×1.6) on the trait front row (her column ahead), ×1 elsewhere; one attackId', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [6, true, RX], [6, true, RY]]) {
+    const { h, u } = field({ tier, elite, mod, skill: 1 });
+    u.skill.charges = 0; u.skill.sp = 0;
+    h.b.addBuff(u, { key: 'test:noSp', flags: { noSp: true } });
+    const front = h.spawn('enemy_dummy', { pos: [10, 5] }), up1 = h.spawn('enemy_dummy', { pos: [9, 5] });
+    const far = h.spawn('enemy_dummy', { pos: [10, 6] }), fly = h.spawn('enemy_fly', { pos: [11, 6] });
+    const out = h.spawn('enemy_dummy', { pos: [10, 7] });
+    assert.ok(h.runUntil(() => atkHits(h, u).length >= 4, 5), 'an attack');
+    const first = atkHits(h, u);
+    const id = first[0].dmg.attackId;
+    const hit = first.filter((c) => c.dmg.attackId === id);
+    assert.deepEqual(new Set(hit.map((c) => c.target)), new Set([front, up1, far, fly]), `T${tier}: every enemy of 2-5`);
+    const sc = mod === RX ? 1.6 : 1.5;
+    for (const c of hit) approx(c.amount, u.s.atk * ([front, up1].includes(c.target) ? sc : 1), `T${tier} ${mod}: ${c.target.tileR},${c.target.tileC}`);
+    assert.ok(!hit.some((c) => c.target === out), `T${tier}: [0,3] is outside 2-5`);
+    done(h);
+  }
+});
+
+test('S1 高压冲击 (AUTO, attack SP 6 / 5, data DEFAULT): after that many attacks ATK +55 % / +70 %, 4 bullets, every enemy of her range takes the trait multiplier; ends after 4 attacks', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S1);
+    assert.deepEqual([sk.spType, sk.spCost, sk.initSp, sk.bb.atk, sk.bb['attack@trigger_time'], sk.skillType], ['INCREASE_WHEN_ATTACK', elite ? 5 : 6, 0, elite ? 0.7 : 0.55, 4, 'AUTO'], `T${tier}`);
+    const { h, u } = field({ tier, elite, skill: 0 });
+    assert.deepEqual([u.skill.kind, u.skill.rule, u.skill.spType], ['ammo', 'DEFAULT', 'attack']);
+    const SP = h.b.rng.chance; // no spare shots for an exact count: her own 节约风气 is tested below
+    h.b.rng.chance = () => false;
+    h.spawn('enemy_dummy', { pos: [10, 5] });
+    h.spawn('enemy_dummy', { pos: [10, 6] });
+    assert.ok(h.runUntil(() => u.skill.active, 60), `T${tier}: cast`);
+    const plain = h.hooksOf('attack').filter((c) => c.attacker === u && !c.isSkill);
+    assert.equal(plain.length, sk.spCost, `T${tier}: after ${sk.spCost} attacks`);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK +${sk.bb.atk * 100} %`);
+    h.runUntil(() => !u.skill.active, 30);
+    h.b.rng.chance = SP;
+    h.run(1); // the last arrows land
+    const skillAttacks = h.hooksOf('attack').filter((c) => c.attacker === u && c.isSkill);
+    assert.equal(skillAttacks.length, 4, `T${tier}: 4 bullets, the cast's own attack the first`);
+    const skillHits = atkHits(h, u).filter((c) => c.dmg.isSkill);
+    assert.equal(skillHits.length, 8, `T${tier}: 4 attacks × 2 enemies`);
+    // (the last attack's arrows land after the skill ended: the engine reads the ATK at the impact)
+    const ids = [...new Set(skillHits.map((c) => c.dmg.attackId))];
+    for (const c of skillHits.filter((x) => ids.indexOf(x.dmg.attackId) < 3)) approx(c.amount, u.base.atk * (1 + sk.bb.atk) * 1.5, `T${tier}: ×1.5 on both (the trait's front row and the tile beyond)`);
+    assert.equal(h.hooksOf('ammoUsed').filter((c) => c.unit === u).length, 4, `T${tier}: 4 bullets`);
+    approx(u.s.atk, u.base.atk, `T${tier}: ATK back`);
+    done(h);
+  }
+});
+
+test('S2 “堇青之夜” (MANUAL, data DEFAULT, 蓄力 2): 27 / 24 SP from 5 / 10; cast with one charge 8 bullets, ATK +50 % / +65 %; with both stored (蓄力) 20 bullets; every cast empties the SP', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S2);
+    assert.deepEqual([sk.spCost, sk.initSp, sk.maxChargeTime, sk.bb.atk, sk.bb['attack@trigger_time'], sk.bb['attack@another_trigger_time']],
+      [elite ? 24 : 27, elite ? 10 : 5, 2, elite ? 0.65 : 0.5, 8, 20], `T${tier}`);
+    const { h, u } = field({ tier, elite, skill: 1 });
+    const atStart = [];
+    h.b.on('skillStart', (c) => { if (c.unit === u) atStart.push([c.skill.ammoLeft, c.skill.ammoMax, c.skill.charges, c.skill.sp, u.mem.chen2Charged]); }, { priority: -1000 });
+    assert.deepEqual([u.skill.kind, u.skill.rule, u.skill.maxCharges], ['ammo', 'DEFAULT', 2]);
+    approx(u.skill.sp, sk.initSp, `T${tier}: initial SP`, 0.02);
+    // one charge and some SP towards the second: 8 bullets, everything spent
+    u.skill.gainSp(sk.spCost - u.skill.sp + 5);
+    assert.equal(u.skill.charges, 1);
+    approx(u.skill.sp, 5, 'SP towards the second charge');
+    h.spawn('enemy_dummy', { pos: [10, 5] });
+    assert.ok(h.runUntil(() => u.skill.active, 5), `T${tier}: cast`);
+    assert.deepEqual(atStart[0], [8, 8, 0, 0, false], `T${tier}: 8 bullets, SP emptied`);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`);
+    u.skill.end('test');
+    // 蓄力: both charges stored
+    u.skill.gainSp(999, 'init');
+    assert.equal(u.skill.charges, 2);
+    assert.ok(h.runUntil(() => u.skill.active, 10), `T${tier}: charged cast`);
+    assert.deepEqual(atStart[1], [20, 20, 0, 0, true], `T${tier}: 20 bullets`);
+    done(h);
+  }
+});
+
+test('slime (S2 / S3): each attack slimes the tiles of her attack range (2-5; S3 2-6) for 5 s; a ground enemy there — struck or not, stealthed too — moves ×0.8 / ×0.7 / ×0.6 and loses 100 / 150 / 200 DEF after its multipliers (not stacking); a flyer or an enemy outside never; it lapses 5 s after her last attack; two 假日威龙陈 each slow', () => {
+  for (const [tier, elite, skill] of [[5, false, 1], [6, true, 1], [5, false, 2], [6, true, 2]]) {
+    const sk = skillOf(tier, elite, [S1, S2, S3][skill]);
+    const [ms, def, life] = [sk.bb['attack@move_speed'], sk.bb['attack@def'], sk.bb['attack@projectile_life_time']];
+    const { h, u } = field({ tier, elite, skill });
+    const e = h.spawn('enemy_armor', { pos: [10, 5] });
+    const fly = h.spawn('enemy_fly', { pos: [10, 6] });
+    const out = h.spawn('enemy_armor', { pos: [10, 8] });
+    cast(h, u);
+    assert.ok(h.runUntil(() => h.hooksOf('attack').some((c) => c.attacker === u && c.isSkill), 5), 'an attack');
+    h.run(0.25);
+    const tiles = slimeOf(h.b, u);
+    assert.deepEqual([...tiles.keys()].sort((a, b) => a - b), [...u.rangeKeys].sort((a, b) => a - b), `T${tier} S${skill + 1}: her range (${skill === 2 ? '2-6' : '2-5'})`);
+    const key = slimeKey(u);
+    const b = e.findBuff(key);
+    assert.ok(b, `T${tier} S${skill + 1}: the ground enemy is slimed`);
+    approx(b.mods.moveMul, 1 + ms, `×${1 + ms}`);
+    approx(e.s.def, 500 + def, `DEF ${def}`);
+    assert.equal(fly.findBuff(key), null, 'never a flyer');
+    assert.equal(out.findBuff(key), null, 'not outside her range');
+    // a stealthed ground enemy that walks in (never struck: she cannot see it) — 无视无法选择
+    const sneak = h.spawn('enemy_armor', { pos: [9, 6] });
+    h.b.addBuff(sneak, { key: 'test:stealth', flags: { stealth: true } });
+    h.run(0.25);
+    assert.ok(sneak.findBuff(key), 'a stealthed enemy in the slime is slimed');
+    // the DEF cut is a final addition: after a ×0.7 DEF status
+    h.b.applyStatus(e, 'defDown', { duration: 30, value: 0.3, source: u });
+    h.run(0.25);
+    approx(e.s.def, 500 * 0.7 + def, 'DEF ×0.7 then the cut');
+    assert.equal(e.buffs.filter((x) => x.key === key).length, 1, '不叠加');
+    // stop her: the slime lapses life s after her last attack
+    u.skill.end('test');
+    h.b.addBuff(u, { key: 'test:disarm', flags: { disarm: true } });
+    const tLast = h.hooksOf('attack').filter((c) => c.attacker === u).slice(-1)[0].t;
+    h.run(tLast + life - 0.3 - h.b.time);
+    assert.ok(e.findBuff(key), 'still slimed');
+    h.run(0.7);
+    assert.equal(e.findBuff(key), null, `gone ${life} s after her last attack`);
+    done(h);
+  }
+  // two of them: one slow each (independentCharacterSource)
+  const h = makeBattle({
+    defs: { enemies: ENEMIES }, timeLimit: 60, autoFinish: false, seed: 3, flags: { dpPerSec: 0 },
+    units: [{ uid: 1, diy: { slot: 5, charId: CHEN, skillIndex: 1 }, row: 10, col: 4 }, { uid: 2, diy: { slot: 6, charId: CHEN, skillIndex: 1 }, row: 11, col: 4 }],
+  });
+  h.step();
+  const e = h.spawn('enemy_armor', { pos: [10, 5] });
+  for (const id of [1, 2]) h.unit(id).skill.gainSp(999);
+  h.run(3);
+  assert.ok(e.findBuff(slimeKey(h.unit(1))) && e.findBuff(slimeKey(h.unit(2))), 'both slimes');
+  approx(e.s.def, 500 - 200, 'DEF −100 twice');
+  done(h);
+});
+
+test('S3 “假日风暴” (MANUAL, data ACTIVE_RANGE on 2-6): an enemy only on 2-6 casts it; range 2-6 (and back); ATK +55 % / +70 %, every attack strikes twice with the trait multiplier on every enemy; 32 bullets, 2 per attack (16 attacks), one left still attacks', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S3);
+    assert.deepEqual([sk.spCost, sk.initSp, sk.bb.atk, sk.bb['attack@trigger_time'], sk.rangeId], [elite ? 60 : 65, elite ? 25 : 20, elite ? 0.7 : 0.55, 32, '2-6'], `T${tier}`);
+    const { h, u } = field({ tier, elite, skill: 2 });
+    assert.deepEqual([u.skill.kind, u.skill.rule], ['ammo', 'ACTIVE_RANGE']);
+    const SP = h.b.rng.chance;
+    h.b.rng.chance = () => false;
+    const n0 = h.hooksOf('ammoUsed').filter((c) => c.unit === u).length;
+    const a0 = h.hooksOf('attack').filter((c) => c.attacker === u && c.isSkill).length;
+    u.skill.gainSp(999);
+    const corner = h.spawn('enemy_dummy', { pos: [12, 6] });
+    assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: cast for [2,2] (outside 2-5)`);
+    assert.deepEqual(u.liveRangeGrid, sk.rangeGrid, `T${tier}: 2-6 while it runs`);
+    const front = h.spawn('enemy_dummy', { pos: [10, 5] });
+    h.runUntil(() => !u.skill.active, 60);
+    h.b.rng.chance = SP;
+    const attacks = h.hooksOf('attack').filter((c) => c.attacker === u && c.isSkill).length - a0;
+    assert.equal(attacks, 16, `T${tier}: 32 bullets / 2`);
+    assert.equal(h.hooksOf('ammoUsed').filter((c) => c.unit === u).length - n0, 32, `T${tier}: one ammoUsed per bullet`);
+    const hits = atkHits(h, u).filter((c) => c.dmg.isSkill && c.target === front);
+    assert.ok(hits.length >= 28, `T${tier}: two hits per attack (${hits.length})`);
+    const byId = new Map();
+    for (const c of hits) byId.set(c.dmg.attackId, (byId.get(c.dmg.attackId) ?? 0) + 1);
+    assert.ok([...byId.values()].every((n) => n === 2), `T${tier}: two damage instances per attack`);
+    const atk = u.base.atk * (1 + sk.bb.atk);
+    for (const c of hits) approx(c.amount, atk * 1.5, `T${tier}: front ×1.5`);
+    const onCorner = atkHits(h, u).filter((c) => c.dmg.isSkill && c.target === corner);
+    assert.ok(onCorner.length >= 30, `T${tier}: [2,2] struck too`);
+    for (const c of onCorner) approx(c.amount, atk * 1.5, `T${tier}: [2,2] also ×1.5`);
+    assert.deepEqual(u.liveRangeGrid, formOf(tier, elite).rangeGrid, `T${tier}: back to 2-5`);
+    // 即使剩余弹药数小于2发仍可"消耗2发弹药"进行攻击
+    h.b.on('skillStart', (c) => { if (c.unit === u) c.skill.ammoLeft = 3; }, { priority: -1000 });
+    h.b.rng.chance = () => false;
+    const a1 = h.hooksOf('attack').filter((c) => c.attacker === u && c.isSkill).length;
+    u.skill.gainSp(999, 'init');
+    assert.ok(h.runUntil(() => u.skill.active, 5));
+    h.runUntil(() => !u.skill.active, 30);
+    h.b.rng.chance = SP;
+    assert.equal(h.hooksOf('attack').filter((c) => c.attacker === u && c.isSkill).length - a1, 2, `T${tier}: 3 bullets ⇒ 2 attacks (2 + the last one)`);
+    done(h);
+  }
+});
+
+test('T1 节约风气: her ammo-skill attacks spare their bullets 20 % of the time (RPR-X stage 3: 25 %) — one roll per attack, S3 spares both bullets, every ammoUsed still fires', () => {
+  for (const [tier, elite, mod, p] of [[5, false, null, 0.2], [5, true, RX, 0.2], [6, true, RX, 0.25], [6, true, RY, 0.2]]) {
+    for (const skill of [1, 2]) {
+      const { h, u } = field({ tier, elite, mod, skill, seed: 17 });
+      h.spawn('enemy_dummy', { pos: [10, 5] });
+      cast(h, u);
+      assert.equal(spareChance(h.b, u), p, `T${tier} ${mod}: her chance`);
+      u.skill.ammoLeft = 100000;
+      const u0 = h.hooksOf('ammoUsed').filter((c) => c.unit === u).length;
+      const before = new Map();
+      h.b.on('attack', (c) => { if (c.attacker === u) before.set(u.stats.attacks, u.skill.ammoLeft); }, { priority: 1000 });
+      const spent = [];
+      h.b.on('attack', (c) => { if (c.attacker === u) h.b.after(0, () => spent.push(before.get(u.stats.attacks) - u.skill.ammoLeft)); }, { priority: 1000 });
+      h.run(900);
+      h.b.addBuff(u, { key: 'test:disarm', flags: { disarm: true } });
+      h.step(3);
+      const per = skill === 2 ? 2 : 1;
+      assert.ok(spent.length > 300, `${spent.length} attacks`);
+      assert.ok(spent.every((n) => n === 0 || n === per), `T${tier} S${skill + 1}: 0 or ${per} per attack`);
+      const r = spent.filter((n) => n === 0).length / spent.length;
+      assert.ok(Math.abs(r - p) < 0.05, `T${tier} ${mod} S${skill + 1}: spare rate ${r} ≈ ${p}`);
+      const used = h.hooksOf('ammoUsed').filter((c) => c.unit === u).length - u0;
+      assert.equal(used, spent.length * per, `T${tier} S${skill + 1}: every bullet's ammoUsed fires, spared or not`);
+      done(h);
+    }
+  }
+});
+
+test('T1 节约风气 on others while she is on the field: another 【狙击】 operator\'s 弹药类技能 20 % (PRTS 修正 over the text\'s 10 %; RPR-X stage 3 too), another 远程 operator\'s 0 % / 12 % (RPR-X stage 3), never a 技能 without "攻击装有X发" nor a summon; none once she leaves; the highest of two 假日威龙陈', () => {
+  const t0 = FORMS['2/1/4/0'].talents.find((t) => t.index === 0);
+  assert.deepEqual(t0.bb, { 'spareshot_chen.prob': 0.2, prob: 0.1 }, 'the base row: 20 % / the text\'s 10 %');
+  assert.deepEqual(modOf(6, RX).talentChanges[0].bb, { 'e_spareshot_chen.prob': 0.25, 'chen2_t_002[spareshot][other].prob': 0.12, 'chen2_t_002[spareshot][sniper].prob': 0.2 });
+  for (const [tier, elite, mod, sniper, other] of [[5, false, null, 0.2, 0], [5, true, RX, 0.2, 0], [6, true, RX, 0.2, 0.12], [6, true, RY, 0.2, 0]]) {
+    const others = [
+      { uid: 2, chessId: 'chess_char_1_01_a', row: 11, col: 3 },   // 隐现 (狙击): S2 "攻击装有14发弹药"
+      { uid: 3, chessId: 'chess_char_5_03_a', row: 12, col: 3 },   // 烛煌 (术师, 远程): S3 "攻击装有18发弹药"
+      { uid: 4, chessId: 'chess_char_5_08_a', skillIndex: 1, row: 9, col: 7 },   // 号角 (重装): S2 "技能拥有10枚弹药" — no 攻击装有
+    ];
+    const { h, u } = field({ tier, elite, mod, skill: 0, others });
+    const inside = h.unit(2), blaze = h.unit(3), horn = h.unit(4);
+    assert.equal(spareChance(h.b, inside), sniper, `${tier} ${mod}: 狙击`);
+    assert.equal(spareChance(h.b, blaze), other, `${tier} ${mod}: 远程`);
+    assert.equal(spareChance(h.b, horn), 0, `${tier} ${mod}: 地面`);
+    // the roll only applies to a running 弹药类技能 (whose text says 攻击装有X发…)
+    for (const x of [inside, blaze]) assert.match(x.skill.def.description, /攻击装有\d+发/);
+    assert.doesNotMatch(horn.skill.def.description, /攻击装有\d+发/);
+    // 隐现's S2 over many attacks
+    h.spawn('enemy_dummy', { pos: [11, 5] });
+    inside.skill.gainSp(999);
+    assert.ok(h.runUntil(() => inside.skill.active, 10), '隐现 casts');
+    inside.skill.ammoLeft = 100000;
+    let spared = 0, n = 0;
+    h.b.on('attack', (c) => {
+      if (c.attacker !== inside) return;
+      const left = inside.skill.ammoLeft;
+      h.b.after(0, () => { n++; if (inside.skill.ammoLeft === left) spared++; });
+    }, { priority: 1000 });
+    h.run(500);
+    h.b.addBuff(inside, { key: 'test:disarm', flags: { disarm: true } });
+    h.step(3);
+    assert.ok(n > 200, `${n} attacks`);
+    assert.ok(Math.abs(spared / n - sniper) < 0.06, `T${tier} ${mod}: 隐现 ${spared}/${n} ≈ ${sniper}`);
+    // she leaves: nobody's chance
+    h.b.retreat(u);
+    assert.deepEqual([spareChance(h.b, inside), spareChance(h.b, blaze)], [0, 0], 'only while she is on the field');
+    done(h);
+  }
+  // two 假日威龙陈 (a shared field): each takes the highest — the RPR-X stage-3 one gives the other 20 % (≥ her own 20 %)
+  const h = makeBattle({
+    defs: { enemies: ENEMIES }, timeLimit: 60, autoFinish: false, seed: 3, flags: { dpPerSec: 0 },
+    units: [{ uid: 1, diy: { slot: 6, charId: CHEN, skillIndex: 0, uniEquipId: RX }, elite: true, row: 10, col: 4 },
+      { uid: 2, diy: { slot: 5, charId: CHEN, skillIndex: 0, uniEquipId: null }, elite: false, row: 11, col: 4 },
+      { uid: 3, chessId: 'chess_char_5_03_a', row: 12, col: 3 }],
+  });
+  h.step();
+  assert.deepEqual([spareChance(h.b, h.unit(1)), spareChance(h.b, h.unit(2)), spareChance(h.b, h.unit(3))], [0.25, 0.2, 0.12]);
+  done(h);
+});
+
+test('T2 假日余韵: ASPD +8 (no level of the mode has the water TAG); RPR-Y stage 3: ATK +15 % ASPD +12, and while her skill runs the field counts as water: ATK +28 % ASPD +20 — for every 假日威龙陈 of the field — until it ends', () => {
+  // the two rows of the data: base [map] = the step (8 + 4 = 12), module [map] = the totals (20 / 28 %), as their texts say
+  const base = FORMS['2/1/4/0'].talents.find((t) => t.index === 1);
+  assert.match(base.desc, /改为攻击速度\+12/);
+  assert.deepEqual(holidayLines(base), { common: { atkPct: 0, aspd: 8 }, water: { atkPct: 0, aspd: 12 } });
+  const row = modOf(6, RY).talentChanges[0];
+  assert.match(row.desc, /改为攻击力\+28%，攻击速度\+20，技能开启时，场地视为水地形/);
+  assert.deepEqual(holidayLines({ ...row, fromModule: true }), { common: { atkPct: 0.15, aspd: 12 }, water: { atkPct: 0.28, aspd: 20 } });
+  assert.deepEqual(modOf(5, RY).talentChanges, [], 'RPR-Y stage 1 changes no talent');
+  for (const f of FORMS_ALL) {
+    const [tier, elite, mod] = f;
+    const y3 = elite && mod === RY && tier === 6;
+    const { h, u } = field({ tier, elite, mod, skill: 2, others: [{ uid: 2, diy: { slot: 5, charId: CHEN, skillIndex: 0 }, row: 12, col: 4 }] });
+    const mate = h.unit(2);
+    approx(u.s.aspd, 100 + (elite ? (modOf(tier, mod)?.attr.aspd ?? 0) : 0) + (y3 ? 12 : 8), `${label(f)}: ASPD`);
+    approx(u.s.atk, u.base.atk * (y3 ? 1.15 : 1), `${label(f)}: ATK`);
+    assert.equal(waterOn(h.b), false);
+    h.spawn('enemy_dummy', { pos: [10, 5] });
+    cast(h, u);
+    h.step();
+    assert.equal(waterOn(h.b), y3, `${label(f)}: water while her skill runs`);
+    approx(u.s.aspd, 100 + (y3 ? 20 : 8), `${label(f)}: ASPD during the skill`);
+    approx(u.s.atk, u.base.atk * (1 + skillOf(tier, elite, S3).bb.atk + (y3 ? 0.28 : 0)), `${label(f)}: ATK during the skill`);
+    approx(mate.s.aspd, 100 + (y3 ? 12 : 8), `${label(f)}: the other 假日威龙陈 (no module) gets the water line too`);
+    u.skill.end('test');
+    h.step();
+    assert.equal(waterOn(h.b), false, `${label(f)}: the TAG ends with the skill`);
+    approx(u.s.aspd, 100 + (y3 ? 12 : 8), `${label(f)}: back`);
+    approx(mate.s.aspd, 108, `${label(f)}: the other back to +8`);
+    if (y3) {
+      cast(h, u);
+      h.step();
+      assert.equal(waterOn(h.b), true);
+      h.b.retreat(u);
+      h.step();
+      assert.equal(waterOn(h.b), false, 'cleared when she leaves');
+    }
+    done(h);
+  }
+});

test/content/op_ray.test.js

@@ -0,0 +1,371 @@
+// test/content/op_ray.test.js — the 自选 operator kit of 莱伊 (char_4117_ray, 6★ 猎手; kit
+// server/sim/content/kits/ops/op-ray.js) and of her summon 沙地兽 (token_10034_ray_sndbst), fielded the production way (a DIY
+// slot + its `diy` pick, simdata getDiy; the 沙地兽 as the placed hand piece of her player) in every form: tiers 5 / 6,
+// normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module, HUN-X 《跳舞的月光》 or HUN-Y 证明什么？
+// at stage 1 (tier 5) / 3 (tier 6). Numbers from data/backups.json; the fidelity checklist of kits/README.md.
+// Run: node --test test/content/op_ray.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';
+import { SANDBEAST, SPECIAL_TAG } from '../../server/sim/content/kits/ops/op-ray.js';
+import { PUSH_TILES } from '../../server/sim/constants.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 RAY = 'char_4117_ray';
+const FORMS = BACKUPS.units[RAY].forms;
+const TOKREC = BACKUPS.tokens[SANDBEAST];
+const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' };
+const HX = 'uniequip_002_ray', HY = 'uniequip_003_ray';
+const S1 = 'skchr_ray_1', S2 = 'skchr_ray_2', S3 = 'skchr_ray_3';
+const statusOf = (tier, elite) => (elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0');
+const formOf = (tier, elite) => FORMS[statusOf(tier, elite)];
+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);
+/** The 沙地兽's variant of a form, with the pick's module (getDiyToken). */
+const tokOf = (tier, elite, mod) => {
+  const v = TOKREC.variants[`${RAY}@${statusOf(tier, elite)}`];
+  return mod && v.byModule?.[mod] ? { ...v, ...v.byModule[mod] } : v;
+};
+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_weak: dummy('enemy_weak', { hp: 10 }),
+  enemy_atk: dummy('enemy_atk', { atk: 500, range: 2 }),
+};
+const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, HX, HY].map((m) => [t, true, m]))];
+const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`;
+
+/** 莱伊 as uid 1 at (row, col) facing RIGHT; `beast` = the 沙地兽 piece's tile (uid 2) or null. */
+function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 3, beast = null, beastFirst = false, others = [], seed = 5, flags = {} } = {}) {
+  const op = { uid: 1, diy: { slot: SLOT[tier], charId: RAY, skillIndex: skill, uniEquipId: mod }, elite, row, col };
+  const piece = beast ? [{ uid: 2, kind: 'token', tokenId: SANDBEAST, ownerUid: 1, row: beast[0], col: beast[1] }] : [];
+  const h = makeBattle({
+    defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed,
+    flags: { dpPerSec: 0, dpMax: 999, ...flags }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied', 'death', 'deploy', 'attack', 'kill'], captureNoisy: true,
+    units: beastFirst ? [...piece, op, ...others] : [op, ...piece, ...others],
+  });
+  h.step();
+  return { h, u: h.unit(1), t: h.b.allyUnits.find((a) => a.kind === 'token' && a.defId === SANDBEAST) ?? null };
+}
+const atkHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.isAttack);
+function done(h) {
+  checkInvariants(h.b);
+  assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0]));
+}
+/** Record (time, ammo) every time her magazine changes. */
+function ammoLog(h, u) {
+  const log = [];
+  let last = u.trait.ammo;
+  h.b.on('tick', () => { if (u.trait.ammo !== last) { log.push([h.b.time, u.trait.ammo]); last = u.trait.ammo; } });
+  return log;
+}
+
+test('莱伊 in every 自选 form: her kit (all three skills authored), the form\'s stats + module attributes, 4-9, 猎手 (ranged physical, hits air, 8 bullets, ×1.2 / HUN-Y ×1.33), blocks 1, ground-targetable, the triggers (S2 at full SP); offered as a pick', () => {
+  assert.equal(OPERATOR_KITS[RAY], KITS[RAY]);
+  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], [RAY, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f));
+      assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def, u.base.aspd],
+        [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0), 100 + (m?.attr.aspd ?? 0)], `${label(f)}: stats`);
+      assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.canHitFly, u.profile.dmgType, u.profile.sub, u.base.bat, u.profile.ammoMax, u.profile.ammoScale, u.trait.ammo],
+        [1, 'ranged', true, 'phys', 'hunter', 1.6, 8, mod === HY ? 1.33 : 1.2, 8], `${label(f)}: 猎手`);
+      assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 4-9`);
+      assert.equal(u.skill.rule, skill === 1 ? 'SP_FULL' : form.skills[skill].trigger.rule, `${label(f)}: trigger`);
+      assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target her`);
+      done(h);
+    }
+  }
+  assert.deepEqual(formOf(6, true).skills.map((s) => s.trigger.rule), ['DEFAULT', 'DEFAULT', 'ACTIVE_RANGE']);
+  assert.deepEqual([modOf(5, HX).attr, modOf(6, HX).attr, modOf(5, HY).attr, modOf(6, HY).attr],
+    [{ maxHp: 150, atk: 50, def: 15 }, { maxHp: 200, atk: 70, def: 25 }, { maxHp: 100, atk: 60, aspd: 5 }, { maxHp: 200, atk: 75, aspd: 7 }]);
+  const data = { chess: CHESS, backups: BACKUPS };
+  assert.ok(KITTED_CHARS.includes(RAY) && [5, 6].every((t) => diyPool(t, { data, kitted: KITTED_CHARS }).includes(RAY)));
+  assert.equal(validateDiyPicks({ [SLOT[5]]: { charId: RAY, skillIndex: 1, uniEquipId: HX } }, { data, kitted: KITTED_CHARS }).ok, true);
+});
+
+test('trait 猎手: 8 bullets, one per attack at ×1.2 (HUN-Y ×1.33); empty ⇒ a reload of her BASE attack time (1.6 s, ASPD +100 changes nothing) loads one bullet; HUN-X loads one more onto an empty magazine; with nobody to shoot she reloads to full and stops', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [5, true, HX], [6, true, HX], [6, true, HY]]) {
+    const { h, u } = field({ tier, elite, mod, skill: 1 });
+    u.skill.sp = 0;
+    h.b.addBuff(u, { key: 'test:noSp', flags: { noSp: true } });
+    h.b.addBuff(u, { key: 'test:fast', mods: { aspd: 100 } });
+    const log = ammoLog(h, u);
+    const e = h.spawn('enemy_dummy', { pos: [10, 5] });
+    assert.ok(h.runUntil(() => u.trait.ammo === 0, 20), `${mod}: the magazine runs out`);
+    assert.equal(h.hooksOf('attack').filter((c) => c.attacker === u).length, 8, `${mod}: 8 shots`);
+    h.run(0.3); // the last arrow lands (the reload has begun meanwhile)
+    const hits = atkHits(h, u);
+    assert.equal(hits.length, 8);
+    const sc = mod === HY ? 1.33 : 1.2;
+    // (入神 adds +8 % / +9 % per attack on the same target; the first shot has one layer)
+    const t1 = (mod === HY && tier === 6) ? 0.09 : 0.08;
+    approx(hits[0].amount, u.base.atk * (1 + t1) * sc, `${mod}: ×${sc}`);
+    const iv = u.s.interval;
+    approx(iv, 1.6 * 100 / (u.base.aspd + 100), 'ASPD +100 shortens her attacks');
+    // empty with a target: each reload (after the attack cooldown) loads, and she shoots at once — HUN-X: two bullets
+    const hx = elite && mod === HX;
+    assert.ok(h.runUntil(() => h.hooksOf('attack').filter((c) => c.attacker === u).length >= 12, 30), 'more shots');
+    const ts = h.hooksOf('attack').filter((c) => c.attacker === u).map((c) => c.t);
+    for (let i = 1; i < 8; i++) approx(ts[i] - ts[i - 1], iv, `${mod}: the magazine at ${iv.toFixed(2)} s`, 0.05);
+    approx(ts[8] - ts[7], iv + 1.6, `${mod}: cooldown + a 1.6 s reload (never shortened)`, 0.05);
+    if (hx) {
+      approx(ts[9] - ts[8], iv, 'HUN-X: the second bullet of that reload', 0.05);
+      approx(ts[10] - ts[9], iv + 1.6, 'then a reload again', 0.05);
+    } else {
+      approx(ts[9] - ts[8], iv + 1.6, `${mod}: one bullet per reload`, 0.05);
+    }
+    // nobody to shoot: one bullet per 1.6 s up to 8, then nothing
+    h.b.kill(e, null);
+    const n0 = log.length;
+    h.run(20);
+    const reloads = log.slice(n0);
+    assert.equal(reloads[reloads.length - 1][1], 8, `${mod}: full`);
+    for (let i = 1; i < reloads.length; i++) approx(reloads[i][0] - reloads[i - 1][0], 1.6, `${mod}: one bullet per 1.6 s`, 0.03);
+    const tFull = reloads[reloads.length - 1][0];
+    assert.ok(h.b.time - tFull > 5 && u.trait.ammo === 8, 'stops at 8');
+    done(h);
+  }
+});
+
+test('莱伊 shoots air units (猎手 "可对空"): a flyer in her range is her target; physical arrows', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [6, true, HY]]) {
+    const { h, u } = field({ tier, elite, mod, skill: 1 });
+    u.skill.sp = 0;
+    h.b.addBuff(u, { key: 'test:noSp', flags: { noSp: true } });
+    const fly = h.spawn('enemy_fly', { pos: [10, 6] });
+    h.run(3);
+    const hits = atkHits(h, u).filter((c) => c.target === fly);
+    assert.ok(hits.length >= 1 && hits.every((c) => c.type === 'phys'), `T${tier}: the flyer is shot`);
+    done(h);
+  }
+});
+
+test('T2 入神: +8 % ATK per attack on the same target, ≤ 3 layers (HUN-Y stage 3: +9 %, ≤ 4), lost on a new target (one layer again)', () => {
+  for (const [tier, elite, mod] of [[5, false, null], [5, true, HY], [6, true, HY], [6, true, HX]]) {
+    const y3 = tier === 6 && mod === HY;
+    const [per, max] = y3 ? [0.09, 4] : [0.08, 3];
+    const t1 = (mod ? formOf(tier, true) : formOf(tier, elite)).talents.find((t) => t.index === 1).bb;
+    if (!y3) assert.deepEqual(t1, { atk: 0.08, max_stack_cnt: 3 });
+    const { h, u } = field({ tier, elite, mod, skill: 1 });
+    u.skill.sp = 0;
+    h.b.addBuff(u, { key: 'test:noSp', flags: { noSp: true } });
+    const atks = [];
+    h.b.on('damaged', (c) => { if (c.source === u && c.dmg.isAttack) atks.push([c.target, u.s.atk]); }, { priority: -100 });
+    const a = h.spawn('enemy_dummy', { pos: [10, 5] });
+    h.runUntil(() => atks.length >= 6, 20);
+    for (let i = 0; i < 6; i++) approx(atks[i][1], u.base.atk * (1 + per * Math.min(max, i + 1)), `${label([tier, elite, mod])}: attack ${i + 1}`);
+    h.b.kill(a, null);
+    const b = h.spawn('enemy_dummy', { pos: [10, 6] });
+    const n = atks.length;
+    h.runUntil(() => atks.length >= n + 1, 20);
+    assert.equal(atks[n][0], b);
+    approx(atks[n][1], u.base.atk * (1 + per), 'a new target: one layer');
+    done(h);
+  }
+});
+
+test('S1 脱身矢 (MANUAL, 2 charges, data DEFAULT): a special bullet at once (no bullet of the magazine) for 290 % / 360 % × the trait scale, pushed 中力 along her facing; off her facing radial at 力度 −1; a kill loads one more bullet at the next reload; with an empty magazine it still fires', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S1);
+    assert.deepEqual([sk.spCost, sk.initSp, sk.maxChargeTime, sk.bb.atk_scale, sk.bb.force, sk.bb.cnt], elite ? [12, 10, 2, 3.6, 1, 1] : [14, 10, 2, 2.9, 1, 1], `T${tier}`);
+    // straight ahead: pushed along +x
+    {
+      const { h, u } = field({ tier, elite, skill: 0, row: 11 });
+      assert.deepEqual([u.skill.kind, u.skill.rule, u.skill.maxCharges], ['charges', 'DEFAULT', 2]);
+      const atkAt = [];
+      h.b.on('damaged', (c) => { if (c.source === u) atkAt.push([c, u.s.atk]); }, { priority: -100 });
+      const e = h.spawn('enemy_dummy', { pos: [11, 5] });
+      u.skill.gainSp(999);
+      assert.ok(h.runUntil(() => u.skill.activations === 1, 3), `T${tier}: cast`);
+      const ammo0 = u.trait.ammo;
+      h.run(0.6);
+      const special = atkAt.filter(([c]) => c.dmg.tags?.includes(SPECIAL_TAG));
+      assert.equal(special.length, 1, `T${tier}: one special bullet`);
+      const [c, atk] = special[0];
+      approx(c.amount, atk * sk.bb.atk_scale * 1.2, `T${tier}: ${sk.bb.atk_scale * 100} % × 1.2`);
+      assert.deepEqual([c.type, c.dmg.isSkill, c.dmg.isAttack], ['phys', true, true]);
+      assert.equal(ammo0, 7, `T${tier}: the cast's normal attack took one bullet, the special one none`);
+      approx(e.x, 5 + PUSH_TILES[1], `T${tier}: pushed ${PUSH_TILES[1]} tiles along her facing`, 0.03);
+      approx(e.y, 11, 'no sideways push');
+      done(h);
+    }
+    // beside her (90° off): radial, 力度 −1 (中力 − 1 = level 0 on a weight-0 enemy — the wall stops it at 8.5)
+    {
+      const { h, u } = field({ tier, elite, skill: 0, row: 11 });
+      const e = h.spawn('enemy_dummy', { pos: [10, 3] });
+      u.skill.gainSp(999);
+      assert.ok(h.runUntil(() => u.skill.activations === 1, 3));
+      h.run(0.6);
+      approx(e.x, 3, 'no forward push');
+      assert.ok(10 - e.y > 1, `T${tier}: radial at level 0 (${(10 - e.y).toFixed(2)} tiles, the engine's −2 would be ${PUSH_TILES[-1] ?? 0.44})`);
+      done(h);
+    }
+    // a kill: +1 bullet at the next reload; an empty magazine: the cast still comes
+    {
+      const { h, u } = field({ tier, elite, skill: 0 });
+      u.trait.ammo = 0;
+      const log = ammoLog(h, u);
+      h.spawn('enemy_weak', { pos: [10, 5] });
+      u.skill.gainSp(999);
+      assert.ok(h.runUntil(() => u.skill.activations === 1, 1), `T${tier}: cast with an empty magazine`);
+      h.run(0.6);
+      assert.equal(h.hooksOf('kill').filter((k) => k.killer === u).length, 1, 'the special bullet killed it');
+      assert.equal(u.trait.ammo, 0, 'no bullet spent, none loaded yet');
+      assert.ok(h.runUntil(() => u.trait.ammo > 0, 5));
+      assert.equal(log[log.length - 1][1], 2, `T${tier}: 1 + 1 bullets`);
+      done(h);
+    }
+  }
+});
+
+test('S2 广域警觉 (AUTO, attack SP 16): on at full SP — no enemy needed beyond the attacks that fill it — for good: range 4-10, ATK +60 % / +90 %', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S2);
+    assert.deepEqual([sk.skillType, sk.spType, sk.spCost, sk.bb.atk, sk.bb.respawn_time, sk.rangeId], ['AUTO', 'INCREASE_WHEN_ATTACK', 16, elite ? 0.9 : 0.6, elite ? -0.3 : -0.2, '4-10'], `T${tier}`);
+    const { h, u } = field({ tier, elite, skill: 1 });
+    assert.deepEqual([u.skill.kind, u.skill.rule], ['toggle', 'SP_FULL']);
+    const e = h.spawn('enemy_dummy', { pos: [10, 5] });
+    assert.ok(h.runUntil(() => u.skill.active, 120), `T${tier}: on`);
+    assert.equal(h.hooksOf('attack').filter((c) => c.attacker === u).length, 16, `T${tier}: after 16 attacks (reloads give no SP)`);
+    assert.deepEqual(u.liveRangeGrid, sk.rangeGrid, `T${tier}: 4-10`);
+    approx(u.s.atk, u.base.atk * (1 + sk.bb.atk + u.mem.rayStacks * 0.08), `T${tier}: ATK (with 入神's layers)`);
+    h.b.kill(e, null);
+    h.run(200);
+    assert.ok(u.skill.active, `T${tier}: 持续时间无限`);
+    // an enemy two tiles above her: only 4-10 reaches it
+    const top = h.spawn('enemy_dummy', { pos: [12, 3] });
+    h.run(3);
+    assert.ok(atkHits(h, u).some((c) => c.target === top), `T${tier}: [2,0] of 4-10`);
+    done(h);
+  }
+});
+
+test('S3 “得见光芒” (MANUAL, 16 s, data ACTIVE_RANGE on 3-8): an enemy only on 3-8 casts it; no attack until the magazine is full, reloading every 0.4 s (1.6 − 1.2); range 3-8; attacks 230 % / 270 % × 1.2 and 束缚 2 s; a kill during it ⇒ +10 SP at its end, through 阻回', () => {
+  for (const [tier, elite] of [[5, false], [6, true]]) {
+    const sk = skillOf(tier, elite, S3);
+    assert.deepEqual([sk.duration, sk.spCost, sk.initSp, sk.bb.reload_interval, sk.bb['attack@atk_scale'], sk.bb['attack@unmove_duration'], sk.bb.sp, sk.rangeId],
+      [16, elite ? 33 : 37, elite ? 20 : 15, -1.2, elite ? 2.7 : 2.3, 2, 10, '3-8'], `T${tier}`);
+    const { h, u } = field({ tier, elite, skill: 2 });
+    assert.deepEqual([u.skill.kind, u.skill.rule], ['duration', 'ACTIVE_RANGE']);
+    u.trait.ammo = 2;
+    const log = ammoLog(h, u);
+    u.skill.gainSp(999);
+    const side = h.spawn('enemy_dummy', { pos: [11, 6] });   // [1,3]: in 3-8, not in 4-9
+    assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: cast for [1,3]`);
+    assert.deepEqual(u.liveRangeGrid, sk.rangeGrid, `T${tier}: 3-8 while it runs`);
+    const tCast = h.b.time;
+    const attacksAfter = () => h.hooksOf('attack').filter((c) => c.attacker === u && c.t > tCast - 1e-9);
+    assert.ok(h.runUntil(() => attacksAfter().length > 0, 5), 'attacks once full');
+    // 2 → 8 one bullet every 0.4 s, the first attack on the reload that fills it (the log sees 3 … 7, then 7 after that shot)
+    const fills = log.filter((x) => x[0] > tCast - 1e-9);
+    assert.deepEqual(fills.map((x) => x[1]), [3, 4, 5, 6, 7], `T${tier}: one at a time`);
+    for (let i = 1; i < fills.length; i++) approx(fills[i][0] - fills[i - 1][0], 0.4, `T${tier}: a reload every 0.4 s`, 0.05);
+    approx(attacksAfter()[0].t - fills[fills.length - 1][0], 0.4, `T${tier}: the 8th bullet, then the shot`, 0.05);
+    assert.equal(u.trait.ammo, 7, `T${tier}: full when it shot`);
+    const atkAt = [];
+    h.b.on('damaged', (c) => { if (c.source === u && c.dmg.isAttack) atkAt.push([c, u.s.atk]); }, { priority: -100 });
+    h.run(4);
+    assert.ok(atkAt.length >= 2, `T${tier}: attacks once full`);
+    for (const [c, atk] of atkAt) approx(c.amount, atk * sk.bb['attack@atk_scale'] * 1.2, `T${tier}: ${sk.bb['attack@atk_scale'] * 100} % × 1.2`);
+    const binds = h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'bind' && c.target === side);
+    assert.ok(binds.length >= 2 && binds.every((c) => Math.abs(c.duration - 2) < 1e-6), `T${tier}: 束缚 2 s on each hit`);
+    // a kill during it: +10 SP at its end, through 阻回
+    const weak = h.spawn('enemy_weak', { pos: [10, 4] });
+    h.runUntil(() => !weak.alive, 10);
+    h.b.addBuff(u, { key: 'test:noSp', flags: { noSp: true } });
+    h.runUntil(() => !u.skill.active, 20);
+    approx(u.skill.sp, sk.bb.sp, `T${tier}: +${sk.bb.sp} SP at the end`, 0.01);
+    assert.deepEqual(u.liveRangeGrid, formOf(tier, elite).rangeGrid, `T${tier}: back to 4-9`);
+    done(h);
+  }
+});
+
+test('沙地兽 (her placed piece): untargetable, 无敌, 禁疗, no attack; while it scouts (25 s) the enemies of its 3×3 are in her range and her skill trigger range, she shoots them first, ×1.15 (HUN-X stage 3: ×1.2) physical; then it leaves, and comes back on its tile after 30 s (HUN-X stage 3: 20 s) paying 3 DP', () => {
+  for (const [tier, elite, mod, ds, resp] of [[5, false, null, 0.15, 30], [5, true, HX, 0.15, 30], [6, true, HX, 0.2, 20], [6, true, HY, 0.15, 30]]) {
+    for (const beastFirst of [false, true]) {
+      const { h, u, t } = field({ tier, elite, mod, skill: 2, beast: [10, 6], beastFirst });
+      assert.ok(t && t.alive && t.deployed, `${mod}: deployed with the board`);
+      assert.equal(t.ownerUnit, u);
+      assert.deepEqual([t.base.respawnTime, t.base.cost, t.s.blockCnt], [tokOf(tier, elite, mod).stats.respawnTime, 3, 0], `${mod}: its stats`);
+      assert.equal(t.base.respawnTime, resp);
+      assert.ok(t.s.flags.untargetable && t.s.flags.invulnerable && t.s.flags.noHeal && t.profile.noAttack, `${mod}: untargetable, 无敌, 禁疗, no attack`);
+      assert.equal(t.kit.skill, null, 'no skill of its own');
+      // its area: in her range (and the trigger range of her skill)
+      const away = h.spawn('enemy_dummy', { pos: [11, 7] });   // [1,4] of hers: outside 4-9 (and 3-8), inside its 3×3
+      assert.ok(u.rangeKeySet.has(11 * 21 + 7), 'in her range');
+      u.skill.gainSp(999);
+      assert.ok(h.runUntil(() => u.skill.active, 1), `${mod}: S3 cast for an enemy of the area only`);
+      u.skill.end('test');
+      u.skill.sp = 0;
+      h.b.addBuff(u, { key: 'test:noSp', flags: { noSp: true } });
+      h.run(1); // S3's arrows land
+      // priority: an enemy in her own range nearer the goal loses to the one of the area
+      const near = h.spawn('enemy_dummy', { pos: [10, 4] });
+      const atkAt = [];
+      h.b.on('damaged', (c) => { if (c.source === u && c.dmg.isAttack) atkAt.push([c, u.s.atk]); }, { priority: -100 });
+      h.run(3);
+      assert.ok(atkAt.length >= 1 && atkAt.every(([c]) => c.target === away), `${mod}: she shoots the area's enemy first`);
+      for (const [c, atk] of atkAt) approx(c.amount, atk * 1.2 * (mod === HY ? 1.33 / 1.2 : 1) * (1 + ds), `${mod}: ×${1 + ds} in the area`);
+      h.b.kill(away, null);
+      const n = atkAt.length;
+      h.run(3);
+      for (const [c, atk] of atkAt.slice(n)) { assert.equal(c.target, near); approx(c.amount, atk * (mod === HY ? 1.33 : 1.2), 'no bonus outside'); }
+      // it leaves after its 25 s, her range is her own again
+      const life = tokOf(tier, elite, mod).talents[0].bb.duration;
+      assert.equal(life, 25);
+      assert.ok(h.runUntil(() => !t.alive, 30), 'leaves');
+      approx(h.b.time, life + h.b.dt, `${mod}: after ${life} s`, 0.02);
+      assert.ok(!u.rangeKeySet.has(11 * 21 + 7), 'her range back');
+      // back after its redeploy time, paying 3 DP
+      h.b.players[0].dp = 10;
+      const left = h.b.time;
+      assert.ok(h.runUntil(() => t.alive, resp + 2), `${mod}: back`);
+      approx(h.b.time - left, resp, `${mod}: after ${resp} s`, 0.3);
+      assert.deepEqual([t.tileR, t.tileC, h.b.players[0].dp], [10, 6, 7], `${mod}: on its tile, 3 DP paid`);
+      done(h);
+    }
+  }
+});
+
+test('沙地兽 with S2: 广域警觉 cuts its redeploy time by 20 % / 30 % while on; its passive gives back the bullets that hit in its area when it leaves; withdrawn when 莱伊 leaves, back once she is', () => {
+  for (const [tier, elite, mod, resp] of [[5, false, null, 30], [6, true, null, 30], [6, true, HX, 20]]) {
+    const sk = skillOf(tier, elite, S2);
+    const { h, u, t } = field({ tier, elite, mod, skill: 1, beast: [10, 6] });
+    const e = h.spawn('enemy_dummy', { pos: [11, 7] });   // in its area only
+    // the bullets that hit in its area: counted, given back when it leaves
+    h.runUntil(() => u.trait.ammo <= 3, 20);
+    const spent = 8 - u.trait.ammo;
+    h.b.addBuff(u, { key: 'test:disarm', flags: { disarm: true } });
+    h.run(1);
+    const before = u.trait.ammo;
+    assert.ok(h.runUntil(() => !t.alive, 30), 'leaves');
+    assert.equal(u.trait.ammo, Math.min(8, before + spent), `T${tier}: ${spent} bullets back`);
+    h.b.removeBuff(u, 'test:disarm');
+    h.b.kill(e, null);
+    // S2 on ⇒ redeploy ×(1 + respawn_time)
+    u.skill.gainSp(999, 'init');
+    h.step();
+    assert.ok(u.skill.active, 'S2 on');
+    const left = h.b.time;
+    assert.ok(h.runUntil(() => t.alive, resp + 2), 'back');
+    approx(h.b.time - left, resp * (1 + sk.bb.respawn_time), `T${tier} ${mod}: ${resp} × ${1 + sk.bb.respawn_time} s`, 0.3);
+    // 莱伊 leaves: the 沙地兽 goes too; it waits for her
+    h.b.retreat(u);
+    h.step();
+    assert.ok(!t.alive, 'withdrawn with her');
+    h.run(resp + 5);
+    assert.ok(!t.alive, 'not back while she is away');
+    h.b.redeploy(u);
+    assert.ok(h.runUntil(() => t.alive, 2), 'back with her');
+    done(h);
+  }
+});

test/golden/diy.json

@@ -3494,8 +3494,8 @@
       "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,
+      "about": "5_diy1_a=chen2/S1 5_diy2_a=chen2/S2 5_diy1_a=chen2/S3 5_diy2_b=chen2/S1 5_diy1_b=chen2/S2 5_diy2_b=chen2/S3 5_diy1_b=chen2/S1/002_chen2 5_diy2_b=chen2/S2/002_chen2 5_diy1_b=chen2/S3/002_chen2 5_diy2_b=chen2/S1/003_chen2 5_diy1_b=chen2/S2/003_chen2 5_diy2_b=chen2/S3/003_chen2",
+      "fast": false,
       "kind": "normal",
       "stageId": "act1autochess_m05",
       "modeId": "mode_multi_abyss",
@@ -3505,122 +3505,121 @@
       "time": 213.67,
       "ticks": 6410,
       "reason": "cleared",
-      "killed": 1,
+      "killed": 3,
       "total": 72,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 0,
+      "rngDraws": 9,
       "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":{}}},
+      "players": {"p1":{"killed":3,"total":72,"perfect":false,"leaks":69,"leaksUncounted":0,"coins":0,"dmg":103348,"bossDmg":0,"heal":0,"deaths":19,"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]
+        ["p1",1,"op","chess_char_5_diy1_a",0,null,0,0,57,0,7121,3750,0,6,0],
+        ["p1",2,"op","chess_char_5_diy2_a",1,null,0,0,53,1,7221,3750,0,6,0],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,0,0,1,0,4721,1875,0,4,0],
+        ["p1",4,"op","chess_char_5_diy2_b",0,"none",0,0,3,1,8575,2290,0,5,0],
+        ["p1",5,"op","chess_char_5_diy1_b",1,"none",0,0,5,0,10724,2290,0,3,1],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"none",0,0,7,0,10069,2290,0,6,0],
+        ["p1",7,"op","chess_char_5_diy1_b",0,"uniequip_002_chen2",0,0,9,0,1168,2290,0,1,0],
+        ["p1",8,"op","chess_char_5_diy2_b",1,"uniequip_002_chen2",0,0,51,0,10489,4580,0,4,0],
+        ["p1",9,"op","chess_char_5_diy1_b",2,"uniequip_002_chen2",0,0,2,0,20242,2290,0,5,1],
+        ["p1",10,"op","chess_char_5_diy2_b",0,"uniequip_003_chen2",0,0,91,0,10365,7275,0,5,0],
+        ["p1",11,"op","chess_char_5_diy1_b",1,"uniequip_003_chen2",2425,1,92,1,6293,4850,0,4,1],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_003_chen2",0,0,86,0,6360,4850,0,6,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"
+      "enemies": {"enemy_1005_yokai_2":[18,3,15,5699,34400],"enemy_1041_lazerd_2":[24,0,24,36681,54839],"enemy_1042_frostd":[30,0,30,0,14109]},
+      "hooks": [1,92,6410,150,150,200,200,0,22,91,3,3,12,6644,0,0,72,69,1,22,0,0,0],
+      "events": {"atk":215,"deploy":20,"die":22,"dmg":200,"fx":6,"leak":69,"skill":6,"spawn":84,"status":36},
+      "fx": {"reload":3,"zone":3},
+      "snaps": "f6fa0106 e7d7f790 da41fbcd 79be412e 6a50ceb1 0f273552 f79e9380 4069bc36 855b6919 b766a5fa aa20a6fd 4feaee31 540d226f 7ec78984 07020c87 d519af22 60f79c2e a1fce2e9 93a053a4 b08df923 1a7bc2a9 18ec1c85"
     },
     "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",
+      "about": "6_diy1_a=chen2/S1 6_diy2_a=chen2/S2 6_diy1_a=chen2/S3 6_diy2_b=chen2/S1 6_diy1_b=chen2/S2 6_diy2_b=chen2/S3 6_diy1_b=chen2/S1/002_chen2 6_diy2_b=chen2/S2/002_chen2 6_diy1_b=chen2/S3/002_chen2 6_diy2_b=chen2/S1/003_chen2 6_diy1_b=chen2/S2/003_chen2 6_diy2_b=chen2/S3/003_chen2",
       "fast": false,
       "kind": "normal",
       "stageId": "act1autochess_m06",
       "modeId": "mode_multi_funny",
-      "round": 12,
+      "round": 13,
       "seed": 1650236694,
-      "waveId": "act1autochess_h05",
-      "time": 187.97,
-      "ticks": 5639,
+      "waveId": "act1autochess_h06",
+      "time": 194.23,
+      "ticks": 5827,
       "reason": "cleared",
-      "killed": 315,
-      "total": 315,
+      "killed": 255,
+      "total": 255,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 223,
+      "rngDraws": 240,
       "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":{}}},
+      "players": {"p1":{"killed":255,"total":255,"perfect":true,"leaks":0,"leaksUncounted":0,"coins":0,"dmg":623424,"bossDmg":0,"heal":0,"deaths":4,"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]
+        ["p1",1,"op","chess_char_6_diy1_a",0,null,1875,1,1,0,0,0,0,0,0],
+        ["p1",2,"op","chess_char_6_diy2_a",1,null,1875,1,3,1,1956,0,0,15,1],
+        ["p1",3,"op","chess_char_6_diy1_a",2,null,1875,1,5,18,14580,0,0,47,1],
+        ["p1",4,"op","chess_char_6_diy2_b",0,"none",2290,1,2,0,0,0,0,0,0],
+        ["p1",5,"op","chess_char_6_diy1_b",1,"none",1353.2,1,8,29,38897,937,0,73,4],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"none",2290,1,240,46,91365,2290,0,58,1],
+        ["p1",7,"op","chess_char_6_diy1_b",0,"uniequip_002_chen2",2050.4,1,261,8,19891,4820,0,25,2],
+        ["p1",8,"op","chess_char_6_diy2_b",1,"uniequip_002_chen2",2290,1,7,29,51670,0,0,76,4],
+        ["p1",9,"op","chess_char_6_diy1_b",2,"uniequip_002_chen2",2170.2,1,9,77,302500,120,0,90,2],
+        ["p1",10,"op","chess_char_6_diy2_b",0,"uniequip_003_chen2",2470,1,247,18,72880,2470,0,55,6],
+        ["p1",11,"op","chess_char_6_diy1_b",1,"uniequip_003_chen2",2470,1,4,0,3001,0,0,15,1],
+        ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_003_chen2",2470,1,6,29,26684,0,0,50,1]
       ],
       "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]
+        "enemy_1197_sfshu": [15,15,0,86,36000],
+        "enemy_1197_sfshu_2": [39,39,0,689,125424],
+        "enemy_1198_msfshu": [45,45,0,0,135],
+        "enemy_1198_msfshu_2": [117,117,0,0,468],
+        "enemy_9010_acpupp": [39,39,0,9862,461397]
       },
-      "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"
+      "hooks": [1,271,5827,526,526,2566,1731,0,259,259,23,19,339,21133,0,17,255,0,1,299,0,0,0],
+      "events": {"atk":2115,"deploy":16,"die":259,"dmg":1731,"fx":363,"skill":42,"spawn":267,"status":41},
+      "fx": {"ember":40,"reload":48,"revive":1,"shieldBreak":157,"summon":54,"telegraph":40,"zone":23},
+      "snaps": "ce1454fd 14a61b8f f9a2bcaf 8c273236 4d7141ef c869d474 d5e368ba a4a61ee8 3f6e2c0e f6f1f292 c88a2147 d900808f 4c90faf8 60b8ccc9 bdc48574 8046fefe 2de920cc 0cedbbd1 c2137de1 9c0893cc"
     },
     "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",
+      "about": "5_diy1_a=ray/S1 5_diy2_a=ray/S2 5_diy1_a=ray/S3 5_diy2_b=ray/S1 5_diy1_b=ray/S2 5_diy2_b=ray/S3 5_diy1_b=ray/S1/002_ray 5_diy2_b=ray/S2/002_ray 5_diy1_b=ray/S3/002_ray 5_diy2_b=ray/S1/003_ray 5_diy1_b=ray/S2/003_ray 5_diy2_b=ray/S3/003_ray",
       "fast": false,
       "kind": "normal",
       "stageId": "act1autochess_m07",
       "modeId": "mode_single_hard",
-      "round": 13,
+      "round": 12,
       "seed": 9899299,
-      "waveId": "act1autochess_h06",
-      "time": 219.17,
-      "ticks": 6575,
+      "waveId": "act1autochess_h05",
+      "time": 193,
+      "ticks": 5790,
       "reason": "cleared",
-      "killed": 19,
-      "total": 135,
+      "killed": 13,
+      "total": 75,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 292,
+      "rngDraws": 0,
       "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":{}}},
+      "players": {"p1":{"killed":13,"total":75,"perfect":false,"leaks":62,"leaksUncounted":0,"coins":0,"dmg":275082,"bossDmg":0,"heal":0,"deaths":20,"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],
+        ["p1",1,"op","chess_char_5_diy1_a",0,null,0,0,82,0,12886,3014,0,9,2],
+        ["p1",2,"op","chess_char_5_diy2_a",1,null,0,0,69,1,9221,3014,0,10,0],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,1507,1,98,0,14671,3014,0,9,1],
+        ["p1",4,"op","chess_char_5_diy2_b",0,"none",0,0,61,2,10019,3578,0,9,2],
+        ["p1",5,"op","chess_char_5_diy1_b",1,"none",0,0,54,0,10464,3578,0,9,0],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"none",0,0,91,1,38413,3578,0,17,1],
+        ["p1",7,"op","chess_char_5_diy1_b",0,"uniequip_002_ray",0,0,8,0,7796,1939,0,3,1],
+        ["p1",8,"op","chess_char_5_diy2_b",1,"uniequip_002_ray",0,0,10,0,10500,1939,0,10,0],
+        ["p1",9,"op","chess_char_5_diy1_b",2,"uniequip_002_ray",0,0,58,2,17896,3878,0,13,1],
+        ["p1",10,"op","chess_char_5_diy2_b",0,"uniequip_003_ray",0,0,53,0,22297,3778,0,11,2],
+        ["p1",11,"op","chess_char_5_diy1_b",1,"uniequip_003_ray",0,0,3,2,38470,1889,0,25,1],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_003_ray",0,0,4,5,82449,1889,0,31,2],
         ["-","~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"
+      "enemies": {"enemy_1267_nhpbr_2":[36,6,30,1350,79032],"enemy_1270_nhstlk_2":[27,5,22,2606,145450],"enemy_1272_nhtank_2":[12,2,10,31132,50600]},
+      "hooks": [1,98,5790,199,199,412,412,0,33,95,13,13,0,7906,31,3,75,62,1,33,0,0,0],
+      "events": {"atk":199,"deploy":21,"die":33,"dmg":412,"fx":28,"leak":62,"skill":26,"spawn":89,"status":40},
+      "fx": {"displace":4,"zone":24},
+      "snaps": "6e3248e9 72c4fbbf 9543fa1e 70b4d06d e4899e45 bafab963 2dd9e470 41b96ccb 8f4078fd 174c7c0e 0ed669a8 5e579b2e d125723a cd717feb ea5fff6f da05543c 4041688a f747c66a 3c33dd58 80eb47e3"
     },
     "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",
+      "about": "6_diy1_a=ray/S1 6_diy2_a=ray/S2 6_diy1_a=ray/S3 6_diy2_b=ray/S1 6_diy1_b=ray/S2 6_diy2_b=ray/S3 6_diy1_b=ray/S1/002_ray 6_diy2_b=ray/S2/002_ray 6_diy1_b=ray/S3/002_ray 6_diy2_b=ray/S1/003_ray 6_diy1_b=ray/S2/003_ray 6_diy2_b=ray/S3/003_ray",
       "fast": false,
       "kind": "normal",
       "stageId": "act2autochess_m01",
@@ -3628,35 +3627,289 @@
       "round": 13,
       "seed": 2664068408,
       "waveId": "act1autochess_h06",
-      "time": 230,
-      "ticks": 6900,
-      "reason": "timeout",
+      "time": 226.4,
+      "ticks": 6792,
+      "reason": "cleared",
       "killed": 2,
       "total": 78,
       "unspawned": 0,
       "bossHpLeft": null,
-      "rngDraws": 1111,
+      "rngDraws": 0,
       "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":{}}},
+      "players": {"p1":{"killed":2,"total":78,"perfect":false,"leaks":76,"leaksUncounted":0,"coins":0,"dmg":377192,"bossDmg":0,"heal":0,"deaths":19,"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]
+        ["p1",1,"op","chess_char_6_diy1_a",0,null,1507,1,2,0,60496,0,0,77,15],
+        ["p1",2,"op","chess_char_6_diy2_a",1,null,1507,1,3,0,44021,0,0,66,1],
+        ["p1",3,"op","chess_char_6_diy1_a",2,null,1507,1,4,1,69210,0,0,78,4],
+        ["p1",4,"op","chess_char_6_diy2_b",0,"none",0,0,97,0,32669,5367,0,27,5],
+        ["p1",5,"op","chess_char_6_diy1_b",1,"none",0,0,100,0,11236,5367,0,20,0],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"none",1789,1,101,1,29859,3578,0,17,1],
+        ["p1",7,"op","chess_char_6_diy1_b",0,"uniequip_002_ray",0,0,69,0,13764,3978,0,13,3],
+        ["p1",8,"op","chess_char_6_diy2_b",1,"uniequip_002_ray",0,0,57,0,6034,3978,0,10,0],
+        ["p1",9,"op","chess_char_6_diy1_b",2,"uniequip_002_ray",0,0,84,0,34484,3978,0,23,1],
+        ["p1",10,"op","chess_char_6_diy2_b",0,"uniequip_003_ray",0,0,54,0,23411,3978,0,16,3],
+        ["p1",11,"op","chess_char_6_diy1_b",1,"uniequip_003_ray",0,0,90,0,18160,3978,0,22,1],
+        ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_003_ray",0,0,5,0,33847,1989,0,21,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"
+      "enemies": {"enemy_1045_hammer_2":[18,0,18,7356,39805],"enemy_1061_zomshd":[60,2,58,28835,337387]},
+      "hooks": [1,101,6792,439,439,439,439,20630,21,97,35,34,0,17284,59,21,78,76,1,21,0,0,0],
+      "events": {"atk":439,"deploy":23,"die":21,"dmg":439,"fx":12,"leak":76,"skill":69,"spawn":90,"status":67},
+      "fx": {"displace":12},
+      "snaps": "382cfb68 89fd2ef2 ae0983a2 52cf0a0f 0c120fc1 75e6c03a c61dd517 9fcfad0a a454c86c e4fd3f81 48826f23 92243937 1f31267b 37dac700 50875275 bd20cb01 e7b00ec0 d9e875e7 f0133d6d 82d0ebfc 401a1955 6d80a504 2a55d02e"
+    },
+    "diy-086": {
+      "about": "5_diy1_a=ascln/S1 5_diy2_a=ascln/S2 5_diy1_a=ascln/S3 5_diy2_b=ascln/S1 5_diy1_b=ascln/S2 5_diy2_b=ascln/S3 5_diy1_b=ascln/S1/002_ascln 5_diy2_b=ascln/S2/002_ascln 5_diy1_b=ascln/S3/002_ascln 5_diy2_b=ascln/S1/003_ascln 5_diy1_b=ascln/S2/003_ascln 5_diy2_b=ascln/S3/003_ascln",
+      "fast": false,
+      "kind": "normal",
+      "stageId": "act2autochess_m02",
+      "modeId": "mode_multi_hard",
+      "round": 12,
+      "seed": 1023677650,
+      "waveId": "act1autochess_h05",
+      "time": 196.9,
+      "ticks": 5907,
+      "reason": "cleared",
+      "killed": 47,
+      "total": 126,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 218,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":47,"total":126,"perfect":false,"leaks":79,"leaksUncounted":0,"coins":0,"dmg":1110670,"bossDmg":0,"heal":1179,"deaths":21,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_5_diy1_a",0,null,0,0,138,1,34301,2466,0,8,3],
+        ["p1",2,"op","chess_char_5_diy2_a",1,null,0,0,149,5,79673,2466,0,13,1],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,0,0,124,3,66430,2466,0,13,1],
+        ["p1",4,"op","chess_char_5_diy2_b",0,"none",0,0,7,11,152441,1492,0,15,9],
+        ["p1",5,"op","chess_char_5_diy1_b",1,"none",0,0,100,4,164632,2984,0,16,1],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"none",0,0,91,1,74937,3133,149,15,1],
+        ["p1",7,"op","chess_char_5_diy1_b",0,"uniequip_002_ascln",0,0,94,6,119333,3344,0,15,6],
+        ["p1",8,"op","chess_char_5_diy2_b",1,"uniequip_002_ascln",0,0,8,1,100447,1672,0,14,2],
+        ["p1",9,"op","chess_char_5_diy1_b",2,"uniequip_002_ascln",0,0,81,1,15893,3344,0,7,1],
+        ["p1",10,"op","chess_char_5_diy2_b",0,"uniequip_003_ascln",0,0,109,0,49193,2984,0,9,6],
+        ["p1",11,"op","chess_char_5_diy1_b",1,"uniequip_003_ascln",0,0,103,1,79396,2984,0,8,1],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_003_ascln",0,0,6,13,173994,2522,1030,30,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]
+      ],
+      "enemies": {"enemy_1251_lysyta_2":[54,25,29,0,284055],"enemy_1252_lysytb_2":[42,12,30,31857,424331],"enemy_1329_cbshld_2":[30,10,20,0,402283]},
+      "hooks": [1,149,5907,351,351,3070,2978,23,68,147,33,33,0,13141,0,0,126,79,1,68,0,0,92],
+      "events": {"atk":965,"deploy":21,"die":68,"dmg":2978,"fx":138,"heal":16,"leak":79,"skill":66,"spawn":140},
+      "fx": {"aoe":35,"dodge":103},
+      "snaps": "f27e0385 dd73df32 e8d8c18c 58fe88a0 d321d506 d7741b8d f8590d2b a58179cb 0c2e0a26 485cbac2 1e6839a1 429fff2c 655317d1 2d0586dd 0663ee85 116eac80 19150b2c 0b0dc74f cece33a4 457ed1ac"
+    },
+    "diy-087": {
+      "about": "6_diy1_a=ascln/S1 6_diy2_a=ascln/S2 6_diy1_a=ascln/S3 6_diy2_b=ascln/S1 6_diy1_b=ascln/S2 6_diy2_b=ascln/S3 6_diy1_b=ascln/S1/002_ascln 6_diy2_b=ascln/S2/002_ascln 6_diy1_b=ascln/S3/002_ascln 6_diy2_b=ascln/S1/003_ascln 6_diy1_b=ascln/S2/003_ascln 6_diy2_b=ascln/S3/003_ascln",
+      "fast": false,
+      "kind": "normal",
+      "stageId": "act2autochess_m03",
+      "modeId": "mode_single_normal",
+      "round": 13,
+      "seed": 3678121797,
+      "waveId": "act1autochess_h06",
+      "time": 206.23,
+      "ticks": 6187,
+      "reason": "cleared",
+      "killed": 111,
+      "total": 111,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 0,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":111,"total":111,"perfect":true,"leaks":0,"leaksUncounted":0,"coins":0,"dmg":1995944,"bossDmg":0,"heal":0,"deaths":0,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_6_diy1_a",0,null,1233,1,4,0,0,0,0,0,0],
+        ["p1",2,"op","chess_char_6_diy2_a",1,null,1233,1,6,0,0,0,0,0,0],
+        ["p1",3,"op","chess_char_6_diy1_a",2,null,1233,1,10,1,13894,0,0,24,2],
+        ["p1",4,"op","chess_char_6_diy2_b",0,"none",1492,1,13,20,229642,0,0,57,25],
+        ["p1",5,"op","chess_char_6_diy1_b",1,"none",1492,1,14,38,632149,0,0,66,4],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"none",1492,1,8,0,0,0,0,0,0],
+        ["p1",7,"op","chess_char_6_diy1_b",0,"uniequip_002_ascln",1762,1,11,0,0,0,0,0,0],
+        ["p1",8,"op","chess_char_6_diy2_b",1,"uniequip_002_ascln",1762,1,15,38,836075,0,0,66,4],
+        ["p1",9,"op","chess_char_6_diy1_b",2,"uniequip_002_ascln",1762,1,5,0,0,0,0,0,0],
+        ["p1",10,"op","chess_char_6_diy2_b",0,"uniequip_003_ascln",1492,1,7,5,67773,0,0,32,21],
+        ["p1",11,"op","chess_char_6_diy1_b",1,"uniequip_003_ascln",1492,1,9,7,114460,0,0,49,3],
+        ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_003_ascln",1492,1,12,2,101950,0,0,70,2],
+        ["-","~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_1010_demon":[54,54,0,0,755827],"enemy_1320_wdrrl_2":[18,18,0,0,839808],"enemy_1422_lrsldr_2":[39,39,0,0,400308]},
+      "hooks": [1,126,6187,364,364,4867,4867,44,111,111,61,59,0,29355,0,0,111,0,1,111,0,0,0],
+      "events": {"atk":1313,"deploy":12,"die":111,"dmg":4867,"fx":128,"skill":120,"spawn":126},
+      "fx": {"aoe":128},
+      "snaps": "c58a3354 0088be2f 9b417aea b12db011 204cabfe 6b77bd28 4275f3de 48c31853 7996459e 84e6878a cab22d6b 4f6e4875 373eca89 1da2800d 2a337d35 247543d4 2bd5fb12 dd85c84f 3d388cb7 8a8c3fce cc65b065"
+    },
+    "diy-088": {
+      "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": "act2autochess_m04",
+      "modeId": "mode_multi_abyss",
+      "round": 12,
+      "seed": 2037857272,
+      "waveId": "act1autochess_h05",
+      "time": 218.57,
+      "ticks": 6557,
+      "reason": "cleared",
+      "killed": 6,
+      "total": 117,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 0,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":6,"total":117,"perfect":false,"leaks":111,"leaksUncounted":0,"coins":0,"dmg":49809,"bossDmg":0,"heal":7862,"deaths":26,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_5_diy1_a",2,null,0,0,7,0,0,4259,0,0,0],
+        ["p1",2,"op","chess_char_5_diy2_b",2,"none",0,0,99,0,0,7479,0,0,0],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,0,0,144,0,0,5682,0,0,0],
+        ["p1",4,"op","chess_char_5_diy2_b",2,"none",3089.26,1,146,0,0,6913,0,0,0],
+        ["p1",5,"op","chess_char_5_diy1_a",2,null,0,0,145,1,15398,3813,0,39,1],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"none",0,0,127,5,20168,3020,0,36,1],
+        ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,87,0,1401,3284,0,3,0],
+        ["p1",8,"op","chess_char_5_diy2_b",2,"none",0,0,80,0,6039,2720,0,11,0],
+        ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,104,0,0,2803,5507,11,1],
+        ["p1",10,"op","chess_char_5_diy2_b",2,"none",0,0,89,0,0,3803,2355,5,1],
+        ["p1",11,"op","chess_char_5_diy1_a",2,null,0,0,142,0,3555,2796,0,9,0],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"none",0,0,135,0,3248,4466,0,7,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_1005_yokai":[51,6,45,0,36058],"enemy_1005_yokai_2":[54,0,54,22898,3215],"enemy_1005_yokai_3":[12,0,12,28140,10536]},
+      "hooks": [1,146,6557,375,375,304,304,16,32,143,4,4,0,8931,16,0,117,111,1,32,0,0,0],
+      "events": {"atk":375,"deploy":27,"die":32,"dmg":304,"heal":16,"leak":111,"skill":8,"spawn":131,"status":26},
+      "fx": {},
+      "snaps": "0f6c29b3 7d7f4cb5 60c56598 80baeb1b e9f961db f42bb481 ab0c4234 bc807e95 481eca65 7d2d5ac3 10328772 da749f2b 29b08f41 f36f08b8 cdccb32d d4a823cf 613f1734 a1ceda81 7735a612 aaa1475f 3e23da31 af08b882"
+    },
+    "diy-089": {
+      "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_m01",
+      "modeId": "mode_multi_funny",
+      "round": 12,
+      "seed": 875916966,
+      "waveId": "act1autochess_h05",
+      "time": 218.67,
+      "ticks": 6560,
+      "reason": "cleared",
+      "killed": 77,
+      "total": 135,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 536,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":77,"total":135,"perfect":false,"leaks":58,"leaksUncounted":0,"coins":0,"dmg":535252,"bossDmg":0,"heal":14403,"deaths":18,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_5_diy1_a",2,null,0,0,7,3,18450,2604,0,55,1],
+        ["p1",2,"op","chess_char_5_diy2_b",2,"uniequip_002_acfend",1486.7,1,152,6,32120,5255,0,78,2],
+        ["p1",3,"op","chess_char_5_diy1_a",2,null,1529,1,160,7,13390,3058,0,18,2],
+        ["p1",4,"op","chess_char_5_diy2_b",2,"uniequip_002_acpion",1904,1,161,18,91337,3808,0,32,3],
+        ["p1",5,"op","chess_char_5_diy1_a",2,null,0,0,104,5,33204,5276,0,38,2],
+        ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_002_acguad",0,0,8,16,46690,7492,0,38,2],
+        ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,4,3,49382,1272,0,76,2],
+        ["p1",8,"op","chess_char_5_diy2_b",2,"uniequip_002_acnipe",0,0,5,4,113248,1587,0,86,2],
+        ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,110,9,71607,3782,0,19,1],
+        ["p1",10,"op","chess_char_5_diy2_b",2,"uniequip_002_accast",1749,1,159,6,65824,4166,0,18,1],
+        ["p1",11,"op","chess_char_5_diy1_a",2,null,0,0,6,0,0,2380,7014,27,2],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_002_acmedc",1414,1,154,0,0,10288,7389,15,2],
+        ["-","~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_2021_syfish":[105,68,37,6080,298282],"enemy_2025_syufo":[30,9,21,44888,236970]},
+      "hooks": [1,161,6560,1085,1085,1814,2038,55,95,153,22,20,0,23267,0,66,135,58,1,127,0,29,52],
+      "events": {"atk":1188,"deploy":23,"die":95,"dmg":2038,"fx":228,"heal":44,"leak":58,"skill":42,"spawn":150,"status":101},
+      "fx": {"aoe":78,"burst":29,"dodge":52,"dp":30,"slash":34,"spGain":5},
+      "snaps": "9dae7911 a9a69c15 b04b9d6b 2632cde7 a3eb28e7 91d0121a 8b90f890 da0d4315 95f51ef4 382d7798 752fd542 8c1e8dba d3a902c5 68ce96e9 44d2a08a e5fc8710 1297af66 be66a715 acc679a6 cae1e0f8 7b516454 05df224b"
+    },
+    "diy-090": {
+      "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_m02",
+      "modeId": "mode_single_hard",
+      "round": 13,
+      "seed": 3530218451,
+      "waveId": "act1autochess_h06",
+      "time": 225.2,
+      "ticks": 6756,
+      "reason": "cleared",
+      "killed": 25,
+      "total": 123,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 278,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":25,"total":123,"perfect":false,"leaks":98,"leaksUncounted":0,"coins":0,"dmg":536476,"bossDmg":0,"heal":0,"deaths":24,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_6_diy1_a",2,null,0,0,114,0,1948,5208,0,14,1],
+        ["p1",2,"op","chess_char_6_diy2_b",2,"uniequip_002_acfend",3431,1,151,0,11220,3431,0,38,1],
+        ["p1",3,"op","chess_char_5_diy1_a",0,null,0,0,124,0,16534,3730,0,56,1],
+        ["p1",4,"op","chess_char_5_diy2_b",0,"uniequip_002_sharp2",0,0,119,5,117142,4748,0,72,1],
+        ["p1",5,"op","chess_char_6_diy1_a",2,null,1529,1,154,3,21255,3058,0,26,2],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acpion",1904,1,145,6,137754,3808,0,25,5],
+        ["p1",7,"op","chess_char_5_diy1_a",2,null,339.26,1,142,2,36131,7739,0,74,0],
+        ["p1",8,"op","chess_char_5_diy2_b",2,"uniequip_002_acspec",1448,1,153,0,15364,5792,0,34,0],
+        ["p1",9,"op","chess_char_6_diy1_a",2,null,0,0,3,2,18571,2638,0,15,1],
+        ["p1",10,"op","chess_char_6_diy2_b",2,"uniequip_002_acguad",0,0,100,4,72172,7062,0,54,2],
+        ["p1",11,"op","chess_char_5_diy1_a",2,null,1160,1,6,2,34981,0,0,137,3],
+        ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_002_acsupo",1430,1,8,1,53404,0,0,149,3]
+      ],
+      "enemies": {"enemy_1010_demon":[54,10,44,19382,232506],"enemy_1422_lrsldr_2":[39,14,25,3166,147540],"enemy_1425_lrcmra_2":[30,1,29,24666,156430]},
+      "hooks": [1,154,6756,881,881,1337,1432,0,49,147,20,28,0,23030,12048,54,123,98,1,50,0,0,7],
+      "events": {"atk":935,"deploy":31,"die":49,"dmg":1396,"fx":148,"leak":98,"skill":62,"spawn":135,"status":962},
+      "fx": {"aoe":35,"displace":17,"dodge":24,"dp":16,"slash":56},
+      "snaps": "45d547f5 f06f8156 d86aa4cf 4dc98162 8dfe9b80 67d08948 a0676382 b36bcb6d a2adf966 33640ca3 fc3edcfd 972111f3 b5adab54 098c6c79 93608620 4a6dfc91 93584952 55293420 3b94baf7 cf0d6edf 02e20ddd f5822da3 9c2357ae"
+    },
+    "diy-091": {
+      "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": "act1autochess_m03",
+      "modeId": "mode_multi_normal",
+      "round": 13,
+      "seed": 452598099,
+      "waveId": "act1autochess_h06",
+      "time": 203.07,
+      "ticks": 6092,
+      "reason": "cleared",
+      "killed": 182,
+      "total": 270,
+      "unspawned": 0,
+      "bossHpLeft": null,
+      "rngDraws": 603,
+      "errors": {"count":0,"kinds":[]},
+      "players": {"p1":{"killed":182,"total":270,"perfect":false,"leaks":88,"leaksUncounted":0,"coins":0,"dmg":753683,"bossDmg":0,"heal":43799,"deaths":9,"layerGains":{}}},
+      "units": [
+        ["p1",1,"op","chess_char_6_diy1_a",0,null,0,0,257,14,25600,3730,0,65,1],
+        ["p1",2,"op","chess_char_6_diy2_b",0,"uniequip_002_sharp2",2494,1,262,62,164726,4376,0,113,3],
+        ["p1",3,"op","chess_char_6_diy1_a",2,null,1154,1,265,7,40217,21340,0,135,0],
+        ["p1",4,"op","chess_char_6_diy2_b",2,"uniequip_002_acspec",1484,1,245,14,63710,22396,0,163,0],
+        ["p1",5,"op","chess_char_6_diy1_a",2,null,1272,1,8,14,15309,0,0,75,2],
+        ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acnipe",1643,1,12,8,47792,0,0,83,2],
+        ["p1",7,"op","chess_char_6_diy1_a",2,null,1372,1,14,2,27768,0,0,34,1],
+        ["p1",8,"op","chess_char_6_diy2_b",2,"uniequip_002_accast",1819,1,4,57,203553,0,0,69,2],
+        ["p1",9,"op","chess_char_6_diy1_a",2,null,1224,1,6,0,0,0,27634,64,2],
+        ["p1",10,"op","chess_char_6_diy2_b",2,"uniequip_002_acmedc",1464,1,256,0,0,6076,16165,37,2],
+        ["p1",11,"op","chess_char_6_diy1_a",2,null,1160,1,13,4,65081,0,0,143,2],
+        ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_002_acsupo",1450,1,15,0,99926,0,0,151,2],
+        ["-","~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,26,13,11065,182952],
+        "enemy_1196_msfyin": [52,36,16,0,83],
+        "enemy_1197_sfshu": [48,34,14,19041,288162],
+        "enemy_1198_msfshu": [102,68,34,0,238],
+        "enemy_1199_sfjin": [18,11,7,27811,282012],
+        "enemy_1200_msfjin": [11,7,4,0,236]
+      },
+      "hooks": [1,293,6092,1361,1361,1774,1911,148,191,279,19,22,0,32384,5465,66,270,88,1,191,0,0,0],
+      "events": {"atk":1471,"deploy":20,"die":191,"dmg":1897,"fx":110,"heal":123,"leak":88,"skill":50,"spawn":285,"status":825},
+      "fx": {"aoe":15,"displace":5,"dodge":10,"spGain":9,"summon":71},
+      "snaps": "2a7e310a f77b6f7e 58e269bd d77c5d12 33a04af1 c8474941 85999194 5896c818 c4ffef53 7d1661ce 805b05d6 04606e57 48e3022e 07e8e0a3 e1ba8c7b b3674111 6368bf11 fadf3fe0 8eca6edf 04ff41a3 68434c4b"
     }
   }
 }