From e0cce79f98bd9b45493e267ce0cfad89234f826e Mon Sep 17 00:00:00 2001 From: sganggs Date: Tue, 6 Oct 2026 01:38:08 +0800 Subject: [PATCH] =?UTF-8?q?feedback5=20O11:=20=E8=87=AA=E9=80=89=20operato?= =?UTF-8?q?r=20kits=20=E8=96=87=E8=96=87=E5=AE=89=E5=A8=9C,=20=E6=80=92?= =?UTF-8?q?=E6=BD=AE=E5=87=9B=E5=86=AC=20and=20=E8=B5=AB=E5=BE=B7=E9=9B=B7?= =?UTF-8?q?=20=E2=80=94=20every=20skill,=20talent,=20trait=20and=20module?= =?UTF-8?q?=20(stage=201=20/=203)=20at=20every=20form?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - kits/ops/op-vvana.js, op-headb2.js, op-hodrer.js (registered in OPERATOR_KIT_FILES), checked against the data, PRTS and the client's battle data (charpacks, [uc]skills / [uc]equips prefabs, buff templates, 怒潮凛冬's Skill_3 clip events). - Engine (additive): ai.js enemyAttack marks a shot that flies as a projectile isProjectile (远程途径: 薇薇安娜's 散华 护盾 blocks melee-path hits only); targeting.js priority 'elite' (薇薇安娜 S3 "优先攻击精英或领袖敌人"); docs/SIM.md §4 / §8. - Tests: test/content/op_vvana.test.js (13), op_headb2.test.js (10), op_hodrer.test.js (8). - Golden: only diy moved — diy-049 … 054 now field the three operators in every form × module × skill, the prototypes follow in diy-054 … 058 (same packing); diy-001 … 048 and every other family unchanged. --- docs/SIM.md | 8 +- server/sim/ai.js | 8 +- server/sim/content/kits/index.js | 3 + server/sim/content/kits/ops/op-headb2.js | 281 ++++++++++++++ server/sim/content/kits/ops/op-hodrer.js | 176 +++++++++ server/sim/content/kits/ops/op-vvana.js | 283 ++++++++++++++ server/sim/targeting.js | 2 + test/content/op_headb2.test.js | 323 ++++++++++++++++ test/content/op_hodrer.test.js | 288 +++++++++++++++ test/content/op_vvana.test.js | 419 +++++++++++++++++++++ test/golden/diy.json | 450 +++++++++++++++++------ 11 files changed, 2128 insertions(+), 113 deletions(-) create mode 100644 server/sim/content/kits/ops/op-headb2.js create mode 100644 server/sim/content/kits/ops/op-hodrer.js create mode 100644 server/sim/content/kits/ops/op-vvana.js create mode 100644 test/content/op_headb2.test.js create mode 100644 test/content/op_hodrer.test.js create mode 100644 test/content/op_vvana.test.js diff --git a/docs/SIM.md b/docs/SIM.md index b2c94271..5a8f89ed 100644 --- a/docs/SIM.md +++ b/docs/SIM.md @@ -655,7 +655,10 @@ HP left is refused (damage.js `hasHp`: a lethal hit's `damaged` hook runs before `battle.dealDamage(source, target, dmg)` → HP removed. `DamageInfo = { amount, type:'phys'|'arts'|'true'|'elemental'|'element', element?, defIgnoreFlat, defIgnorePct, resIgnoreFlat, resIgnorePct, mul=1, canDodge (phys/arts), isSkill, isSplash, -isAttack, attackId, ignoreSleep, ignoreSelect, sourceless, tags[], cancel }` (`ignoreSelect`: no selection 无法选择 +isAttack, isProjectile, attackId, ignoreSleep, ignoreSelect, sourceless, tags[], cancel }` (`isProjectile`: 远程途径 — an +enemy normal attack that flew as a projectile (ai.js enemyAttack; PRTS 作战机制 "有弹道的攻击固定为10，无弹道的攻击固定为01") +and 怒潮凛冬's 高台 splash (PRTS "被视为远程途径伤害"); every other hit is 近战途径 — what only melee-path damage triggers +reads it: 薇薇安娜's 散华 护盾, kits/ops/op-vvana.js; `ignoreSelect`: no selection 无法选择 effects stop — an ability "无视无法选择", a direct pick such as a counter on the attacker, a flying unit's blast credited to a ground leader, the tick of a debuff already on the unit — it reaches an airborne 起飞 ally whatever its source; `sourceless`: 无来源 damage — the source's stats add nothing and the hooks get `source: null` plus `credit` = the source, @@ -1149,7 +1152,8 @@ S3 未照耀的荣光 — its CUSTOM_RANGE trigger also counts flyers). A stun / instant, and so are `'beam'` hits (a 锁定攻击范围 AoE without a projectile — `rangeAoe` profiles: "在攻击前摇结束时选取范围内的全体目标，同时造成伤害", PRTS 作战机制). Kit-settable profile flags beyond the table: `hitSleep` (targets and damages sleeping enemies — "可以攻击沉睡的敌人"), `onEachHit(b, u, victim, hctx)`, `dmgMul`, `afterHit`, `afterAttack`, `canAttack`, `hitsFn`, `priority` (targeting.js PRIORITY_FNS — `'heaviest'`: the 攻城手 trait -"优先攻击重量最重的敌人", the highest current 重量等级 first: 早露 / 提丰), `blockFly`, `noHeal`, `skipEnemy(e)` (an enemy the unit never +"优先攻击重量最重的敌人", the highest current 重量等级 first: 早露 / 提丰; `'elite'`: "优先攻击精英或领袖敌人", an ELITE / BOSS +rank enemy or a leader first: 薇薇安娜 S3), `blockFly`, `noHeal`, `skipEnemy(e)` (an enemy the unit never selects — its attacks, the enemies it blocks and its skill-trigger targets: targeting.js canTargetEnemy; 嵯峨 "不攻击重伤 单位"), `boomerang` (the projectile stays `'boomerang'` whatever the data's generic ranged projectile says), `boomerangOnward(ctx)` (a boomerang's flight after its diff --git a/server/sim/ai.js b/server/sim/ai.js index 149469b9..d91b0b21 100644 --- a/server/sim/ai.js +++ b/server/sim/ai.js @@ -713,12 +713,14 @@ function enemyAttack(b, e) { for (const t of targets) { b._ev(['atk', e.id, t.id, deferred ? (e.profile.shot || 'none') : rangedShot ? 'enemy' : 'none']); if (deferred) continue; - const hit = (tt) => { + // a shot that flies as a projectile is 远程途径 (DamageInfo `isProjectile`; PRTS 作战机制 "有弹道的攻击固定为10，无弹道的攻击 + // 固定为01"): what only 近战途径 damage triggers skips it (薇薇安娜's 散华 护盾, kits/ops/op-vvana.js) + const hit = (tt, isProjectile = false) => { if (!tt || !tt.alive || !e.alive && !rangedShot) return; - b.dealDamage(e, tt, { amount: e.s.atk * (e.profile?.atkScale ?? 1), type, isAttack: true, attackId }); + b.dealDamage(e, tt, { amount: e.s.atk * (e.profile?.atkScale ?? 1), type, isAttack: true, attackId, isProjectile }); }; if (rangedShot && Math.hypot(t.x - e.x, t.y - e.y) > 0.75) { - b.addProjectile({ from: e, target: t, speed: PROJECTILE_SPEEDS.enemy, visual: 'enemy', source: e, onHit: (c) => hit(c.target) }); + b.addProjectile({ from: e, target: t, speed: PROJECTILE_SPEEDS.enemy, visual: 'enemy', source: e, onHit: (c) => hit(c.target, true) }); } else hit(t); } if (b._hooks.attack) b.emit('attack', { attacker: e, targets, isSkill: false }); diff --git a/server/sim/content/kits/index.js b/server/sim/content/kits/index.js index 99f513f5..98eccca8 100644 --- a/server/sim/content/kits/index.js +++ b/server/sim/content/kits/index.js @@ -103,6 +103,9 @@ export const OPERATOR_KIT_FILES = Object.freeze([ 'op-ifrit.js', 'op-aphris.js', 'op-lin.js', + 'op-vvana.js', + 'op-headb2.js', + 'op-hodrer.js', ]); /** diff --git a/server/sim/content/kits/ops/op-headb2.js b/server/sim/content/kits/ops/op-headb2.js new file mode 100644 index 00000000..f3af1f5d --- /dev/null +++ b/server/sim/content/kits/ops/op-headb2.js @@ -0,0 +1,281 @@ +// server/sim/content/kits/ops/op-headb2.js — 怒潮凛冬 (char_1051_headb2) 自选 operator kit: 6★ 撼地者 (近卫), an owned-6★ pick +// of the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and the module at every form. +// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)"). +// +// Forms (data/backups.json units.char_1051_headb2, the DIY slot statuses): normal = E2 Lv1, skills at rank 4, no module; +// elite = E2 Lv60, rank 7, HAM-X at stage 1 (tier 5) or 3 (tier 6) when picked. Potential 0 [ASSUMED: no account]. +// Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json; teamId `student`); PRTS +// 怒潮凛冬 (备注 of 汹涌怒火, 绝不罢休 and 无可抵挡); gamedata_const ba.sluggish 停顿, ba.root 束缚; the client's battle data read +// from the local install — charpack char_1051_headb2, battle/prefabs [uc]skills skchr_headb2_3 and [uc]equips headb2_equip_*, +// buff_template_data headb2_* (named below) — and the battle skeleton's Skill_3 clip events. +// - Trait (撼地者) "攻击使目标周围的其他敌人受到相当于攻击力50%的群体物理伤害": the profession splash (radius 1.0, 50 %, others only, +// ground enemies — the trait bb). +// - Module HAM-X 迟到的勋章: trait "溅射范围内有大于或等于3个敌人时，使当次攻击力提升至115%" (trait bb cnt / atk_scale_e; +// headb2_e_002_trait: ON_CALCULATE_DAMAGE, CheckEnemyCountWhenAttackDoCast ≥ cnt — the enemies the attack, or S3's ability, +// strikes — then AtkScaleUp): an attack whose target and splash victims (radius 1.0 around the target, ground) number at least +// cnt deals ×atk_scale_e on each of its damage instances (an ATK scale: before DEF); an S3 hammer counts its own 1.5 range, +// every 高台 splash its own x-5 (PRTS "每个溅射效果独立计算X模组特性加成"). Stage 3: 汹涌怒火 +40 % (below). +// - T1 汹涌怒火 "特性溅射造成的物理伤害提升24%，且溅射到的每个高台对周围四格所有地面敌人造成相当于攻击力24%的物理伤害和0.5秒停顿" +// (damage_scale; HAM-X stage 3 1.4 — attack@splash_atk_scale, attack@sluggish): the trait splash ×damage_scale +// (headb2_t_1[damage_scale]: ON_OUTPUT_DAMAGE on the APPLY_TO_HAMMER_SUBCLASS_SPLASH_TARGET damage, PHYSICAL — PRTS "伤害倍率提升 +// 而非攻击倍率提升，且不对特性主目标生效": dmg.mul, splash victims only). 高台 splash (PRTS "独立于攻击的效果，其以该次攻击中心为中心， +// 选择1.0半径内的地块触发溅射（重叠判定），伤害溅射范围为周围4格+本格x-5（格子判定），造成物理溅射伤害" / "伤害会被视为远程途径伤害… +// 由此伤害击倒的敌人会被视为无来源击杀"; the charpack's highland AoE: radius 1.0, x-5, targetMotion ground, physical, `_attackType` +// ranged, sluggish from the blackboard, `_intervalTime` 0.1, SP via headb2_s_2[sp]): after each attack, every 高台 (a HIGH +// tile of the field rect: walls and forbidden blocks) whose square the circle of radius 1.0 around the target touches +// triggers; 0.1 s later the ground enemies she could select on its x-5 take attack@splash_atk_scale × her ATK at the trigger +// (physical 溅射伤害: no dodge; 无来源 credited to her, 远程途径 — DamageInfo isProjectile) and 停顿 attack@sluggish s. +// - T2 万众巨潮 "技能期间所有场上干员攻击力和防御力+14%，【乌萨斯学生自治团】干员获得加成效果翻倍" (atk / def, scale_bonus; the aura's +// validator: ally operators of every profession, herself included; headb2_skill_judge switches it with her skill's start / +// finish; headb2_t_2[filter_tag]: CheckCharacterGroupTag `student` ⇒ ×scale_bonus, MULTIPLIER attributes): while a skill of +// hers runs, every operator of the field (teammates' in a shared field — the kits' field-wide convention) ATK / DEF +// +atk / +def, ×scale_bonus for the 【乌萨斯学生自治团】 (character_table teamId `student`) — given at the cast, renewed every +// TIDE_IV s (operators deployed meanwhile) and taken back at the end; two sources keep the strongest. +// - S1 誓不低头 (MANUAL, data DEFAULT, 30 s): ATK +atk, ASPD +attack_speed. +// - S2 绝不罢休 (AUTO): "被动效果：每次有高台触发第一天赋的效果时，获得1点技力" (sp_per_highland; PRTS 备注 "根据单次天赋触发的高台 +// 数量提供相应的sp") — +sp per 高台 that triggers, none while a skill runs (AK). "自动开启：攻击范围扩大，攻击力+60%，防御力+40%" — +// a self buff, so it fires at full SP (`trigger: 'SP_FULL'`, the owner's AUTO rule, kits/README.md checklist 5): the 2-5 +// range, ATK / DEF for 16 s; "第二次及以后使用时能力加成变为最初的两倍，且持续时间无限" (headb2_s_2[second].atk / .def): from +// the second cast of a deployment [ASSUMED: counted per deployment, as 提丰's S2] the doubled values until she leaves (a +// toggle the kit ends after `duration` s on its first cast, as op-typhon.js). +// - S3 无可抵挡 (MANUAL, data CUSTOM_RANGE on its trigger grid; the ability headb2_s3: `_additionalTimes` 4, each hit on its +// clip's attack event, not affected by ASPD — PRTS 备注 "锤击间隔1.8s…不受攻击速度影响"): ATK +atk_base; five hammers at the +// Skill_3 clip's OnAttack events (HAMMER_FRAMES at 30 fps: 1.1 … 7.77 s after the cast) and the skill over with the clip +// (SKILL3_FRAMES, 9.23 s); she makes no normal attack meanwhile. headb2_s_3: spell_times from −1, +1 at each hammer's spell +// ⇒ hammer k at ATK +atk_base + atk_step × (k − 1). Each hammer is centred 1.0 ahead (备注 "每次锤击以正前方1.0距离位置为中心"): +// an enemy on the tile ahead is its main target (her order; usually none), atk_scale × ATK physical; every other ground enemy +// within HAMMER_SPLASH ("主攻击拥有1.5的溅射半径") takes the trait's splash share (`_splashAtkScaleKey` atk_scale_2 — × atk_scale +// as well, the kits' 撼地者 convention, 佩佩 S1 [ASSUMED] — ×汹涌怒火) — skill damage, not a normal attack [ASSUMED]. Each hammer +// runs 汹涌怒火's 高台 round at its centre with the skill's change "伤害效果提升至3.5倍，控制效果变为1秒束缚" (the skill's AoE: +// splash_atk_scale_base × splash_atk_scale_bonus, headb2_s_3[unmovable] for `unmovable` s instead of 停顿, `_firstIntervalTime` +// 0.1 then `_intervalTime` 0.125 per step) and the spread (备注 "第二次锤击起，所有本次锤击触发第一天赋的高台生效时将令相邻的未受 +// 影响的高台触发第一天赋（即扩散），最大扩散次数等同于当前已完成锤击次数；不论如何，一轮锤击中每个高台只会触发一次天赋效果" / "离场时， +// 未完成的天赋效果扩散将立刻终止"): hammer k spreads up to k − 1 steps to the four tiles next to each affected 高台 [ASSUMED: +// "相邻" = the 4 neighbours]. A hammer due while she cannot act is lost [ASSUMED]. + +import { num, talentBb, traitBb, skillRec, up, giveSp } from '../shared/tier1.js'; +import { COLS } from '../../../constants.js'; +import { sortEnemyTargets } from '../../../targeting.js'; + +const S1 = 'skchr_headb2_1'; +const S2 = 'skchr_headb2_2'; +const S3 = 'skchr_headb2_3'; +/** PRTS 汹涌怒火 备注: "选择1.0半径内的地块触发溅射（重叠判定）". */ +const HIGHLAND_PICK_RADIUS = 1.0; +/** PRTS 汹涌怒火 备注: "伤害溅射范围为周围4格+本格x-5（格子判定）" (symmetric: no rotation). */ +const X5 = Object.freeze([[0, 0], [1, 0], [-1, 0], [0, 1], [0, -1]]); +/** 汹涌怒火's 高台 AoE: `_intervalTime` 0.1 (PRTS "高台溅射效果从触发/被扩散到生效具有0.1秒内置延迟"); S3's own AoE: `_firstIntervalTime` + * 0.1, then `_intervalTime` 0.125 per spread step. */ +const HIGHLAND_DELAY = 0.1, S3_SPREAD_STEP = 0.125; +/** The battle skeleton's Skill_3 clip (30 fps): 277 frames, OnAttack at frames 33, 84, 133, 182 and 233 (PRTS "锤击间隔1.8s"). */ +const FPS = 30, SKILL3_FRAMES = 277, HAMMER_FRAMES = Object.freeze([33, 84, 133, 182, 233]); +/** PRTS 无可抵挡 备注: "每次锤击以正前方1.0距离位置为中心" / "主攻击拥有1.5的溅射半径". */ +const HAMMER_REACH = 1.0, HAMMER_SPLASH = 1.5; +/** 【乌萨斯学生自治团】: character_table teamId `student` (古米, 凛冬, 烈夏, 苦艾, 真理, 早露, 怒潮凛冬; as op-poca.js). */ +const STUDENTS = new Set(['char_196_sunbr', 'char_115_headbr', 'char_194_leto', 'char_405_absin', 'char_195_glassb', + 'char_197_poca', 'char_1051_headb2']); +/** 万众巨潮: the renewal of the aura while a skill of hers runs. */ +const TIDE_IV = 0.25; +const TIDE_KEY = 'talent:headb2:tide'; +const S2_KEY = 'skill:headb2:s2'; +const STEP_KEY = 'skill:headb2:step'; +const HAMMER_TAG = 'headb2Hammer'; +const HIGHLAND_TAG = 'headb2Highland'; +const GROUND = Object.freeze({ canHitFly: false }); + +const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {}; +const tagged = (d, tag) => !!d && Array.isArray(d.tags) && d.tags.includes(tag); +const isOp = (a) => !!a && a.kind === 'op'; + +/** Tile keys of the 高台 (HIGH tiles of the field rect) whose square the circle of radius `r` around (x, y) touches. */ +function highlandsAround(battle, x, y, r = HIGHLAND_PICK_RADIUS) { + const g = battle.grid, out = []; + for (let row = Math.floor(y - r); row <= Math.ceil(y + r); row++) { + for (let col = Math.floor(x - r); col <= Math.ceil(x + r); col++) { + if (!g.inRect(row, col) || g.tile(row, col).height !== 'HIGH') continue; + const dx = Math.max(Math.abs(x - col) - 0.5, 0), dy = Math.max(Math.abs(y - row) - 0.5, 0); + if (dx * dx + dy * dy <= r * r + 1e-9) out.push(row * COLS + col); + } + } + return out; +} +/** The 高台 next to tile key `k` (the spread of S3). */ +function highlandNeighbours(battle, k) { + const r = Math.floor(k / COLS), c = k % COLS, g = battle.grid, out = []; + for (const [dr, dc] of X5) { + if (!dr && !dc) continue; + const rr = r + dr, cc = c + dc; + if (g.inRect(rr, cc) && g.tile(rr, cc).height === 'HIGH') out.push(rr * COLS + cc); + } + return out; +} + +export default { + char_1051_headb2: (bb, chess) => { + const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1); + const tb = traitBb(chess); + const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3); + const s2 = skillRec(chess, S2); + const splashMul = num(t0.damage_scale, 1); + const hxScale = num(tb.atk_scale_e, 1), hxCnt = num(tb.cnt, Infinity); + const hamx = (n) => (hxScale !== 1 && n >= hxCnt ? hxScale : 1); + const traitShare = num(tb['attack@atk_scale_2'], 0.5); + + /** One 高台 taking effect: its x-5 ground enemies take the splash and 停顿 (束缚 during S3). */ + const highlandStrike = (battle, unit, k, atk, s3) => { + const r = Math.floor(k / COLS), c = k % COLS; + const keys = []; + for (const [dr, dc] of X5) if (battle.grid.inRect(r + dr, c + dc)) keys.push((r + dr) * COLS + c + dc); + const foes = battle.enemiesInKeys(keys, unit, GROUND); + battle.fx('aoe', { x: c, y: r, radius: 1, id: unit.id, skill: 'headb2:highland' }); + if (!foes.length) return; + const amount = atk * num(t0['attack@splash_atk_scale']) * (s3 ? num(b3.splash_atk_scale_bonus, 1) : 1) * hamx(foes.length); + for (const e of foes) { + if (!e.alive) continue; + battle.dealDamage(unit, e, { amount, type: 'phys', isSplash: true, canDodge: false, sourceless: true, isProjectile: true, tags: [HIGHLAND_TAG] }); + if (!e.alive) continue; + if (s3) battle.applyStatus(e, 'bind', { duration: num(b3.unmovable, 1), source: unit }); + else if (num(t0['attack@sluggish']) > 0) battle.applyStatus(e, 'sluggish', { duration: num(t0['attack@sluggish']), source: unit }); + } + }; + /** + * A round of 汹涌怒火's 高台 splashes centred on (x, y): every 高台 within 1.0 triggers now and takes effect + * HIGHLAND_DELAY s later; with `depth` > 0 (S3) each one that takes effect makes the 高台 next to it that this round has + * not touched yet trigger — S3_SPREAD_STEP s later —, up to `depth` steps. S2's passive: +sp per 高台 that triggers. + */ + const highlandRound = (battle, unit, x, y, depth = 0) => { + const tiles = highlandsAround(battle, x, y); + if (!tiles.length) return; + const seq = unit.deploySeq, atk = unit.s.atk; + const s3 = !!(unit.skill?.active && unit.skill.id === S3); + const sp = unit.skill?.id === S2 ? num(b2.sp_per_highland) : 0; + const seen = new Set(tiles); + const trigger = (k, step) => { + if (sp > 0) giveSp(unit, sp); + battle.after(step > 0 && s3 ? S3_SPREAD_STEP : HIGHLAND_DELAY, () => { + if (!(unit.alive && unit.deployed && unit.deploySeq === seq)) return; // 离场: the round stops + highlandStrike(battle, unit, k, atk, s3); + if (step >= depth) return; + for (const nb of highlandNeighbours(battle, k)) if (!seen.has(nb)) { seen.add(nb); trigger(nb, step + 1); } + }, { owner: unit }); + }; + for (const k of tiles) trigger(k, 0); + }; + /** S3 hammer `k` (1-based): centred 1.0 ahead, a main target on the tile ahead if any, the 1.5 splash, the 高台 round. */ + const hammer = (battle, unit, k) => { + const [fr, fc] = unit.fwd; + const cx = unit.x + fc * HAMMER_REACH, cy = unit.y + fr * HAMMER_REACH; + const tr = unit.tileR + fr, tc = unit.tileC + fc; + let main = null; + if (battle.grid.inRect(tr, tc)) { + const cands = battle.enemiesInKeys([tr * COLS + tc], unit, unit.profile); + sortEnemyTargets(battle, unit, cands, unit.profile?.priority ?? null); + main = cands[0] ?? null; + } + const around = battle.foesInRadius(cx, cy, HAMMER_SPLASH, true).filter((e) => e !== main && !e.isFlying); + const atk = unit.s.atk, scale = num(b3.atk_scale, 1) * hamx((main ? 1 : 0) + around.length); + battle.fx('aoe', { x: cx, y: cy, radius: HAMMER_SPLASH, id: unit.id, skill: 'headb2:hammer' }); + if (main && main.alive) battle.dealDamage(unit, main, { amount: atk * scale, type: 'phys', isSkill: true, tags: ['skill', HAMMER_TAG] }); + for (const e of around) { + if (!e.alive) continue; + battle.dealDamage(unit, e, { amount: atk * scale * traitShare, type: 'phys', isSkill: true, isSplash: true, mul: splashMul, tags: ['skill', HAMMER_TAG] }); + } + highlandRound(battle, unit, cx, cy, k - 1); + }; + + return { + skills: { + [S1]: { kind: 'duration', mods: { atkPct: num(b1.atk), aspd: num(b1.attack_speed) } }, + [S2]: { + kind: 'toggle', + trigger: { rule: 'SP_FULL' }, + targeting: { rangeGrid: s2?.rangeGrid ?? null }, + onStart({ battle, unit, skill }) { + const later = (unit.mem.headb2S2Casts ?? 0) >= 1; + unit.mem.headb2S2Casts = (unit.mem.headb2S2Casts ?? 0) + 1; + const atk = later ? num(b2['headb2_s_2[second].atk']) : num(b2.atk); + const def = later ? num(b2['headb2_s_2[second].def']) : num(b2.def); + battle.addBuff(unit, { key: S2_KEY, mods: { atkPct: atk, defPct: def }, tags: ['skill'] }); + skill.timeLeft = later ? Infinity : Math.max(0.01, skill.duration); + }, + onTick({ skill, dt }) { + if (!Number.isFinite(skill.timeLeft)) return; + skill.timeLeft -= dt; + if (skill.timeLeft <= 1e-9) skill.end('duration'); + }, + onEnd({ battle, unit }) { battle.removeBuff(unit, S2_KEY); }, + }, + [S3]: { + kind: 'duration', + duration: SKILL3_FRAMES / FPS, + mods: { atkPct: num(b3.atk_base) }, + attack: { noAttack: true }, + onStart({ battle, unit, skill }) { + const n0 = skill.activations, seq = unit.deploySeq, step = num(b3.atk_step); + let done = 0; + for (const f of HAMMER_FRAMES) { + battle.after(f / FPS, () => { + if (!(unit.alive && unit.deployed && unit.deploySeq === seq && skill.active && skill.activations === n0)) return; + if (!unit.canAct) return; // a hammer due while she cannot act is lost [ASSUMED] + hammer(battle, unit, done + 1); + done++; + if (step) battle.addBuff(unit, { key: STEP_KEY, mods: { atkPct: step * done }, tags: ['skill'] }); + }, { owner: unit }); + } + }, + onEnd({ battle, unit }) { battle.removeBuff(unit, STEP_KEY); }, + }, + }, + talents: [ + { install(battle, unit) { // 汹涌怒火: the trait splash ×damage_scale (the 高台 rounds: trait.afterHit and the hammers) + if (splashMul === 1) return; + battle.on('hit', (c) => { + const d = c.dmg; + if (c.source === unit && d.isAttack && d.isSplash && !tagged(d, HAMMER_TAG)) d.mul *= splashMul; + }, { owner: unit }); + } }, + { install(battle, unit) { // 万众巨潮: every operator of the field ATK / DEF + while a skill of hers runs (students ×) + const a = num(t1.atk), d = num(t1.def), x = num(t1.scale_bonus, 1); + if (!a && !d) return; + const inSkill = () => !!(unit.skill && unit.skill.active && unit.skill.kind !== 'passive'); + const give = () => { + if (!up(unit) || !inSkill()) return; + for (const o of battle.alliesFor(unit)) { + if (!isOp(o)) continue; + const k = STUDENTS.has(o.def?.charId) ? x : 1; + const cur = o.findBuff(TIDE_KEY); + if (cur && cur.source !== unit && (cur.data?.v ?? 0) > a * k && cur.timeLeft > 0.05) continue; + battle.addBuff(o, { key: TIDE_KEY, duration: TIDE_IV + 0.1, mods: { atkPct: a * k, defPct: d * k }, source: unit, data: { v: a * k }, tags: ['aura'] }); + } + }; + battle.every(TIDE_IV, give, { owner: unit }); + battle.on('skillStart', (c) => { if (c.unit === unit) give(); }, { owner: unit }); + battle.on('skillEnd', (c) => { + if (c.unit !== unit) return; + for (const o of battle.allyUnits) { const b = o.findBuff(TIDE_KEY); if (b && b.source === unit) battle.removeBuff(o, b); } + }, { owner: unit }); + } }, + ], + // 汹涌怒火's 高台 round after each attack, centred on its target + trait: { afterHit: (battle, unit, target, hctx) => { if (unit.alive && unit.deployed) highlandRound(battle, unit, hctx.x, hctx.y); } }, + install(battle, unit) { + // S2: the cast count of a deployment [ASSUMED per deployment] + battle.on('deploy', (c) => { if (c.unit === unit) unit.mem.headb2S2Casts = 0; }, { owner: unit }); + // HAM-X: ≥ cnt ground enemies in the splash range of the attack's target ⇒ ×atk_scale_e on each of its instances + if (hxScale === 1) return; + battle.on('hit', (c) => { + const d = c.dmg; + if (c.source !== unit || !d.isAttack || !d.attackId || tagged(d, HAMMER_TAG)) return; + const m = unit.mem; + if (m.headb2HamxId !== d.attackId) { + // the first instance of an attack is its target's (ai.js resolveHit: the main hit, then the splash) + const t = c.target; + m.headb2HamxId = d.attackId; + m.headb2HamxMul = hamx(1 + battle.foesInRadius(t.x, t.y, unit.profile?.splashRadius || 1, true).filter((e) => e !== t && !e.isFlying).length); + } + d.amount *= m.headb2HamxMul ?? 1; + }, { owner: unit, priority: 5 }); + }, + }; + }, +}; diff --git a/server/sim/content/kits/ops/op-hodrer.js b/server/sim/content/kits/ops/op-hodrer.js new file mode 100644 index 00000000..2588e432 --- /dev/null +++ b/server/sim/content/kits/ops/op-hodrer.js @@ -0,0 +1,176 @@ +// server/sim/content/kits/ops/op-hodrer.js — 赫德雷 (char_4088_hodrer) 自选 operator kit: 6★ 重剑手 (近卫), an owned-6★ pick of +// the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and both modules at every form. +// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)"). +// +// Forms (data/backups.json units.char_4088_hodrer, the DIY slot statuses): normal = E2 Lv1, skills at rank 4, no module; +// elite = E2 Lv60, rank 7, the picked module at stage 1 (tier 5) or 3 (tier 6). Potential 0 [ASSUMED: no account]. +// Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json); PRTS 赫德雷 (备注 of 及锋而试 +// and 死境硝烟); PRTS 卫戍协议/帮助 §技能操作 ("携带状态切换类技能的干员…每次部署后仅开启一次技能"); gamedata_const ba.protect 庇护, +// ba.stun 晕眩, ba.root 束缚; PRTS 伤害分类 (无来源真实持续伤害); the client's battle data read from the local install — +// charpack char_4088_hodrer, battle/prefabs [uc]skills skchr_hodrer_1/2/3 and [uc]equips hodrer_equip_*, buff_template_data +// hodrer_* (named below). +// - Trait (重剑手) "同时攻击阻挡的所有敌人": the profession (melee physical, ground only, block 2, 2.5 s). +// - Module CRU-X 新的生活: trait "受到的治疗效果提升20%" (trait bb heal_scale; equip_heal_scale_up): healingTakenMul ×heal_scale — +// his own S1 / S3 heals included. Stage 3: 余火之氅 28 % and 物理伤害 +10 % (below). +// - Module CRU-Y 笔迹: trait "对被阻挡的敌人伤害提升至110%" (trait bb damage_scale; hodrer_e_003_tr: ON_OUTPUT_DAMAGE, CheckBlocked +// by the buff's source — him): ×damage_scale (a damage multiplier) on every damage of his on an enemy HE blocks. Stage 3: +// 及锋而试 130 % / 160 % and its first-hit stun (below). +// - T1 及锋而试 "攻击敌人时攻击力提升至110%，若目标处于晕眩、束缚则改为提升至140%" (atk_scale_2 / atk_scale; hodrer_t_1: +// ON_CALCULATE_DAMAGE, abnormal flags STUNNED / UNMOVABLE → AtkScaleUp): each damage instance of his attacks ×atk_scale_2, or +// ×atk_scale on a target under a 晕眩 or 束缚 status (冻结 is neither) — an ATK scale, before DEF. PRTS 备注 "本天赋于每次攻击的 +// 附加效果后、计算伤害前判断并生效": the attack's riders come first, in the same `hit` step — S2's stun and S3's stun roll (the +// attacks' `_activeBuffs`), then CRU-Y stage 3's "且对阻挡的敌人首次造成伤害时对其造成2.5秒晕眩效果" (hodrer_e_003_t, event +// priority 2000 — before 及锋而试: an enemy he blocks without his mark gets it and stuns `stun` s; the marks are derived from +// the module talent's buff, so they go when he leaves the field and a redeployed 赫德雷 stuns anew) — so a hit that stuns +// counts as on a stunned target; a rider lands when the hit is then dodged [ASSUMED: the client applies them in the attack's +// damage calculation]. +// - T2 余火之氅 "使自身与身后一格的友军获得18%的庇护" (damage_resistance, talent grid b-1: his tile and the one behind; CRU-X +// stage 3 "28%…且造成的物理伤害提升10%" — hodrer_equip_1_3_p2 gives damage_resistance[inf] and hodrer_equip[damage_scale_up] +// (ON_OUTPUT_DAMAGE PHYSICAL ×damage_scale) to the same targets, ally side, any motion, removed when they leave): 庇护 +// (ba.protect "受到的物理和法术伤害降低相应比例（同名效果取最高）") = phys / artsTakenMul 1 − value as one instance per ally +// (applyStrongest) with physDealtMul ×damage_scale, renewed every PROTECT_IV s on the allies of the grid while he is deployed. +// - S1 重锋不熄 (AUTO, hit SP: INCREASE_WHEN_ATTACK, data DEFAULT): the next attack (every enemy he blocks) at atk_scale × ATK; +// hodrer_s[heal] (ON_ABILITY_SPELL_ON, HealViaMaxHpRatio) heals hp_ratio of his max HP once for that attack. +// - S2 余烬重荷 (MANUAL, data DEFAULT): "被动效果：攻击力+16%" (atk; the skill's extra ability hodrer_s_2[passive]) while it is +// his skill; "主动触发可以在下列状态和初始状态间切换" — a 状态切换类 skill, switched on once per deployment and kept (the official +// auto-battle rule, `toggle`): attack interval +base_attack_time s (flat), block +block_cnt, every attack stuns its targets +// attack@stun s. +// - S3 死境硝烟 (MANUAL, data ACTIVE_RANGE on its running range, 70 / 70 s): max HP +max_hp, ATK +atk, 攻击距离 +// +ability_range_forward_extend; each attack heals attack@hp_ratio of his max HP (hodrer_s[heal], once per attack) and stuns +// each target attack@stun s with attack@buff_prob. hodrer_s_3[damage] (triggerInterval 1 s, the first after 1 s): he loses +// attack@value HP every second (FixedValueDamage that skips the damage events: a 流失 here [ASSUMED: it may knock him out — +// no floor is named]); every damage he outputs on an enemy, and every damage an enemy deals him, marks that enemy if it is +// not 无敌 (one hodrer_s_3[burn] per enemy and 赫德雷, PRTS 备注 "仅判定本次技能期间满足条件的非无敌敌方单位…不可叠加"): from +// then on it takes attack@damage 无来源 true damage (NoSourceDamage PURE: damage.js periodicDamage, credited to him) every +// second of its own (triggerInterval 1 s from its mark) until the skill ends (a derived buff of the skill's). + +import { num, talentBb, talentGrid, moduleBb, traitBb, skillRec, statBuff, up, batMod, alliesInGridOf } from '../shared/tier1.js'; +import { periodicDamage } from '../../../damage.js'; + +const S1 = 'skchr_hodrer_1'; +const S2 = 'skchr_hodrer_2'; +const S3 = 'skchr_hodrer_3'; +/** 余火之氅's grid when the data carries none: his tile and the one behind him (range b-1). */ +const BEHIND = Object.freeze([Object.freeze([0, -1]), Object.freeze([0, 0])]); +const PROTECT_IV = 0.25; +const PROTECT_KEY = 'talent:hodrer:protect'; +const S2_PASSIVE_KEY = 'skill:hodrer:s2passive'; +/** hodrer_s_3[damage] / hodrer_s_3[burn]: triggerInterval 1 s, waitFirstTriggerInterval. */ +const SMOKE_IV = 1; +/** The riders and 及锋而试 before the other `hit` handlers read the hit. */ +const T1_PRIORITY = 10; + +const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {}; +/** Under a 晕眩 or 束缚 status (及锋而试: abnormal flags STUNNED / UNMOVABLE). */ +const held = (e) => e.buffs.some((b) => (b.status ?? b.key) === 'stun' || (b.status ?? b.key) === 'bind'); +/** The S3 burn of one 赫德雷 on an enemy (independentCharacterSource: one per source). */ +const smokeKey = (unit) => `skill:hodrer:smoke:${unit.id}`; + +export default { + char_4088_hodrer: (bb, chess) => { + const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1); + const hidden = moduleBb(chess); // CRU-Y stage 3: stun (the first-hit stun on an enemy he blocks) + const tb = traitBb(chess); + const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3); + const selfHeal = (battle, unit, ratio) => { if (ratio > 0) battle.heal(unit, unit, unit.s.maxHp * ratio, { self: true }); }; + /** S3: mark `e` (not 无敌) for this cast — its own 1 s burn until the skill ends. */ + const mark = (battle, unit, e) => { + const marks = unit.mem.hodrerMarks; + if (!marks || marks.has(e) || !e.alive || e.s.flags.invulnerable) return; + marks.add(e); + const dmg = num(b3['attack@damage']); + battle.addBuff(e, { + key: smokeKey(unit), interval: SMOKE_IV, source: unit, tags: ['skill'], + onTick: ({ battle: b, unit: target }) => { if (dmg > 0) b.dealDamage(unit, target, periodicDamage(dmg)); }, + }); + }; + return { + skills: { + [S1]: { + kind: 'instant', + attack: { atkScale: num(b1.atk_scale, 1) }, + onAttack({ battle, unit }) { selfHeal(battle, unit, num(b1.hp_ratio)); }, + }, + [S2]: { + kind: 'toggle', + mods: { batPct: batMod(b2.base_attack_time, chess), blockCnt: num(b2.block_cnt) }, + }, + [S3]: { + kind: 'duration', + mods: { hpPct: num(b3.max_hp), atkPct: num(b3.atk) }, + targeting: { rangeExtend: num(b3.ability_range_forward_extend) }, + onStart({ battle, unit, skill }) { + const n0 = skill.activations; + unit.mem.hodrerMarks = new Set(); + unit.mem.hodrerSmoke = battle.every(SMOKE_IV, (b, sc) => { + if (!skill.active || skill.activations !== n0 || !up(unit)) { sc.cancel(); return; } + battle.loseHp(unit, num(b3['attack@value']), { source: unit, tags: ['hodrer:smoke'] }); + }, { owner: unit }); + }, + onAttack({ battle, unit }) { selfHeal(battle, unit, num(b3['attack@hp_ratio'])); }, + onEnd({ battle, unit }) { + unit.mem.hodrerSmoke?.cancel(); + unit.mem.hodrerSmoke = null; + for (const e of unit.mem.hodrerMarks ?? []) battle.removeBuff(e, smokeKey(unit)); + unit.mem.hodrerMarks = null; + }, + }, + }, + talents: [ + { install(battle, unit) { // 及锋而试 (+ the riders that precede it): ×atk_scale_2, ×atk_scale on a stunned / bound target + const firstStun = num(hidden.stun); + let stunnedOnce = new WeakSet(); // CRU-Y stage 3's marks, gone with his deployment + battle.on('deploy', (c) => { if (c.unit === unit) stunnedOnce = new WeakSet(); }, { owner: unit }); + battle.on('hit', (c) => { + const d = c.dmg, e = c.target; + if (c.source !== unit || !d.isAttack || d.cancel || !e || e.side !== 'enemy') return; + const sk = unit.skill; + if (sk?.active && sk.id === S2) battle.applyStatus(e, 'stun', { duration: num(b2['attack@stun']), source: unit }); + if (sk?.active && sk.id === S3 && e.alive && battle.rng.chance(num(b3['attack@buff_prob']))) { + battle.applyStatus(e, 'stun', { duration: num(b3['attack@stun']), source: unit }); + } + if (firstStun > 0 && e.alive && e.blockedBy === unit && !stunnedOnce.has(e)) { + stunnedOnce.add(e); + battle.applyStatus(e, 'stun', { duration: firstStun, source: unit }); + } + d.amount *= held(e) ? num(t0.atk_scale, 1) : num(t0.atk_scale_2, 1); + }, { owner: unit, priority: T1_PRIORITY }); + } }, + { install(battle, unit) { // 余火之氅: 庇护 (and CRU-X stage 3 物理伤害 +) on his tile and the one behind + const dr = num(t1.damage_resistance), ds = num(t1.damage_scale, 1); + const grid = talentGrid(chess, 1) ?? BEHIND; + if (!(dr > 0) && ds === 1) return; + const mods = (v) => ({ physTakenMul: 1 - v, artsTakenMul: 1 - v, ...(ds !== 1 ? { physDealtMul: ds } : {}) }); + const give = () => { + if (!up(unit)) return; + for (const a of alliesInGridOf(battle, unit, grid)) battle.applyStrongest(a, PROTECT_KEY, { duration: PROTECT_IV + 0.1, value: dr, mods, source: unit }); + }; + battle.every(PROTECT_IV, give, { owner: unit }); + battle.on('battleStart', give, { owner: unit }); + battle.on('deploy', (c) => { if (c.unit === unit && battle.started) give(); }, { owner: unit }); + } }, + ], + install(battle, unit) { + // CRU-X: 受到的治疗效果提升20% + statBuff(battle, unit, 'trait:hodrer:heal', { healingTakenMul: num(tb.heal_scale, 1) }); + // CRU-Y: 对被（自身）阻挡的敌人伤害提升至110% + const vs = num(tb.damage_scale, 1); + if (vs !== 1) { + battle.on('hit', (c) => { + if (c.source === unit && c.target && c.target.side === 'enemy' && c.target.blockedBy === unit) c.dmg.mul *= vs; + }, { owner: unit }); + } + // S2's passive part: 攻击力+16% while 余烬重荷 is his skill + if (unit.skill?.id === S2) statBuff(battle, unit, S2_PASSIVE_KEY, { atkPct: num(b2.atk) }); + // S3: every damage either way between him and an enemy marks the enemy for the running cast + if (unit.skill?.id === S3) { + battle.on('hit', (c) => { + if (!unit.mem.hodrerMarks) return; + if (c.source === unit && c.target && c.target.side === 'enemy') mark(battle, unit, c.target); + else if (c.target === unit && c.source && c.source.side === 'enemy') mark(battle, unit, c.source); + }, { owner: unit }); + } + }, + }; + }, +}; diff --git a/server/sim/content/kits/ops/op-vvana.js b/server/sim/content/kits/ops/op-vvana.js new file mode 100644 index 00000000..f9f00fde --- /dev/null +++ b/server/sim/content/kits/ops/op-vvana.js @@ -0,0 +1,283 @@ +// server/sim/content/kits/ops/op-vvana.js — 薇薇安娜 (char_4098_vvana) 自选 operator kit: 6★ 术战者 (近卫), an owned-6★ pick +// of the tier-5 and tier-6 自选 slots; every skill, both talents, the trait and both modules at every form. +// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)"). +// +// Forms (data/backups.json units.char_4098_vvana, the DIY slot statuses): normal = E2 Lv1, skills at rank 4, no module; +// elite = E2 Lv60, rank 7, the picked module at stage 1 (tier 5) or 3 (tier 6). Potential 0 [ASSUMED: no account]. +// Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json); PRTS 薇薇安娜 (备注 of +// 散华, 光影迅捷剑 and “明灭”, the AFT-Δ trait note); gamedata_const ba.charged 蓄力, ba.shield 护盾, ba.steal 偷取, +// ba.magicfragile 法术脆弱; PRTS 作战机制 (伤害流程, 远近途径 "有弹道的攻击固定为10，无弹道的攻击固定为01"); range_table 3-2; the +// client's battle data read from the local install — charpack char_4098_vvana, battle/prefabs [uc]skills skchr_vvana_1/2/3 +// and [uc]equips vvana_equip_*, buff_template_data vvana_* (the templates are named below). +// - Trait (术战者) "攻击造成法术伤害": the profession (melee arts, ground only, block 1, 1.25 s). +// - Module AFT-D 目不能及之处: trait "攻击灼燃损伤爆发期间的目标时额外造成攻击力15%的元素伤害" (trait bb ep_damage_ratio; PRTS +// "※于任意非本模组特性的伤害的输出伤害时触发"; vvana_e_002_trait: ON_OUTPUT_DAMAGE, not its own damage, the target in its FIRE +// 爆发冷却 → ELEMENT damage ep_damage_ratio × ATK): every damage instance she outputs on an enemy holding the `burnBurst` lock +// (docs/SIM.md §3) — at the output (the `hit` step, before the target's dodge / cancel) — adds ep_damage_ratio × ATK +// 元素伤害. Stage 3: 燃烛施明's 灼燃损伤 (below). +// - Module AFT-Y “最后一行”: trait "自身阻挡的敌人受到10%的法术脆弱效果" (trait bb damage_scale 1.1; vvana_equip_2_*: weak[magic] +// to every blockee): the 法术脆弱 status (同名效果取最高) on each enemy she blocks, renewed every 0.2 s for 0.3 s (as 史尔特尔's +// AFT-Y). Stage 3: 散华 25 %, 2 layers (below). +// - T1 燃烛施明 "造成的法术伤害+8%，受到的物理和法术伤害-8%。攻击范围内存在精英或领袖敌人时，该效果提升至2倍" (damage_scale_m, +// damage_resistance_pm, super_scale; vvana_t_1[self] / [aura] / [super]: an aura on the enemies of her current range — +// targetMotion ALL, flyers too, no untargetable one — and on those she blocks; an ELITE / BOSS one swaps [self] for [super], +// ×super_scale): artsDealtMul 1 + 0.08 f, phys / artsTakenMul 1 − 0.08 f, f = super_scale while such an enemy is there, else +// 1 — re-read every tick and before every hit she deals or takes. AFT-D stage 3 "攻击附带相当于9%伤害的灼燃损伤" +// (ep_damage_ratio_m; the templates' ON_AFTER_OUTPUT_DAMAGE on her non-continuous arts damage, ApplyElementDamageBasedOnDamageValue +// FIRE): each arts damage instance of hers that removes HP carries ep × f × that damage as 灼燃损伤. +// - T2 散华 "攻击精英或领袖敌人时，有18%概率获得一层仅抵挡近战攻击的护盾（最多1层）" (prob; AFT-Y stage 3: 25 %, max_stack_cnt 2; +// S3: × talent_scale; vvana_t_2: ON_OUTPUT_DAMAGE on an ELITE_AND_BOSS target, Dice prob, CreateBuff vvana_t_2[block_melee] — +// UNIQUE without max_stack_cnt, STACK up to it with — so a roll at the cap changes nothing, PRTS "※自身未存在本天赋的护盾时，每对 +// 符合条件的目标造成一次伤害判定一次本天赋"): one roll per damage instance she outputs on an elite / leader (any damage — the AFT-D +// rider too — at the output, before the target's dodge / cancel). vvana_t_2[block_melee]: ON_TAKE_DAMAGE from an ENEMY source +// with apply way MELEE → BlockDamage, one layer spent (ba.shield "每层护盾可以抵挡一次伤害"; PRTS "※仅来源于敌方单位的近战途径伤害 +// 可触发本天赋的护盾"): an enemy's damage that did not fly as a projectile (DamageInfo `isProjectile`, ai.js enemyAttack) is +// negated whole in a late `hit` handler (cancel, as the enemies' 护盾 layers in content/enemies.js); 无来源 damage has no enemy +// source. The enemy content's own projectiles (invisible / leaders / fly kits) are not marked and count as melee [ASSUMED]. +// - S1 光影迅捷剑 (AUTO, 2 charges, data DEFAULT — a "next attack" waits for her attack): the next attack at atk_scale × ATK, +// S1_HITS hits (S1_Attack2, `_additionalTimes` 1). 蓄力 (ba.charged "回复至上限2倍时进入蓄力状态…任何时候开启均消耗全部技力"; PRTS +// 备注 "未满足蓄力所需技力时…仅消耗技能最低所需技力" / "“蓄力”模式将在下一次技能结束时结束" / "“蓄力”模式期间…攻击范围变为3-2"; +// the skill's toggle at SP ratio 1 puts vvana_s_1[mode] — mode 1, range 3-2 — whose ON_SKILL_START clears the SP and +// ON_SKILL_FINISH ends it; S1_Attack, `_additionalTimes` 2 on 3-2, needs its mark): with both charges stored her own range is +// 3-2 (the DEFAULT trigger's initial range and the card follow it) until the next end of the skill; a cast then hits +// S1_CHARGED_HITS times and spends every charge, a cast below that spends one charge. +// - S2 烛燃影息 (MANUAL, data DEFAULT, 28 / 30 s; mode 2): ATK +atk, DEF +def, block +block_cnt, every attack hits all the +// enemies she blocks; each attack picks Attack_Once / Attack_Twice (attack@prob_once / attack@prob_twice: one roll per +// attack), the double hit at attack@atk_scale_twice × ATK carrying vvana_s_2[steal] (ON_BEFORE_TARGET_APPLY_MODIFIER of each +// damage → vvana_steal_attack_speed: ba.steal "减少目标的基础属性作为自身加成，目标减少和自身加成的属性不超过指定上限（同类属性取最高）"): +// each enemy it hits loses attack@steal_atk_speed ASPD (at most attack@steal_atk_speed_max per enemy, the largest of several +// thieves) and she gains as much (at most the max in all) — "持续至技能结束或薇薇安娜离场"; a dodged hit steals too (the step +// comes before the target's checks). +// - S3 “明灭” (MANUAL, data DEFAULT, 15 s): attack interval +base_attack_time s (flat), ATK +atk, DEF +def, RES +// +magic_resistance, S3_HITS hits per attack, 散华 × talent_scale, elite / leader enemies first (targeting priority 'elite', +// after the enemies she blocks — the engine's order). "第二次及以后使用时，攻击距离+2，攻击变为三连击，持续时间延长至25秒" (PRTS +// 备注 "每次部署薇薇安娜时，重新计算该技能的使用次数" / "首次技能结束后，本技能的技能范围永久扩大至3-2"; vvana_s_3[check]: a +// skill triggered before ⇒ the enhance mark and duration_plus = enhance_duration, vvana_s_3: mode 4 instead of 3): from her +// second cast of a deployment the skill runs enhance_duration s with S3_LATER_HITS hits on the 3-2 range (her own grid while +// it runs: the card shows it). The trigger stays the data's DEFAULT on her own range for every cast — the later casts' +// larger running range is no data range (reported, not changed: kits/README.md checklist 5). + +import { num, talentBb, traitBb, skillRec, up, batMod } from '../shared/tier1.js'; +import { isElite, elementDmg, enemiesIn } from '../shared/tier6.js'; +import { hasHp } from '../../../damage.js'; + +const S1 = 'skchr_vvana_1'; +const S2 = 'skchr_vvana_2'; +const S3 = 'skchr_vvana_3'; +/** range_table 3-2: the 蓄力 range (PRTS S1 备注) and S3's range from its second cast (PRTS S3 备注). */ +const RANGE_3_2 = Object.freeze([[0, 0], [0, 1], [0, 2], [0, 3]].map((p) => Object.freeze(p))); +/** S1 "并连续攻击两次" / 蓄力 "改为连续攻击三次"; S2 "二连击"; S3 "攻击变为二连击" / later "攻击变为三连击" — text only. */ +const S1_HITS = 2, S1_CHARGED_HITS = 3, S2_TWICE_HITS = 2, S3_HITS = 2, S3_LATER_HITS = 3; +/** AFT-Y: the 法术脆弱 renewal (as 史尔特尔's AFT-Y, kits/ops/chess_char_5_07-surtr.js). */ +const FRAGILE_IV = 0.2, FRAGILE_DUR = 0.3; +const AFTD_TAG = 'vvanaAftD'; +const CANDLE_KEY = 'talent:vvana:candle'; +const SHIELD_KEY = 'talent:vvana:shield'; +const LOOT_KEY = 'skill:vvana:loot'; +const STOLEN_KEY = 'skill:vvana:stolen'; +/** `hit` order: 燃烛施明 re-reads its factor first; the output effects (AFT-D, 散华's roll) come before the target-side + * handlers (priority 0: the enemies' own 护盾, guards); 散华's 护盾 itself last (a guard that cancelled first spends none). */ +const CANDLE_PRIORITY = 100, OUTPUT_PRIORITY = 50, SHIELD_PRIORITY = -500; + +const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {}; +const tagged = (d, tag) => !!d && Array.isArray(d.tags) && d.tags.includes(tag); +/** Her own range grid (the form's 1-1), or the range she switches to. */ +function setGrid(battle, unit, grid) { + if (!grid || unit.rangeGrid === grid) return; + unit.rangeGrid = grid; + battle.refreshRange(unit); +} + +// ---- S2 偷取: the losses of the enemies, one battle-wide table (同类属性取最高 over several thieves) --------------------- +/** battle → Map(enemy → Map(thief id → ASPD stolen)). */ +const STOLEN = new WeakMap(); +const stolenOf = (battle) => { let m = STOLEN.get(battle); if (!m) STOLEN.set(battle, (m = new Map())); return m; }; +function applyLoss(battle, e, per) { + let a = 0; + for (const v of per.values()) a = Math.max(a, v); + if (!(a > 0)) { battle.removeBuff(e, STOLEN_KEY); return; } + battle.addBuff(e, { key: STOLEN_KEY, mods: { aspd: -a }, tags: ['steal'] }); +} +function steal(battle, unit, e, n, cap) { + if (!(n > 0) || !e || !e.alive || e.side !== 'enemy') return; + const losses = stolenOf(battle); + let per = losses.get(e); + if (!per) losses.set(e, (per = new Map())); + per.set(unit.id, Math.min(cap, (per.get(unit.id) ?? 0) + n)); + applyLoss(battle, e, per); + (unit.mem.vvanaVictims ??= new Set()).add(e); + unit.mem.vvanaLoot = Math.min(cap, (unit.mem.vvanaLoot ?? 0) + n); + battle.addBuff(unit, { key: LOOT_KEY, mods: { aspd: unit.mem.vvanaLoot }, tags: ['skill'] }); +} +/** "持续至技能结束或薇薇安娜离场": she gives everything back. */ +function returnLoot(battle, unit) { + battle.removeBuff(unit, LOOT_KEY); + unit.mem.vvanaLoot = 0; + const losses = stolenOf(battle); + for (const e of unit.mem.vvanaVictims ?? []) { + const per = losses.get(e); + if (!per || !per.delete(unit.id)) continue; + if (e.alive) applyLoss(battle, e, per); + } + unit.mem.vvanaVictims = new Set(); +} + +export default { + char_4098_vvana: (bb, chess) => { + const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1); + const tb = traitBb(chess); + const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3); + const twice = num(b2['attack@atk_scale_twice'], 1); + return { + skills: { + [S1]: { + kind: 'charges', + attack: { atkScale: num(b1.atk_scale, 1), hitsFn: (b, u) => (u.mem.vvanaCast === 'charged' ? S1_CHARGED_HITS : S1_HITS) }, + onStart({ unit, skill }) { + // after activate's one charge: still ≥ max − 1 ⇒ every charge was stored (蓄力) — a charged cast spends them all + const charged = !!unit.mem.vvanaCharged || (skill.maxCharges > 1 && skill.charges >= skill.maxCharges - 1); + unit.mem.vvanaCast = charged ? 'charged' : 'plain'; + if (charged) { skill.charges = 0; skill.sp = 0; } + }, + onEnd({ unit }) { unit.mem.vvanaCast = null; }, + }, + [S2]: { + kind: 'duration', + mods: { atkPct: num(b2.atk), defPct: num(b2.def), blockCnt: num(b2.block_cnt) }, + attack: { + hitAllBlocked: true, + hitsFn: (b, u) => (u.mem.vvanaTwice ? S2_TWICE_HITS : 1), + dmgMul: (b, u) => (u.mem.vvanaTwice ? twice : 1), + onEachHit({ battle, unit, target, kind }) { + if (unit.mem.vvanaTwice && kind === 'main') steal(battle, unit, target, num(b2['attack@steal_atk_speed']), num(b2['attack@steal_atk_speed_max'], Infinity)); + }, + }, + onStart({ battle, unit }) { returnLoot(battle, unit); }, + onEnd({ battle, unit }) { unit.mem.vvanaTwice = false; returnLoot(battle, unit); }, + }, + [S3]: { + kind: 'duration', + mods: { batPct: batMod(b3.base_attack_time, chess), atkPct: num(b3.atk), defPct: num(b3.def), resFlat: num(b3.magic_resistance) }, + targeting: { priority: 'elite' }, + attack: { hitsFn: (b, u) => (u.mem.vvanaS3Later ? S3_LATER_HITS : S3_HITS) }, + onStart({ battle, unit, skill }) { + const later = (unit.mem.vvanaS3Casts ?? 0) >= 1; + unit.mem.vvanaS3Casts = (unit.mem.vvanaS3Casts ?? 0) + 1; + unit.mem.vvanaS3Later = later; + if (!later) return; + skill.timeLeft = Math.max(0.01, num(b3.enhance_duration, skill.duration)); + setGrid(battle, unit, RANGE_3_2); + }, + onEnd({ battle, unit }) { + if (unit.mem.vvanaS3Later) setGrid(battle, unit, unit.def?.rangeGrid); + unit.mem.vvanaS3Later = false; + }, + }, + }, + talents: [ + { install(battle, unit) { // 燃烛施明: arts dealt +, phys / arts taken −, ×super_scale with an elite / leader there + const dsm = num(t0.damage_scale_m), drp = num(t0.damage_resistance_pm), sup = num(t0.super_scale, 1), ep = num(t0.ep_damage_ratio_m); + const factor = () => (enemiesIn(battle, unit, unit.rangeKeys).some(isElite) || unit.blocking.some(isElite) ? sup : 1); + const check = () => { + if (!up(unit)) return; + const f = factor(); + if (unit.mem.vvanaCandle === f && unit.findBuff(CANDLE_KEY)) return; + unit.mem.vvanaCandle = f; + battle.addBuff(unit, { key: CANDLE_KEY, mods: { artsDealtMul: 1 + dsm * f, physTakenMul: 1 - drp * f, artsTakenMul: 1 - drp * f }, data: { f }, tags: ['talent'] }); + }; + battle.on('tick', check, { owner: unit }); + battle.on('battleStart', check, { owner: unit }); + battle.on('deploy', (c) => { if (c.unit === unit) { unit.mem.vvanaCandle = null; check(); } }, { owner: unit }); + // exact at the damage: re-read before any hit she deals or takes is resolved (the pipeline reads both units' + // stats after the `hit` hook) + battle.on('hit', (c) => { if (c.source === unit || c.target === unit) check(); }, { owner: unit, priority: CANDLE_PRIORITY }); + if (!(ep > 0)) return; + // AFT-D stage 3: 攻击附带相当于9%伤害的灼燃损伤 (× the same factor) — her arts damage that removed HP + battle.on('damaged', (c) => { + const d = c.dmg; + if (c.source !== unit || c.type !== 'arts' || tagged(d, 'dot') || !(c.amount > 0) || !c.target || c.target.side !== 'enemy') return; + elementDmg(battle, unit, c.target, 'burn', c.amount * ep * (unit.mem.vvanaCandle ?? 1), ['talent']); + }, { owner: unit }); + } }, + { install(battle, unit) { // 散华: a melee-only 护盾 layer from her damage on elite / leader enemies + const p = num(t1.prob), max = Math.max(1, Math.floor(num(t1.max_stack_cnt, 1))); + const s3Scale = num(b3.talent_scale, 1); + const layers = () => unit.findBuff(SHIELD_KEY)?.data?.n ?? 0; + const setLayers = (n) => { + if (n > 0) battle.addBuff(unit, { key: SHIELD_KEY, data: { n }, visible: true, tags: ['talent'] }); + else battle.removeBuff(unit, SHIELD_KEY); + }; + battle.on('hit', (c) => { + if (c.source !== unit || !isElite(c.target) || !up(unit)) return; + const have = layers(); + if (have >= max) return; + const prob = p * (unit.skill?.active && unit.skill.id === S3 ? s3Scale : 1); + if (!(prob > 0) || !battle.rng.chance(prob)) return; + setLayers(have + 1); + battle.fx('shield', { x: unit.x, y: unit.y, id: unit.id }); + }, { owner: unit, priority: OUTPUT_PRIORITY }); + battle.on('hit', (c) => { + if (c.target !== unit || c.dmg.cancel) return; + const s = c.source; + if (!s || s.side !== 'enemy' || c.dmg.isProjectile) return; + const have = layers(); + if (!(have > 0)) return; + c.dmg.cancel = true; + setLayers(have - 1); + battle.fx('shieldBreak', { x: unit.x, y: unit.y, id: unit.id }); + }, { owner: unit, priority: SHIELD_PRIORITY }); + } }, + ], + install(battle, unit) { + const own = unit.def?.rangeGrid; + // S1's 蓄力 mode: both charges stored ⇒ her range is 3-2 until the next end of the skill + if (unit.skill?.id === S1) { + const leave = () => { unit.mem.vvanaCharged = false; setGrid(battle, unit, own); }; + battle.on('tick', () => { + const sk = unit.skill; + if (!up(unit) || unit.mem.vvanaCharged || !sk || !(sk.maxCharges > 1) || sk.charges < sk.maxCharges) return; + unit.mem.vvanaCharged = true; + setGrid(battle, unit, RANGE_3_2); + }, { owner: unit }); + battle.on('skillEnd', (c) => { if (c.unit === unit && c.skill.id === S1 && unit.mem.vvanaCharged) leave(); }, { owner: unit }); + battle.on('deploy', (c) => { if (c.unit === unit) leave(); }, { owner: unit }); + } + // S2: one Attack_Once / Attack_Twice pick per attack while it runs + if (unit.skill?.id === S2) { + const prob = num(b2['attack@prob_twice']); + battle.on('beforeAttack', (c) => { + if (c.attacker !== unit) return; + unit.mem.vvanaTwice = !!(unit.skill?.active && unit.skill.id === S2) && prob > 0 && battle.rng.chance(prob); + }, { owner: unit }); + battle.on('death', (c) => { if (c.unit === unit) returnLoot(battle, unit); }, { owner: unit }); + } + // S3: the cast count of a deployment ("每次部署…重新计算"), her own range back + if (unit.skill?.id === S3) { + battle.on('deploy', (c) => { + if (c.unit !== unit) return; + unit.mem.vvanaS3Casts = 0; + unit.mem.vvanaS3Later = false; + setGrid(battle, unit, own); + }, { owner: unit }); + } + // AFT-D: 元素伤害 at the output of every damage of hers on an enemy in its 灼燃 爆发冷却 (not on this rider's own) + const er = num(tb.ep_damage_ratio); + if (er > 0) { + battle.on('hit', (c) => { + const t = c.target; + if (c.source !== unit || !t || t.side !== 'enemy' || tagged(c.dmg, AFTD_TAG) || !hasHp(t) || !t.findBuff('burnBurst')) return; + battle.dealDamage(unit, t, { amount: unit.s.atk * er, type: 'elemental', element: 'burn', canDodge: false, tags: [AFTD_TAG, 'dot'] }); + }, { owner: unit, priority: OUTPUT_PRIORITY }); + } + // AFT-Y: 自身阻挡的敌人受到10%的法术脆弱效果 + const fragile = num(tb.damage_scale, 1) - 1; + if (fragile > 0) { + battle.every(FRAGILE_IV, () => { + if (!up(unit)) return; + for (const e of unit.blocking) if (e.alive) battle.applyStatus(e, 'artsFragile', { duration: FRAGILE_DUR, value: fragile, source: unit }); + }, { owner: unit }); + } + }, + }; + }, +}; diff --git a/server/sim/targeting.js b/server/sim/targeting.js index 84b3bdc3..e5110dd4 100644 --- a/server/sim/targeting.js +++ b/server/sim/targeting.js @@ -181,6 +181,8 @@ const PRIORITY_FNS = { lowestHpRatio: (e) => e.hpRatio, highestAtk: (e) => -e.s.atk, boss: (e) => (e.isBoss ? 0 : 1), + // "优先攻击精英或领袖敌人" (薇薇安娜 S3: kits/ops/op-vvana.js): an ELITE / BOSS rank enemy or a leader first + elite: (e) => (e.isBoss || e.def?.rank === 'ELITE' || e.def?.rank === 'BOSS' ? 0 : 1), notBurst: (e) => (e.s.flags.burstLock ? 1 : 0), ground: (e) => (e.isFlying ? 1 : 0), // 攻城手 trait "优先攻击重量最重的敌人" (早露 / 提丰: kits/ops/op-poca.js, op-typhon.js): the highest current 重量等级 diff --git a/test/content/op_headb2.test.js b/test/content/op_headb2.test.js new file mode 100644 index 00000000..98a6582c --- /dev/null +++ b/test/content/op_headb2.test.js @@ -0,0 +1,323 @@ +// test/content/op_headb2.test.js — the 自选 operator kit of 怒潮凛冬 (char_1051_headb2, 6★ 撼地者; kit +// server/sim/content/kits/ops/op-headb2.js), fielded the production way (a DIY slot + its `diy` pick, simdata getDiy) in every +// form: tiers 5 / 6, normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module or HAM-X 迟到的勋章 at +// stage 1 (tier 5) / 3 (tier 6). Every number is read back from data/backups.json (the form of that slot status); the +// fidelity checklist of kits/README.md item by item. The 高台 of 汹涌怒火 are HIGH tiles of the field rect: the tests put +// forbidden blocks ('#') next to the lane of the flat stage. +// Run: node --test test/content/op_headb2.test.js + +import { test } from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js'; +import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js'; +import { diyPool, validateDiyPicks } from '../../shared/diy.js'; + +const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8')); +const CHESS = load('chess'); +const BACKUPS = load('backups'); +const ZIMA = 'char_1051_headb2'; +const FORMS = BACKUPS.units[ZIMA].forms; +const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' }; +const HAMX = 'uniequip_002_headb2'; +const S1 = 'skchr_headb2_1', S2 = 'skchr_headb2_2', S3 = 'skchr_headb2_3'; +const TIDE = 'talent:headb2:tide'; +/** The Skill_3 clip of the battle skeleton (30 fps): OnAttack at frames 33 / 84 / 133 / 182 / 233, 277 frames long. */ +const HAMMER_T = [33, 84, 133, 182, 233].map((f) => f / 30), SKILL3_T = 277 / 30; +/** Row 11 of the flat stage with one 高台 at (11, 7) — diagonal to the tile ahead of her (10, 6) — or a row of four. */ +const ONE_HIGH = { 11: '##hrrrr#rrfrrrrrrrf##' }; +const FOUR_HIGH = { 11: '##hrrrr####rrrrrrrf##' }; +const formOf = (tier, elite) => FORMS[elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0']; +const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id); +const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null); +const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`); +const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o }); +const ENEMIES = { enemy_dummy: dummy('enemy_dummy'), enemy_fly: dummy('enemy_fly', { motion: 'FLY' }) }; +const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, HAMX].map((m) => [t, true, m]))]; + +/** A battle with 怒潮凛冬 as uid 1 at (row, col) facing RIGHT, plus `others`. */ +function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 5, others = [], seed = 5, rows = null, noSp = false } = {}) { + const h = makeBattle({ + defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed, flat: rows ? { rows } : undefined, + flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'skillStart', 'skillEnd', 'statusApplied', 'spGain', 'attack'], captureNoisy: true, + units: [{ uid: 1, diy: { slot: SLOT[tier], charId: ZIMA, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others], + }); + h.step(); + const u = h.unit(1); + if (noSp) h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; }); + return { h, u }; +} +const dmgOn = (h, e, pred = () => true) => h.hooksOf('damaged').filter((c) => c.target === e && pred(c)); +const highland = (c) => (c.dmg?.tags ?? []).includes('headb2Highland'); +const hammerHit = (c) => (c.dmg?.tags ?? []).includes('headb2Hammer'); +function done(h) { + checkInvariants(h.b); + assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0])); +} +const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`; +const t0Of = (u) => u.def.raw.talents.find((t) => t.index === 0).bb; + +test('怒潮凛冬 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + HAM-X attributes, 1-1, blocks 2, melee physical ground-only with the 撼地者 splash, no bond, no 特质', () => { + assert.equal(OPERATOR_KITS[ZIMA], KITS[ZIMA]); + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + for (const skill of [0, 1, 2]) { + const { h, u } = field({ tier, elite, mod, skill }); + const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null; + assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [ZIMA, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f)); + assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0)], `${label(f)}: stats`); + assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.base.bat], [2, 'melee', 'phys', false, 1.8], `${label(f)}: 撼地者`); + assert.deepEqual([u.profile.splashRadius, u.profile.splashScale, u.profile.splashOthersOnly], [1, 0.5, true], `${label(f)}: the trait splash`); + assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 1-1`); + assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [['emptyShip'], []], `${label(f)}: bonds / 特质`); + assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target her`); + done(h); + } + } + // zh_CN: E2 Lv1 2301 / 1060 / 346, E2 Lv60 2731 / 1194 / 387; HAM-X +250 / +63 / +21 → +380 / +83 / +30 + assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk], [2301, 1060, 2731, 1194]); + assert.deepEqual([modOf(5, HAMX).attr, modOf(6, HAMX).attr], [{ maxHp: 250, atk: 63, def: 21 }, { maxHp: 380, atk: 83, def: 30 }]); +}); + +test('a 自选 pick: 怒潮凛冬 is offered at tiers 5 and 6 (she has a kit) and a roster with her passes validateDiyPicks', () => { + const data = { chess: CHESS, backups: BACKUPS }; + assert.ok(KITTED_CHARS.includes(ZIMA)); + for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(ZIMA), `tier ${t}`); + assert.deepEqual(validateDiyPicks({ [SLOT[5]]: { charId: ZIMA, skillIndex: 2, uniEquipId: HAMX } }, { data, kitted: KITTED_CHARS }), + { ok: true, picks: { [SLOT[5]]: { charId: ZIMA, skillIndex: 2, uniEquipId: HAMX } } }); +}); + +test('trait + T1 汹涌怒火 + HAM-X: the target takes ATK, the others within 1.0 the 50 % splash ×1.24 (HAM-X stage 3 ×1.4) — not flyers; with 3 enemies in the splash range HAM-X lifts the attack to 115 %', () => { + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + const { h, u } = field({ tier, elite, mod, skill: 0, noSp: true }); + const ds = t0Of(u).damage_scale; + assert.equal(ds, elite && tier === 6 && mod === HAMX ? 1.4 : 1.24, `${label(f)}: damage_scale`); + const a = h.spawn('enemy_dummy', { pos: [10, 6] }); + const c = h.spawn('enemy_dummy', { pos: [9, 6] }); + const fly = h.spawn('enemy_fly', { pos: [11, 6] }); + h.run(0.1); + const ma = dmgOn(h, a), mc = dmgOn(h, c); + assert.ok(ma.length === 1 && mc.length === 1, `${label(f)}: one attack (${ma.length} / ${mc.length})`); + approx(ma[0].amount, u.s.atk, `${label(f)}: the target 100 % (no ×${ds})`); + approx(mc[0].amount, u.s.atk * 0.5 * ds, `${label(f)}: splash 50 % × ${ds}`); + assert.deepEqual([mc[0].dmg.isSplash, mc[0].type], [true, 'phys']); + assert.equal(dmgOn(h, fly).length, 0, `${label(f)}: no flyer`); + // a third enemy in the splash range: HAM-X ×1.15 on the attack + h.spawn('enemy_dummy', { pos: [10, 7] }); + h.run(u.s.interval); + const hx = elite && mod === HAMX ? 1.15 : 1; + const ma2 = dmgOn(h, a).slice(1), mc2 = dmgOn(h, c).slice(1); + assert.ok(ma2.length >= 1 && mc2.length >= 1, `${label(f)}: the next attack`); + approx(ma2[0].amount, u.s.atk * hx, `${label(f)}: the target ×${hx}`); + approx(mc2[0].amount, u.s.atk * 0.5 * ds * hx, `${label(f)}: the splash ×${hx}`); + done(h); + } +}); + +test('T1 汹涌怒火 高台: every 高台 the 1.0 circle around her target touches hits the ground enemies of its x-5 0.1 s later — 24 % ATK physical 溅射 (no dodge, 无来源, 远程途径) + 停顿 0.5 s; HAM-X: ×1.15 with 3 there', () => { + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + const { h, u } = field({ tier, elite, mod, skill: 0, noSp: true, rows: ONE_HIGH }); + const t0 = t0Of(u); + assert.deepEqual([t0['attack@splash_atk_scale'], t0['attack@sluggish']], [0.24, 0.5], label(f)); + assert.equal(h.b.grid.tile(11, 7).height, 'HIGH'); + const a = h.spawn('enemy_dummy', { pos: [10, 6] }); + const b = h.spawn('enemy_dummy', { pos: [12, 7] }); // only on (11, 7)'s x-5 + const far = h.spawn('enemy_dummy', { pos: [12, 9] }); // on no 高台's x-5 + const fly = h.spawn('enemy_fly', { pos: [11, 8] }); // an air unit on the x-5 + h.step(); + const atkT = h.b.time, atk = u.s.atk; + assert.equal(dmgOn(h, a).length, 1, `${label(f)}: her attack`); + h.run(0.05); + assert.equal(dmgOn(h, b).length, 0, `${label(f)}: not before 0.1 s`); + h.run(0.1); + const hb = dmgOn(h, b); + assert.equal(hb.length, 1, `${label(f)}: the 高台 splash`); + const d = hb[0]; + approx(d.t - atkT, 0.1, `${label(f)}: 0.1 s after the attack`, 0.4); + approx(d.amount, atk * 0.24, `${label(f)}: 24 % ATK`); + assert.deepEqual([d.type, d.source, d.credit, d.dmg.isSplash, d.dmg.canDodge, d.dmg.sourceless, d.dmg.isProjectile], ['phys', null, u, true, false, true, true], `${label(f)}: physical 溅射, 无来源 credited to her, 远程途径`); + const st = h.hooksOf('statusApplied').filter((s) => s.target === b && s.status === 'sluggish'); + assert.ok(st.length === 1 && Math.abs(st[0].duration - 0.5) < 1e-9, `${label(f)}: 停顿 0.5 s`); + assert.ok(dmgOn(h, far).length === 0 && dmgOn(h, fly).length === 0, `${label(f)}: off the x-5 / air: nothing`); + assert.equal(dmgOn(h, a, highland).length, 0, `${label(f)}: the target is diagonal to the 高台 — not on its x-5`); + // three ground enemies on the x-5: HAM-X ×1.15 on that splash + h.spawn('enemy_dummy', { pos: [11, 6] }); + h.spawn('enemy_dummy', { pos: [11, 8] }); + const n0 = dmgOn(h, b, highland).length; + h.run(u.s.interval + 0.2); + const next = dmgOn(h, b, highland).slice(n0); + assert.ok(next.length >= 1, `${label(f)}: the next attack's 高台 splash`); + approx(next[0].amount, u.s.atk * 0.24 * (elite && mod === HAMX ? 1.15 : 1), `${label(f)}: ×${elite && mod === HAMX ? 1.15 : 1} with 3 on the x-5`); + done(h); + } +}); + +test('S2 绝不罢休\'s passive: +1 SP per 高台 that triggers 汹涌怒火 (none without one, none while the skill runs)', () => { + for (const [tier, elite] of [[5, false], [6, true]]) { + const sk = skillOf(tier, elite, S2); + assert.equal(sk.bb.sp_per_highland, 1); + const { h, u } = field({ tier, elite, skill: 1, rows: FOUR_HIGH, seed: 9 }); + h.spawn('enemy_dummy', { pos: [10, 6] }); // (11, 7) only + const talentSp = () => h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'talent'); + const attacks = () => h.hooksOf('attack').filter((c) => c.attacker === u).length; + h.run(5); + assert.ok(attacks() >= 2 && talentSp().length === attacks(), `T${tier}: ${talentSp().length} SP gifts for ${attacks()} attacks (one 高台 each)`); + assert.ok(talentSp().every((c) => c.amount === 1)); + assert.ok(h.runUntil(() => u.skill.active, 60), `T${tier}: S2 casts`); + const n = talentSp().length; + h.run(5); + assert.equal(talentSp().length, n, `T${tier}: none while it runs`); + done(h); + } + // no 高台 around her target: no gift + const { h, u } = field({ tier: 5, skill: 1, seed: 9 }); + h.spawn('enemy_dummy', { pos: [10, 6] }); + h.run(5); + assert.equal(h.hooksOf('spGain').filter((c) => c.unit === u && c.reason === 'talent').length, 0); + done(h); +}); + +test('T2 万众巨潮: while a skill of hers runs every operator of the field ATK / DEF +14 % — 【乌萨斯学生自治团】 (her, 古米) +28 % — and nothing before or after it', () => { + for (const [tier, elite, skill] of [[5, false, 0], [6, true, 1]]) { + const others = [{ uid: 2, chessId: 'chess_char_1_10_a', row: 11, col: 3 }, { uid: 3, chessId: 'chess_char_1_08_a', row: 12, col: 3 }]; + const { h, u } = field({ tier, elite, skill, others }); + const gummy = h.unit(2), texas = h.unit(3); + const t1 = u.def.raw.talents.find((t) => t.index === 1).bb; + assert.deepEqual([t1.atk, t1.def, t1.scale_bonus], [0.14, 0.14, 2]); + h.run(0.5); + for (const o of [u, gummy, texas]) assert.equal(o.findBuff(TIDE), null, `T${tier}: nothing before her skill (${o.def.charId})`); + u.skill.gainSp(999); + if (skill === 0) { h.spawn('enemy_dummy', { pos: [10, 6] }); assert.ok(h.runUntil(() => u.skill.active, 3)); } else assert.ok(h.runUntil(() => u.skill.active, 1), 'S2 at full SP'); + for (const [o, v] of [[u, 0.28], [gummy, 0.28], [texas, 0.14]]) { + const m = o.findBuff(TIDE)?.mods; + assert.ok(m, `T${tier}: ${o.def.charId} in her skill`); + approx(m.atkPct, v, `T${tier}: ${o.def.charId} ATK`); + approx(m.defPct, v, `T${tier}: ${o.def.charId} DEF`); + } + h.run(3); + assert.ok(texas.findBuff(TIDE), `T${tier}: kept while it runs`); + u.skill.end('test'); + for (const o of [u, gummy, texas]) assert.equal(o.findBuff(TIDE), null, `T${tier}: gone at its end (${o.def.charId})`); + done(h); + } +}); + +test('S1 誓不低头 (MANUAL, DEFAULT): 30 s, ATK +32 % / 39 %, ASPD +35 / 40 (her own 万众巨潮 +28 % on top); all back after', () => { + for (const [tier, elite] of [[5, false], [6, true]]) { + const sk = skillOf(tier, elite, S1); + const { h, u } = field({ tier, elite, skill: 0 }); + assert.deepEqual([u.skill.rule, sk.duration, sk.bb.atk, sk.bb.attack_speed], ['DEFAULT', 30, elite ? 0.39 : 0.32, elite ? 40 : 35], `T${tier}`); + u.skill.gainSp(999); + h.run(1); + assert.equal(u.skill.activations, 0, `T${tier}: no enemy, no cast`); + h.spawn('enemy_dummy', { pos: [10, 6] }); + assert.ok(h.runUntil(() => u.skill.active, 3), `T${tier}: cast with an enemy in range`); + approx(u.skill.timeLeft, 30, `T${tier}: 30 s`, 0.01); + approx(u.s.atk, u.base.atk * (1 + sk.bb.atk + 0.28), `T${tier}: ATK`); + approx(u.s.aspd, 100 + sk.bb.attack_speed, `T${tier}: ASPD`); + h.runUntil(() => !u.skill.active, 40); + approx(u.s.atk, u.base.atk, `T${tier}: ATK back`); + done(h); + } +}); + +test('S2 绝不罢休 (AUTO, SP_FULL — a self buff): at full SP with no enemy, 2-5, ATK +60 / 75 %, DEF +40 / 50 % for 16 s; the second cast of a deployment doubles them for good; a redeploy counts again', () => { + for (const [tier, elite] of [[5, false], [6, true]]) { + const sk = skillOf(tier, elite, S2); + const { h, u } = field({ tier, elite, skill: 1 }); + assert.deepEqual([u.skill.rule, sk.skillType, sk.duration, sk.spCost, sk.initSp, sk.rangeId], ['SP_FULL', 'AUTO', 16, elite ? 53 : 57, elite ? 24 : 20, '2-5'], `T${tier}`); + h.run(sk.spCost - sk.initSp - 0.5); + assert.equal(u.skill.activations, 0, `T${tier}: not before full SP`); + assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: at full SP, no enemy on the field`); + assert.deepEqual(u.liveRangeGrid, sk.rangeGrid, `T${tier}: 2-5 while it runs`); + approx(u.s.atk, u.base.atk * (1 + sk.bb.atk + 0.28), `T${tier}: ATK (+ her 万众巨潮)`); + approx(u.s.def, u.base.def * (1 + sk.bb.def + 0.28), `T${tier}: DEF`); + h.run(15.9); + assert.ok(u.skill.active, `T${tier}: 16 s`); + h.run(0.2); + assert.ok(!u.skill.active, `T${tier}: over after 16 s`); + assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 1-1 again`); + u.skill.gainSp(999); + assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: the second cast`); + approx(u.s.atk, u.base.atk * (1 + sk.bb['headb2_s_2[second].atk'] + 0.28), `T${tier}: ATK doubled`); + approx(u.s.def, u.base.def * (1 + sk.bb['headb2_s_2[second].def'] + 0.28), `T${tier}: DEF doubled`); + h.run(200); + assert.ok(u.skill.active, `T${tier}: 持续时间无限`); + h.b.retreat(u); + h.b.redeploy(u); + h.step(); + u.skill.gainSp(999); + assert.ok(h.runUntil(() => u.skill.active, 1)); + approx(u.s.atk, u.base.atk * (1 + sk.bb.atk + 0.28), `T${tier}: a new deployment's first cast`); + done(h); + } +}); + +test('S3 无可抵挡 (MANUAL, data CUSTOM_RANGE): five hammers on the Skill_3 clip\'s attack events (1.1 … 7.77 s), no normal attack, 9.23 s; the target ahead atk_scale × ATK, the others within 1.5 the splash; ATK +atk_base, +30 % per hammer; 高台 ×3.5 with 束缚, spreading k − 1 steps (0.1 s, then 0.125 s a step)', () => { + for (const [tier, elite, mod] of [[5, false, null], [6, true, HAMX]]) { + const sk = skillOf(tier, elite, S3); + const { h, u } = field({ tier, elite, mod, skill: 2, rows: FOUR_HIGH, seed: 17 }); + assert.deepEqual([u.skill.rule, sk.bb.atk_scale, sk.bb.atk_step, sk.bb.splash_atk_scale_bonus, sk.bb.unmovable, sk.bb.atk_base], + ['CUSTOM_RANGE', elite ? 2.1 : 1.9, 0.3, 3.5, elite ? 1.5 : 1, elite ? 0.8 : 0.65], `T${tier}`); + const ds = t0Of(u).damage_scale; + // the 高台 at (11, 7)…(11, 10); a dummy on each one's own x-5 tile below it + const under = [7, 8, 9, 10].map((c) => h.spawn('enemy_dummy', { pos: [12, c] })); + const side = h.spawn('enemy_dummy', { pos: [9, 7] }); // in the hammer's 1.5, not the 1.0 of the trait + u.skill.gainSp(999); + h.run(1); + assert.equal(u.skill.activations, 0, `T${tier}: nothing in the trigger grid`); + const main = h.spawn('enemy_dummy', { pos: [10, 6] }); + assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: an enemy in the trigger grid`); + const t0 = h.hooksOf('skillStart').find((c) => c.unit === u).t; + approx(u.skill.timeLeft, SKILL3_T - (h.b.time - t0), `T${tier}: the clip's 277 frames`, 0.01); + h.runUntil(() => !u.skill.active, 12); + approx(h.b.time - t0, SKILL3_T, `T${tier}: over with the clip`, 0.02); + assert.equal(h.hooksOf('attack').filter((c) => c.attacker === u && c.t > t0 && c.t < t0 + SKILL3_T - 0.1).length, 0, `T${tier}: no normal attack`); + const atkK = (k) => u.base.atk * (1 + sk.bb.atk_base + 0.28 + sk.bb.atk_step * (k - 1)); + const mh = dmgOn(h, main, (c) => c.t >= t0 && hammerHit(c)); + assert.equal(mh.length, 5, `T${tier}: five hammers on the target ahead`); + mh.forEach((c, i) => { approx(c.t - t0, HAMMER_T[i], `T${tier}: hammer ${i + 1} at ${HAMMER_T[i].toFixed(3)} s`, 0.02); approx(c.amount, atkK(i + 1) * sk.bb.atk_scale, `T${tier}: hammer ${i + 1} ${sk.bb.atk_scale * 100} %`); }); + const sh = dmgOn(h, side, (c) => c.t >= t0 && hammerHit(c)); + assert.equal(sh.length, 5, `T${tier}: the splash within 1.5`); + sh.forEach((c, i) => approx(c.amount, atkK(i + 1) * sk.bb.atk_scale * 0.5 * ds, `T${tier}: splash ${i + 1}`)); + // the 高台 rounds: hammer k reaches k − 1 steps along the row + const counts = under.map((e) => dmgOn(h, e, (c) => c.t >= t0 && highland(c)).length); + assert.deepEqual(counts, [5, 4, 3, 2], `T${tier}: (11, 7) every hammer, (11, 8) from the 2nd, (11, 9) the 3rd, (11, 10) the 4th`); + const first = dmgOn(h, under[0], (c) => c.t >= t0 && highland(c)); + first.forEach((c, i) => approx(c.amount, atkK(i + 1) * 0.24 * 3.5, `T${tier}: 高台 ×3.5 at hammer ${i + 1}`)); + const last = dmgOn(h, under[3], (c) => c.t >= t0 && highland(c)); + approx(last[0].t - (t0 + HAMMER_T[3]), 0.1 + 3 * 0.125, `T${tier}: 0.1 s, then three spread steps of 0.125 s after the 4th hammer`, 0.03); + const binds = h.hooksOf('statusApplied').filter((s) => s.target === under[0] && s.status === 'bind' && s.t >= t0); + assert.ok(binds.length === 5 && binds.every((s) => Math.abs(s.duration - sk.bb.unmovable) < 1e-9), `T${tier}: 束缚 ${sk.bb.unmovable} s (${binds.length})`); + assert.equal(h.hooksOf('statusApplied').filter((s) => s.target === under[0] && s.status === 'sluggish' && s.t >= t0).length, 0, `T${tier}: no 停顿 in the skill`); + approx(u.s.atk, u.base.atk, `T${tier}: ATK back`); + done(h); + } +}); + +test('S3: leaving the field stops the 高台 spread at once; a hammer due while she is stunned is lost', () => { + const { h, u } = field({ tier: 6, elite: true, skill: 2, rows: FOUR_HIGH, seed: 17 }); + const under = [7, 8, 9, 10].map((c) => h.spawn('enemy_dummy', { pos: [12, c] })); + h.spawn('enemy_dummy', { pos: [10, 6] }); + u.skill.gainSp(999); + assert.ok(h.runUntil(() => u.skill.active, 1)); + const t0 = h.hooksOf('skillStart').find((c) => c.unit === u).t; + h.run(HAMMER_T[3] + 0.15 - (h.b.time - t0)); // the 4th hammer: (11, 7) at +0.1, (11, 8) due at +0.225 + h.b.retreat(u); + h.run(2); + const counts = under.map((e) => dmgOn(h, e, (c) => c.t >= t0 && highland(c)).length); + assert.deepEqual(counts, [4, 2, 1, 0], 'the 4th round stopped after its first step: (11, 8) / (11, 9) / (11, 10) keep the earlier rounds only'); + done(h); + // stunned through the 1st hammer (1.1 s) + const s = field({ tier: 5, skill: 2, seed: 17 }); + const main = s.h.spawn('enemy_dummy', { pos: [10, 6] }); + s.u.skill.gainSp(999); + assert.ok(s.h.runUntil(() => s.u.skill.active, 1)); + s.h.run(1.0); + s.h.b.applyStatus(s.u, 'stun', { duration: 1.5, source: null }); + s.h.runUntil(() => !s.u.skill.active, 12); + assert.equal(dmgOn(s.h, main, hammerHit).length, 4, 'four hammers landed'); + done(s.h); +}); diff --git a/test/content/op_hodrer.test.js b/test/content/op_hodrer.test.js new file mode 100644 index 00000000..5348ea1d --- /dev/null +++ b/test/content/op_hodrer.test.js @@ -0,0 +1,288 @@ +// test/content/op_hodrer.test.js — the 自选 operator kit of 赫德雷 (char_4088_hodrer, 6★ 重剑手; kit +// server/sim/content/kits/ops/op-hodrer.js), fielded the production way (a DIY slot + its `diy` pick, simdata getDiy) in every +// form: tiers 5 / 6, normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module, CRU-X 新的生活 or +// CRU-Y 笔迹 at stage 1 (tier 5) / 3 (tier 6). Every number is read back from data/backups.json (the form of that slot status); +// the fidelity checklist of kits/README.md item by item. +// Run: node --test test/content/op_hodrer.test.js + +import { test } from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js'; +import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js'; +import { diyPool, validateDiyPicks } from '../../shared/diy.js'; + +const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8')); +const CHESS = load('chess'); +const BACKUPS = load('backups'); +const HOD = 'char_4088_hodrer'; +const FORMS = BACKUPS.units[HOD].forms; +const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' }; +const CRUX = 'uniequip_002_hodrer', CRUY = 'uniequip_003_hodrer'; +const S1 = 'skchr_hodrer_1', S2 = 'skchr_hodrer_2', S3 = 'skchr_hodrer_3'; +const PROTECT = 'talent:hodrer:protect'; +const formOf = (tier, elite) => FORMS[elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0']; +const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id); +const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null); +const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`); +const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o }); +const ENEMIES = { + enemy_dummy: dummy('enemy_dummy'), + enemy_fly: dummy('enemy_fly', { motion: 'FLY' }), + enemy_walk: enemyRec({ key: 'enemy_walk', hp: 1e9, speed: 0.6, mass: 0 }), + enemy_brute: enemyRec({ key: 'enemy_brute', hp: 1e9, speed: 0.6, mass: 0, atk: 300, bat: 1 }), +}; +const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, CRUX, CRUY].map((m) => [t, true, m]))]; + +/** A battle with 赫德雷 as uid 1 at (row, col) facing RIGHT, plus `others`. */ +function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 5, others = [], seed = 5, noSp = false } = {}) { + const h = makeBattle({ + defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed, + flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'heal', 'skillStart', 'skillEnd', 'statusApplied', 'attack'], captureNoisy: true, + units: [{ uid: 1, diy: { slot: SLOT[tier], charId: HOD, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others], + }); + h.step(); + const u = h.unit(1); + if (noSp) h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; }); + return { h, u }; +} +const atkHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.isAttack); +const byAttack = (hits) => { const m = new Map(); for (const c of hits) { const k = c.dmg.attackId; if (!m.has(k)) m.set(k, []); m.get(k).push(c); } return [...m.values()]; }; +function done(h) { + checkInvariants(h.b); + assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0])); +} +const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`; +const t0Of = (u) => u.def.raw.talents.find((t) => t.index === 0).bb; +const t1Of = (u) => u.def.raw.talents.find((t) => t.index === 1).bb; +/** 余火之氅 on his own tile: CRU-X stage 3 "造成的物理伤害提升10%" (damage_scale) — 1 otherwise. */ +const ownPhys = (u) => t1Of(u).damage_scale ?? 1; + +test('赫德雷 in every 自选 form: his operator kit (all three skills authored), the form\'s stats + module attributes, 1-1, blocks 2, melee physical ground-only hitting all he blocks, no bond, no 特质', () => { + assert.equal(OPERATOR_KITS[HOD], KITS[HOD]); + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + for (const skill of [0, 1, 2]) { + const { h, u } = field({ tier, elite, mod, skill }); + const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null; + assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [HOD, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f)); + assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def], `${label(f)}: stats`); + assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.profile.hitAllBlocked, u.base.bat], [2, 'melee', 'phys', false, true, 2.5], `${label(f)}: 重剑手`); + assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 1-1`); + assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [['emptyShip'], []], `${label(f)}: bonds / 特质`); + assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target him`); + done(h); + } + } + // zh_CN: E2 Lv1 4670 / 1323 / 0, E2 Lv60 5544 / 1491 / 0; CRU-X +290 / +92 → +450 / +130, CRU-Y +300 / +110 → +400 / +160 + assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk], [4670, 1323, 5544, 1491]); + assert.deepEqual([modOf(5, CRUX).attr, modOf(6, CRUX).attr, modOf(5, CRUY).attr, modOf(6, CRUY).attr], [{ maxHp: 290, atk: 92 }, { maxHp: 450, atk: 130 }, { maxHp: 300, atk: 110 }, { maxHp: 400, atk: 160 }]); +}); + +test('a 自选 pick: 赫德雷 is offered at tiers 5 and 6 (he has a kit) and a roster with him passes validateDiyPicks', () => { + const data = { chess: CHESS, backups: BACKUPS }; + assert.ok(KITTED_CHARS.includes(HOD)); + for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(HOD), `tier ${t}`); + assert.deepEqual(validateDiyPicks({ [SLOT[6]]: { charId: HOD, skillIndex: 0, uniEquipId: CRUY } }, { data, kitted: KITTED_CHARS }), + { ok: true, picks: { [SLOT[6]]: { charId: HOD, skillIndex: 0, uniEquipId: CRUY } } }); +}); + +test('trait + T1 及锋而试: every attack hits all he blocks; ×1.1 (CRU-Y stage 3 ×1.3), ×1.4 (×1.6) on a stunned or bound target — not a frozen one, never a flyer', () => { + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + const { h, u } = field({ tier, elite, mod, skill: 0, noSp: true }); + const t0 = t0Of(u); + const y3 = elite && tier === 6 && mod === CRUY; + assert.deepEqual([t0.atk_scale_2, t0.atk_scale], y3 ? [1.3, 1.6] : [1.1, 1.4], label(f)); + const e = h.spawn('enemy_dummy', { pos: [10, 6] }); + h.spawn('enemy_fly', { pos: [10, 6] }); + const hitOn = () => { const n = atkHits(h, u).length; h.runUntil(() => atkHits(h, u).length > n, 3); return atkHits(h, u).slice(n); }; + let hs = hitOn(); + assert.ok(hs.length === 1 && hs[0].target === e, `${label(f)}: the ground dummy only`); + approx(hs[0].amount, u.s.atk * t0.atk_scale_2 * ownPhys(u), `${label(f)}: ×${t0.atk_scale_2}`); + for (const [st, mul] of [['stun', t0.atk_scale], ['bind', t0.atk_scale], ['freeze', t0.atk_scale_2]]) { + h.b.applyStatus(e, st, { duration: 60, source: null }); + hs = hitOn(); + approx(hs[0].amount, u.s.atk * mul * ownPhys(u), `${label(f)}: ${st} ×${mul}`); + h.b.removeStatus(e, st); + } + done(h); + } + // all he blocks, at once + const { h, u } = field({ tier: 6, elite: true, skill: 0, row: 9, col: 5, noSp: true }); + h.spawn('enemy_walk', { routeIndex: 0 }); + h.spawn('enemy_walk', { routeIndex: 0, time: 0 }); + assert.ok(h.runUntil(() => u.blocking.length === 2, 40), 'blocks two'); + const n = atkHits(h, u).length; + h.run(6); + const att = byAttack(atkHits(h, u).slice(n)); + assert.ok(att.length >= 2 && att.every((a) => a.length === 2 && new Set(a.map((c) => c.target)).size === 2), '同时攻击阻挡的所有敌人'); + done(h); +}); + +test('CRU-Y stage 3: his first damage on an enemy he blocks stuns it 2.5 s — before 及锋而试 reads it (×1.6) — once per enemy and deployment; CRU-Y ×1.1 on the enemies he blocks (stages 1 and 3), not on others', () => { + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + const { h, u } = field({ tier, elite, mod, skill: 0, row: 9, col: 5, noSp: true }); + const y = elite && mod === CRUY, y3 = y && tier === 6; + const w = h.spawn('enemy_walk', { routeIndex: 0 }); + assert.ok(h.runUntil(() => u.blocking.includes(w), 40), `${label(f)}: blocked`); + const n = atkHits(h, u).length; + h.runUntil(() => atkHits(h, u).length > n, 4); + const first = atkHits(h, u).slice(n)[0]; + const stuns = () => h.hooksOf('statusApplied').filter((s) => s.target === w && s.status === 'stun' && s.source === u); + const t0 = t0Of(u); + assert.equal(stuns().length, y3 ? 1 : 0, `${label(f)}: the first-hit stun`); + if (y3) assert.equal(stuns()[0].duration, 2.5); + approx(first.amount, u.s.atk * (y3 ? t0.atk_scale : t0.atk_scale_2) * (y ? 1.1 : 1) * ownPhys(u), `${label(f)}: the first hit`); + h.run(8); + assert.equal(stuns().length, y3 ? 1 : 0, `${label(f)}: once per enemy`); + if (y3) { + // the marks go with his deployment (derived from the module talent's buff): a redeployed 赫德雷 stuns it anew + h.b.retreat(u); + h.b.redeploy(u); + assert.ok(h.runUntil(() => stuns().length === 2, 20), `${label(f)}: stunned again after a redeploy`); + } + done(h); + } + // an enemy another operator blocks: no CRU-Y ×1.1 (hodrer_e_003_tr: CheckBlocked by him) + for (const [tier, mod] of [[5, CRUY], [6, CRUY]]) { + const { h, u } = field({ tier, elite: true, mod, skill: 0, noSp: true, others: [{ uid: 2, chessId: 'chess_char_1_02_a', row: 10, col: 6 }] }); + const e = h.spawn('enemy_dummy', { pos: [10, 6] }); + assert.ok(h.runUntil(() => e.blockedBy === h.unit(2), 3), `T${tier}: blocked by 角峰`); + const n = atkHits(h, u).length; + h.runUntil(() => atkHits(h, u).filter((c) => c.target === e).length > 0 && atkHits(h, u).length > n, 6); + const c = atkHits(h, u).filter((x) => x.target === e).pop(); + approx(c.amount, u.s.atk * t0Of(u).atk_scale_2, `T${tier}: ×${t0Of(u).atk_scale_2} only`); + done(h); + } +}); + +test('T2 余火之氅: he and the ally on the tile behind him get 18 % 庇护 (CRU-X stage 3: 28 % and 物理伤害 +10 %); not the ally beside him; gone once he leaves', () => { + const others = [{ uid: 2, chessId: 'chess_char_1_08_a', row: 10, col: 4 }, { uid: 3, chessId: 'chess_char_1_10_a', row: 11, col: 5 }]; + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + const { h, u } = field({ tier, elite, mod, skill: 0, others }); + const behind = h.unit(2), beside = h.unit(3); + h.run(0.5); + const x3 = elite && tier === 6 && mod === CRUX; + const dr = t1Of(u).damage_resistance; + assert.equal(dr, x3 ? 0.28 : 0.18, label(f)); + for (const a of [u, behind]) { + const m = a.findBuff(PROTECT)?.mods; + assert.ok(m, `${label(f)}: ${a.def.charId} protected`); + approx(m.physTakenMul, 1 - dr, `${label(f)}: phys`); + approx(m.artsTakenMul, 1 - dr, `${label(f)}: arts`); + assert.equal(m.physDealtMul ?? 1, x3 ? 1.1 : 1, `${label(f)}: 物理伤害`); + } + assert.equal(beside.findBuff(PROTECT), null, `${label(f)}: not beside him`); + const hp = behind.hp; + h.b.dealDamage(null, behind, { amount: 1000, type: 'arts' }); + approx(hp - behind.hp, 1000 * (1 - behind.s.res / 100) * (1 - dr), `${label(f)}: arts taken behind him`); + h.b.retreat(u); + h.run(0.5); + assert.equal(behind.findBuff(PROTECT), null, `${label(f)}: gone with him`); + done(h); + } +}); + +test('S1 重锋不熄 (AUTO, hit SP 3, DEFAULT): every 4th attack hits all he blocks at 180 % / 200 % (× 及锋而试) and heals 15 % / 20 % of his max HP once (CRU-X: ×1.2 受到的治疗)', () => { + for (const [tier, elite, mod] of [[5, false, null], [6, true, null], [6, true, CRUX]]) { + const sk = skillOf(tier, elite, S1); + const { h, u } = field({ tier, elite, mod, skill: 0, row: 9, col: 5 }); + assert.deepEqual([u.skill.rule, u.skill.spType, u.skill.spCost, sk.bb.atk_scale, sk.bb.hp_ratio], ['DEFAULT', 'attack', 3, elite ? 2 : 1.8, elite ? 0.2 : 0.15], `T${tier}`); + h.spawn('enemy_walk', { routeIndex: 0 }); + h.spawn('enemy_walk', { routeIndex: 0, time: 0 }); + assert.ok(h.runUntil(() => u.blocking.length === 2, 40)); + u.hp = u.s.maxHp * 0.3; + const n0 = atkHits(h, u).length; + h.run(2.5 * 8 + 0.1); + const att = byAttack(atkHits(h, u).slice(n0)); + const sk1 = att.filter((a) => a[0].dmg.isSkill); + assert.ok(sk1.length >= 2, `T${tier}: casts (${sk1.length} in ${att.length} attacks)`); + const idx = att.map((a, i) => (a[0].dmg.isSkill ? i : -1)).filter((i) => i >= 0); + for (let i = 1; i < idx.length; i++) assert.equal(idx[i] - idx[i - 1], 4, `T${tier}: one cast every 4 attacks`); + for (const c of sk1[0]) approx(c.amount, u.s.atk * sk.bb.atk_scale * 1.1 * ownPhys(u), `T${tier}: ${sk.bb.atk_scale * 100} % × 1.1`); + assert.equal(sk1[0].length, 2, `T${tier}: both blocked enemies`); + const heals = h.hooksOf('heal').filter((c) => c.target === u && c.source === u); + assert.equal(heals.length, sk1.length, `T${tier}: one heal per cast`); + approx(heals[0].amount, u.s.maxHp * sk.bb.hp_ratio * (mod === CRUX ? 1.2 : 1), `T${tier}: ${sk.bb.hp_ratio * 100} % max HP${mod === CRUX ? ' × 1.2' : ''}`); + done(h); + } +}); + +test('S2 余烬重荷 (MANUAL, DEFAULT, a 状态切换 toggle): ATK +16 % / 28 % from the deployment on; switched on once and kept — interval 2.5 + 0.5 s, block 3, every attack stuns its targets 1 s before 及锋而试 reads them (×1.4)', () => { + for (const [tier, elite] of [[5, false], [6, true]]) { + const sk = skillOf(tier, elite, S2); + const { h, u } = field({ tier, elite, skill: 1, row: 9, col: 5 }); + assert.deepEqual([u.skill.rule, u.skill.kind, sk.spCost, sk.initSp, sk.bb.atk, sk.bb.base_attack_time, sk.bb.block_cnt, sk.bb['attack@stun']], ['DEFAULT', 'toggle', elite ? 8 : 9, 0, elite ? 0.28 : 0.16, 0.5, 1, 1], `T${tier}`); + approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: the passive ATK`); + for (let i = 0; i < 3; i++) h.spawn('enemy_walk', { routeIndex: 0, time: 0 }); + assert.ok(h.runUntil(() => u.skill.active, 30), `T${tier}: switched on with an enemy`); + approx(u.s.interval, 3.0, `T${tier}: 攻击间隔略微增大(+0.5)`); + assert.equal(u.s.blockCnt, 3, `T${tier}: 阻挡数+1`); + assert.ok(h.runUntil(() => u.blocking.length === 3, 30), `T${tier}: blocks three`); + const n0 = atkHits(h, u).length; + h.run(9.1); + const att = byAttack(atkHits(h, u).slice(n0)); + assert.ok(att.length >= 3 && att.every((a) => a.length === 3), `T${tier}: all three each attack`); + for (const a of att) for (const c of a) approx(c.amount, u.s.atk * 1.4, `T${tier}: stunned first ⇒ ×1.4`); + const stuns = h.hooksOf('statusApplied').filter((s) => s.source === u && s.status === 'stun'); + assert.ok(stuns.length >= 9 && stuns.every((s) => s.duration === 1), `T${tier}: 晕眩1秒 on every target`); + h.run(60); + assert.ok(u.skill.active, `T${tier}: kept on`); + assert.equal(u.skill.activations, 1, `T${tier}: switched on once`); + done(h); + } +}); + +test('S3 死境硝烟 (MANUAL, data ACTIVE_RANGE): cast with an enemy 2 tiles ahead; 70 s, max HP +30 / 45 %, ATK +60 / 90 %, range +1; heals 5 % per attack, 25 % stuns 3 / 4 s; −100 HP / s and 200 无来源 true / s on the enemies he attacked or that attacked him', () => { + for (const [tier, elite] of [[5, false], [6, true]]) { + const sk = skillOf(tier, elite, S3); + const { h, u } = field({ tier, elite, skill: 2, seed: 19 }); + assert.deepEqual([u.skill.rule, sk.duration, sk.bb.max_hp, sk.bb.atk, sk.bb['attack@hp_ratio'], sk.bb['attack@buff_prob'], sk.bb['attack@stun'], sk.bb.ability_range_forward_extend, sk.bb['attack@value'], sk.bb['attack@damage']], + ['ACTIVE_RANGE', 70, elite ? 0.45 : 0.3, elite ? 0.9 : 0.6, 0.05, 0.25, elite ? 4 : 3, 1, 100, 200], `T${tier}`); + assert.deepEqual(sk.trigger.customRangeGrid, [[0, 0], [0, 1], [0, 2]], `T${tier}: the running range`); + u.skill.gainSp(999); + const near = h.spawn('enemy_dummy', { pos: [9, 6] }); // beside his range: never attacked + h.run(1); + assert.equal(u.skill.activations, 0, `T${tier}: nothing in his range`); + const far = h.spawn('enemy_dummy', { pos: [10, 7] }); + assert.ok(h.runUntil(() => u.skill.active, 1), `T${tier}: an enemy 2 tiles ahead (the running range)`); + assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1], [0, 2]], `T${tier}: 攻击距离+1`); + approx(u.skill.timeLeft, 70, `T${tier}: 70 s`, 0.01); + approx(u.s.maxHp, u.base.maxHp * (1 + sk.bb.max_hp), `T${tier}: max HP`); + approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`); + const t0 = h.hooksOf('skillStart').find((c) => c.unit === u).t; + h.run(10); + const ticks = (e) => h.hooksOf('damaged').filter((c) => c.target === e && c.credit === u && c.source === null && (c.dmg?.tags ?? []).includes('periodic')); + const onFar = ticks(far); + assert.ok(onFar.length >= 8 && onFar.every((c) => c.amount === 200 && c.type === 'true'), `T${tier}: 200 无来源 true / s on the enemy he attacked (${onFar.length})`); + assert.equal(ticks(near).length, 0, `T${tier}: none on an enemy he never attacked`); + const losses = h.hooksOf('damaged').filter((c) => c.target === u && (c.dmg?.tags ?? []).includes('hpLoss') && c.t >= t0); + assert.ok(losses.length >= 9 && losses.every((c) => c.amount === 100), `T${tier}: 每秒流失100点生命 (${losses.length})`); + const heals = h.hooksOf('heal').filter((c) => c.target === u && c.source === u && c.t >= t0); + const attacks = h.hooksOf('attack').filter((c) => c.attacker === u && c.t >= t0); + assert.ok(heals.length >= 2 && Math.abs(heals.length - attacks.length) <= 1, `T${tier}: one heal per attack (${heals.length} / ${attacks.length})`); + // an enemy that attacks him joins + const brute = h.spawn('enemy_brute', { routeIndex: 1 }); + assert.ok(h.runUntil(() => ticks(brute).length >= 2, 40), `T${tier}: the brute that hit him burns too`); + h.b.kill(brute, null); + u.hp = u.s.maxHp; + // the stun roll over many attacks ≈ 25 % + u.skill.extend(600); + const s0 = h.hooksOf('statusApplied').filter((s) => s.source === u && s.status === 'stun' && s.target === far).length; + const a0 = atkHits(h, u).filter((c) => c.target === far).length; + h.run(500); + const sN = h.hooksOf('statusApplied').filter((s) => s.source === u && s.status === 'stun' && s.target === far); + const aN = atkHits(h, u).filter((c) => c.target === far).length - a0; + const rate = (sN.length - s0) / aN; + assert.ok(rate > 0.17 && rate < 0.33 && sN.every((s) => s.duration === sk.bb['attack@stun']), `T${tier}: stun ${(rate * 100).toFixed(1)} % ≈ 25 %, ${sk.bb['attack@stun']} s`); + u.skill.end('test'); + const n = ticks(far).length; + h.run(3); + assert.equal(ticks(far).length, n, `T${tier}: no tick after the skill`); + assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 1-1 again`); + done(h); + } +}); diff --git a/test/content/op_vvana.test.js b/test/content/op_vvana.test.js new file mode 100644 index 00000000..0c1b52a7 --- /dev/null +++ b/test/content/op_vvana.test.js @@ -0,0 +1,419 @@ +// test/content/op_vvana.test.js — the 自选 operator kit of 薇薇安娜 (char_4098_vvana, 6★ 术战者; kit +// server/sim/content/kits/ops/op-vvana.js), fielded the production way (a DIY slot + its `diy` pick, simdata getDiy) in every +// form: tiers 5 / 6, normal (E2 Lv1, skill rank 4, no module) and elite (E2 Lv60, rank 7) with no module, AFT-D 目不能及之处 or +// AFT-Y “最后一行” at stage 1 (tier 5) / 3 (tier 6). Every number is read back from data/backups.json (the form of that slot +// status); the fidelity checklist of kits/README.md item by item. +// Run: node --test test/content/op_vvana.test.js + +import { test } from 'node:test'; +import assert from 'node:assert/strict'; +import { readFileSync } from 'node:fs'; +import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js'; +import { KITTED_CHARS, OPERATOR_KITS, KITS } from '../../server/sim/content/kits/index.js'; +import { sortEnemyTargets } from '../../server/sim/targeting.js'; +import { diyPool, validateDiyPicks } from '../../shared/diy.js'; + +const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8')); +const CHESS = load('chess'); +const BACKUPS = load('backups'); +const VVANA = 'char_4098_vvana'; +const FORMS = BACKUPS.units[VVANA].forms; +const SLOT = { 5: 'chess_char_5_diy1_a', 6: 'chess_char_6_diy1_a' }; +const AFTD = 'uniequip_002_vvana', AFTY = 'uniequip_003_vvana'; +const S1 = 'skchr_vvana_1', S2 = 'skchr_vvana_2', S3 = 'skchr_vvana_3'; +const SHIELD = 'talent:vvana:shield', CANDLE = 'talent:vvana:candle'; +const RANGE_3_2 = [[0, 0], [0, 1], [0, 2], [0, 3]]; +/** The unit form of a slot (tier, normal / elite). */ +const formOf = (tier, elite) => FORMS[elite ? (tier === 5 ? '2/60/7/1' : '2/60/7/3') : '2/1/4/0']; +const skillOf = (tier, elite, id) => formOf(tier, elite).skills.find((s) => s.skillId === id); +const modOf = (tier, mod) => (mod ? formOf(tier, true).modules.find((m) => m.uniEquipId === mod) : null); +const approx = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps * Math.max(1, Math.abs(b)), `${msg}: ${a} vs ${b}`); +const dummy = (key, o = {}) => enemyRec({ key, hp: 1e9, speed: 0, mass: 0, ...o }); +const ENEMIES = { + enemy_dummy: dummy('enemy_dummy'), + enemy_elite: dummy('enemy_elite', { rank: 'ELITE' }), + enemy_fly: dummy('enemy_fly', { motion: 'FLY' }), + enemy_walk: enemyRec({ key: 'enemy_walk', hp: 1e9, speed: 0.6, mass: 0 }), + enemy_brute: enemyRec({ key: 'enemy_brute', hp: 1e9, speed: 0.6, mass: 0, atk: 500, bat: 1 }), + enemy_shooter: dummy('enemy_shooter', { atk: 300, range: 3, bat: 1 }), +}; +/** Every 自选 form: [tier, elite, module]. */ +const FORMS_ALL = [[5, false, null], [6, false, null], ...[5, 6].flatMap((t) => [null, AFTD, AFTY].map((m) => [t, true, m]))]; + +/** A battle with 薇薇安娜 as uid 1 at (row, col) facing RIGHT, plus `others`. */ +function field({ tier = 5, elite = false, mod = null, skill = 0, row = 10, col = 5, others = [], seed = 5 } = {}) { + const h = makeBattle({ + defs: { enemies: ENEMIES }, timeLimit: 900, autoFinish: false, seed, + flags: { dpPerSec: 0, dpMax: 999 }, hooks: ['damaged', 'hit', 'skillStart', 'skillEnd', 'statusApplied'], captureNoisy: true, + units: [{ uid: 1, diy: { slot: SLOT[tier], charId: VVANA, skillIndex: skill, uniEquipId: mod }, elite, row, col }, ...others], + }); + h.step(); + return { h, u: h.unit(1) }; +} +const atkHits = (h, u) => h.hooksOf('damaged').filter((c) => c.source === u && c.dmg?.isAttack); +const byAttack = (hits) => { const m = new Map(); for (const c of hits) { const k = c.dmg.attackId; if (!m.has(k)) m.set(k, []); m.get(k).push(c); } return [...m.values()]; }; +function done(h) { + checkInvariants(h.b); + assert.equal(h.b.errors.length, 0, JSON.stringify(h.b.errors[0])); +} +const label = ([tier, elite, mod]) => `T${tier} ${elite ? 'elite' : 'normal'} ${mod ?? 'none'}`; +const keysOf = (u, grid) => grid.map(([dr, dc]) => (u.tileR + dr) * 21 + u.tileC + dc).sort((a, b) => a - b); + +test('薇薇安娜 in every 自选 form: her operator kit (all three skills authored), the form\'s stats + module attributes, 1-1 range, blocks 1, melee arts ground-only, 卡西米尔, no 特质', () => { + assert.equal(OPERATOR_KITS[VVANA], KITS[VVANA]); + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + for (const skill of [0, 1, 2]) { + const { h, u } = field({ tier, elite, mod, skill }); + const form = formOf(tier, elite), m = elite ? modOf(tier, mod) : null; + assert.deepEqual([u.def.charId, u.def.diyFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [VVANA, SLOT[tier], form.skills[skill].skillId, false, 'skills'], label(f)); + assert.deepEqual([u.base.maxHp, u.base.atk, u.base.def, u.base.res], [form.stats.maxHp + (m?.attr.maxHp ?? 0), form.stats.atk + (m?.attr.atk ?? 0), form.stats.def + (m?.attr.def ?? 0), form.stats.res], `${label(f)}: stats`); + assert.deepEqual([u.s.blockCnt, u.profile.attack, u.profile.dmgType, u.profile.canHitFly, u.base.bat], [1, 'melee', 'arts', false, 1.25], `${label(f)}: 术战者`); + assert.deepEqual(u.liveRangeGrid, form.rangeGrid, `${label(f)}: 1-1`); + assert.deepEqual([u.def.bonds, u.def.raw.garrisonIds], [['kazimierzShip'], []], `${label(f)}: bonds / 特质`); + assert.ok(!u.s.flags.liftoff && !u.s.flags.camou && !u.s.flags.stealth, `${label(f)}: ground enemies target her`); + done(h); + } + } + // zh_CN: E2 Lv1 2219 / 523 / 371, E2 Lv60 2684 / 605 / 421; AFT-D +240 / +30 → +420 / +60 HP / ATK, AFT-Y +240 / +30 / +30 → +300 / +45 / +45 + assert.deepEqual([FORMS['2/1/4/0'].stats.maxHp, FORMS['2/1/4/0'].stats.atk, FORMS['2/60/7/1'].stats.maxHp, FORMS['2/60/7/1'].stats.atk], [2219, 523, 2684, 605]); + assert.deepEqual([modOf(5, AFTD).attr, modOf(6, AFTD).attr, modOf(5, AFTY).attr, modOf(6, AFTY).attr], [{ maxHp: 240, atk: 30 }, { maxHp: 420, atk: 60 }, { maxHp: 240, atk: 30, def: 30 }, { maxHp: 300, atk: 45, def: 45 }]); +}); + +test('a 自选 pick: 薇薇安娜 is offered at tiers 5 and 6 (she has a kit) and a roster with her passes validateDiyPicks', () => { + const data = { chess: CHESS, backups: BACKUPS }; + assert.ok(KITTED_CHARS.includes(VVANA)); + for (const t of [5, 6]) assert.ok(diyPool(t, { data, kitted: KITTED_CHARS }).includes(VVANA), `tier ${t}`); + assert.deepEqual(validateDiyPicks({ [SLOT[6]]: { charId: VVANA, skillIndex: 2, uniEquipId: AFTY } }, { data, kitted: KITTED_CHARS }), + { ok: true, picks: { [SLOT[6]]: { charId: VVANA, skillIndex: 2, uniEquipId: AFTY } } }); +}); + +test('S1 光影迅捷剑 (AUTO, DEFAULT, 2 charges): with one charge the next attack hits twice at 155 % / 170 % ATK (arts) and spends one charge; the range stays 1-1', () => { + for (const [tier, elite] of [[5, false], [6, true]]) { + const sk = skillOf(tier, elite, S1); + const { h, u } = field({ tier, elite, skill: 0 }); + assert.deepEqual([u.skill.rule, u.skill.maxCharges, u.skill.spCost, sk.initSp, sk.bb.atk_scale], ['DEFAULT', 2, elite ? 4 : 5, 0, elite ? 1.7 : 1.55], `T${tier}`); + const e = h.spawn('enemy_dummy', { pos: [10, 6] }); + const fly = h.spawn('enemy_fly', { pos: [10, 6] }); + assert.ok(h.runUntil(() => u.skill.activations === 1, sk.spCost + 2), `T${tier}: cast once a charge is stored`); + assert.equal(h.hooksOf('damaged').filter((c) => c.target === fly).length, 0, `T${tier}: a melee 术战者 never hits the flyer`); + h.run(0.1); + const skillAtk = byAttack(atkHits(h, u).filter((c) => c.dmg.isSkill)); + assert.equal(skillAtk.length, 1, `T${tier}: one skill attack`); + assert.equal(skillAtk[0].length, 2, `T${tier}: 连续攻击两次`); + for (const c of skillAtk[0]) { + assert.deepEqual([c.target, c.type], [e, 'arts'], `T${tier}: the target, arts`); + approx(c.amount, u.s.atk * sk.bb.atk_scale * 1.08, `T${tier}: ${sk.bb.atk_scale * 100} % ATK (× 燃烛施明 1.08)`); + } + assert.ok(u.skill.charges < 1 && !u.mem.vvanaCharged, `T${tier}: one charge spent, no 蓄力`); + assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 1-1`); + // plain attacks hit once at 100 % + const plain = byAttack(atkHits(h, u).filter((c) => !c.dmg.isSkill)); + assert.ok(plain.length > 0 && plain.every((a) => a.length === 1), `T${tier}: plain attacks hit once`); + done(h); + } +}); + +test('S1 蓄力: both charges stored ⇒ the 3-2 range (card and trigger), the cast spends every charge and hits three times from 3 tiles away; the range is 1-1 again after it', () => { + for (const [tier, elite] of [[5, false], [6, true]]) { + const sk = skillOf(tier, elite, S1); + const { h, u } = field({ tier, elite, skill: 0 }); + h.run(sk.spCost * 2 - 0.5); + assert.equal(u.skill.charges, 1, `T${tier}: one charge after ${sk.spCost * 2 - 0.5} s`); + assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: not yet`); + h.run(0.6); + assert.equal(u.skill.charges, 2, `T${tier}: both charges`); + assert.deepEqual(u.liveRangeGrid, RANGE_3_2, `T${tier}: 蓄力 — 3-2`); + assert.deepEqual([...u.baseRangeKeys].sort((a, b) => a - b), keysOf(u, RANGE_3_2), `T${tier}: the DEFAULT trigger range follows`); + const e = h.spawn('enemy_dummy', { pos: [10, 8] }); + assert.ok(h.runUntil(() => u.skill.activations === 1, 2), `T${tier}: cast on the enemy 3 tiles ahead`); + h.step(); + const skillAtk = byAttack(atkHits(h, u).filter((c) => c.dmg.isSkill)); + assert.equal(skillAtk.length, 1); + assert.equal(skillAtk[0].length, 3, `T${tier}: 改为连续攻击三次`); + for (const c of skillAtk[0]) { assert.equal(c.target, e); approx(c.amount, u.s.atk * sk.bb.atk_scale * 1.08, `T${tier}: ${sk.bb.atk_scale * 100} %`); } + assert.ok(u.skill.charges === 0 && u.skill.sp < 0.2, `T${tier}: 任何时候开启均消耗全部技力 (${u.skill.charges} / ${u.skill.sp})`); + assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 蓄力 over with the skill`); + const n = atkHits(h, u).length; + h.run(3); + assert.equal(atkHits(h, u).length, n, `T${tier}: the enemy 3 tiles ahead is out of her 1-1 again`); + done(h); + } +}); + +test('S1 蓄力 mode stays until the next end of the skill: silenced with both charges she attacks with the 3-2 range (plain attacks); a redeploy clears it', () => { + const { h, u } = field({ tier: 6, elite: true, skill: 0 }); + h.run(9); + assert.equal(u.skill.charges, 2); + h.b.applyStatus(u, 'silence', { duration: 4, source: null }); + const e = h.spawn('enemy_dummy', { pos: [10, 8] }); + h.run(3); + const hits = atkHits(h, u).filter((c) => c.target === e); + assert.ok(hits.length >= 2 && hits.every((c) => !c.dmg.isSkill), `plain attacks from the 3-2 range: ${hits.length}`); + assert.deepEqual(u.liveRangeGrid, RANGE_3_2); + h.b.retreat(u); + h.b.redeploy(u); + h.step(); + assert.deepEqual([u.liveRangeGrid, !!u.mem.vvanaCharged], [[[0, 0], [0, 1]], false], 'a new deployment: 1-1, SP from 0'); + done(h); +}); + +test('S2 烛燃影息 (MANUAL, DEFAULT): 28 / 30 s, ATK +20 / 30 %, DEF +80 / 110 %, block 2, every attack hits all she blocks; 20 % double hits at 130 / 140 % that steal 25 / 30 ASPD (capped), given back at the end', () => { + for (const [tier, elite, mod] of [[5, false, null], [6, true, AFTD]]) { + const sk = skillOf(tier, elite, S2); + const { h, u } = field({ tier, elite, mod, skill: 1, row: 9, col: 5, seed: 13 }); + assert.deepEqual([u.skill.rule, sk.duration, sk.bb.atk, sk.bb.def, sk.bb.block_cnt, sk.bb['attack@prob_twice'], sk.bb['attack@atk_scale_twice'], sk.bb['attack@steal_atk_speed'], sk.bb['attack@steal_atk_speed_max']], + ['DEFAULT', elite ? 30 : 28, elite ? 0.3 : 0.2, elite ? 1.1 : 0.8, 1, 0.2, elite ? 1.4 : 1.3, elite ? 30 : 25, elite ? 30 : 25], `T${tier}`); + h.spawn('enemy_walk', { routeIndex: 0 }); + h.spawn('enemy_walk', { routeIndex: 0, time: 0 }); + assert.ok(h.runUntil(() => u.blocking.length === 1, 30), `T${tier}: blocks one`); + h.run(2); + assert.equal(u.blocking.length, 1, `T${tier}: block 1 before the skill`); + u.skill.gainSp(999); + assert.ok(h.runUntil(() => u.skill.active, 3), `T${tier}: cast with an enemy blocked`); + approx(u.skill.timeLeft, sk.duration, `T${tier}: ${sk.duration} s`, 0.01); + approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`); + approx(u.s.def, u.base.def * (1 + sk.bb.def), `T${tier}: DEF`); + assert.ok(h.runUntil(() => u.blocking.length === 2, 10), `T${tier}: block 2 (阻挡数+1)`); + const n0 = atkHits(h, u).length; + u.skill.extend(300); + h.run(300); + const attacks = byAttack(atkHits(h, u).slice(n0)); + const both = attacks.filter((a) => new Set(a.map((c) => c.target)).size === 2); + assert.ok(both.length > attacks.length * 0.9, `T${tier}: ${both.length} / ${attacks.length} attacks hit both blocked enemies`); + const twice = attacks.filter((a) => a.length === 4); + const once = attacks.filter((a) => a.length === 2); + assert.equal(twice.length + once.length, attacks.length, `T${tier}: one or two hits per target`); + const rate = twice.length / attacks.length; + assert.ok(rate > 0.13 && rate < 0.27, `T${tier}: double hits ${twice.length} / ${attacks.length} ≈ 20 %`); + for (const c of once[0]) approx(c.amount, u.s.atk * 1.08, `T${tier}: a plain hit 100 %`, 1e-3); + for (const c of twice[0]) approx(c.amount, u.s.atk * sk.bb['attack@atk_scale_twice'] * 1.08, `T${tier}: a double hit ${sk.bb['attack@atk_scale_twice'] * 100} %`, 1e-3); + // 偷取: capped on both sides + const steal = sk.bb['attack@steal_atk_speed']; + assert.equal(u.findBuff('skill:vvana:loot')?.mods.aspd, steal, `T${tier}: her +${steal} ASPD (max ${steal})`); + for (const e of u.blocking) assert.equal(e.findBuff('skill:vvana:stolen')?.mods.aspd, -steal, `T${tier}: each target −${steal}`); + approx(u.s.aspd, 100 + steal, `T${tier}: her ASPD`); + const victims = u.blocking.slice(); + u.skill.end('test'); + assert.equal(u.findBuff('skill:vvana:loot'), null, `T${tier}: given back at the end`); + for (const e of victims) assert.equal(e.findBuff('skill:vvana:stolen'), null, `T${tier}: the enemies get theirs back`); + approx(u.s.atk, u.base.atk, `T${tier}: ATK back`); + done(h); + } +}); + +test('S3 “明灭” (MANUAL, DEFAULT): 15 s, interval 1.25 + 0.5 s, ATK / DEF / RES up, double hits, 1-1; from the second cast of a deployment 25 s, triple hits on 3-2, elite / leader enemies first; a redeploy counts again', () => { + for (const [tier, elite] of [[5, false], [6, true]]) { + const sk = skillOf(tier, elite, S3); + const { h, u } = field({ tier, elite, skill: 2, seed: 3 }); + assert.deepEqual([u.skill.rule, sk.duration, sk.bb.base_attack_time, sk.bb.atk, sk.bb.def, sk.bb.magic_resistance, sk.bb.enhance_duration, sk.bb.talent_scale, sk.rangeId], + ['DEFAULT', 15, 0.5, elite ? 0.75 : 0.55, elite ? 0.6 : 0.4, elite ? 20 : 15, 25, elite ? 2 : 1.8, '1-1'], `T${tier}`); + u.skill.gainSp(999); + h.run(2); + assert.equal(u.skill.activations, 0, `T${tier}: no enemy, no cast`); + const front = h.spawn('enemy_dummy', { pos: [10, 6] }); + assert.ok(h.runUntil(() => u.skill.active, 3), `T${tier}: cast with an enemy in her range`); + approx(u.skill.timeLeft, 15, `T${tier}: 15 s`, 0.01); + approx(u.s.interval, 1.75, `T${tier}: 攻击间隔延长(+0.5)`); + approx(u.s.atk, u.base.atk * (1 + sk.bb.atk), `T${tier}: ATK`); + approx(u.s.def, u.base.def * (1 + sk.bb.def), `T${tier}: DEF`); + approx(u.s.res, u.base.res + sk.bb.magic_resistance, `T${tier}: RES`); + assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: the first cast keeps 1-1`); + const n0 = atkHits(h, u).length; + h.runUntil(() => !u.skill.active, 20); + const first = byAttack(atkHits(h, u).slice(n0).filter((c) => c.dmg.isSkill)); + assert.ok(first.length >= 7 && first.every((a) => a.length === 2), `T${tier}: ${first.length} double hits`); + approx(u.s.interval, 1.25, `T${tier}: interval back`); + // the second cast: 25 s, 3-2, triple hits, the elite first + h.b.kill(front, null); + const normal = h.spawn('enemy_dummy', { pos: [10, 7] }); + const eliteE = h.spawn('enemy_elite', { pos: [10, 8] }); + assert.deepEqual(sortEnemyTargets(h.b, u, [eliteE, normal], null).map((e) => e.defId), ['enemy_dummy', 'enemy_elite'], `T${tier}: her usual order takes the one nearer the goal`); + assert.deepEqual(sortEnemyTargets(h.b, u, [normal, eliteE], 'elite').map((e) => e.defId), ['enemy_elite', 'enemy_dummy'], `T${tier}: the 'elite' priority (targeting.js)`); + u.skill.gainSp(999); + u.skill.activate('test'); + approx(u.skill.timeLeft, 25, `T${tier}: 持续时间延长至25秒`, 0.01); + assert.deepEqual(u.liveRangeGrid, RANGE_3_2, `T${tier}: 3-2 while it runs`); + const n1 = atkHits(h, u).length; + h.run(10); + const second = byAttack(atkHits(h, u).slice(n1).filter((c) => c.dmg.isSkill)); + assert.ok(second.length >= 5 && second.every((a) => a.length === 3 && a.every((c) => c.target === eliteE)), `T${tier}: triple hits on the elite (${second.length})`); + h.runUntil(() => !u.skill.active, 20); + assert.deepEqual(u.liveRangeGrid, [[0, 0], [0, 1]], `T${tier}: 1-1 after it`); + // a new deployment counts from one again + h.b.retreat(u); + h.b.redeploy(u); + h.step(); + u.skill.gainSp(999); + u.skill.activate('test'); + assert.deepEqual([Math.round(u.skill.timeLeft), u.liveRangeGrid], [15, [[0, 0], [0, 1]]], `T${tier}: the first cast of the new deployment`); + done(h); + } +}); + +test('T1 燃烛施明: arts dealt ×1.08, physical / arts taken ×0.92 — ×1.16 / ×0.84 while an elite / leader enemy is in her range; AFT-D stage 3: 9 % (18 %) of her attack damage as 灼燃损伤', () => { + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + const { h, u } = field({ tier, elite, mod, skill: 2 }); + const t0 = u.def.raw.talents.find((t) => t.index === 0).bb; + assert.deepEqual([t0.damage_scale_m, t0.damage_resistance_pm, t0.super_scale], [0.08, 0.08, 2], label(f)); + assert.deepEqual(u.findBuff(CANDLE)?.mods, { artsDealtMul: 1.08, physTakenMul: 0.92, artsTakenMul: 0.92 }, `${label(f)}: no elite`); + const taken = (type) => { const hp = u.hp; h.b.dealDamage(null, u, { amount: 1000, type }); const d = hp - u.hp; u.hp = u.s.maxHp; return d; }; + approx(taken('arts'), 1000 * (1 - u.s.res / 100) * 0.92, `${label(f)}: arts taken −8 %`); + approx(taken('true'), 1000, `${label(f)}: true damage untouched`); + const el = h.spawn('enemy_elite', { pos: [10, 6] }); + h.step(); + approx(taken('arts'), 1000 * (1 - u.s.res / 100) * 0.84, `${label(f)}: −16 % with the elite in her range`); + const m = u.findBuff(CANDLE).mods; + approx(m.artsDealtMul, 1.16, `${label(f)}: elite in range — arts dealt`); + approx(m.physTakenMul, 0.84, `${label(f)}: phys taken`); + approx(m.artsTakenMul, 0.84, `${label(f)}: arts taken`); + const ep = elite && tier === 6 && mod === AFTD ? 0.09 : 0; + assert.equal(t0.ep_damage_ratio_m ?? 0, ep, `${label(f)}: the AFT-D stage-3 灼燃损伤`); + h.run(1.3); + const hit = atkHits(h, u).find((c) => c.target === el); + assert.ok(hit, `${label(f)}: she hits the elite`); + approx(el.elem.burn, ep * 2 * atkHits(h, u).filter((c) => c.target === el).reduce((s, c) => s + c.amount, 0), `${label(f)}: 灼燃损伤 ×2 next to an elite`); + h.b.kill(el, null); + h.step(); + approx(u.findBuff(CANDLE).mods.artsDealtMul, 1.08, `${label(f)}: back without the elite`); + if (ep) { + const e = h.spawn('enemy_dummy', { pos: [10, 6] }); + h.run(1.3); + approx(e.elem.burn, ep * atkHits(h, u).filter((c) => c.target === e).reduce((s, c) => s + c.amount, 0), `${label(f)}: 9 % next to no elite`); + } + done(h); + } +}); + +test('T2 散华: hits on elite / leader enemies give a 护盾 layer at 18 % (AFT-Y stage 3: 25 %, 2 layers; × talent_scale while S3 runs) — only on elites, never above the cap', () => { + const rateOf = (tier, elite, mod, s3) => { + const { h, u } = field({ tier, elite, mod, skill: s3 ? 2 : 1, seed: 21 }); + if (!s3) h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; }); + const el = h.spawn('enemy_elite', { pos: [10, 6] }); + if (s3) { u.skill.gainSp(999); u.skill.activate('test'); u.skill.extend(600); } + let gains = 0, rolls = 0; + const cap = mod === AFTY && tier === 6 ? 2 : 1; + h.b.on('damaged', (c) => { + if (c.source !== u || c.target !== el || !c.dmg.isAttack) return; + rolls++; + const n = u.findBuff(SHIELD)?.data.n ?? 0; + assert.ok(n <= cap, `never above ${cap}`); + if (n > 0) { gains++; h.b.removeBuff(u, SHIELD); } + }, { priority: -100 }); + h.run(400); + done(h); + return gains / rolls; + }; + for (const [tier, elite, mod, p] of [[5, false, null, 0.18], [6, true, AFTY, 0.25], [5, true, AFTY, 0.18]]) { + const r = rateOf(tier, elite, mod, false); + assert.ok(Math.abs(r - p) < 0.06, `T${tier} ${mod ?? 'none'}: ${r.toFixed(3)} ≈ ${p}`); + } + for (const [tier, elite, mod, p] of [[5, false, null, 0.18 * 1.8], [6, true, AFTY, 0.25 * 2]]) { + const r = rateOf(tier, elite, mod, true); + assert.ok(Math.abs(r - p) < 0.08, `T${tier} ${mod ?? 'none'} under S3: ${r.toFixed(3)} ≈ ${p}`); + } + // a normal enemy gives none; AFT-Y stage 3 holds two layers + const { h, u } = field({ tier: 6, elite: true, mod: AFTY, skill: 1, seed: 2 }); + h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; }); + const e = h.spawn('enemy_dummy', { pos: [10, 6] }); + h.run(60); + assert.equal(u.findBuff(SHIELD), null, 'no layer from a normal enemy'); + h.b.kill(e, null); + h.spawn('enemy_elite', { pos: [10, 6] }); + assert.ok(h.runUntil(() => (u.findBuff(SHIELD)?.data.n ?? 0) === 2, 120), 'two layers (AFT-Y stage 3)'); + h.run(30); + assert.equal(u.findBuff(SHIELD).data.n, 2, 'no third'); + done(h); +}); + +test('T2 散华\'s 护盾 negates one whole enemy melee-path damage per layer — not an enemy shot that flew as a projectile, not 无来源 damage', () => { + const { h, u } = field({ tier: 6, elite: true, mod: AFTY, skill: 1, seed: 4 }); + h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; }); + const el = h.spawn('enemy_elite', { pos: [10, 6] }); + assert.ok(h.runUntil(() => (u.findBuff(SHIELD)?.data.n ?? 0) === 2, 120), 'two layers'); + h.b.kill(el, null); + const brute = h.spawn('enemy_dummy', { pos: [11, 9] }); + const hp0 = u.hp; + // a projectile-borne hit and a 无来源 one pass + assert.ok(h.b.dealDamage(brute, u, { amount: 300, type: 'phys', isAttack: true, isProjectile: true }) > 0, 'a projectile hit lands'); + assert.ok(h.b.dealDamage(brute, u, { amount: 300, type: 'true', sourceless: true }) > 0, 'a 无来源 hit lands'); + assert.equal(u.findBuff(SHIELD).data.n, 2, 'both layers kept'); + // a melee-path hit (an attack or an ability) is negated whole, one layer each + const hp1 = u.hp; + assert.equal(h.b.dealDamage(brute, u, { amount: 5000, type: 'phys', isAttack: true }), 0, 'a melee attack: negated'); + assert.equal(u.findBuff(SHIELD).data.n, 1); + assert.equal(h.b.dealDamage(brute, u, { amount: 5000, type: 'arts' }), 0, 'a melee-path ability: negated'); + assert.equal(u.findBuff(SHIELD), null, 'no layer left'); + assert.equal(u.hp, hp1, 'no HP lost to them'); + assert.ok(h.b.dealDamage(brute, u, { amount: 300, type: 'phys', isAttack: true }) > 0, 'without a layer the hit lands'); + assert.ok(u.hp < hp0); + done(h); +}); + +test('T2 散华 in battle: an enemy shooter\'s projectile (ai.js: DamageInfo isProjectile) never spends a layer; a blocked brute\'s blow does', () => { + const { h, u } = field({ tier: 6, elite: true, mod: AFTY, skill: 1, row: 9, col: 5, seed: 4 }); + h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; }); + const el = h.spawn('enemy_elite', { pos: [9, 6] }); + assert.ok(h.runUntil(() => (u.findBuff(SHIELD)?.data.n ?? 0) === 2, 120), 'two layers'); + h.b.kill(el, null); + const shooter = h.spawn('enemy_shooter', { pos: [11, 6] }); + const hits0 = h.hooksOf('hit').length; + assert.ok(h.runUntil(() => h.hooksOf('hit').slice(hits0).some((c) => c.source === shooter && c.target === u), 10), 'the shooter hits her'); + const shot = h.hooksOf('hit').slice(hits0).find((c) => c.source === shooter && c.target === u); + assert.deepEqual([shot.dmg.isProjectile, shot.dmg.cancel], [true, false], 'a projectile, not negated'); + assert.equal(u.findBuff(SHIELD).data.n, 2, 'the layers stay'); + h.b.kill(shooter, null); + h.spawn('enemy_brute', { routeIndex: 0 }); + assert.ok(h.runUntil(() => (u.findBuff(SHIELD)?.data.n ?? 0) < 2, 60), 'the brute\'s blow spends one'); + const blow = h.hooksOf('hit').filter((c) => c.source?.defId === 'enemy_brute' && c.target === u)[0]; + assert.deepEqual([blow.dmg.isProjectile, blow.dmg.cancel], [false, true], 'a melee blow, negated'); + done(h); +}); + +test('AFT-D 目不能及之处 trait: her damage on an enemy in its 灼燃 爆发冷却 is followed by 15 % ATK 元素伤害 (stages 1 and 3) — once per instance, never otherwise', () => { + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + const { h, u } = field({ tier, elite, mod, skill: 1, seed: 8 }); + h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; }); + const e = h.spawn('enemy_dummy', { pos: [10, 6] }); + h.run(3); + const rider = () => h.hooksOf('damaged').filter((c) => c.source === u && c.type === 'elemental'); + assert.equal(rider().length, 0, `${label(f)}: no rider without a burst`); + h.b.dealDamage(null, e, { type: 'element', element: 'burn', amount: 2000 }); + assert.ok(e.findBuff('burnBurst'), `${label(f)}: 灼燃 burst`); + const n0 = atkHits(h, u).length; + h.run(4); + const hits = atkHits(h, u).slice(n0); + const aftd = elite && mod === AFTD; + assert.equal(rider().length, aftd ? hits.length : 0, `${label(f)}: one rider per hit (${hits.length})`); + if (aftd) { + assert.equal(u.def.raw.trait.bb.ep_damage_ratio, 0.15); + for (const c of rider()) approx(c.amount, u.s.atk * 0.15, `${label(f)}: 15 % ATK 元素伤害`); + } + done(h); + } +}); + +test('AFT-Y “最后一行” trait: the enemies she blocks take 10 % 法术脆弱 (her arts hits ×1.1); not an enemy she does not block, none without the module', () => { + for (const f of FORMS_ALL) { + const [tier, elite, mod] = f; + const { h, u } = field({ tier, elite, mod, skill: 1, row: 9, col: 5, seed: 6 }); + h.b.on('spGain', (c) => { if (c.unit === u) c.amount = 0; }); + const far = h.spawn('enemy_dummy', { pos: [10, 6] }); + const w = h.spawn('enemy_walk', { routeIndex: 0 }); + assert.ok(h.runUntil(() => u.blocking.includes(w), 30), `${label(f)}: blocks the walker`); + h.run(0.5); + const afty = elite && mod === AFTY; + const fv = w.findBuff('artsFragile')?.data?.value ?? null; + if (afty) approx(fv, 0.1, `${label(f)}: 法术脆弱 on the blocked one`); else assert.equal(fv, null, `${label(f)}: no 法术脆弱`); + assert.equal(far.findBuff('artsFragile'), null, `${label(f)}: none on the unblocked one`); + if (afty) { + const n0 = atkHits(h, u).length; + h.run(2); + const c = atkHits(h, u).slice(n0).find((x) => x.target === w); + approx(c.amount, u.s.atk * 1.08 * 1.1, `${label(f)}: ×1.1 arts`); + } + done(h); + } +}); diff --git a/test/golden/diy.json b/test/golden/diy.json index 0793c28c..ed2f8790 100644 --- a/test/golden/diy.json +++ b/test/golden/diy.json @@ -1974,133 +1974,126 @@ "snaps": "8eac4d32 fa5c2376 bc1e9184 84fb1db6 b4b3b807 cc6f6399 c665e4ff 261094cd 5d5c61fd 1bf27396 b526ffa6 e433a3a2 7d8bd521 d7eb687d 4d18ecc9 f640c5fd 0912a7d6 cc22df71 1a833e56 d877d28b 8a887ef8 8014c7dd" }, "diy-049": { - "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=vvana/S1 5_diy2_a=vvana/S2 5_diy1_a=vvana/S3 5_diy2_b=vvana/S1 5_diy1_b=vvana/S2 5_diy2_b=vvana/S3 5_diy1_b=vvana/S1/002_vvana 5_diy2_b=vvana/S2/002_vvana 5_diy1_b=vvana/S3/002_vvana 5_diy2_b=vvana/S1/003_vvana 5_diy1_b=vvana/S2/003_vvana 5_diy2_b=vvana/S3/003_vvana", + "fast": false, "kind": "normal", "stageId": "act1autochess_m05", "modeId": "mode_multi_normal", "round": 12, "seed": 2215018795, "waveId": "act1autochess_h05", - "time": 230, - "ticks": 6900, - "reason": "timeout", - "killed": 2, + "time": 225.5, + "ticks": 6765, + "reason": "cleared", + "killed": 18, "total": 60, "unspawned": 0, "bossHpLeft": null, - "rngDraws": 0, + "rngDraws": 551, "errors": {"count":0,"kinds":[]}, - "players": {"p1":{"killed":2,"total":60,"perfect":false,"leaks":58,"leaksUncounted":0,"coins":0,"dmg":267738,"bossDmg":0,"heal":59968,"deaths":6,"layerGains":{}}}, + "players": {"p1":{"killed":18,"total":60,"perfect":false,"leaks":42,"leaksUncounted":0,"coins":0,"dmg":710346,"bossDmg":0,"heal":0,"deaths":9,"layerGains":{}}}, "units": [ - ["p1",1,"op","chess_char_5_diy1_a",2,null,0,0,76,0,304,6384,0,22,1], - ["p1",2,"op","chess_char_5_diy2_b",2,"none",0,0,75,0,652,8724,0,41,2], - ["p1",3,"op","chess_char_5_diy1_a",2,null,2564,1,6,0,21282,21790,0,137,3], - ["p1",4,"op","chess_char_5_diy2_b",2,"none",3334,1,8,2,22607,38177,0,115,4], - ["p1",5,"op","chess_char_5_diy1_a",2,null,1271,1,10,0,2272,0,0,99,2], - ["p1",6,"op","chess_char_5_diy2_b",2,"none",1510,1,11,0,2916,0,0,108,3], - ["p1",7,"op","chess_char_5_diy1_a",2,null,1133,1,1,0,0,0,0,0,0], - ["p1",8,"op","chess_char_5_diy2_b",2,"none",1360,1,3,0,97722,0,0,178,4], - ["p1",9,"op","chess_char_5_diy1_a",2,null,1218,1,5,0,0,0,29529,69,4], - ["p1",10,"op","chess_char_5_diy2_b",2,"none",1374,1,7,0,0,0,30439,60,4], - ["p1",11,"op","chess_char_5_diy1_a",2,null,932,1,9,0,56880,0,0,144,3], - ["p1",12,"op","chess_char_5_diy2_b",2,"none",1131,1,12,0,63104,0,0,136,3] + ["p1",1,"op","chess_char_5_diy1_a",0,null,2219,1,79,2,77014,2219,0,77,22], + ["p1",2,"op","chess_char_5_diy2_a",1,null,0,0,78,2,118373,4438,0,87,2], + ["p1",3,"op","chess_char_5_diy1_a",2,null,1135.7,1,64,2,86129,3302,0,83,3], + ["p1",4,"op","chess_char_5_diy2_b",0,"none",2684,1,80,4,120937,2684,0,96,32], + ["p1",5,"op","chess_char_5_diy1_b",1,"none",1251.91,1,72,4,147761,4116,0,98,3], + ["p1",6,"op","chess_char_5_diy2_b",2,"none",1962.69,1,76,4,126102,3405,0,89,3], + ["p1",7,"op","chess_char_5_diy1_b",0,"uniequip_002_vvana",2924,1,77,0,34031,5848,0,27,8], + ["p1",8,"op","chess_char_5_diy2_b",1,"uniequip_002_vvana",2924,1,1,0,0,0,0,0,0], + ["p1",9,"op","chess_char_5_diy1_b",2,"uniequip_002_vvana",2924,1,3,0,0,0,0,0,0], + ["p1",10,"op","chess_char_5_diy2_b",0,"uniequip_003_vvana",2924,1,5,0,0,0,0,0,0], + ["p1",11,"op","chess_char_5_diy1_b",1,"uniequip_003_vvana",2924,1,7,0,0,0,0,0,0], + ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_003_vvana",2924,1,9,0,0,0,0,0,0] ], - "enemies": {"enemy_1045_hammer_2":[12,0,11,37471,77249],"enemy_1061_zomshd":[48,2,45,37605,269489]}, - "hooks": [1,76,6900,1205,1205,3051,3051,29902,8,64,33,29,0,37113,285,23,60,56,1,8,0,0,0], - "events": {"atk":1205,"deploy":16,"die":8,"dmg":3051,"heal":129,"leak":56,"skill":62,"spawn":72,"status":555}, - "fx": {}, - "snaps": "c6bdc18a 6fb12fe1 c3c94d6f f42e9bba 6ea4c93a ff3506ac f551dbb2 248e7a29 e877982d 0b8ac60e d21ffc26 89eda7b5 7ef13ac0 2d2fce6f 32484e38 3407d0b5 1b59f452 55141007 fc87be97 6239dcab e11e96f9 250fe5b6 a75b766c" + "enemies": {"enemy_1045_hammer_2":[12,1,11,12797,164878],"enemy_1061_zomshd":[48,17,31,13215,622348]}, + "hooks": [1,80,6765,692,692,2881,2804,24524,27,69,73,72,0,22697,5,36,60,42,1,27,0,0,0], + "events": {"atk":785,"deploy":20,"die":27,"dmg":2804,"fx":157,"leak":42,"skill":145,"spawn":72,"status":167}, + "fx": {"shield":80,"shieldBreak":77}, + "snaps": "73e26e85 f74f3f2d 18bba4f5 b8e6bc55 6281c209 d1d7783b 7a3afcc3 eb8722dd e3353242 370dc03d de1399c0 2cdb7887 a8acfabe 6aee8a28 df9eed7c 750ec593 7998235f 361f6437 25541ab0 fab193ca 55be8295 6b8e6660 e2b0c041" }, "diy-050": { - "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=vvana/S1 6_diy2_a=vvana/S2 6_diy1_a=vvana/S3 6_diy2_b=vvana/S1 6_diy1_b=vvana/S2 6_diy2_b=vvana/S3 6_diy1_b=vvana/S1/002_vvana 6_diy2_b=vvana/S2/002_vvana 6_diy1_b=vvana/S3/002_vvana 6_diy2_b=vvana/S1/003_vvana 6_diy1_b=vvana/S2/003_vvana 6_diy2_b=vvana/S3/003_vvana", "fast": false, "kind": "normal", "stageId": "act1autochess_m06", "modeId": "mode_multi_hard", - "round": 12, + "round": 13, "seed": 574294847, - "waveId": "act1autochess_h05", - "time": 214.8, - "ticks": 6444, - "reason": "cleared", - "killed": 0, - "total": 60, + "waveId": "act1autochess_h06", + "time": 230, + "ticks": 6900, + "reason": "timeout", + "killed": 5, + "total": 105, "unspawned": 0, "bossHpLeft": null, - "rngDraws": 115, + "rngDraws": 270, "errors": {"count":0,"kinds":[]}, - "players": {"p1":{"killed":0,"total":60,"perfect":false,"leaks":60,"leaksUncounted":0,"coins":0,"dmg":157435,"bossDmg":0,"heal":12039,"deaths":23,"layerGains":{}}}, + "players": {"p1":{"killed":5,"total":105,"perfect":false,"leaks":100,"leaksUncounted":0,"coins":0,"dmg":231643,"bossDmg":0,"heal":0,"deaths":18,"layerGains":{}}}, "units": [ - ["p1",1,"op","chess_char_5_diy1_a",2,null,0,0,82,0,28,5208,0,2,0], - ["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,0,20856,0,0,0,7], - ["p1",4,"op","chess_char_5_diy2_b",2,"uniequip_002_acpion",0,0,72,0,174,5712,0,6,0], - ["p1",5,"op","chess_char_5_diy1_a",2,null,0,0,67,0,13430,5276,0,29,1], - ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_002_acguad",0,0,78,0,61051,12366,0,48,2], - ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,85,0,698,3816,0,13,1], - ["p1",8,"op","chess_char_5_diy2_b",2,"uniequip_002_acnipe",0,0,84,0,2755,4761,0,39,1], - ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,52,0,19051,2744,0,7,1], - ["p1",10,"op","chess_char_5_diy2_b",2,"uniequip_002_accast",0,0,51,0,39393,3498,0,7,1], - ["p1",11,"op","chess_char_5_diy1_a",2,null,0,0,47,0,0,2448,1260,3,0], - ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_002_acmedc",0,0,54,0,0,9324,10779,8,1] + ["p1",1,"op","chess_char_6_diy1_a",0,null,730.03,1,127,0,11969,5927,0,45,10], + ["p1",2,"op","chess_char_6_diy2_a",1,null,2219,1,7,0,0,0,0,0,0], + ["p1",3,"op","chess_char_6_diy1_a",2,null,2219,1,9,0,0,0,0,0,0], + ["p1",4,"op","chess_char_6_diy2_b",0,"none",0,0,113,0,17100,8052,0,31,8], + ["p1",5,"op","chess_char_6_diy1_b",1,"none",2684,1,128,0,30221,5368,0,38,2], + ["p1",6,"op","chess_char_6_diy2_b",2,"none",0,0,82,0,18342,5368,0,49,2], + ["p1",7,"op","chess_char_6_diy1_b",0,"uniequip_002_vvana",0,0,78,0,24946,6208,0,34,13], + ["p1",8,"op","chess_char_6_diy2_b",1,"uniequip_002_vvana",0,0,103,2,53409,6208,0,44,1], + ["p1",9,"op","chess_char_6_diy1_b",2,"uniequip_002_vvana",0,0,80,2,20837,6208,0,38,2], + ["p1",10,"op","chess_char_6_diy2_b",0,"uniequip_003_vvana",2984,1,122,1,22151,2984,0,16,7], + ["p1",11,"op","chess_char_6_diy1_b",1,"uniequip_003_vvana",0,0,3,0,3137,2984,0,2,1], + ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_003_vvana",0,0,5,0,29530,2984,0,48,2] ], - "enemies": {"enemy_1045_hammer_2":[12,0,12,15694,22503],"enemy_1061_zomshd":[48,0,48,39458,134932]}, - "hooks": [1,85,6444,245,245,412,396,10112,23,83,15,15,0,16629,0,28,60,60,1,26,0,0,16], - "events": {"atk":263,"deploy":25,"die":23,"dmg":396,"fx":86,"heal":23,"leak":60,"skill":30,"spawn":72,"status":14}, - "fx": {"aoe":5,"dodge":16,"dp":7,"slash":56,"spGain":2}, - "snaps": "580b238a aa91295b 3af047b3 a833e612 f6a0b595 1eba1563 0c047aab 7838a66c 34fc5adc 627a4814 4d7c5d84 41a4b79a 721f8563 f6d5a347 76cda6c2 74e73fdb 220b1dd6 2f7b90e4 d3a2ce26 6a84c6a3 1aae6574 0e8ef572" + "enemies": {"enemy_1165_duhond":[51,5,46,17121,71957],"enemy_1174_duholy_2":[24,0,23,17708,83630],"enemy_1175_dushdo_2":[30,0,30,17462,76056]}, + "hooks": [1,128,6900,601,601,773,894,0,23,122,48,48,0,16028,515,28,105,99,1,23,0,7,0], + "events": {"atk":628,"deploy":23,"die":23,"dmg":894,"fx":109,"leak":99,"skill":96,"spawn":117,"status":302}, + "fx": {"burst":7,"shield":51,"shieldBreak":51}, + "snaps": "334b187a 254deb7c e109d503 ca23feab 30aae29b e91843d7 aa822d06 d015eabd 88c69f73 cd8ac3bf 5e9ffede 7b7862f3 c2e96252 ceac5c37 ee68d03a f021eab2 2e097e71 359456c2 e5206894 abbfc3dc 0e631ae0 97daa192 edfb2238" }, "diy-051": { - "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=headb2/S1 5_diy2_a=headb2/S2 5_diy1_a=headb2/S3 5_diy2_b=headb2/S1 5_diy1_b=headb2/S2 5_diy2_b=headb2/S3 5_diy1_b=headb2/S1/002_headb2 5_diy2_b=headb2/S2/002_headb2 5_diy1_b=headb2/S3/002_headb2 6_diy1_a=headb2/S1 6_diy2_a=headb2/S2 6_diy1_a=headb2/S3", "fast": false, "kind": "normal", "stageId": "act1autochess_m07", "modeId": "mode_single_normal", - "round": 13, + "round": 12, "seed": 3864737019, - "waveId": "act1autochess_h06", - "time": 204.8, - "ticks": 6144, + "waveId": "act1autochess_h05", + "time": 183.5, + "ticks": 5505, "reason": "cleared", - "killed": 197, - "total": 290, + "killed": 89, + "total": 99, "unspawned": 0, "bossHpLeft": null, - "rngDraws": 282, + "rngDraws": 0, "errors": {"count":0,"kinds":[]}, - "players": {"p1":{"killed":197,"total":290,"perfect":false,"leaks":93,"leaksUncounted":0,"coins":0,"dmg":444885,"bossDmg":0,"heal":0,"deaths":15,"layerGains":{}}}, + "players": {"p1":{"killed":89,"total":99,"perfect":false,"leaks":10,"leaksUncounted":0,"coins":0,"dmg":1135858,"bossDmg":0,"heal":0,"deaths":6,"layerGains":{}}}, "units": [ - ["p1",1,"op","chess_char_6_diy1_a",2,null,0,0,4,7,21881,2604,0,65,1], - ["p1",2,"op","chess_char_6_diy2_b",2,"uniequip_002_acfend",0,0,7,11,35637,3431,0,87,2], - ["p1",3,"op","chess_char_5_diy1_a",0,null,1560.61,1,279,11,28493,2169,0,91,2], - ["p1",4,"op","chess_char_5_diy2_b",0,"uniequip_002_sharp2",1890.36,1,277,51,98505,2858,0,110,3], - ["p1",5,"op","chess_char_6_diy1_a",2,null,0,0,241,13,39114,3058,0,54,3], - ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acpion",0,0,163,43,73993,3808,0,55,4], - ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,285,5,26351,8078,0,87,0], - ["p1",8,"op","chess_char_5_diy2_b",2,"uniequip_002_acspec",1448,1,3,7,19,0,0,16,0], - ["p1",9,"op","chess_char_6_diy1_a",2,null,2638,1,5,10,60,0,0,60,3], - ["p1",10,"op","chess_char_6_diy2_b",2,"uniequip_002_acguad",2339.65,1,8,13,64107,1191,0,82,3], - ["p1",11,"op","chess_char_5_diy1_a",2,null,1160,1,6,10,18397,0,0,78,2], - ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_002_acsupo",1430,1,9,16,38328,0,0,93,2], + ["p1",1,"op","chess_char_5_diy1_a",0,null,2301,1,4,0,19014,0,0,28,2], + ["p1",2,"op","chess_char_5_diy2_a",1,null,2301,1,6,1,38863,0,0,32,2], + ["p1",3,"op","chess_char_5_diy1_a",2,null,2301,1,8,0,44731,0,0,18,3], + ["p1",4,"op","chess_char_5_diy2_b",0,"none",2731,1,10,2,45283,0,0,30,2], + ["p1",5,"op","chess_char_5_diy1_b",1,"none",1964.91,1,12,24,259615,766,0,64,2], + ["p1",6,"op","chess_char_5_diy2_b",2,"none",0,0,13,24,218084,2731,0,36,3], + ["p1",7,"op","chess_char_5_diy1_b",0,"uniequip_002_headb2",1336.67,1,105,16,216630,4625,0,67,2], + ["p1",8,"op","chess_char_5_diy2_b",1,"uniequip_002_headb2",2981,1,3,1,32137,0,0,13,2], + ["p1",9,"op","chess_char_5_diy1_b",2,"uniequip_002_headb2",2610.27,1,5,6,78349,371,0,7,3], + ["p1",10,"op","chess_char_6_diy1_a",0,null,0,0,7,3,40326,2301,0,30,2], + ["p1",11,"op","chess_char_6_diy2_a",1,null,752.62,1,109,4,41511,3849,0,31,1], + ["p1",12,"op","chess_char_6_diy1_a",2,null,0,0,101,8,101317,4602,0,27,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_1195_sfyin": [39,30,9,4143,113683], - "enemy_1196_msfyin": [60,32,28,0,65], - "enemy_1197_sfshu": [48,38,10,10130,184299], - "enemy_1198_msfshu": [114,78,36,0,243], - "enemy_1199_sfjin": [18,11,7,12925,146349], - "enemy_1200_msfjin": [11,8,3,0,246] - }, - "hooks": [1,314,6144,1470,1470,1969,2082,0,212,305,25,30,0,33234,6218,91,290,93,1,212,0,0,11], - "events": {"atk":1512,"deploy":22,"die":212,"dmg":2076,"fx":273,"leak":93,"skill":48,"spawn":304,"status":488}, - "fx": {"aoe":56,"displace":1,"dodge":22,"dp":63,"slash":52,"summon":79}, - "snaps": "cf051c06 587dcba3 94ed6adb bba4fd81 815661ad cbf17744 a8d0c19b 32b88916 1e8bde83 51a1d669 b023b185 df725cf4 bf4681aa 2c372e04 1a001766 3d81d3d6 7f8effe5 11826d80 b4fb05d0 0eed6d6c 65f6503d" + "enemies": {"enemy_1010_demon":[42,42,0,17936,489888],"enemy_1320_wdrrl_2":[12,2,10,0,261058],"enemy_1422_lrsldr_2":[45,45,0,1309,384912]}, + "hooks": [1,116,5505,596,596,1191,1191,0,95,105,26,22,0,32692,183,86,99,10,1,95,0,0,0], + "events": {"atk":596,"deploy":15,"die":95,"dmg":1191,"fx":211,"leak":10,"skill":48,"spawn":113,"status":308}, + "fx": {"aoe":211}, + "snaps": "0c1b4a36 da547781 589dff40 9001aa76 9b56e557 50e14d67 35a5c4c3 f537cfa6 8f62043e ee672a9c a7099d59 75a5af8d 566407ab b8841899 f5952ffa bab73867 b406d2af 737b5a4e f9449e9a" }, "diy-052": { - "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_b=headb2/S1 6_diy2_b=headb2/S2 6_diy1_b=headb2/S3 6_diy2_b=headb2/S1/002_headb2 6_diy1_b=headb2/S2/002_headb2 6_diy2_b=headb2/S3/002_headb2 5_diy1_a=hodrer/S1 5_diy2_a=hodrer/S2 5_diy1_a=hodrer/S3 5_diy2_b=hodrer/S1 5_diy1_b=hodrer/S2 5_diy2_b=hodrer/S3", "fast": false, "kind": "normal", "stageId": "act2autochess_m01", @@ -2108,35 +2101,276 @@ "round": 13, "seed": 1210502478, "waveId": "act1autochess_h06", - "time": 218.57, - "ticks": 6557, + "time": 224.1, + "ticks": 6723, "reason": "cleared", - "killed": 0, + "killed": 5, "total": 123, "unspawned": 0, "bossHpLeft": null, - "rngDraws": 81, + "rngDraws": 3, "errors": {"count":0,"kinds":[]}, - "players": {"p1":{"killed":0,"total":123,"perfect":false,"leaks":123,"leaksUncounted":0,"coins":0,"dmg":76446,"bossDmg":0,"heal":2762,"deaths":33,"layerGains":{}}}, + "players": {"p1":{"killed":5,"total":123,"perfect":false,"leaks":118,"leaksUncounted":0,"coins":0,"dmg":354974,"bossDmg":0,"heal":304,"deaths":22,"layerGains":{}}}, "units": [ - ["p1",1,"op","chess_char_6_diy1_a",0,null,0,0,6,0,2101,1865,0,8,0], - ["p1",2,"op","chess_char_6_diy2_b",0,"uniequip_002_sharp2",0,0,9,0,4660,2494,0,8,0], - ["p1",3,"op","chess_char_6_diy1_a",2,null,1154,1,157,0,13058,11540,0,21,0], - ["p1",4,"op","chess_char_6_diy2_b",2,"uniequip_002_acspec",0,0,156,0,24836,14840,0,17,0], - ["p1",5,"op","chess_char_6_diy1_a",2,null,0,0,151,0,3559,2544,0,18,0], - ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acnipe",0,0,3,0,11692,1643,0,23,0], - ["p1",7,"op","chess_char_6_diy1_a",2,null,0,0,4,0,9700,1372,0,5,1], - ["p1",8,"op","chess_char_6_diy2_b",2,"uniequip_002_accast",0,0,11,0,1022,1819,0,1,0], - ["p1",9,"op","chess_char_6_diy1_a",2,null,0,0,86,0,0,4120,2092,4,1], - ["p1",10,"op","chess_char_6_diy2_b",2,"uniequip_002_acmedc",0,0,74,0,0,4018,670,2,0], - ["p1",11,"op","chess_char_6_diy1_a",2,null,0,0,1,0,1487,1160,0,3,1], - ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_002_acsupo",0,0,5,0,4330,1450,0,7,1] + ["p1",1,"op","chess_char_6_diy1_b",0,"none",0,0,140,0,12412,8193,0,6,1], + ["p1",2,"op","chess_char_6_diy2_b",1,"none",0,0,145,0,21500,8193,0,11,0], + ["p1",3,"op","chess_char_6_diy1_b",2,"none",2731,1,146,0,9036,5462,0,3,0], + ["p1",4,"op","chess_char_6_diy2_b",0,"uniequip_002_headb2",0,0,130,0,5935,6222,0,2,1], + ["p1",5,"op","chess_char_6_diy1_b",1,"uniequip_002_headb2",0,0,79,0,13952,6222,0,2,0], + ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_headb2",0,0,5,5,249364,3111,0,1,1], + ["p1",7,"op","chess_char_5_diy1_a",0,null,0,0,76,0,6517,9340,0,3,0], + ["p1",8,"op","chess_char_5_diy2_a",1,null,0,0,1,0,1849,4670,0,1,1], + ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,2,0,9156,6375,304,2,1], + ["p1",10,"op","chess_char_5_diy2_b",0,"none",0,0,6,0,0,5544,0,0,0], + ["p1",11,"op","chess_char_5_diy1_b",1,"none",0,0,74,0,15193,11088,0,4,1], + ["p1",12,"op","chess_char_5_diy2_b",2,"none",0,0,72,0,10061,11088,0,5,0] ], - "enemies": {"enemy_1019_jshoot_2":[57,0,57,29550,4113],"enemy_1299_ymkilr_2":[27,0,27,14576,26756],"enemy_1422_lrsldr_2":[39,0,39,4739,45577]}, - "hooks": [1,157,6557,277,277,283,291,7,33,156,4,24,0,6272,192,29,123,123,1,33,0,0,0], - "events": {"atk":278,"deploy":34,"die":33,"dmg":269,"fx":19,"heal":7,"leak":123,"skill":8,"spawn":135,"status":92}, - "fx": {"aoe":2,"displace":15,"spGain":2}, - "snaps": "21be44ba 23e43266 29788d55 2f1037e9 363ad836 051606c5 26acdfeb 8dc54607 7a7c6a86 7ebe59b3 d1661fdb 203d434c 2e82423b f7e9ffc1 7a1afa0e 8998df31 0ca38cb6 f3ac5677 87bcc7cf 0f5f3879 0e082cac 62241cef" + "enemies": {"enemy_1019_jshoot_2":[57,0,57,38150,33779],"enemy_1299_ymkilr_2":[27,0,27,42800,81225],"enemy_1422_lrsldr_2":[39,5,34,4257,239970]}, + "hooks": [1,146,6723,202,202,354,357,2,27,145,6,6,0,6633,84,37,123,118,1,27,0,0,0], + "events": {"atk":210,"deploy":23,"die":27,"dmg":357,"fx":68,"heal":1,"leak":118,"skill":12,"spawn":135,"status":158}, + "fx": {"aoe":68}, + "snaps": "9dc64bfa ef0fa2af 488d2dc0 0a4d7946 15cce1e0 193f10aa 520d97a0 bffb4687 1c6b4b7b 98494518 51bd6e09 0989541d 71cd8118 dc878d4b 3bd7e400 a7230ae3 fbcc1416 ceab0c22 95bc0719 e5d27ed4 da56fbad d9155ab1 1bada81a" + }, + "diy-053": { + "about": "5_diy1_b=hodrer/S1/002_hodrer 5_diy2_b=hodrer/S2/002_hodrer 5_diy1_b=hodrer/S3/002_hodrer 5_diy2_b=hodrer/S1/003_hodrer 5_diy1_b=hodrer/S2/003_hodrer 5_diy2_b=hodrer/S3/003_hodrer 6_diy1_a=hodrer/S1 6_diy2_a=hodrer/S2 6_diy1_a=hodrer/S3 6_diy2_b=hodrer/S1 6_diy1_b=hodrer/S2 6_diy2_b=hodrer/S3", + "fast": false, + "kind": "normal", + "stageId": "act2autochess_m02", + "modeId": "mode_multi_funny", + "round": 13, + "seed": 2850577873, + "waveId": "act1autochess_h06", + "time": 209.9, + "ticks": 6297, + "reason": "cleared", + "killed": 76, + "total": 114, + "unspawned": 0, + "bossHpLeft": null, + "rngDraws": 94, + "errors": {"count":0,"kinds":[]}, + "players": {"p1":{"killed":76,"total":114,"perfect":false,"leaks":38,"leaksUncounted":0,"coins":0,"dmg":700284,"bossDmg":0,"heal":43571,"deaths":17,"layerGains":{}}}, + "units": [ + ["p1",1,"op","chess_char_5_diy1_b",0,"uniequip_002_hodrer",0,0,3,7,45724,12488,6654,23,5], + ["p1",2,"op","chess_char_5_diy2_b",1,"uniequip_002_hodrer",0,0,125,6,67771,11668,0,18,2], + ["p1",3,"op","chess_char_5_diy1_b",2,"uniequip_002_hodrer",0,0,5,17,145328,20541,12655,31,1], + ["p1",4,"op","chess_char_5_diy2_b",0,"uniequip_003_hodrer",0,0,118,5,61854,18701,7013,29,6], + ["p1",5,"op","chess_char_5_diy1_b",1,"uniequip_003_hodrer",0,0,87,8,78538,11688,0,18,2], + ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_003_hodrer",0,0,93,9,99596,18884,5508,25,2], + ["p1",7,"op","chess_char_6_diy1_a",0,null,81.72,1,135,6,48256,17431,3503,27,5], + ["p1",8,"op","chess_char_6_diy2_a",1,null,0,0,83,3,22557,9340,0,11,2], + ["p1",9,"op","chess_char_6_diy1_a",2,null,0,0,76,3,31974,10504,911,24,1], + ["p1",10,"op","chess_char_6_diy2_b",0,"none",0,0,9,2,23362,8870,3326,14,3], + ["p1",11,"op","chess_char_6_diy1_b",1,"none",853.6,1,10,4,24791,4690,0,13,1], + ["p1",12,"op","chess_char_6_diy2_b",2,"none",4040.74,1,6,6,50532,8000,4002,36,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_1381_winman":[27,19,8,16483,105792],"enemy_1381_winman_2":[48,32,16,47678,252515],"enemy_1387_winshd":[39,25,14,69724,341977]}, + "hooks": [1,136,6297,710,710,1077,1267,77,93,131,32,30,0,7859,120,111,114,38,1,93,0,0,0], + "events": {"atk":885,"deploy":20,"die":93,"dmg":1267,"heal":75,"leak":38,"skill":62,"spawn":128,"status":187}, + "fx": {}, + "snaps": "ba1d08a7 c12be8c0 6309483f 0a62bc0d 43d056ee cbcfe8e0 df0516ce c9b808a7 fb26d9a6 29045d4a 4116a1d1 4c7401b8 56710523 f1825233 e0591c1c 4b8439a2 80207a59 84ae3793 ba3d212e 41962260 d21cc00c" + }, + "diy-054": { + "about": "5_diy1_a=cdfend 5_diy2_b=cdfend 6_diy1_b=hodrer/S1/002_hodrer 6_diy2_b=hodrer/S2/002_hodrer 6_diy1_b=hodrer/S3/002_hodrer 6_diy2_b=hodrer/S1/003_hodrer 6_diy1_b=hodrer/S2/003_hodrer 6_diy2_b=hodrer/S3/003_hodrer 5_diy1_a=cguard 5_diy2_b=cguard 5_diy1_a=csnipe 5_diy2_b=csnipe", + "fast": true, + "kind": "normal", + "stageId": "act2autochess_m03", + "modeId": "mode_single_hard", + "round": 13, + "seed": 196461732, + "waveId": "act1autochess_h06", + "time": 229.47, + "ticks": 6884, + "reason": "cleared", + "killed": 2, + "total": 66, + "unspawned": 0, + "bossHpLeft": null, + "rngDraws": 0, + "errors": {"count":0,"kinds":[]}, + "players": {"p1":{"killed":2,"total":66,"perfect":false,"leaks":64,"leaksUncounted":0,"coins":0,"dmg":21849,"bossDmg":0,"heal":0,"deaths":21,"layerGains":{}}}, + "units": [ + ["p1",1,"op","chess_char_5_diy1_a",2,null,0,0,86,0,0,4256,0,0,0], + ["p1",2,"op","chess_char_5_diy2_b",2,"none",0,0,90,0,0,5816,0,0,0], + ["p1",3,"op","chess_char_6_diy1_b",0,"uniequip_002_hodrer",5994,1,11,0,0,0,0,0,0], + ["p1",4,"op","chess_char_6_diy2_b",1,"uniequip_002_hodrer",0,0,59,0,0,11988,0,0,0], + ["p1",5,"op","chess_char_6_diy1_b",2,"uniequip_002_hodrer",0,0,57,0,0,11988,0,0,0], + ["p1",6,"op","chess_char_6_diy2_b",0,"uniequip_003_hodrer",0,0,9,0,0,5944,0,0,0], + ["p1",7,"op","chess_char_6_diy1_b",1,"uniequip_003_hodrer",0,0,61,0,0,11888,0,0,0], + ["p1",8,"op","chess_char_6_diy2_b",2,"uniequip_003_hodrer",0,0,54,0,0,11888,0,0,0], + ["p1",9,"op","chess_char_5_diy1_a",2,null,2564,1,94,0,0,5128,0,0,0], + ["p1",10,"op","chess_char_5_diy2_b",2,"none",0,0,68,0,0,6668,0,0,0], + ["p1",11,"op","chess_char_5_diy1_a",2,null,228.91,1,92,1,9604,3584,0,33,1], + ["p1",12,"op","chess_char_5_diy2_b",2,"none",871.27,1,93,1,12246,3659,0,31,1], + ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null], + ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null], + ["-","~3","device","trap_1105_accrate",null,null,100,1,3,0,0,0,0,0,null] + ], + "enemies": {"enemy_1005_yokai_2":[12,1,11,10654,4662],"enemy_1041_lazerd_2":[24,1,23,72153,17013],"enemy_1042_frostd":[30,0,30,0,175]}, + "hooks": [1,94,6884,279,279,268,268,0,23,87,2,2,0,11421,0,0,66,64,1,23,0,0,0], + "events": {"atk":279,"deploy":25,"die":23,"dmg":268,"leak":64,"skill":4,"spawn":81,"status":56}, + "fx": {}, + "snaps": "51a14255 29d23003 cb418cc6 ed83d119 12069e0d 4c56456f 0d13eb47 762ea1b2 cd7bed5e 79189717 ff09eb91 523309ed 6d2af61d c9769bf5 3bb388c6 73186fe4 09360980 0998a6f8 214f959c 23fd8cb4 706f8a17 9b3d12a8 8620b5ec" + }, + "diy-055": { + "about": "5_diy1_a=acfend 5_diy2_b=acfend 5_diy1_a=acpion 5_diy2_b=acpion 5_diy1_a=acguad 5_diy2_b=acguad 5_diy1_a=ccast 5_diy2_b=ccast 5_diy1_a=cmedic 5_diy2_b=cmedic 5_diy1_a=csuppo 5_diy2_b=csuppo", + "fast": false, + "kind": "normal", + "stageId": "act2autochess_m04", + "modeId": "mode_multi_normal", + "round": 12, + "seed": 1597707536, + "waveId": "act1autochess_h05", + "time": 228.5, + "ticks": 6855, + "reason": "cleared", + "killed": 26, + "total": 117, + "unspawned": 0, + "bossHpLeft": null, + "rngDraws": 109, + "errors": {"count":0,"kinds":[]}, + "players": {"p1":{"killed":26,"total":117,"perfect":false,"leaks":91,"leaksUncounted":0,"coins":0,"dmg":116177,"bossDmg":0,"heal":1527,"deaths":24,"layerGains":{}}}, + "units": [ + ["p1",1,"op","chess_char_5_diy1_a",2,null,0,0,120,0,0,5208,0,0,0], + ["p1",2,"op","chess_char_5_diy2_b",2,"uniequip_002_acfend",0,0,116,0,0,6742,0,0,0], + ["p1",3,"op","chess_char_5_diy1_a",2,null,1513.21,1,146,6,18964,3074,0,0,2], + ["p1",4,"op","chess_char_5_diy2_b",2,"uniequip_002_acpion",533.8,1,144,12,53249,5178,0,0,3], + ["p1",5,"op","chess_char_5_diy1_a",2,null,0,0,99,0,0,5276,0,0,0], + ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_002_acguad",0,0,95,0,0,6822,0,0,0], + ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,3,2,2801,1133,0,7,1], + ["p1",8,"op","chess_char_5_diy2_b",2,"none",0,0,4,3,23106,1360,0,44,1], + ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,141,0,0,4624,1341,4,1], + ["p1",10,"op","chess_char_5_diy2_b",2,"none",1374,1,145,0,0,3305,186,1,1], + ["p1",11,"op","chess_char_5_diy1_a",2,null,0,0,134,3,9241,1864,0,25,1], + ["p1",12,"op","chess_char_5_diy2_b",2,"none",0,0,143,0,8816,3393,0,19,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_1005_yokai":[51,14,37,0,29083],"enemy_1005_yokai_2":[54,12,42,15091,46247],"enemy_1005_yokai_3":[12,0,12,32888,40847]}, + "hooks": [1,146,6855,565,565,623,590,5,50,141,11,11,0,14473,41,0,117,91,1,50,0,0,33], + "events": {"atk":565,"deploy":27,"die":50,"dmg":590,"fx":79,"heal":5,"leak":91,"skill":22,"spawn":131,"status":91}, + "fx": {"dodge":33,"dp":23,"slash":23}, + "snaps": "ce9ca917 dc0c23c1 ec28421e 3235af3b 7760df97 37714ea1 2d79aa03 16bcb957 d2059f17 ebee2762 29c4b543 6856ac9b f6227083 c41b8525 a8160d33 202679e9 c5cc7507 c3f7c3db 878a0b36 2200d567 8cab3a1c ad9d8bf1 a37c78c3" + }, + "diy-056": { + "about": "5_diy1_a=sharp2 5_diy2_b=sharp2 5_diy1_a=acspec 5_diy2_b=acspec 5_diy1_a=acnipe 5_diy2_b=acnipe 5_diy1_a=accast 5_diy2_b=accast 5_diy1_a=acmedc 5_diy2_b=acmedc 5_diy1_a=acsupo 5_diy2_b=acsupo", + "fast": false, + "kind": "normal", + "stageId": "act1autochess_m01", + "modeId": "mode_multi_hard", + "round": 12, + "seed": 3238296381, + "waveId": "act1autochess_h05", + "time": 212, + "ticks": 6360, + "reason": "cleared", + "killed": 2, + "total": 75, + "unspawned": 0, + "bossHpLeft": null, + "rngDraws": 115, + "errors": {"count":0,"kinds":[]}, + "players": {"p1":{"killed":2,"total":75,"perfect":false,"leaks":73,"leaksUncounted":0,"coins":0,"dmg":149973,"bossDmg":0,"heal":3310,"deaths":32,"layerGains":{}}}, + "units": [ + ["p1",1,"op","chess_char_5_diy1_a",0,null,0,0,7,0,9094,1865,0,11,1], + ["p1",2,"op","chess_char_5_diy2_b",0,"uniequip_002_sharp2",0,0,9,1,21055,2374,0,10,1], + ["p1",3,"op","chess_char_5_diy1_a",2,null,0,0,110,0,21484,11540,0,17,0], + ["p1",4,"op","chess_char_5_diy2_b",2,"uniequip_002_acspec",1448,1,112,0,44302,14480,0,18,0], + ["p1",5,"op","chess_char_5_diy1_a",2,null,1272,1,111,0,9235,1272,0,26,0], + ["p1",6,"op","chess_char_5_diy2_b",2,"uniequip_002_acnipe",0,0,5,0,21680,1587,0,24,1], + ["p1",7,"op","chess_char_5_diy1_a",2,null,0,0,11,0,9181,1872,0,2,1], + ["p1",8,"op","chess_char_5_diy2_b",2,"uniequip_002_accast",0,0,13,0,5501,1749,0,3,0], + ["p1",9,"op","chess_char_5_diy1_a",2,null,0,0,6,0,0,1224,1482,8,1], + ["p1",10,"op","chess_char_5_diy2_b",2,"uniequip_002_acmedc",0,0,58,0,0,4657,1829,3,0], + ["p1",11,"op","chess_char_5_diy1_a",2,null,0,0,61,0,2034,2320,0,6,0], + ["p1",12,"op","chess_char_5_diy2_b",2,"uniequip_002_acsupo",0,0,8,1,6409,2412,0,10,1], + ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null], + ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null], + ["-","~3","device","trap_1105_accrate",null,null,100,1,3,0,0,0,0,0,null] + ], + "enemies": {"enemy_1267_nhpbr_2":[36,2,34,9446,89200],"enemy_1270_nhstlk_2":[27,0,27,6783,54853],"enemy_1272_nhtank_2":[12,0,12,31122,5919]}, + "hooks": [1,112,6360,204,204,406,419,13,34,107,6,26,0,6739,529,26,75,73,1,34,0,0,0], + "events": {"atk":217,"deploy":34,"die":34,"dmg":355,"fx":56,"heal":12,"leak":73,"skill":12,"spawn":90,"status":210}, + "fx": {"aoe":3,"displace":31,"dodge":2,"spGain":2,"zone":18}, + "snaps": "755acf8e 65e848ea aee3c8d0 c0dbf6b8 6b1b17d0 1de17c9a 41c7cf67 6d809617 89487051 d85151c9 4bc2c240 aba326b4 08e6438e 6a018fd6 da4578ac acba1b10 77b5ea51 b4647e71 ebb093c7 f862b038 cf3f0a5c 698411b8" + }, + "diy-057": { + "about": "6_diy1_a=acfend 6_diy2_b=acfend 6_diy1_a=acpion 6_diy2_b=acpion 6_diy1_a=acguad 6_diy2_b=acguad 6_diy1_a=acnipe 6_diy2_b=acnipe 6_diy1_a=accast 6_diy2_b=accast 6_diy1_a=acmedc 6_diy2_b=acmedc", + "fast": false, + "kind": "normal", + "stageId": "act1autochess_m02", + "modeId": "mode_single_normal", + "round": 13, + "seed": 583790378, + "waveId": "act1autochess_h06", + "time": 230, + "ticks": 6900, + "reason": "timeout", + "killed": 27, + "total": 147, + "unspawned": 0, + "bossHpLeft": null, + "rngDraws": 957, + "errors": {"count":0,"kinds":[]}, + "players": {"p1":{"killed":27,"total":147,"perfect":false,"leaks":120,"leaksUncounted":0,"coins":0,"dmg":816188,"bossDmg":0,"heal":89315,"deaths":5,"layerGains":{}}}, + "units": [ + ["p1",1,"op","chess_char_6_diy1_a",2,null,0,0,163,0,1057,7812,0,37,0], + ["p1",2,"op","chess_char_6_diy2_b",2,"uniequip_002_acfend",3159.36,1,1,0,10504,6519,0,98,2], + ["p1",3,"op","chess_char_6_diy1_a",2,null,1529,1,153,0,13774,5174,0,95,5], + ["p1",4,"op","chess_char_6_diy2_b",2,"uniequip_002_acpion",1904,1,156,5,117662,6159,0,52,8], + ["p1",5,"op","chess_char_6_diy1_a",2,null,2638,1,10,5,49374,16637,0,121,4], + ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acguad",3531,1,11,9,97537,16240,0,128,5], + ["p1",7,"op","chess_char_6_diy1_a",2,null,1272,1,5,0,19178,0,0,171,3], + ["p1",8,"op","chess_char_6_diy2_b",2,"uniequip_002_acnipe",1643,1,8,1,97455,0,0,192,3], + ["p1",9,"op","chess_char_6_diy1_a",2,null,1372,1,6,6,175317,0,0,77,2], + ["p1",10,"op","chess_char_6_diy2_b",2,"uniequip_002_accast",1819,1,9,1,234331,0,0,82,3], + ["p1",11,"op","chess_char_6_diy1_a",2,null,1224,1,12,0,0,35218,38674,78,3], + ["p1",12,"op","chess_char_6_diy2_b",2,"uniequip_002_acmedc",1464,1,2,0,0,7074,50642,74,3] + ], + "enemies": {"enemy_1166_dusbr_2":[39,10,29,1287,210292],"enemy_1169_duphlx_2":[57,10,46,56400,279740],"enemy_1170_dushld_2":[51,7,42,43145,326156]}, + "hooks": [1,163,6900,1572,1572,3294,3267,251,32,149,41,37,0,46308,0,43,147,117,1,32,0,0,27], + "events": {"atk":1850,"deploy":16,"die":32,"dmg":3267,"fx":236,"heal":232,"leak":117,"skill":78,"spawn":159,"status":172}, + "fx": {"aoe":91,"dodge":27,"dp":18,"slash":98,"spGain":2}, + "snaps": "763f5829 14e476f8 8427cf50 1f17887d 31accd4f bca21d62 979b8a03 056885f6 7be715ee 7f7c774a 9f8ec3ab 9e65a95f 4f03c156 3a02c890 a875ae0f c4a6206c dd5bb5e4 14eadfdf 87568458 e6be5156 3d7da02b bb73bb00 1d514e99" + }, + "diy-058": { + "about": "6_diy1_a=sharp2 6_diy2_b=sharp2 6_diy1_a=acspec 6_diy2_b=acspec 6_diy1_a=acsupo 6_diy2_b=acsupo", + "fast": false, + "kind": "normal", + "stageId": "act1autochess_m03", + "modeId": "mode_multi_abyss", + "round": 13, + "seed": 2224511831, + "waveId": "act1autochess_h06", + "time": 208.07, + "ticks": 6242, + "reason": "cleared", + "killed": 0, + "total": 105, + "unspawned": 0, + "bossHpLeft": null, + "rngDraws": 53, + "errors": {"count":0,"kinds":[]}, + "players": {"p1":{"killed":0,"total":105,"perfect":false,"leaks":105,"leaksUncounted":0,"coins":0,"dmg":94634,"bossDmg":0,"heal":0,"deaths":26,"layerGains":{}}}, + "units": [ + ["p1",1,"op","chess_char_6_diy1_a",0,null,0,0,4,0,2431,1865,0,8,0], + ["p1",2,"op","chess_char_6_diy2_b",0,"uniequip_002_sharp2",0,0,5,0,20502,2494,0,12,1], + ["p1",3,"op","chess_char_6_diy1_a",2,null,0,0,134,0,22891,11540,0,20,0], + ["p1",4,"op","chess_char_6_diy2_b",2,"uniequip_002_acspec",1484,1,135,0,38022,13356,0,21,0], + ["p1",5,"op","chess_char_6_diy1_a",2,null,0,0,76,0,9532,2320,0,29,2], + ["p1",6,"op","chess_char_6_diy2_b",2,"uniequip_002_acsupo",0,0,121,0,1255,4350,0,4,0], + ["-","~1","device","trap_1105_accrate",null,null,100,1,1,0,0,0,0,0,null], + ["-","~2","device","trap_1105_accrate",null,null,100,1,2,0,0,0,0,0,null], + ["-","~3","device","trap_1105_accrate",null,null,100,1,3,0,0,0,0,0,null] + ], + "enemies": {"enemy_1229_darmy":[27,0,27,2887,28278],"enemy_1229_darmy_2":[57,0,57,6910,40954],"enemy_1275_dwlock_2":[21,0,21,26127,25401]}, + "hooks": [1,135,6242,149,149,288,335,0,26,131,3,22,0,3213,711,22,105,105,1,26,0,0,1], + "events": {"atk":153,"deploy":27,"die":26,"dmg":275,"fx":60,"leak":105,"skill":6,"spawn":114,"status":206}, + "fx": {"beam":26,"displace":33,"dodge":1}, + "snaps": "94943173 294f52f9 121acf93 d3fc4a35 953aa247 3c7a92c8 3ab8693e 76fa1f07 0d33591f a915e831 339dbaef 60e1df5b 95bdb81e 74579379 3e516ade 76530183 87d55d71 15280bc2 0961f61a c2a04d2f a28c2997" } } }