feedback5 WE1: enemy attacks strike at their damage frame; a short stun before it cuts the swing (GitHub #187 point 1, #170)

PRTS 状态机: ATTACK / COMBAT "每帧检查异常状态，若有则切换到异常状态的状态"; PRTS 异常效果 STUNNED (the state machine
leaves the attack), DISARMED "正在进行的普通攻击将被中断". The strike frame is data/enemies.json attackAnim.hit.

- ai.js: attackWindup = the clip's strike frame (half the clip when none is named), shortened with the clip like the
  stand; the cooldown counts down to the strike and the swing (enemy.swing) starts when it reaches the wind-up with a
  target in reach (attackTargets, shared with the frame) — steady-state strikes stay one interval apart. An enemy whose
  cooldown ran out before it had a target (walking, just blocked, a cut swing) swings from the start: the whole wind-up.
- A stun / freeze / sleep / 浮空 / hiding, 缴械, 恐惧, 战栗 while blocked or losing every target cuts a swing short of its
  frame: no strike, the next swing starts from its wind-up. A stun in the cooldown only pauses it; a strike already
  made stays made. No clip known (36 of 249 kinds): no wind-up, the old rule. [ASSUMED] targets re-taken at the frame,
  a cut swing does not spend the cooldown, enemy heals keep no wind-up.

Golden: 275 of 283 scenarios moved — roster all 49; bonds 41 of 46 (unchanged: bond-arcaneShip-high,
bond-kjeragShip-low, bond-maniShip-low, bond-skillfulShip-high, bond-swiftShip-low); fields all 22; matches all 18;
standins all 10; diy 135 of 138 (unchanged: diy-027, diy-029, diy-087) — every battle where a clip-carrying enemy meets an
operator: the first strike of a contact waits its wind-up, stuns cut swings (the cut alone moves 55). With every
attackAnim stripped from the data the corpus is byte-identical to the previous commit (nothing else moved). Bot
matches: solo-HARD-2 now wins, coop2-NORMAL-8-serverrun now loses; the other 16 keep their result.

Tests: test/sim/feedback5-enemy-swing.test.js (new, 6). Updated on purpose: feedback2-enemy-attack-stand.test.js (it
locked the instant first strike), enemies_bosses.test.js (沉沙 / 新硎's cleared interval, 帝国的甲胄, 斩胄之剑 / 破胄之锤 wait
for the frame). test/sim, test/content, test/match pass. Docs: SIM.md, DATA.md (attackAnim), ASSETS.md.

server/sim/ai.js

@@ -18,9 +18,11 @@
 // its unit blocks (PRTS 卫戍协议/帮助 "对于医疗干员（咒愈师分支除外），攻击目标为需要治疗的单位"). An ally target
 // (Battle.setAllyTarget: 白铁's 铁钳号·原型机, an enemy-camp summon our operators attack, 嘲讽等级 −2) on the range comes after
 // every enemy (acquireTargets) and a ranged attack flies to it like to an enemy.
-// Unblocked ranged enemies attack allies within their radius and stand for each attack's clip — through its wind-up
-// and until the clip ends — then walk on (attackStand, GitHub #58; ATTACK_PAUSE after the strike when no clip is known;
-// 「不停止移动」 attackers never stop); the candidates pass the enemy's own rule (`e.profile.canTarget`) and are ordered
+// Every enemy attack strikes at its clip's damage frame after its swing starts (attackWindup; a stun before the frame
+// cuts the swing — enemyAttack, GitHub #187). Unblocked ranged enemies attack allies within their radius and stand for
+// each attack's clip — through its wind-up and until the clip ends — then walk on (attackStand, GitHub #58;
+// ATTACK_PAUSE after the strike when no clip is known; 「不停止移动」 attackers never stop); the candidates pass the
+// enemy's own rule (`e.profile.canTarget`) and are ordered
 // blocker → taunt → latest deployed (targeting.js sortAllyTargets). An enemy's damage type is its data's unless content
 // arms it (`e.profile.dmgType`: 转译基底's forms, whose data never attacks). Reaching the final leg's end = leak. A `fear` (恐惧) status suspends the route: the
 // enemy runs between random checkpoints away from the fear's source (fear.js moveFeared; a self-inflicted fear
@@ -499,9 +501,13 @@ export function updateEnemy(b, e, dt) {
   if (!e.alive) return;
   // hidden (teleporting) enemies only advance wait legs
   const stunned = e.s.flags.stun;
+  const prevCd = e.atkCd;
   if (e.atkCd > 0 && !stunned && !e.hidden) e.atkCd = Math.max(0, e.atkCd - dt);
+  // a stun / freeze / sleep / 浮空 — or leaving the field — takes the enemy out of its attack: a swing short of its damage
+  // frame does not land, and the attack starts again from its wind-up afterwards (enemyAttack)
+  if (e.swing && (stunned || e.hidden)) e.swing = false;
   // true: an unblocked ranged enemy in the wind-up of its next attack with a target in range (it stands)
-  const winding = !e.hidden && !stunned && enemyAttack(b, e);
+  const winding = !e.hidden && !stunned && enemyAttack(b, e, prevCd);
   if (!e.alive) return;
   // a stun / freeze / sleep cuts the attack clip short: no stand left once it ends [ASSUMED]
   if (stunned && !e.hidden) { e.atkStandUntil = -Infinity; return; }
@@ -656,43 +662,31 @@ export function attackStand(e, out = { wind: 0, rest: 0 }) {
   if (e.profile?.attackMoves ?? e.def?.attackMoves) return out;
   const a = e.def?.attackAnim;
   if (!a || !(a.dur > 0)) { out.rest = ATTACK_PAUSE; return out; }
-  const iv = e.s.interval;
-  const speed = iv > 0 && iv < a.dur ? a.dur / iv : 1;
-  const hit = Number.isFinite(a.hit) ? Math.min(a.dur, Math.max(0, a.hit)) : a.dur / 2;
+  const speed = clipSpeed(e, a);
+  const hit = clipHit(a);
   out.wind = hit / speed;
   out.rest = (a.dur - hit) / speed;
   return out;
 }
 const STAND = { wind: 0, rest: 0 };
+/** The attack clip's strike frame (s into the clip); half the clip when the manifest names none. */
+const clipHit = (a) => (Number.isFinite(a.hit) ? Math.min(a.dur, Math.max(0, a.hit)) : a.dur / 2);
+/** The clip plays faster when the attacks come quicker than it. */
+const clipSpeed = (e, a) => { const iv = e.s.interval; return iv > 0 && iv < a.dur ? a.dur / iv : 1; };
 
 /**
- * One tick of an enemy's attack: attacks when its cooldown is over and a target is in reach. Returns true while an
- * unblocked ranged enemy is in the wind-up of its next attack (cooldown ≤ its clip's wind-up, attackStand) with a
- * target in range: it stands (updateEnemy).
+ * The damage frame of an enemy's normal attack: seconds from the start of its swing to the strike — its attack clip's
+ * strike frame (data/enemies.json `attackAnim.hit`, half the clip when the manifest names none), shortened with the clip
+ * when the attacks come quicker than it (as attackStand; a 「不停止移动」 attacker swings on the move); 0 with no clip known
+ * (the strike as the swing starts — the rule before 0.2.0).
  */
-function enemyAttack(b, e) {
-  const def = e.def;
-  if (e.profile && e.profile.noAttack) return false;
-  const dmgType = (e.profile && e.profile.dmgType) || def.dmgType;
-  if (dmgType === 'none' || e.s.atk <= 0) return false;
-  if (e.s.flags.fear || e.s.flags.disarm) return false;
-  if (e.s.flags.tremble && e.blockedBy) return false; // 战栗: 被阻挡后无法进行普通攻击
-  if (dmgType === 'heal') { if (e.atkCd <= 0) enemyHeal(b, e, e.base.rangeRadius); return false; }
-  // applyWay MELEE enemies only ever hit their blocker, even when their data carries a rangeRadius (粉碎攻坚手 2.5,
-  // 宿主士兵 2.5, 深池伙友卫队 1.4 … — that radius belongs to their abilities/splash, handled by content).
-  // Content may flip it with `e.profile.melee = false`.
-  const melee = e.profile?.melee ?? def.applyWay === 'MELEE';
-  const radius = melee ? 0 : e.base.rangeRadius;
-  // the range circle takes an ally whose 0.25 collider touches it (PRTS 作战机制 §碰撞体积: 索敌 uses the colliders)
-  const reach = radius > 0 ? radius + ALLY_COLLIDER_RADIUS : 0;
-  // `e.profile.canTarget(ally)`: the enemy's own target rule (只攻击地面单位, 不会攻击飞行单位 …; content/enemies/*.js),
-  // applied to the candidates before the priority sort and the target count
-  const own = e.profile && typeof e.profile.canTarget === 'function' ? e.profile.canTarget : null;
-  if (e.atkCd > 0) {
-    // the wind-up of the next attack (GitHub #58): an unblocked ranged enemy stands once a target is in range
-    if (e.blockedBy || radius <= 0 || !(e.atkCd <= attackStand(e, STAND).wind + 1e-9)) return false;
-    return b.alliesInRadius(e.x, e.y, reach, null).some((a) => canTargetAlly(e, a, true) && (!own || own(a)));
-  }
+export function attackWindup(e) {
+  const a = e.def?.attackAnim;
+  return a && a.dur > 0 ? clipHit(a) / clipSpeed(e, a) : 0;
+}
+
+/** The allies `e` could hit now: its blocker (and, with a range, the others in reach), passing its own target rule. */
+function attackTargets(b, e, radius, reach, own) {
   let targets = [];
   if (e.blockedBy) {
     const bl = e.blockedBy;
@@ -704,8 +698,55 @@ function enemyAttack(b, e) {
     targets = b.alliesInRadius(e.x, e.y, reach, null).filter((a) => canTargetAlly(e, a, true));
   }
   if (own && targets.length) targets = targets.filter((a) => own(a));
+  return targets;
+}
+
+/**
+ * One tick of an enemy's attack. Its cooldown (`atkCd`) counts down to the damage frame of its next attack: the swing
+ * starts `attackWindup` before it — the cooldown down to the wind-up with a target in reach (attackTargets) — and lasts
+ * while a target stays in reach; at the frame the attack is made on the targets in reach then. An enemy whose cooldown
+ * ran out before it had a target (walking, a swing cut short) swings from the start: the whole wind-up from that tick.
+ * A swing short of its frame is cut by a stun / freeze / sleep / 浮空 / leaving the field (updateEnemy), 缴械, 恐惧, 战栗
+ * while blocked, or losing every target: no damage, and the next swing starts from its wind-up again — PRTS 状态机
+ * (ATTACK / COMBAT "每帧检查异常状态，若有则切换到异常状态的状态") and 异常效果 (STUNNED, DISARMED "正在进行的普通攻击将被
+ * 中断"); GitHub #187 / #170 (a 0.1 s 卡西米尔 pulse, 忍冬 S3's 0.2 s stun). A strike already made stays made (a shot in
+ * flight lands). An enemy with no attack clip known has no wind-up: it strikes as the swing starts (the old rule).
+ * [ASSUMED] the targets are taken at the frame (the swing needs one in reach every tick; the official selection happens
+ * as the swing starts); an enemy healer's heal has no wind-up.
+ * Returns true while an unblocked ranged enemy swings (its wind-up): it stands (updateEnemy). `prevCd`: the cooldown
+ * before this tick's countdown.
+ */
+function enemyAttack(b, e, prevCd) {
+  const def = e.def;
+  if (e.profile && e.profile.noAttack) { e.swing = false; return false; }
+  const dmgType = (e.profile && e.profile.dmgType) || def.dmgType;
+  if (dmgType === 'none' || e.s.atk <= 0) { e.swing = false; return false; }
+  // 恐惧 / 缴械 / 战栗 (被阻挡后无法进行普通攻击): no normal attack, and the one swung is interrupted
+  if (e.s.flags.fear || e.s.flags.disarm || (e.s.flags.tremble && e.blockedBy)) { e.swing = false; return false; }
+  if (dmgType === 'heal') { if (e.atkCd <= 0) enemyHeal(b, e, e.base.rangeRadius); return false; }
+  // applyWay MELEE enemies only ever hit their blocker, even when their data carries a rangeRadius (粉碎攻坚手 2.5,
+  // 宿主士兵 2.5, 深池伙友卫队 1.4 … — that radius belongs to their abilities/splash, handled by content).
+  // Content may flip it with `e.profile.melee = false`.
+  const melee = e.profile?.melee ?? def.applyWay === 'MELEE';
+  const radius = melee ? 0 : e.base.rangeRadius;
+  // the range circle takes an ally whose 0.25 collider touches it (PRTS 作战机制 §碰撞体积: 索敌 uses the colliders)
+  const reach = radius > 0 ? radius + ALLY_COLLIDER_RADIUS : 0;
+  // `e.profile.canTarget(ally)`: the enemy's own target rule (只攻击地面单位, 不会攻击飞行单位 …; content/enemies/*.js),
+  // applied to the candidates before the priority sort and the target count
+  const own = e.profile && typeof e.profile.canTarget === 'function' ? e.profile.canTarget : null;
+  const wind = attackWindup(e);
+  if (e.atkCd > wind + 1e-9) { e.swing = false; return false; }   // the cooldown runs
+  let targets = attackTargets(b, e, radius, reach, own);
+  if (!targets.length) { e.swing = false; return false; }          // ready, nobody in reach: no swing (or it is cut)
+  if (!e.swing) {
+    e.swing = true;
+    // ready before this tick (it walked with its cooldown over, or its swing was cut): the whole wind-up from now
+    if (prevCd < wind) e.atkCd = wind;
+  }
+  // the wind-up (GitHub #58): an unblocked ranged enemy stands through it (a 「不停止移动」 one walks on)
+  if (e.atkCd > 0) return !e.blockedBy && radius > 0 && !(e.profile?.attackMoves ?? def.attackMoves);
+  e.swing = false;
   if (targets.length > 1) sortAllyTargets(e, targets);
-  if (!targets.length) return false;
   // `enemyAttackStart` { enemy, targets }: the enemy starts a normal attack, before 麻痹 may interrupt it (the client's
   // ON_BEFORE_ABILITY_SPELL_ON of an attack that 麻痹 can interrupt — 酒神 堕梦 "攻击范围内的敌人普通攻击时受到70点神经损伤",
   // PRTS 备注 "于敌人成功普通攻击前之前触发（意味着触发的元素爆发可打断当次普攻…）": a burst it causes interrupts this attack)

server/sim/battle/spawns.js

@@ -132,6 +132,7 @@ export class BattleSpawns {
     e.atkCd = 0;
     e.pauseUntil = -Infinity;      // content holds (暴鸰's drop)
     e.atkStandUntil = -Infinity;   // standing for its attack clip (ai.js attackStand)
+    e.swing = false;               // a normal attack swung, its damage frame not reached yet (ai.js enemyAttack)
     // every enemy profile starts with the same fields (stable object shapes keep the hot loop's property reads fast);
     // `dmgType` null = the data's (content may arm a data-unarmed enemy: ai.js enemyAttack)
     e.profile = { noAttack: def.dmgType === 'none', maxTargets: 1, atkScale: 1, dmgType: null };