feedback1 integrate: WT 蒂比's 起飞 is 对地规避 - ground enemies no longer select or hit her while airborne

Conflicts resolved keeping both sides: - buffs.js FLAG_KEYS: liftoff beside the integration's selfBound. - Battle.js: targeting import union (extendedGrid + evadesGround); _blockerFor keeps the fenced-tile gate (WU) and adds liftoff; applyStatus keeps the 无敌 + 无法选中 refusal and adds the 对地规避 refusal. - enemies.js: header DOT entry from WT with the integration's INVISIBLE entry; import union; enemy_1273_stmgun_2 keeps the integration's rewrite (it filters through canTargetAlly, which now includes liftoff). - tier2.js 蒂比 comment: the integration's 受到伤害前触发 text plus the 起飞 line. - tier5.js 隐德来希血镰: liftoff flag with the integration's foesInRadius. - SIM.md: blocking keeps the fenced-tile passage and adds air-only blocking while airborne; the 污染秽蚀 / 燃烧区域 sentence goes before the chimera aura; statuses keep both refusals.
2026-10-03 13:36:17 +08:00
commit 987126cc1a
@@ -185,7 +185,8 @@ to a new pick. A `wait` leg keeps counting; when the fear ends the route re-plan
 **Blocking** (`Battle._checkBlock`, official contact rule — PRTS 游戏数据基础 §阻挡半径, 作战机制 "中点判定 … 案例: 阻挡";
 user playtest #5 item 4): an unblocked, blockable enemy is blocked by an ally (or device) whose centre is within its
 block radius of the enemy's position — `constants.js BLOCK_RADIUS`: ground 0.7071 (compared as d² < 0.49999037, the
-tile's circumscribed circle), air 0.8944 (blockFly units against flyers), devices 0.4472 — while that blocker has free
+tile's circumscribed circle), air 0.8944 (blockFly units against flyers; an airborne 起飞 unit — flag `liftoff` — blocks
+flyers only, PRTS 术语释义 起飞 "阻挡模式变为空中阻挡"), devices 0.4472 — while that blocker has free
 capacity for the enemy's `blockWeight` (data `blockCnt`). A unit standing on a tile ground units cannot pass — the
 fenced 围墙 / 围栏 tiles (`b`: low, deployable, flyers only; the only low tiles of that kind on the stages) — blocks no
 ground enemy (PRTS 围墙 / 围栏 地形机制 "部署在其中的单位，若当前阻挡类型为'地面阻挡'则无法阻挡敌人";
@@ -228,6 +229,15 @@ its blocker → highest taunt level → latest deployed (`aggroSeq` = the deploy
 latest). `enemy.profile.canTarget(ally)` (content: 萨卡兹枯朽战车 "只攻击位于低地的我方单位，且不会攻击飞行单位", 掠海漂移体 / “萨科塔之眼” 不会攻击飞行单位 …) filters the candidates before the order;
 a special priority (假想敌：铳 / 昆图斯 highest DEF, 假想敌：胄 highest / lowest ATK, “自在” nearest …) sorts by its key and
 breaks ties by taunt, then latest deployed (`aggroCmp`); `untargetable` / sleeping allies and devices are never targets;
+an airborne ally (起飞, flag `liftoff`: 蒂比's skills) never for a ground enemy (对地规避 — `targeting.js evadesGround`,
+PRTS 术语释义 起飞 "无法被不同阵营行动方式为地面的单位选中"; flyers, 近地悬浮 and 浮空 enemies still pick it; content picks
+and one-shot areas that bypass `canTargetAlly` — 控潮术师 / 腐败骑士's 周围四格, 陷落雪祀's chain, the 碎铳之簧 bounce, the
+自行炮 shells, “帝国的甲胄”'s barrage, 鼠王's 沙狱, 烹泉's death blast and steam — filter it too; not selections, so they
+still reach it (`ignoreSelect`): abilities PRTS marks "无视无法选择" (【污染秽蚀】, 假想敌：铳's 【盲信之誓】, 萨卡兹悖谬
+暴虐兵长's 暴击 splash), direct picks (碎铳之簧's 法术护盾 counter on its attacker — PRTS 异常效果 "'直接选中'的能力…不受这些
+仅在选择时生效的异常效果制约"), the blasts of flying units credited to the ground 胄 (刺胄之弹, 斩胄之剑 / 破胄之锤 — whose
+掷剑 / 掷锤 pick "（无视无法选择）") and the ticks of a debuff a ground enemy put on it before it took off (出血, 沙狱,
+burning DoTs, 淤困, 【自然涌动】 — a tick selects nobody); auras of ground enemies still apply [ASSUMED]);
 a stealthed ally (隐匿, 排气格栅) only for the enemy it blocks — our operators keep 隐匿 while blocking (PRTS 作战机制
 §隐匿; 索敌的概念: a blocked enemy "强行无视对方可选性" attacks its blocker); a camouflaged one (迷彩, flag `camou`: ba.camou
 "不阻挡时不成为敌方普通攻击的目标") likewise (PRTS 异常效果: neither anomaly is "阻挡时解除") [ASSUMED: enemy skills and
@@ -257,7 +267,10 @@ tick, damage-taken modifiers scale it and it counts for 受击回复 SP and TAKE
 excepted). 【污染秽蚀】 (萨卡兹枯朽战车's 秽蚀轰击,
 萨卡兹枯朽战士's death) is **true** damage, 50 / 25 per second on low / high ground (PRTS "每秒受到50/25点真实普通伤害 …
 同名效果不叠加", user playtest #6): a unit covered by several zones takes one tick per second (`unit.mem.pollutedAt`), so
-a crowd of dying 萨卡兹枯朽战士 totals 50 / s, not 50 × n. An activated 孽罪奇美拉's aura (`kitChimera`, PRTS "自身半径1.2
+a crowd of dying 萨卡兹枯朽战士 totals 50 / s, not 50 × n. It is "可对空，无视无法选择": it also burns an airborne 起飞 ally
+(`ignoreSelect`), at the low-ground rate on a low tile. The other zones are no exception to 对地规避: a ground enemy's
+燃烧区域 (集团军重型火炮, PRTS "碰撞不受迷彩制约，不可对空" — 迷彩 only) skips an airborne 起飞 ally; the sourceless 毒雾 of
+假想敌：蚀裂 reaches everyone inside. An activated 孽罪奇美拉's aura (`kitChimera`, PRTS "自身半径1.2
 范围内的所有单位持续视为受到源石污染区影响，技力自然回复速度倍率-80%，每0.5秒受到50真实持续伤害（同类效果取最高）") is the same
 kind of damage — 无来源 true (like the terrain it stands for [ASSUMED]), the chimera credited — not a 流失 (player report
 D1 audit): radius 1.2, a tick every 0.5 s, one tick per unit per 0.5 s however many chimeras reach it (`mem.chimeraAt`).
@@ -447,8 +460,14 @@ A `rangeExtend` on a `persist` never-expiring buff is **permanent**: it also wid
 a running skill's range too, unless that skill's range ignores 攻击距离 (`targeting.noRangeExtend`; PRTS 数值范围 "根据配置
 不同，任何范围都可以受/不受该属性影响" — 信仰搅拌机 S3 "此技能的攻击范围不受“攻击距离”属性影响").
 **Flags:** `stun freeze sleep silence disarm stealth invulnerable unblockable levitate fear cold reveal bind noHeal
-untargetable blockFly noMove noSp burstLock hidden attract float noDisplace isolated camou` (`float` = 近地悬浮 (an air
-unit, `Unit.isFlying`), `noDisplace` = 失衡免疫 (`displace()` moves nothing), `isolated` = 孤立 ("无法被同阵营选中": no ally
+untargetable blockFly noMove noSp burstLock hidden attract float noDisplace isolated camou liftoff` (`float` = 近地悬浮 (an air
+unit, `Unit.isFlying`), `liftoff` = an ally's 起飞 (蒂比's skills; gamedata_const ba.liftoff "不阻挡地面敌人且不会被地面敌人攻击，
+可以阻挡飞行敌人"): it blocks no ground enemy (`Battle._blockerFor`) and has 对地规避 — no ground enemy (not `isFlying`)
+selects it, so no selected damage or status of one lands on it (`targeting.js evadesGround`), while what selects nobody
+still does (`ignoreSelect` / 无来源: 无视无法选择 abilities, direct picks, flying units' blasts, a debuff's ticks); flyers,
+近地悬浮 and 浮空 enemies still select it,
+with no 对空 check, since it stays a ground unit on its tile (`unit.ground` unchanged; PRTS 行动方式 "起飞的干员仍然是地面单位"),
+`noDisplace` = 失衡免疫 (`displace()` moves nothing), `isolated` = 孤立 ("无法被同阵营选中": no ally
 ability selects it — no heal, buff, aura or talent pick from another ally (`battle.allySelectable` / `alliesFor`,
 `alliesInGrid`; PRTS 选择器 可选判定), enemies still target it; a summon's tokens.json `abnormal` 'isolated' also sets
 `noHeal`, 'healFree' (禁疗) sets `noHeal` — Battle._setupUnit, DATA.md tokens.json; 禁疗 keeps heals off only — an HP-regen
@@ -458,7 +477,8 @@ as +1 taunt level (DESIGN §5.3).
 **Statuses** — `battle.applyStatus(target, key, { duration, source, value, force, refresh, point })` (returns true if
 applied); a unit that is 无敌 and 无法选中 at once (flags `invulnerable` + `untargetable`: a 重生 in progress, a hovering or
 永久无敌 leader part) takes no status from the other side, `force` included (PRTS 无敌 "无法被不同阵营选中" — so the status
-a knocking-out hit carries, 妮芙 S2's fear say, does not land after the 重生's cleanse; since 0.1.1's QA); honours
+a knocking-out hit carries, 妮芙 S2's fear say, does not land after the 重生's cleanse; since 0.1.1's QA); refused when
+`source` is a ground enemy and the target an airborne 起飞 ally (对地规避, unless `ignoreSelect`); honours
 enemy/op immunities (`stun`, `silence`, `sleep`, `frozen`, `levitate`, `feared`) unless `force`; fires
 `beforeStatus` (cancellable; handlers may also change `ctx.duration` / `ctx.value`), then applies 抵抗 (`resist`, below)
 and the 浮空 weight rule, then `statusApplied { source, target, status, duration (final), value, entered }` — `entered`
@@ -560,15 +580,23 @@ 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, sourceless, tags[], cancel }` (`sourceless`: 无来源 damage — the source's stats add
-nothing and the hooks get `source: null` plus `credit` = the source, which keeps the stats and the kill; a `loseHp` whose
-`from` is 无来源 is 无来源 too; element bursts, leader-part transfers and 坚守 thorns use it — content damage that has a
+isAttack, attackId, ignoreSleep, ignoreSelect, sourceless, tags[], cancel }` (`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,
+which keeps the stats and the kill; a `loseHp` whose `from` is 无来源 is 无来源 too; element bursts, leader-part transfers and 坚守 thorns use it — content damage that has a
 responsible unit should pass it as `source` with `sourceless: true` rather than `source: null`, which credits nobody)
 (`battle.makeDamage(d)` normalises). `attackId` is the same for every
 damage instance of one normal attack (all targets, splash, chain, projectile impacts; 0 for non-attack damage) — use it
 for "本次攻击" procs that must roll once per attack. **Dodge** from several buffs rolls independently: the unit's
 `s.dodgePhys` = 1 − Π(1 − pᵢ) (a single source keeps its exact value).
-Order: invulnerable / asleep? → **`hit`** (mutate `dmg`, set `dmg.cancel`) → dodge (`rng()`) → mitigation (phys
+Order: invulnerable / asleep / 对地规避? (a ground enemy's damage or element fill on an airborne 起飞 ally — flag `liftoff`,
+`targeting.js evadesGround` — is refused unless `ignoreSelect` or 无来源: it cannot select her, so its splash and area
+abilities skip her and a shot in flight when she took off lands on nothing [ASSUMED: PRTS 伤害流程 7 "取消掉隐匿/无敌状态
+下的攻击" read for 对地规避]; the ticks of a debuff already on her select nobody and land (content passes `ignoreSelect`;
+PRTS 异常效果: 无法选择 effects "仅在选择时生效"); checked before `hit` only — 蒂比 S2 takes off inside the
+`hit` of the attack that set it off, which resolves as usual) → **`hit`** (mutate `dmg`, set `dmg.cancel`) → dodge
+(`rng()`) → mitigation (phys
 `max(A − max(0, D×(1−defIgnorePct) − defIgnoreFlat), 5 %A)`, arts `max(A×(1 − R′/100), 5 %A)`, elemental
 `max(A×(1 − 元素抗性/100), 5 %A)`, true = A; source ignore mods are added) → × source `dmgDealtMul` (× phys/artsDealtMul)
 × target `dmgTakenMul` (not for elemental) × type-taken mul × `dmg.mul` (a `sourceless` hit skips every source term) →
@@ -1045,7 +1073,7 @@ table: `hitSleep` (targets and damages sleeping enemies — "可以攻击沉睡
 | dollkeeper | fatal damage ⇒ substitute for 20 s (bb duration): block 0, doll HP (its own substitute token's stats, else 50 % max HP: 归溟幽灵鲨); swaps back at full HP; dies if the doll dies |
 | geek | loses 1–3 % max HP per second (bb hp_ratio), never lethal on its own |
 | merchant | −3 DP every 3 s (bb cost/interval); retreats when DP runs out |
-| skywalker | can block FLY enemies |
+| skywalker | can block FLY enemies (蒂比's kit: only while airborne — 起飞, flag `liftoff`, which also releases the ground enemies she blocked) |
 | stalker | hits every enemy in range; 50 % dodge (bb prob), taunt −1 |
 | traper | ranged, ground only |

@@ -28,7 +28,7 @@ import { Grid } from './grid.js';
 import { Unit } from './units.js';
 import { makeBuff, STATUS, RESIST_STATUSES } from './buffs.js';
 import { dealDamage as pipeDamage, heal as pipeHeal, applyHpLoss, makeDamageInfo, reduceElement, palsyBuff, elementView, leaderHitCancelled } from './damage.js';
-import { absoluteRangeKeys, canTargetEnemy, extendedGrid } from './targeting.js';
+import { absoluteRangeKeys, canTargetEnemy, extendedGrid, evadesGround } from './targeting.js';
 import { bodyKeys, bodyInKeys, bodyInRadius } from './body.js';
 import { normDir, mirrorDir, localOrder, localBefore } from './dir.js';
 import { ProjectileSystem } from './projectiles.js';
@@ -1127,12 +1127,15 @@ export class Battle {
   * 阻挡'则无法阻挡敌人". The gate reads the tile's ground passability; on the stages the fenced tiles are the only low
   * tiles ground units cannot pass. Air blocking (blockFly against flyers) stays [ASSUMED: PRTS restricts the rule to
   * 地面阻挡]. Nothing walks onto such a tile, so it matters for an enemy pushed or pulled against the fence
-   * (Battle.displace stops it at the tile edge, 0.5 from the fenced unit — inside the ground block radius).
+   * (Battle.displace stops it at the tile edge, 0.5 from the fenced unit — inside the ground block radius). An airborne
+   * unit (起飞, flag `liftoff`: "不阻挡地面敌人…可以阻挡飞行敌人") blocks flyers only.
   */
  _blockerFor(u, e, w) {
    if (!u.alive || !u.deployed || u.hidden || u.s.flags.noBlock || u.s.flags.sleep) return false;
    if (e.isFlying && !(u.s.flags.blockFly || (u.profile && u.profile.blockFly))) return false;
-    if (!e.isFlying && (!u.ground || this.grid.tile(u.tileR, u.tileC).pass !== 'ALL')) return false;
+    // ground enemies: only a ground unit that has not taken off (起飞 "不阻挡地面敌人": flag `liftoff`), standing on a tile
+    // ground units can pass (not a fenced 围墙 / 围栏 tile)
+    if (!e.isFlying && (!u.ground || u.s.flags.liftoff || this.grid.tile(u.tileR, u.tileC).pass !== 'ALL')) return false;
    const cap = u.s.blockCnt;
    if (cap <= 0) return false;
    let used = 0;
@@ -1291,12 +1294,14 @@ export class Battle {
   * `statusApplied` reports the final duration and `entered` (the target did not carry the status before).
   * A unit that is 无敌 and 无法选中 at once (a 重生 in progress, a hovering or 永久无敌 leader part) takes no status from
   * the other side, `force` included — PRTS 无敌 "无法被不同阵营选中": so a status carried by the very hit that knocked an
-   * enemy out does not land after its 重生's cleanse (DESIGN §21.4).
+   * enemy out does not land after its 重生's cleanse (DESIGN §21.4). A ground enemy's status never lands on an airborne
+   * 起飞 ally (对地规避: targeting.js evadesGround) unless `opts.ignoreSelect`.
   */
  applyStatus(target, key, opts = {}) {
    if (!target || !target.alive) return false;
    const src = opts.source;
    if (src && src.side && src.side !== target.side && target.s.flags.invulnerable && target.s.flags.untargetable) return false;
+    if (!opts.ignoreSelect && target.s.flags.liftoff && evadesGround(src, target)) return false;
    const tpl = STATUS[key] || { flags: { [key]: true } };
    let duration = opts.duration == null ? Infinity : Number(opts.duration);
    let value = opts.value;
@@ -28,11 +28,15 @@ export const MUL_KEYS = Object.freeze([
  'trueTakenMul', 'elemTakenMul', 'elementalTakenMul', 'healingDealtMul', 'healingTakenMul', 'spRecoveryMul', 'redeployMul',
  'atkScaleMul', 'physDealtMul', 'artsDealtMul',
 ]);
-/** Boolean flag keys (OR). `taunt` is also accepted as a numeric mod. */
+/**
+ * Boolean flag keys (OR). `taunt` is also accepted as a numeric mod. `liftoff` = 起飞 of an ally (蒂比's skills): blocks
+ * no ground enemy (Battle._blockerFor), 对地规避 against ground enemies (targeting.js evadesGround); it stays a ground
+ * unit on its tile (`unit.ground` unchanged).
+ */
 export const FLAG_KEYS = Object.freeze([
  'stun', 'freeze', 'sleep', 'silence', 'disarm', 'stealth', 'invulnerable', 'unblockable', 'levitate', 'fear',
  'cold', 'reveal', 'bind', 'noHeal', 'untargetable', 'blockFly', 'noMove', 'noSp', 'burstLock', 'hidden',
-  'noBlock', 'tremble', 'hitCount', 'hitCountArts', 'attract', 'float', 'noDisplace', 'isolated', 'camou',
+  'noBlock', 'tremble', 'hitCount', 'hitCountArts', 'attract', 'float', 'noDisplace', 'isolated', 'camou', 'liftoff',
  // 自缚 (the unit's own immobility: 守墓石像's 转换模式, the 自缚 leaders) beside its `noMove` — 束缚 sets noMove too, and
  // only 自缚 makes a unit "不视为可达目标" for 余 S2's teleport (PRTS 余 S2 备注)
  'selfBound',
@@ -53,12 +53,16 @@
 // The huge leaders (SELF_BOUND: 胄 ×2, 管 ×2, 昆图斯, 阿利斯泰尔, 萨米的意志 — the 巨型单位 with a data `hitArea`) are
 // 自缚 + 无法被阻挡 (PRTS 天赋): a persistent noMove + unblockable buff from spawn, so they never walk their route.
 // Every leader (tag boss) ignores 侵蚀 gauge damage ("最终攻势中，敌方领袖不会受到侵蚀损伤").
+// An airborne (起飞) operator is no selection of a ground leader or part (对地规避: canTargetAlly, the damage pipeline,
+// the 碎铳之簧 bounce); still reach it (`ignoreSelect`): the 刺胄之弹 / 剑 / 锤 blasts (flying units, 无来源 DoT; 掷剑 /
+// 掷锤 pick their operator "（无视无法选择）"), the 盲信之誓 chains ("无视无法选择"), the 法术护盾 counter on its attacker
+// (a direct pick) and the ticks of a debuff already on it (【自然涌动】: a tick selects nobody).
 // LP effects ('lpLoss' hook + result.lpLoss) must be applied by the match (see the report of this module's owner).
 // fx kinds: 'beam' 'shell' 'explode' 'telegraph' 'charge' 'link' 'dash' 'column' 'tide' 'rockfall' 'tentacle' 'equip'
 //   'sword' 'vest' 'blink' 'summon' 'grow' 'phase' 'lpLoss' (x, y + extra {id, r, tiles, kind, tx, ty …}).

 import { MOVE_SCALE } from '../constants.js';
-import { canTargetAlly, aggroCmp } from '../targeting.js';
+import { canTargetAlly, aggroCmp, evadesGround } from '../targeting.js';
 import { compileRoute } from '../ai.js';
 import { normalizeRoute } from '../simdata.js';
 import {
@@ -320,13 +324,17 @@ export function fairOrder(b, e, list, P) {
  return out.concat(rest);
 }

-/** Stun + phys DoT on the 3×3 around (r, c). */
+/**
+ * Stun + phys DoT on the 3×3 around (r, c), credited to `src` (胄). The blast is a flying unit's — 刺胄之弹 / 斩胄之剑 /
+ * 破胄之锤 (PRTS 行动方式 飞行) — and its damage 无来源, so 对地规避 does not stop it: `ignoreSelect` (an airborne 起飞 ally in
+ * the 3×3 is stunned and hurt like the others, although the credited 胄 walks).
+ */
 function stunBlast(b, src, r, c, stun, dot, dur, kind) {
  b.fx('explode', { x: c, y: r, r: 1.5, kind, tiles: 'box' });
  for (const u of alliesInTiles(b, r, c, 'box', 1)) {
-    if (stun > 0) b.applyStatus(u, 'stun', { duration: stun, source: src });
+    if (stun > 0) b.applyStatus(u, 'stun', { duration: stun, source: src, ignoreSelect: true });
    if (dot > 0 && dur > 0) b.addBuff(u, { key: `boss:${kind}Dot`, duration: dur, refresh: 'replace', interval: 1, visible: true,
-      onTick: ({ battle, unit }) => battle.dealDamage(src, unit, { amount: dot, type: 'phys', canDodge: false, tags: ['enemyAbility', kind] }) });
+      onTick: ({ battle, unit }) => battle.dealDamage(src, unit, { amount: dot, type: 'phys', canDodge: false, ignoreSelect: true, tags: ['enemyAbility', kind] }) });
  }
 }
 /** Distance from point p to segment a–b. */
@@ -587,11 +595,11 @@ function kitGun(ab, e, b) {
    });
    if (s3) list.push({
      iv: s3.bb.interval ?? 1,
-      tick(b2, e2) { // 【盲信之誓】 links: phys per second on operators standing on a line
+      tick(b2, e2) { // 【盲信之誓】 links: phys per second on operators standing on a line ("无视无法选择、迷彩": 起飞 too)
        for (const sp of b2.enemies) {
          if (!sp.alive || !isSpring(sp)) continue;
          b2.fx('link', { x: e2.x, y: e2.y, from: e2.id, to: sp.id, kind: 'faithLink', dur: s3.bb.interval ?? 1 });
-          for (const u of b2.allies()) if (segDist(u.x, u.y, e2.x, e2.y, sp.x, sp.y) <= LINK_WIDTH) hurt(b2, e2, u, s3.bb.value ?? 0, 'phys');
+          for (const u of b2.allies()) if (segDist(u.x, u.y, e2.x, e2.y, sp.x, sp.y) <= LINK_WIDTH) hurt(b2, e2, u, s3.bb.value ?? 0, 'phys', { ignoreSelect: true, tags: ['faithLink'] });
        }
      },
    });
@@ -636,8 +644,10 @@ function kitSpring(ab, e) {
            if (P.barrier <= 1e-6) { P.barrier = 0; drop(b); }
          } else if (ty === 'phys') {
            c.dmg.mul *= scale;
-            const s = c.source;
-            if (s && s.side === 'ally' && s.alive) { hurt(b, e2, s, e2.s.atk * (T(ab, '1.atk_scale') ?? 0), 'phys'); elem(b, e2, s, 'erosion', e2.s.atk * (T(ab, '1.ep_damage_ratio') ?? 0)); }
+            // the counter "对来源造成…无来源物理附加伤害" picks its attacker directly — no selection, so an airborne 起飞
+            // attacker takes it too (PRTS 异常效果 无法选择: "'直接选中'的能力…不受这些仅在选择时生效的异常效果制约")
+            const s = c.source, o = { ignoreSelect: true, tags: ['springCounter'] };
+            if (s && s.side === 'ally' && s.alive) { hurt(b, e2, s, e2.s.atk * (T(ab, '1.atk_scale') ?? 0), 'phys', o); elem(b, e2, s, 'erosion', e2.s.atk * (T(ab, '1.ep_damage_ratio') ?? 0), o); }
          }
        } else if (kind === 'element') {                 // 元素护盾: phys/arts heavily reduced
          if (ty === 'phys' || ty === 'arts') c.dmg.mul *= scale;
@@ -687,7 +697,7 @@ function kitSpring(ab, e) {
            b.fx('beam', { x: e2.x, y: e2.y, from: e2.id, to: t.id, kind: 'springBullet' });
            elem(b, e2, t, 'erosion', e2.s.atk * ratio * Math.pow(SPRING_BOUNCE_FALLOFF, k));
            const prev = t;
-            t = b.alliesInRadius(prev.x, prev.y, SPRING_BOUNCE_RANGE).filter((u) => !hit.has(u)).sort((p, q) => Math.hypot(p.x - prev.x, p.y - prev.y) - Math.hypot(q.x - prev.x, q.y - prev.y) || aggroCmp(p, q))[0];
+            t = b.alliesInRadius(prev.x, prev.y, SPRING_BOUNCE_RANGE).filter((u) => !hit.has(u) && !evadesGround(e2, u)).sort((p, q) => Math.hypot(p.x - prev.x, p.y - prev.y) - Math.hypot(q.x - prev.x, q.y - prev.y) || aggroCmp(p, q))[0];
          }
        } else { // 十连击
          b.fx('beam', { x: e2.x, y: e2.y, from: e2.id, to: t0.id, kind: 'springCombo' });
@@ -1066,7 +1076,7 @@ function kitDeer(ab, e) {
          b.fx('beam', { x: e2.x, y: e2.y, from: e2.id, to: t.id, kind: 'naturalSurge', dur });
          b.applyStatus(t, 'stun', { duration: dur, source: e2 });
          b.addBuff(t, { key: 'boss:surge', duration: dur, interval: 1, visible: true,
-            onTick: ({ battle, unit }) => battle.dealDamage(e2, unit, { amount: e2.s.atk * (lasso.bb.atk_scale ?? 0), type: 'arts', canDodge: false, tags: ['enemyAbility'] }) });
+            onTick: ({ battle, unit }) => battle.dealDamage(e2, unit, { amount: e2.s.atk * (lasso.bb.atk_scale ?? 0), type: 'arts', canDodge: false, ignoreSelect: true, tags: ['enemyAbility'] }) });
        }
      },
    },
@@ -33,7 +33,15 @@
 //   keeps its ground path, Unit.isFlying; kitSyufo / kitParrot lose it when stunned). `e.profile.canTarget(ally)` = the
 //   enemy's own target rule (只攻击地面单位 …), applied by the engine to the candidates before its priority order; a
 //   special priority (优先攻击防御力最高的… / 生命上限最高的…) sorts by its key, ties by taunt then latest deployed
-//   (targeting.js aggroCmp — PRTS 索敌: 特殊优先级 → 仇恨值).
+//   (targeting.js aggroCmp — PRTS 索敌: 特殊优先级 → 仇恨值). An airborne ally (起飞, flag `liftoff`) is no target of a
+//   ground enemy (对地规避, targeting.js evadesGround): targetsNear / allTargets skip it through canTargetAlly, the picks
+//   and one-shot areas that bypass it (周围四格 additions, chain and bounce jumps, shells, barrages, 沙狱, death blasts)
+//   filter it, and the engine refuses a ground enemy's damage and statuses on it. Not selections, so they still reach
+//   it (`ignoreSelect`): abilities PRTS marks "无视无法选择" (【污染秽蚀】, 【盲信之誓】, 萨卡兹悖谬暴虐兵长's 暴击 splash),
+//   direct picks of the attacker (碎铳之簧's counter — PRTS 异常效果 "'直接选中'的能力…不受这些仅在选择时生效的异常效果
+//   制约"), the blasts of flying units credited to a ground leader (刺胄之弹, 斩胄之剑 / 破胄之锤) and the ticks of a debuff
+//   already on it (出血, 沙狱, “庞贝”'s burning, 淤困, 【自然涌动】 — a tick selects nobody). Auras of ground enemies still
+//   apply [ASSUMED].
 //
 // Special types (factions.json):
 //   FLY        — engine (FLY motion, ranged-only targeting). Flyer kits below (御4, 护障, 寒霜, 萨科塔之翼/眼, 黑云 …).
@@ -43,8 +51,9 @@
 //                create those units (death spawns, embers, blades, 再生).
 //   ELEMENT    — element damage on hit = ATK × ep_damage_ratio into the ally's gauge. 侵蚀 (erosion) is an engine
 //                gauge whose burst is the official one (termDescription ba.dt.erosion: "永久降低100点防御力并受到800点物理伤害").
-//   DOT        — damage zones (污染秽蚀: true damage, one tick per second however many cover a unit; 毒雾, 燃烧区域),
-//                bleeding (removed by healing), pulsing auras.
+//   DOT        — damage zones (污染秽蚀: true damage, one tick per second however many cover a unit, "可对空，无视无法选择"
+//                — `ignoreSelect`, 起飞 allies included; 毒雾, 燃烧区域: a ground enemy's zone skips a 起飞 ally — PRTS
+//                集团军重型火炮 "碰撞不受迷彩制约，不可对空", no 无视无法选择), bleeding (removed by healing), pulsing auras.
 //   INVISIBLE  — permanent `stealth` flag (engine: untargetable unless blocked or revealed). An operator's radius area
 //                damage skips an unblocked one too (Battle.foesInRadius: profession splash around a struck target,
 //                skill circles — PRTS 作战机制 §AOE伤害判定 "对攻击范围内的每个可以被选中的敌人进行判定"; until 0.1.1 it
@@ -69,7 +78,7 @@
 // Custom hook: 'lpLoss' {amount, reason, source} — leader "扣除目标生命" effects; also summed into result.lpLoss.

 import { TICK, MOVE_SCALE, ELEMENT, ATTACK_PAUSE, PROJECTILE_SPEEDS, ALLY_COLLIDER_RADIUS } from '../constants.js';
-import { canTargetAlly, sortAllyTargets, aggroCmp } from '../targeting.js';
+import { canTargetAlly, sortAllyTargets, aggroCmp, evadesGround } from '../targeting.js';
 import { mitigate, periodicDamage } from '../damage.js';

 // ---------------------------------------------------------------------------------------------------------------
@@ -363,17 +372,21 @@ function onTick(b, dt) {
 // ---------------------------------------------------------------------------------------------------------------
 // helpers (exported for bosses.js)

-/** Element damage (erosion mapped onto the engine gauge). */
-export function elem(b, src, tgt, el, amount) {
+/** Element damage (erosion mapped onto the engine gauge); `ignoreSelect` / `tags` as hurt(). */
+export function elem(b, src, tgt, el, amount, { ignoreSelect = false, tags = [] } = {}) {
  if (!tgt || !tgt.alive || !(amount > 0)) return 0;
  const element = el === 'erosion' ? EROSION : el;
-  return b.dealDamage(src, tgt, { type: 'element', element, amount, tags: ['enemyAbility'] });
+  return b.dealDamage(src, tgt, { type: 'element', element, amount, ignoreSelect, tags: ['enemyAbility', ...tags] });
 }

-/** Skill / ability damage (no dodge unless asked). */
-export function hurt(b, src, tgt, amount, type = 'phys', { canDodge = false, tags = [], isSkill = true } = {}) {
+/**
+ * Skill / ability damage (no dodge unless asked). `ignoreSelect` = no selection the target's 无法选择 effects stop
+ * (abilities that "无视无法选择", direct picks, a flying unit's blast credited to a ground leader): it also reaches an
+ * airborne 起飞 ally, which a ground enemy's damage otherwise skips (damage.js, targeting.js evadesGround).
+ */
+export function hurt(b, src, tgt, amount, type = 'phys', { canDodge = false, tags = [], isSkill = true, ignoreSelect = false } = {}) {
  if (!tgt || !tgt.alive || !(amount > 0)) return 0;
-  return b.dealDamage(src, tgt, { amount, type, canDodge, isSkill, tags: ['enemyAbility', ...tags] });
+  return b.dealDamage(src, tgt, { amount, type, canDodge, isSkill, ignoreSelect, tags: ['enemyAbility', ...tags] });
 }

 /** Allies whose tile is within `n` of (r, c): 'plus' = Manhattan (周围四格), 'box' = Chebyshev (周围8格). */
@@ -960,7 +973,10 @@ function statue(ab) {
  };
 }

-/** Bleeding on hit (逐腐兽): arts damage per second, removed by healing. */
+/**
+ * Bleeding on hit (逐腐兽): arts damage per second, removed by healing. A tick selects nobody (`ignoreSelect`): it keeps
+ * hurting an ally that took off (起飞) after the bleed landed; so do the other enemy debuff DoTs (沙狱, burnDot, 淤困).
+ */
 function bleed(ab) {
  const dmg = T(ab, 'Bleeding.attack@bleeding_damage') ?? 0, dur = T(ab, 'Bleeding.attack@duration') ?? 0;
  return {
@@ -968,7 +984,7 @@ function bleed(ab) {
      if (!(dmg > 0 && dur > 0)) return;
      b.addBuff(c.target, {
        key: 'ab:bleed', duration: dur, refresh: 'replace', interval: 1, visible: true,
-        onTick: ({ battle, unit }) => battle.dealDamage(e, unit, { amount: dmg, type: 'arts', canDodge: false, tags: ['enemyAbility', 'bleed'] }),
+        onTick: ({ battle, unit }) => battle.dealDamage(e, unit, { amount: dmg, type: 'arts', canDodge: false, ignoreSelect: true, tags: ['enemyAbility', 'bleed'] }),
      });
    },
  };
@@ -977,8 +993,8 @@ function bleed(ab) {
 /**
 * 【污染秽蚀】 zone (PRTS 萨卡兹枯朽战士 / 萨卡兹枯朽战车: "范围内位于低地/高地的我方干员和召唤物每秒受到50/25点真实普通伤害
 * （可对空，无视无法选择、迷彩；同名效果不叠加）"): `low` true damage per second on low ground, `high` on high ground, to every
- * ally inside (flyers, stealthed and untargetable ones included); a unit inside several zones takes one tick per second
- * (`mem.pollutedAt`: the last tick it took).
+ * ally inside (flyers, stealthed, untargetable and airborne 起飞 ones included — `ignoreSelect`; an airborne 蒂比 stands on
+ * her low tile: `low`); a unit inside several zones takes one tick per second (`mem.pollutedAt`: the last tick it took).
 */
 function pollution(b, src, x, y, r, life, low, high) {
  zone(b, { x, y, r, life, iv: POLLUTION_INTERVAL, kind: 'pollution', tick(units) {
@@ -986,15 +1002,22 @@ function pollution(b, src, x, y, r, life, low, high) {
      const v = u.ground ? low : high;
      if (!(v > 0) || b.time - (u.mem.pollutedAt ?? -Infinity) < POLLUTION_INTERVAL - 1e-6) continue;
      u.mem.pollutedAt = b.time;
-      hurt(b, src, u, v, 'true', { tags: ['pollution'] });
+      hurt(b, src, u, v, 'true', { tags: ['pollution'], ignoreSelect: true });
    }
  } });
 }

-/** Damage zone (arts per tick). */
+/**
+ * Damage zone (`amount` per tick, tagged `kind`) on every ally inside. Unlike 【污染秽蚀】 it does not ignore 无法选择:
+ * a ground enemy's zone skips an airborne 起飞 ally (the damage pipeline; PRTS 集团军重型火炮 【燃烧区域】 "碰撞不受迷彩
+ * 制约，不可对空" — 迷彩 only). A sourceless zone (假想敌：蚀裂's 毒雾) reaches everyone inside.
+ */
 function dmgZone(b, src, x, y, r, life, iv, amount, type = 'arts', kind = 'zone', el = null, elAmount = 0) {
  zone(b, { x, y, r, life, iv, kind, tick(units) {
-    for (const u of units) { hurt(b, src, u, amount, type); if (el && elAmount > 0) elem(b, src, u, el, elAmount); }
+    for (const u of units) {
+      hurt(b, src, u, amount, type, { tags: [kind] });
+      if (el && elAmount > 0) elem(b, src, u, el, elAmount, { tags: [kind] });
+    }
  } });
 }

@@ -1149,7 +1172,7 @@ function kitTidmag(ab) {
      const t0 = c.targets[0];
      if (!t0) return;
      const l = c.targets.slice();
-      for (const u of alliesInTiles(b, t0.tileR, t0.tileC, 'plus', 1)) if (!l.includes(u)) l.push(u);
+      for (const u of alliesInTiles(b, t0.tileR, t0.tileC, 'plus', 1)) if (!l.includes(u) && !evadesGround(e, u)) l.push(u);
      c.targets = l;
    },
  }];
@@ -1395,6 +1418,11 @@ function kitRush(ab) {
  }];
 }

+/**
+ * 萨卡兹悖谬暴虐兵长: blocked only by a blocker with ≥ 3 free block; its first hit also strikes the units around its target
+ * (PRTS 技能0 暴击 "对目标和周围4格的我方单位造成攻击力150%的物理普通伤害（无视无法选择，无视迷彩）※此技能仅能触发一次"):
+ * the splash ignores 无法选择, so it reaches an airborne 起飞 ally too (`ignoreSelect`).
+ */
 function kitFirstAoe(ab) {
  const scale = T(ab, 'AOEAttack.atk_scale') ?? 0;
  return [blockWeight(3), {
@@ -1402,7 +1430,9 @@ function kitFirstAoe(ab) {
      if (a.done) return;
      a.done = true;
      b.fx('explode', { x: c.target.x, y: c.target.y, r: 1, kind: 'aoeAttack' });
-      for (const u of b.alliesInRadius(c.target.x, c.target.y, 1)) if (u !== c.target) hurt(b, e, u, e.s.atk * scale, 'phys');
+      for (const u of b.alliesInRadius(c.target.x, c.target.y, 1)) {
+        if (u !== c.target) hurt(b, e, u, e.s.atk * scale, 'phys', { ignoreSelect: true, tags: ['aoeAttack'] });
+      }
    },
  }];
 }
@@ -1456,7 +1486,7 @@ function kitParasite(ab) {
      b.addBuff(host, {
        // "受到的元素损伤提高至130%": a 元素损伤 multiplier on the element hit (ensureParasiteHook), not 元素伤害
        key: 'ab:parasite', visible: true, interval: 1, data: { src: e, spread: PARASITE_SPREAD, epMul: elMul },
-        onTick: ({ battle, unit }) => { if (e.alive) battle.dealDamage(e, unit, { amount: e.s.atk * scale, type: 'arts', canDodge: false, tags: ['enemyAbility', 'parasite'] }); },
+        onTick: ({ battle, unit }) => { if (e.alive) battle.dealDamage(e, unit, { amount: e.s.atk * scale, type: 'arts', canDodge: false, ignoreSelect: true, tags: ['enemyAbility', 'parasite'] }); },
      });
    },
    death(c, b, e, a) { if (a.host) b.removeBuff(a.host, 'ab:parasite'); },
@@ -1719,12 +1749,14 @@ function kitTeapot(ab) {
      if (c.reason !== 'killed') return;
      const aspd = T(ab, 'DeadBoom.attack_speed') ?? 0, dur = T(ab, 'DeadBoom.duration') ?? 0, iv = T(ab, 'DeadBoom.interval') ?? 1;
      const r = e.base.rangeRadius || 2, atk = e.s.atk, x = e.x, y = e.y;
+      // a selection (PRTS 烹泉 "死亡爆炸（…无视迷彩，不可对空）", no 无视无法选择): an airborne 起飞 ally is skipped
+      const hit = (units) => units.filter((u) => !evadesGround(e, u));
      // 被击倒后爆炸造成范围法术伤害 (one blast of ATK ×1 [ASSUMED scale]) …
      b.fx('explode', { x, y, r, kind: 'teaBoom', id: e.id });
-      for (const u of b.alliesInRadius(x, y, r)) hurt(b, null, u, atk, 'arts');
+      for (const u of hit(b.alliesInRadius(x, y, r))) hurt(b, null, u, atk, 'arts', { tags: ['teaBoom'] });
      // … 使我方攻击速度大幅降低（可被抵抗）: the steam lingers `duration` s; allies inside keep the ASPD cut (re-applied
      // every `interval` s)
-      const slow = (units) => { for (const u of units) b.addBuff(u, { key: 'ab:teaBoom', duration: iv + 0.1, refresh: 'extend', mods: { aspd }, visible: true }); };
+      const slow = (units) => { for (const u of hit(units)) b.addBuff(u, { key: 'ab:teaBoom', duration: iv + 0.1, refresh: 'extend', mods: { aspd }, visible: true }); };
      slow(b.alliesInRadius(x, y, r));
      if (dur > 0) zone(b, { x, y, r, life: dur, iv, kind: 'teaSteam', tick: slow });
    },
@@ -1747,7 +1779,7 @@ function kitLeaderMisc(key, ab, e) {
        dealt(c, b, e2) {
          if (!(dot.dur > 0)) return;
          b.addBuff(c.target, { key: 'ab:burnDot', duration: dot.dur, refresh: 'replace', interval: dot.iv, visible: true,
-            onTick: ({ battle, unit }) => battle.dealDamage(e2, unit, { amount: dot.dmg, type: 'arts', canDodge: false, tags: ['enemyAbility'] }) });
+            onTick: ({ battle, unit }) => battle.dealDamage(e2, unit, { amount: dot.dmg, type: 'arts', canDodge: false, ignoreSelect: true, tags: ['enemyAbility'] }) });
        },
      }, {
        iv: T(ab, 'rangedamage.interval') ?? 10,
@@ -1802,9 +1834,11 @@ function kitLeaderMisc(key, ab, e) {
          if (!t) return;
          const dur = ss.bb.duration ?? 0, x = t.x, y = t.y;
          b.fx('zone', { x, y, r: SANDSTORM_RADIUS, dur, kind: 'sandStorm', id: e2.id });
+          // the 沙狱弹道 "击中…范围内的所有我方单位（弹道可对空）" selects: an airborne 起飞 ally is skipped (no 无视无法选择)
          for (const u of b.alliesInRadius(x, y, SANDSTORM_RADIUS)) {
+            if (evadesGround(e2, u)) continue;
            b.addBuff(u, { key: 'ab:sandStorm', duration: dur, refresh: 'replace', interval: 1, visible: true, mods: { atkPct: ss.bb.atk ?? 0 },
-              onTick: ({ battle, unit }) => battle.dealDamage(e2, unit, { amount: ss.bb.damage ?? 0, type: 'arts', canDodge: false, tags: ['enemyAbility', 'sandStorm'] }) });
+              onTick: ({ battle, unit }) => battle.dealDamage(e2, unit, { amount: ss.bb.damage ?? 0, type: 'arts', canDodge: false, ignoreSelect: true, tags: ['enemyAbility', 'sandStorm'] }) });
          }
        }, { cond: (b, e2) => allTargets(b, e2).length > 0 }),
      ];
@@ -1822,7 +1856,7 @@ function kitLeaderMisc(key, ab, e) {
    case 'enemy_1513_dekght': {
      // 攻击时使目标与周围四格的单位受到物理伤害; 【蓄力攻击】 charge `duration` s, then ATK×atk_scale on the target's cross
      const s = ab.sk.ChargeAttack;
-      return [kitDekght(ab), { before(c, b, e2) { const t = c.targets[0]; if (t) for (const u of alliesInTiles(b, t.tileR, t.tileC, 'plus', 1)) if (!c.targets.includes(u)) c.targets.push(u); } },
+      return [kitDekght(ab), { before(c, b, e2) { const t = c.targets[0]; if (t) for (const u of alliesInTiles(b, t.tileR, t.tileC, 'plus', 1)) if (!c.targets.includes(u) && !evadesGround(e2, u)) c.targets.push(u); } },
        skill(s, (b, e2) => {
          const t = e2.blockedBy;
          const dur = s.bb.duration ?? 0, r = t.tileR, cc = t.tileC;
@@ -1938,7 +1972,7 @@ function kitLeaderMisc(key, ab, e) {
          let prev = c.target;
          const hit = new Set([prev]);
          for (let k = 1; k < n; k++) {
-            const nx = b.alliesInRadius(prev.x, prev.y, jr).find((u) => !hit.has(u));
+            const nx = b.alliesInRadius(prev.x, prev.y, jr).find((u) => !hit.has(u) && !evadesGround(e2, u));
            if (!nx) break;
            hit.add(nx);
            hurt(b, e2, nx, e2.s.atk * Math.pow(fall, k), 'arts');
@@ -2586,7 +2620,8 @@ export const KITS = Object.freeze({
          if (!lock) return;
          b.fx('telegraph', { x: lock.x, y: lock.y, r: 1, kind: 'barrage', id: e.id });
          for (let i = 0; i < n; i++) {
-            const t = alliesInTiles(b, lock.tileR, lock.tileC, 'box', 1).sort((p, q) => q.hp - p.hp)[0];
+            // "对碰撞范围内的1名当前生命值最高的我方单位" — a selection: never an airborne 起飞 ally (PRTS “帝国的甲胄”)
+            const t = alliesInTiles(b, lock.tileR, lock.tileC, 'box', 1).filter((u) => !evadesGround(e, u)).sort((p, q) => q.hp - p.hp)[0];
            if (t) hurt(b, e, t, e.s.atk, 'phys');
          }
        }, { owner: e });
@@ -35,17 +35,21 @@ function onDefaultSkill(chess) {
  return !d || !chess?.skill || d.skillId === chess.skill.skillId;
 }

-/** 蒂比 take-off (起飞): airborne — blocks flyers only (flags.blockFly of the skill), releases ground enemies. */
+/**
+ * 起飞 of 蒂比's skills (gamedata_const ba.liftoff "不阻挡地面敌人且不会被地面敌人攻击，可以阻挡飞行敌人"): the skill's flags
+ * `liftoff` (no ground enemy blocked — Battle._blockerFor; 对地规避 — targeting.js evadesGround: no ground enemy selects
+ * her, while what selects nobody still lands — 无视无法选择 abilities, direct picks, flying units' blasts, 无来源 damage, the
+ * ticks of a debuff already on her) and `blockFly` (blocks flyers at the air radius). She stays a ground unit on her tile (PRTS 行动方式 "起飞的
+ * 干员仍然是地面单位": `unit.ground` unchanged — 隐德来希's 血镰, 地面干员 bonds / items still count her).
+ */
+const LIFTOFF_FLAGS = Object.freeze({ blockFly: true, liftoff: true });
+/** 蒂比 take-off: the ground enemies she blocked walk on. */
 function tippiTakeOff({ battle, unit }) {
-  unit.mem.tippiGround = unit.ground;
-  unit.ground = false;
  battle.releaseBlocked(unit);
  battle.fx('takeoff', { x: unit.x, y: unit.y, id: unit.id });
 }
-/** 蒂比 landing when the airborne skill ends. */
+/** 蒂比 landing when the airborne skill ends: the flyers she held are released. */
 function tippiLand({ battle, unit }) {
-  if (unit.mem.tippiGround != null) unit.ground = unit.mem.tippiGround;
-  unit.mem.tippiGround = null;
  battle.releaseBlocked(unit);
 }

@@ -601,6 +605,8 @@ export default {
  // every damage instance restarts that timer (dodged or not; a 流失 does not — PRTS 备注).
  // S1 专业喷绘技巧 (alt, DEFAULT trigger from data): takes off at once for its duration — skill range, ATK +atk, blocks
  // flyers only; no triple shot, and incoming attacks never set it off.
+  // Both take off as 起飞 (LIFTOFF_FLAGS): she blocks no ground enemy and none selects her (对地规避), so a ground enemy's
+  // selected damage refused on the way never reaches her `hit` and neither sets off S2 nor restarts 片场工作指南.
  chess_char_2_13_a: (bb, chess, def) => {
    const t = talentBb(chess, 0);
    const s2 = onDefaultSkill(chess);
@@ -608,7 +614,7 @@ export default {
      trait: { blockFly: false },
      skill: {
        kind: 'duration', trigger: { rule: 'CUSTOM_RANGE', grid: [] }, // never by the engine: the hit handler below
-        mods: { atkPct: num(bb.atk) }, flags: { blockFly: true },
+        mods: { atkPct: num(bb.atk) }, flags: LIFTOFF_FLAGS,
        targeting: { rangeGrid: def?.skill?.rangeGrid ?? null },
        attack: { hits: 3 },
        onStart: tippiTakeOff,
@@ -616,7 +622,7 @@ export default {
      },
      skills: {
        skchr_tippi_1: {
-          kind: 'duration', mods: { atkPct: num(bb.atk) }, flags: { blockFly: true },
+          kind: 'duration', mods: { atkPct: num(bb.atk) }, flags: LIFTOFF_FLAGS,
          targeting: { rangeGrid: def?.skill?.rangeGrid ?? null },
          onStart: tippiTakeOff,
          onEnd: tippiLand,
@@ -915,8 +915,8 @@ const KITS = {
              for (const a of unit.mem.sickles || []) {
                if (!a.alive || !a.deployed) continue;
                // PRTS 备注 "被添加血镰的单位处于起飞时，血镰可对空": a sickle on the ground spares air units (FLY, 近地悬浮, 浮空);
-                // 起飞 = an airborne skywalker (蒂比's skill: off the ground, flag blockFly)
-                const air = !a.ground && !!a.s.flags.blockFly;
+                // 起飞 = an airborne skywalker (蒂比's skills: flag `liftoff`; still a 地面单位, so she can carry one)
+                const air = !!a.s.flags.liftoff;
                for (const e of battle.foesInRadius(a.x, a.y, RING1)) {
                  if (e.isFlying && !air) continue;
                  battle.dealDamage(unit, e, { amount: unit.s.atk * num(bb.atk_scale), type: 'phys', isSkill: true, tags: ['skill', 'bloodSickle'] });
@@ -1,6 +1,7 @@
 // server/sim/damage.js — damage & heal pipeline, shields, dodge, element gauges (DESIGN §5.5).
 //
-// dealDamage order: (element → gauge path) | invulnerable? → 'hit' hook (mutable DamageInfo, may set cancel)
+// dealDamage order: (element → gauge path) | invulnerable? / 对地规避 (a ground enemy's damage to an airborne 起飞 ally —
+//   targeting.js evadesGround; not `ignoreSelect` damage: no selection, e.g. a debuff's tick) → 'hit' hook (mutable DamageInfo, may set cancel)
 //   → dodge (phys/arts, canDodge) → mitigation (phys: DEF, arts: RES, true: none)
 //   → × source dmgDealtMul (× phys/artsDealtMul) × target dmgTakenMul (not for 元素伤害) × type-taken mul × dmg.mul
 //   → 限伤 (leaders in boss / hidden battles: a hit of ceil(final) ≥ BOSS_HIT_LIMIT is cancelled, see leaderHitCancelled)
@@ -49,6 +50,7 @@

 import { MIN_DAMAGE_RATIO, ELEMENT, ELEMENT_ORDER, PALSY_MAX } from './constants.js';
 import { BOSS_HIT_LIMIT } from '../../shared/constants.js';
+import { evadesGround } from './targeting.js';

 const clamp01 = (v) => (v < 0 ? 0 : v > 1 ? 1 : v);

@@ -84,6 +86,10 @@ export function makeDamageInfo(d = {}) {
    cancel: false,
    noSp: !!d.noSp,
    ignoreSleep: !!d.ignoreSleep,
+    // no selection 无法选择 effects stop (an ability that "无视无法选择" such as PRTS 【污染秽蚀】, a direct pick, a flying
+    // unit's blast credited to a ground leader, the tick of a debuff already on the unit): reaches an airborne 起飞 ally
+    // whatever the source's 行动方式
+    ignoreSelect: !!d.ignoreSelect,
    sourceless: !!d.sourceless,
    attackId: d.attackId ?? 0,
  };
@@ -115,6 +121,19 @@ function sleepBlocks(target, source, dmg) {
  return !!target.s.flags.sleep && !dmg.ignoreSleep && !(source && source.profile && source.profile.hitSleep);
 }

+/**
+ * 起飞 (flag `liftoff`): a ground enemy's damage never reaches the airborne ally — it cannot select it (对地规避, PRTS 作战机制
+ * "AOE的判定是对攻击范围内的每个可以被选中的敌人进行判定"), so its splash, area abilities and element fills skip it, and a shot
+ * already in flight when it took off lands on nothing [ASSUMED: PRTS 伤害流程 7 "取消掉隐匿/无敌状态下的攻击" read for
+ * 对地规避]. Checked before the `hit` hook only: 蒂比 S2 takes off inside the hook of the hit that set it off, which then
+ * resolves as usual (dodged if physical / arts — PRTS 备注). Sourceless damage and `ignoreSelect` damage still land: no
+ * selection (targeting.js evadesGround) — 无视无法选择 abilities, direct picks, flying units' blasts, and the ticks of a
+ * debuff already on it (PRTS 异常效果: 无法选择 effects "仅在选择时生效"; the debuff's mods stay too).
+ */
+function liftoffEvades(target, source, dmg) {
+  return !!target.s.flags.liftoff && !dmg.ignoreSelect && evadesGround(source, target);
+}
+
 /**
 * Pure mitigation formula (exported for tests). `target` = the target's stats; `ign.elementalRes` = its 元素抗性
 * (epDamageResistance) for 'elemental' damage.
@@ -201,7 +220,7 @@ export function dealDamage(battle, source, target, dmgIn) {
  // gets the stats and the kill (PRTS 伤害分类 无来源 ③)
  const hs = dmg.sourceless ? null : source;
  let ts = target.s;
-  if (ts.flags.invulnerable || sleepBlocks(target, hs, dmg)) return 0;
+  if (ts.flags.invulnerable || sleepBlocks(target, hs, dmg) || liftoffEvades(target, hs, dmg)) return 0;
  if (battle._hooks.hit) {
    battle.emit('hit', { source: hs, target, dmg, credit: source });
    if (dmg.cancel || !target.alive || !target.deployed) return 0;
@@ -360,6 +379,7 @@ export function applyElement(battle, source, target, dmg) {
  if (!el || !(el in target.elem)) return 0;
  if (!hasHp(target)) return 0; // a killing blow's rider: the target is dead, nothing fills or bursts (header)
  if (target.s.flags.invulnerable || sleepBlocks(target, source, dmg)) return 0;
+  if (liftoffEvades(target, dmg.sourceless ? null : source, dmg)) return 0;
  if (burstLocked(target, el)) return 0;
  if (battle._hooks.elementHit) {
    battle.emit('elementHit', { source, target, dmg });
@@ -10,7 +10,7 @@
 // or not — ai.js acquireTargets), (2) profile priority (fly/lowDef/…),
 // (3) higher enemy taunt, (4) least remaining path distance to the goal, (5) earliest spawned. Air units
 // (Unit.isFlying: FLY, 近地悬浮, 浮空) need a profile that can hit them (`canHitFly`, never `groundOnly`). Enemy
-// priority: sortAllyTargets.
+// priority: sortAllyTargets. 起飞 (an ally's flag `liftoff`) = 对地规避: no ground enemy selects it (evadesGround).

 import { COLS, ROWS } from './constants.js';
 import { normDir, rotateOffset } from './dir.js';
@@ -73,16 +73,38 @@ export function canTargetEnemy(attacker, e, profile) {
 * "隐匿与'阻挡时解除'没有直接关系"). Devices are never targets (阻隔工事: obstacles nobody can select; “双眼皮”: 迷彩 and
 * off the enemy paths — PRTS). 迷彩 (flag `camou`, term ba.camou "不阻挡时不成为敌方普通攻击的目标") works the same way:
 * PRTS 异常效果 gives both anomalies the note "与'阻挡时解除'没有直接关系" [ASSUMED: enemy skills and splash selectors
- * treat 迷彩 like target selection — officially splash and selectors without a projectile ignore it].
+ * treat 迷彩 like target selection — officially splash and selectors without a projectile ignore it]. An airborne ally
+ * (起飞, flag `liftoff`) is never a target of a ground enemy (evadesGround).
 */
 export function canTargetAlly(e, a, ranged) {
  if (!a.alive || !a.deployed || a.hidden || a.kind === 'device') return false;
  const f = a.s.flags;
  if (f.untargetable || f.sleep) return false;
  if (ranged && (f.stealth || f.camou) && e.blockedBy !== a) return false;
+  if (f.liftoff && evadesGround(e, a)) return false;
  return true;
 }

+/**
+ * 对地规避 of an airborne ally (起飞, buff flag `liftoff` — 蒂比's skills): true when `src` is an enemy whose 行动方式 is
+ * ground, which then cannot select `a` (gamedata_const ba.liftoff "不阻挡地面敌人且不会被地面敌人攻击，可以阻挡飞行敌人";
+ * PRTS 术语释义 起飞 "包含对地规避（无法被不同阵营行动方式为地面的单位选中）"; PRTS 异常效果 MOTION_TARGET_FREE, a 无法选择
+ * effect that a selector whose 行动方式 is not ground ignores). Flyers, 近地悬浮 and 浮空 enemies (Unit.isFlying — PRTS
+ * 行动方式: a hovering unit "是真正的飞行单位", a levitated one is seen as a flyer) still select it; it stays a ground unit
+ * itself ("起飞的干员仍然是地面单位"), so they need no 对空 check. Used by every enemy selection (canTargetAlly), the damage
+ * pipeline and Battle.applyStatus (a ground enemy's area damage, statuses and hits under way skip it — PRTS 作战机制 "AOE
+ * 的判定是对攻击范围内的每个可以被选中的敌人进行判定"), and the content picks and one-shot areas that bypass canTargetAlly
+ * (chain / bounce jumps, 周围四格 additions, shells, barrages, 沙狱, death blasts). Not selections, so they still reach it:
+ * sourceless damage and DamageInfo / applyStatus `ignoreSelect` — abilities that "无视无法选择" (【污染秽蚀】, 【盲信之誓】,
+ * 萨卡兹悖谬暴虐兵长's 暴击 splash), direct picks (碎铳之簧's counter on its attacker: PRTS 异常效果 "'直接选中'的能力…不受这些
+ * 仅在选择时生效的异常效果制约"), the blasts of flying units credited to a ground leader (刺胄之弹, 斩胄之剑 / 破胄之锤) and
+ * the ticks of a debuff a ground enemy put on it before it took off (出血, 沙狱, burning DoTs, 【自然涌动】: a tick selects
+ * nobody). A shot already in flight is refused [ASSUMED] (damage.js).
+ */
+export function evadesGround(src, a) {
+  return !!(a && a.s && a.s.flags.liftoff && src && src.side === 'enemy' && !src.isFlying);
+}
+
 const PRIORITY_FNS = {
  fly: (e) => (e.isFlying ? 0 : 1),
  lowDef: (e) => e.s.def,
@@ -362,7 +362,8 @@ test('2_13 蒂比 S1 专业喷绘技巧: DEFAULT trigger, takes off (skill range
    const range0 = u.baseRangeKeys.length;
    h.runUntil(() => u.skill.active, 3);
    assert.equal(started(h, u)[0].reason, 'DEFAULT');
-    assert.equal(u.ground, false, 'airborne');
+    assert.equal(u.s.flags.liftoff, true, 'airborne (起飞)');
+    assert.equal(u.ground, true, 'still a ground unit on her low tile');
    approx(u.s.atk, u.base.atk * (1 + bb.atk));
    assert.ok(u.rangeKeys.length > range0, 'skill range');
    const fl = h.spawn('f', { pos: [9, 5] });
@@ -374,7 +375,7 @@ test('2_13 蒂比 S1 专业喷绘技巧: DEFAULT trigger, takes off (skill range
    assert.equal(hits.length, atk.reduce((n, c) => n + c.targets.length, 0), 'one shot per target (no 3 连射)');
    h.runUntil(() => !u.skill.active, 40);
    h.step();
-    assert.equal(u.ground, true, 'landed');
+    assert.ok(!u.s.flags.liftoff, 'landed');
    done(h);
    // an enemy attack from outside her range never sets S1 off (S2's 受到攻击后触发 is not hers)
    const h2 = run({ defs: { enemies: { r: dummy('r', { atk: 300, bat: 1, range: 3.2 }) } }, units: [U(id, 9, 5, { carryState: READY })], enemies: [{ key: 'r', pos: [9, 8] }] });
@@ -962,7 +962,8 @@ test('2_13 蒂比: an incoming attack triggers 紧急赶场通知 and is dodged;
  assert.equal(h.hooksOf('skillStart').find((c) => c.unit === u).reason, 'TAKE_DAMAGE');
  assert.equal(u.stats.taken, 0, 'the triggering hit was dodged');
  approx(u.s.atk, u.base.atk * (1 + bb.atk));
-  assert.equal(u.ground, false);
+  assert.equal(u.s.flags.liftoff, true, 'airborne (起飞)');
+  assert.equal(u.ground, true, 'still a ground unit on her low tile');
  h.step();
  assert.equal(e.blockedBy, null, 'airborne: ground enemies are released');
  const fl = h.spawn('f', { pos: [9, 5] });
@@ -0,0 +1,80 @@
+// test/render/feedback1f-liftoff.browser.test.js — player report F3 (sixth batch after 0.1.0) in headless Chrome: the
+// client replica (the client runner's loadBrowserSim: the same /sim/ modules and data the browser simulates combat with)
+// keeps ground enemies off an airborne 蒂比. On act2 m02's lower lane 蒂比 (S2 紧急赶场通知) stands on the road with 角峰 on
+// the fence tile below her and a still 控潮术师 (ground caster: target + 周围四格) in range of both: its first shot sets her
+// off (dodged), and while she is airborne (起飞: flag `liftoff`, 对地规避) it only hits 角峰 — never her, neither directly
+// nor through the 周围四格 — and once she lands she is hit again (sim: targeting.js evadesGround, damage.js).
+//
+// Opt-in (starts Chrome): RENDER_E2E=1 node --test test/render/feedback1f-liftoff.browser.test.js
+// Chrome path: $CHROME_PATH or the macOS default.
+
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildBattleSpec } from '../../server/sim/spec.js';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const CHROME = process.env.CHROME_PATH || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+const enabled = process.env.RENDER_E2E === '1' && existsSync(CHROME) && existsSync(path.join(ROOT, 'public/assets'));
+const skip = enabled ? false : 'set RENDER_E2E=1 (needs Chrome and downloaded assets)';
+
+const SPEC = buildBattleSpec({
+  battleId: 'e2e.liftoff', fieldId: 'n:P1', kind: 'normal', seed: 3, modeId: 'mode_multi_hard', round: 8, stageId: 'act2autochess_m02', timeLimit: 400,
+  players: [{ playerId: 'P1', seat: 0, side: 'L', colOffset: 0, bonds: {}, playerEffects: [], units: [
+    { uid: 1, kind: 'chess', chessId: 'chess_char_2_13_a', row: 9, col: 5, dir: 'RIGHT', carryState: { sp: 999 } },
+    { uid: 2, kind: 'chess', chessId: 'chess_char_1_02_a', row: 10, col: 5, dir: 'RIGHT' },
+  ] }],
+  spawns: [{ time: 0, enemyKey: 'enemy_1161_tidmag', routeIndex: 0, count: 1, mods: { hpMul: 1e4, speedMul: 0 } }],
+  routes: [{ motion: 'WALK', start: [9, 7], end: [9, 2], checkpoints: [] }], flags: {},
+});
+
+describe('an airborne 蒂比 is no target of ground enemies in the client replica (headless Chrome, real sim)', { skip }, () => {
+  let srv, browser;
+  before(async () => {
+    const puppeteer = (await import('puppeteer-core')).default;
+    const { startServer } = await import('../../server/index.js');
+    srv = await startServer({ port: 0, host: '127.0.0.1', quiet: true });
+    browser = await puppeteer.launch({ executablePath: CHROME, headless: true, args: ['--no-first-run'] });
+  });
+  after(async () => {
+    await browser?.close();
+    await srv?.close();
+  });
+
+  test('控潮术师 hits 角峰 while 蒂比 is airborne, and her again once she lands', async () => {
+    const page = await browser.newPage();
+    const problems = [];
+    page.on('pageerror', (e) => problems.push(`pageerror: ${e.message}`));
+    try {
+      await page.goto(`http://127.0.0.1:${srv.port}/dev/render-demo.html?scene=normal-m01&paused=1&panel=0`);
+      await page.waitForFunction('window.__demo && (window.__demo.ready || window.__demo.error)', { timeout: 30000 });
+      const r = await page.evaluate(async (spec) => {
+        const { loadBrowserSim } = await import('/js/battle/runner.js');
+        const { spec: S, ds } = await loadBrowserSim();
+        const b = S.createBattleFromSpec(spec, ds, { quiet: true });
+        const hits = [];
+        b.on('damaged', (c) => { if (c.source && c.source.side === 'enemy') hits.push({ t: b.time, to: c.target.defId, amount: c.amount, air: !!c.target.s.flags.liftoff }); });
+        let up = null, down = null, ground = null;
+        for (let i = 0; i < 30 * 60 && (down == null || b.time < down + 12); i++) {
+          b.step();
+          const u = b.allyUnits.find((x) => x.defId === 'chess_char_2_13_a');
+          if (up == null && u.skill.active) { up = b.time; ground = u.ground; }
+          if (up != null && down == null && !u.skill.active) down = b.time;
+        }
+        return { up, down, ground, hits, errors: b.errors.length };
+      }, SPEC);
+      assert.ok(r.up != null && r.down != null, `took off at ${r.up}, landed at ${r.down}`);
+      const tippiAir = r.hits.filter((x) => x.to === 'chess_char_2_13_a' && x.t > r.up + 1e-6 && x.t < r.down - 1e-6);
+      assert.deepEqual(tippiAir.map((x) => `${x.t.toFixed(2)} ${Math.round(x.amount)}`), [], 'nothing reaches her while airborne');
+      assert.equal(r.ground, true, 'still a ground unit on her tile');
+      assert.ok(r.hits.some((x) => x.to === 'chess_char_1_02_a' && x.t > r.up && x.t < r.down), 'the caster shoots 角峰 meanwhile');
+      assert.ok(r.hits.some((x) => x.to === 'chess_char_2_13_a' && x.t > r.down), 'hit again after landing');
+      assert.equal(r.errors, 0);
+      assert.deepEqual(problems, []);
+    } finally {
+      await page.close();
+    }
+  });
+});
@@ -0,0 +1,427 @@
+// Player report after the 0.1.0 release (sixth batch, F3): "干员蒂比（巡空者）起飞后仍能被不该打到的攻击打到".
+//
+// Verdict: real. Official rule (gamedata_const termDescriptionDict ba.liftoff 起飞 "不阻挡地面敌人且不会被地面敌人攻击，可以
+// 阻挡飞行敌人"; PRTS 术语释义 起飞 "※包含对地规避（无法被不同阵营行动方式为地面的单位选中）… ※起飞后单位的行动方式依旧是地面";
+// PRTS 异常效果 MOTION_TARGET_FREE 对地规避 "无法被行动方式为地面的不同阵营单位选中（属于无法选择类效果）", ignored when the
+// selector's 行动方式 is not ground; PRTS 行动方式 "起飞的干员仍然是地面单位" and 近地悬浮 / 浮空 units count as flyers;
+// PRTS 作战机制 "AOE的判定是对攻击范围内的每个可以被选中的敌人进行判定"):
+//   - no ground enemy (行动方式 ground: data WALK, not hovering / levitated) selects an airborne operator — normal attacks,
+//     the targets its abilities add (控潮术师's 周围四格, chain / bounce jumps) and its area damage and statuses skip her;
+//   - flyers, 近地悬浮 and 浮空 enemies still select her (she stays a ground unit: no 对空 check);
+//   - what is no selection still reaches her: sourceless damage, abilities that "无视无法选择" (【污染秽蚀】 at the
+//     low-ground rate — she is still on her low tile; 【盲信之誓】; 萨卡兹悖谬暴虐兵长's 暴击 splash), direct picks
+//     (碎铳之簧's counter on its attacker — PRTS 异常效果 "'直接选中'的能力…不受这些仅在选择时生效的异常效果制约"), flying
+//     units' blasts (刺胄之弹, 斩胄之剑) and the ticks of a debuff put on her before she took off (出血, 沙狱, burning);
+//     a ground enemy's zone does not (集团军重型火炮 【燃烧区域】 "碰撞不受迷彩制约，不可对空": 迷彩 only);
+//   - she stays a 地面单位 for ally rules (隐德来希 S2 puts a 血镰 on her; PRTS 备注 "被添加血镰的单位处于起飞时，血镰可对空").
+// Cause: 起飞 was `unit.ground = false` (an operator on a high tile): melee enemies could not reach her (she released them),
+// but every ranged ground enemy kept shooting her and the AoE / skills of ground enemies hit her.
+// [ASSUMED] a ground enemy's shot already in flight is cancelled too (PRTS 作战机制 伤害流程 7 "取消掉隐匿/无敌状态下的攻击",
+// read for 对地规避); auras of ground enemies (光环, field-wide debuffs) still apply.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
+import { hasGeneratedData, getDefaultSource } from '../../server/sim/simdata.js';
+
+const REAL = { skip: !hasGeneratedData() };
+const ds = getDefaultSource();
+const TIPPI = ['chess_char_2_13_a', 'chess_char_2_13_b'];
+const S1 = 'skchr_tippi_1';              // 专业喷绘技巧: MANUAL → DEFAULT trigger, takes off at once
+const S2 = 'skchr_tippi_2';              // 紧急赶场通知: takes off when attacked (dodging that hit)
+const BAIT = 'chess_char_1_02_a';        // 角峰 (TANK) on the fence tile below her
+const TIDMAG = 'enemy_1161_tidmag';      // 控潮术师: ground caster, hits its target and the 周围四格 (+ erosion)
+const JSHOOT = 'enemy_1019_jshoot';      // 隐形弩手: ground sniper
+const DUMAGE = 'enemy_1168_dumage';      // 深池暗影术师: ground caster
+const LAZERD = 'enemy_1041_lazerd';      // 法术大师A1: FLY caster
+const SYUFO = 'enemy_2025_syufo';        // 掠海漂移体: 近地悬浮 (a flyer while it hovers)
+const NHPBR = 'enemy_1267_nhpbr';        // 萨卡兹枯朽战士: ground melee; death → 【污染秽蚀】 50 / 25 true per s
+const ETLCHI = 'chess_char_5_06_a';      // 隐德来希 (S2 绯红壁合: 血镰 on herself and one other 地面单位)
+const GOPRO = 'enemy_1000_gopro_2';      // 猎狗pro: ground melee
+const skillIndex = (id, sk) => ds.rawChess(id).skills.find((s) => s.skillId === sk).index;
+const done = (h) => { checkInvariants(h.b); assert.deepEqual(h.b.errors.map((e) => `${e.label} ${e.message}`), []); };
+
+/**
+ * act2 m02's lower lane: 蒂比 on the road (9,5) facing the gate, 角峰 on the fence tile (10,5) — inside 控潮术师's 周围四格 of
+ * her and she of him — and a still, tanky enemy at (9,7) (in her range and both of them in its own). Runs until she has
+ * landed and `after` more seconds; returns the hits on her while airborne / after landing and those on the bait.
+ */
+function duel(id, sk, enemyKey, { after = 12, mods = {}, pos = [9, 7] } = {}) {
+  const h = makeBattle({
+    stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged', 'skillStart', 'skillEnd'], captureNoisy: true,
+    units: [{ chessId: id, row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(id, sk) }, { chessId: BAIT, row: 10, col: 5 }],
+    enemies: [{ key: enemyKey, pos, mods: { hpMul: 1e4, speedMul: 0, ...mods } }],
+  });
+  const u = h.unit(id), bait = h.unit(BAIT);
+  let up = null, down = null, airborneSeen = false;
+  for (let i = 0; i < 120 * 30 && (down == null || h.b.time < down + after); i++) {
+    h.step();
+    if (up == null && u.skill.active) up = h.b.time;
+    if (u.skill.active && u.s.flags.liftoff) airborneSeen = true;
+    if (up != null && down == null && !u.skill.active) down = h.b.time;
+  }
+  const fromEnemy = (c) => c.source && c.source.side === 'enemy';
+  const on = (t) => h.hooksOf('damaged').filter((c) => c.target === t && fromEnemy(c));
+  const tOf = (c) => c.t ?? c.time;
+  return {
+    h, u, bait, up, down, airborneSeen,
+    air: on(u).filter((c) => tOf(c) > up + 1e-6 && tOf(c) < down - 1e-6),
+    landed: on(u).filter((c) => tOf(c) > down + 1e-6),
+    baitAir: on(bait).filter((c) => tOf(c) > up + 1e-6 && tOf(c) < down - 1e-6),
+  };
+}
+
+test('F3: no ground enemy hits an airborne 蒂比 — 控潮术师 (direct and 周围四格), S1 and S2, normal and elite; she is a target again once landed', REAL, () => {
+  for (const id of TIPPI) for (const sk of [S1, S2]) {
+    const r = duel(id, sk, TIDMAG);
+    assert.ok(r.up != null && r.down != null, `${id} ${sk}: took off and landed`);
+    assert.ok(r.airborneSeen, `${id} ${sk}: 起飞 is the buff flag \`liftoff\``);
+    assert.deepEqual(r.air.map((c) => `${c.type} ${Math.round(c.amount)}`), [], `${id} ${sk}: nothing from the ground caster while airborne`);
+    assert.ok(r.baitAir.length > 0, `${id} ${sk}: the caster shoots 角峰 instead`);
+    assert.ok(r.landed.length > 0, `${id} ${sk}: hit again after landing`);
+    assert.equal(r.u.ground, true, `${id} ${sk}: still on her low tile (行动方式 ground)`);
+    done(r.h);
+  }
+});
+
+test('F3: ranged ground snipers / casters (隐形弩手, 深池暗影术师) never shoot an airborne 蒂比', REAL, () => {
+  // the 隐匿 隐形弩手 is no target of hers, so S1's DEFAULT trigger never fires for it: S2 (its shot sets her off)
+  for (const [key, sk] of [[JSHOOT, S2], [DUMAGE, S1], [DUMAGE, S2]]) {
+    const r = duel(TIPPI[0], sk, key);
+    assert.ok(r.up != null && r.down != null, `${key} ${sk}: took off and landed`);
+    assert.deepEqual(r.air.map((c) => `${c.type} ${Math.round(c.amount)}`), [], `${key} ${sk}: nothing while airborne`);
+    assert.ok(r.baitAir.length > 0, `${key} ${sk}: it shoots 角峰 instead`);
+    done(r.h);
+  }
+});
+
+test('F3: flyers and 近地悬浮 enemies still attack an airborne 蒂比 (对地规避 only stops ground selectors; she stays a ground unit)', REAL, () => {
+  for (const key of [LAZERD, SYUFO]) {
+    const r = duel(TIPPI[0], S1, key, { mods: { atkMul: 0.2 } });
+    assert.ok(r.up != null, `${key}: took off`);
+    assert.ok(r.air.length > 0, `${key}: hits her while she is airborne`);
+    done(r.h);
+  }
+});
+
+test('F3: the pipeline — a ground enemy\'s damage, element and statuses never land on an airborne 蒂比; a flyer\'s and sourceless ones do', REAL, () => {
+  const h = makeBattle({
+    stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['hit', 'damaged', 'statusApplied'], captureNoisy: true,
+    defs: { enemies: { enemy_g: enemyRec({ key: 'enemy_g', hp: 1e7, speed: 0, atk: 0 }), enemy_f: enemyRec({ key: 'enemy_f', hp: 1e7, speed: 0, atk: 0, motion: 'FLY' }) } },
+    units: [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }],
+    enemies: [{ key: 'enemy_g', pos: [11, 9] }, { key: 'enemy_f', pos: [9, 7] }],
+  });
+  const u = h.unit(TIPPI[0]);
+  assert.ok(h.runUntil(() => u.skill.active, 3), 'S1 takes off (the flyer is in range)');
+  const g = h.b.enemies.find((e) => e.defId === 'enemy_g'), f = h.b.enemies.find((e) => e.defId === 'enemy_f');
+  assert.equal(g.isFlying, false);
+  // a ground enemy's hit: cancelled before any hook (she is not selected: no 'hit', no 片场工作指南 / S2 trigger)
+  const hits0 = h.hooksOf('hit').filter((c) => c.target === u).length;
+  assert.equal(h.b.dealDamage(g, u, { amount: 300, type: 'phys', canDodge: false, isAttack: true }), 0, 'ground attack');
+  assert.equal(h.b.dealDamage(g, u, { amount: 300, type: 'true', isSkill: true }), 0, 'ground ability (true damage)');
+  assert.equal(h.b.dealDamage(g, u, { type: 'element', element: 'burn', amount: 500 }), 0, 'ground element fill');
+  assert.equal(u.elem.burn, 0);
+  assert.equal(h.hooksOf('hit').filter((c) => c.target === u).length, hits0, 'no hit hook for a ground source');
+  assert.equal(h.b.applyStatus(u, 'stun', { duration: 2, source: g }), false, 'ground enemy\'s stun refused');
+  assert.equal(u.s.flags.stun, false);
+  // a flyer, sourceless damage and an ability that ignores 无法选择 still land
+  assert.ok(h.b.dealDamage(f, u, { amount: 300, type: 'true', isSkill: true }) > 0, 'flyer');
+  assert.ok(h.b.dealDamage(null, u, { amount: 300, type: 'true' }) > 0, 'sourceless');
+  assert.ok(h.b.dealDamage(g, u, { amount: 300, type: 'true', ignoreSelect: true }) > 0, '无视无法选择 (ignoreSelect)');
+  assert.equal(h.b.applyStatus(u, 'stun', { duration: 0.2, source: f }), true, 'a flyer\'s stun lands');
+  // landed: the ground enemy reaches her again
+  h.runUntil(() => !u.skill.active, 40);
+  h.run(0.5);
+  assert.equal(u.s.flags.liftoff, undefined);
+  assert.ok(h.b.dealDamage(g, u, { amount: 300, type: 'true', isSkill: true }) > 0, 'landed: ground ability lands');
+  done(h);
+});
+
+test('F3: 【污染秽蚀】 (萨卡兹枯朽战士) still reaches an airborne 蒂比, at the low-ground rate (PRTS "可对空，无视无法选择")', REAL, () => {
+  const h = makeBattle({
+    stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged'], captureNoisy: true,
+    units: [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }],
+    enemies: [{ key: NHPBR, pos: [9, 6], mods: { hpMul: 0.01, speedMul: 0 } }],
+  });
+  const u = h.unit(TIPPI[0]);
+  assert.ok(h.runUntil(() => u.skill.active, 3), 'takes off');
+  assert.ok(h.runUntil(() => !h.b.enemies.some((e) => e.alive), 10), 'she kills the 战士 while airborne');
+  h.run(4);
+  assert.ok(u.skill.active && u.s.flags.liftoff, 'still airborne');
+  const ticks = h.hooksOf('damaged').filter((c) => c.target === u && (c.dmg?.tags || []).includes('pollution'));
+  assert.ok(ticks.length >= 3, `pollution ticks on her: ${ticks.length}`);
+  for (const c of ticks) assert.equal(Math.round(c.amount), 50, 'low-ground rate (her tile is low ground)');
+  done(h);
+});
+
+test('F3: an airborne 蒂比 is still a 地面单位 for 隐德来希 S2 — she carries a 血镰 and it cuts the flyer next to her', REAL, () => {
+  const h = makeBattle({
+    stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged', 'skillStart'], captureNoisy: true,
+    units: [
+      { chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) },
+      { chessId: ETLCHI, row: 9, col: 3, skillIndex: skillIndex(ETLCHI, 'skchr_etlchi_2') },
+    ],
+    enemies: [
+      { key: GOPRO, pos: [9, 4], mods: { hpMul: 1e4, speedMul: 0, atkMul: 0 } },
+      { key: LAZERD, pos: [9, 6.2], mods: { hpMul: 1e4, speedMul: 0, atkMul: 0 } },
+    ],
+  });
+  const u = h.unit(TIPPI[0]), et = h.unit(ETLCHI);
+  assert.ok(h.runUntil(() => u.skill.active, 3), '蒂比 takes off');
+  assert.ok(h.runUntil(() => et.skill.active, 40), '隐德来希 casts S2');
+  assert.ok(u.skill.active && u.s.flags.liftoff, 'while 蒂比 is airborne');
+  assert.ok((et.mem.sickles || []).includes(u), 'the second 血镰 is on 蒂比');
+  h.run(2);
+  const fl = h.b.enemies.find((e) => e.defId === LAZERD);
+  const cuts = h.hooksOf('damaged').filter((c) => c.target === fl && c.source === et && (c.dmg?.tags || []).includes('bloodSickle'));
+  assert.ok(cuts.length > 0, 'her 血镰 hits the flyer (可对空 while she is airborne)');
+  done(h);
+});
+
+// ---------------------------------------------------------------------------------------------------------------
+// Review round: which enemy abilities are selections (skip an airborne 蒂比) and which are not (still reach her).
+// PRTS 异常效果 无法选择: "'直接选中'的能力不会进行具体的目标选择，故同样不受这些仅在选择时生效的异常效果制约"; abilities
+// marked "无视无法选择" ignore it; a selector whose 行动方式 is not ground ignores 对地规避 (MOTION_TARGET_FREE).
+
+const UACANN = 'enemy_10122_uacann_2';   // 集团军重型火炮: ground; hits leave a 3 s 【燃烧区域】 (PRTS "碰撞不受迷彩制约，不可对空")
+const SPRING_A = 'enemy_9018_actrpa';    // “碎铳之簧” 法术护盾: phys hits → "对来源造成…无来源物理附加伤害" + erosion
+const GUN2 = 'enemy_9017_achunt_2';      // 假想敌：铳 (隐秘核心): 【盲信之誓】 chains "无视无法选择、迷彩"
+const SPRING_C = 'enemy_9020_actrpc';    // “碎铳之簧” 频次护盾 (a chain end)
+const HELM = 'enemy_9013_acstmk';        // 假想敌：胄 (ground): 【灭顶之灾】 → 刺胄之弹 (行动方式 飞行)
+const BLADE = 'enemy_9014_acstma';       // “斩胄之剑” (行动方式 飞行): 掷剑 "（无视无法选择）"
+const SFHU = 'enemy_1203_sfhu';          // 烹泉: ground; death blast "无视迷彩，不可对空" + 【烹泉减益】
+const MOUSEK = 'enemy_1509_mousek';      // “鼠王”: ground; 【沙狱】 ATK cut + arts per second on a 3×3
+const VTSK = 'enemy_10027_vtsk';         // “帝国的甲胄”: ground; entrance barrage on the highest-HP unit around its lock
+const pool = (hp) => ({ hp, maxHp: hp, damage(pid, a) { this.hp = Math.max(0, this.hp - a); } });
+const WAVES = getDefaultSource();
+const tAt = (c) => c.t ?? c.time;
+/** Steps `h` until 蒂比 has landed (or `max` s); returns [take-off, landing] times. */
+function airborne(h, u, max = 60) {
+  let up = null, down = null;
+  for (let i = 0; i < max * 30 && down == null; i++) {
+    h.step();
+    if (up == null && u.s.flags.liftoff) up = h.b.time;
+    if (up != null && down == null && !u.s.flags.liftoff) down = h.b.time;
+  }
+  return [up, down];
+}
+
+test('F3 review: a ground enemy\'s 【燃烧区域】 (集团军重型火炮, "不可对空", no 无视无法选择) never ticks on an airborne 蒂比; it does once she has landed', REAL, () => {
+  const h = makeBattle({
+    stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged'], captureNoisy: true,
+    units: [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }, { chessId: BAIT, row: 10, col: 5 }],
+    enemies: [{ key: UACANN, pos: [9, 7], mods: { hpMul: 1e4, speedMul: 0 } }],
+  });
+  const u = h.unit(TIPPI[0]), bait = h.unit(BAIT);
+  const [up, down] = airborne(h, u);
+  assert.ok(up != null && down != null, 'took off and landed');
+  assert.ok(u.alive, 'she survives the window (the zones on 角峰 next to her used to kill her)');
+  const burn = (t, a, z) => h.hooksOf('damaged').filter((c) => c.target === t && (c.dmg?.tags || []).includes('burning') && tAt(c) > a && tAt(c) < z);
+  assert.ok(burn(bait, up, down).length > 0, 'the cannon shoots 角峰 and the zone burns him');
+  assert.deepEqual(burn(u, up + 1e-6, down - 1e-6).map((c) => `${tAt(c).toFixed(1)} ${Math.round(c.amount)}`), [], 'no zone tick on her while airborne');
+  h.run(15);
+  assert.ok(burn(u, down, Infinity).length > 0, 'landed: the zone burns her again');
+  done(h);
+});
+
+test('F3 review: “碎铳之簧” 法术护盾 counter is 无来源 on its attacker (直接选中) — it reaches an airborne 蒂比', REAL, () => {
+  const h = makeBattle({
+    stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged'], captureNoisy: true,
+    units: [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }],
+    enemies: [{ key: SPRING_A, pos: [9, 7], mods: { hpMul: 1e4, speedMul: 0 } }],
+  });
+  const u = h.unit(TIPPI[0]);
+  assert.ok(h.runUntil(() => u.s.flags.liftoff, 3), 'takes off (the spring is in range)');
+  h.run(10);
+  assert.ok(u.s.flags.liftoff, 'still airborne');
+  const on = h.hooksOf('damaged').filter((c) => c.target === u);
+  assert.ok(on.some((c) => c.dmg.type === 'phys' && (c.dmg.tags || []).includes('springCounter')), 'the physical counter lands');
+  assert.ok(on.some((c) => c.dmg.type === 'element' && (c.dmg.tags || []).includes('springCounter')), 'its erosion lands');
+  assert.ok(!on.some((c) => c.dmg.isAttack), 'the ground spring\'s own attacks never select her');
+  done(h);
+});
+
+test('F3 review: 假想敌：铳\'s 【盲信之誓】 chain ("无视无法选择") hurts an airborne 蒂比 standing on it', REAL, () => {
+  const h = makeBattle({
+    kind: 'boss', sharedBoss: pool(1e7), seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged'], captureNoisy: true,
+    setup(b) { b.enemyOverrides = WAVES.getWave('act1autochess_h08_02').overrides; },
+    units: [{ chessId: TIPPI[0], row: 10, col: 7, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }],
+  });
+  h.step();
+  const put = (key, pos, o = {}) => h.spawn(key, { pos, routeIndex: 0, mods: { speedMul: 0, ...o.mods }, tag: o.tag ?? null });
+  put(GUN2, [3, 10], { tag: 'boss' }).profile.noAttack = true;
+  put(SPRING_C, [3, 4], { tag: 'part' }).profile.noAttack = true;
+  put(LAZERD, [3, 8.2], { mods: { hpMul: 1e4, atkMul: 0 } });            // her S1 target
+  const u = h.unit(TIPPI[0]);
+  assert.equal(u.y, 3, 'on the chain between 铳 (3,10) and the spring (3,4)');
+  const [up, down] = airborne(h, u);
+  assert.ok(up != null && down != null, 'took off and landed');
+  const chain = h.hooksOf('damaged').filter((c) => c.target === u && (c.dmg?.tags || []).includes('faithLink') && tAt(c) > up && tAt(c) < down);
+  assert.ok(chain.length >= 20, `the chain hurts her every second while airborne: ${chain.length}`);
+  done(h);
+});
+
+test('F3 review: the 刺胄之弹 and 斩胄之剑 blasts (flying units — 对地规避 does not stop them; 无来源 DoT) still stun and hurt an airborne 蒂比', REAL, () => {
+  // 刺胄之弹: 胄 (ground) cannot pick her; the shell flies at 角峰 next to her and its 3×3 blast catches her
+  {
+    const h = makeBattle({
+      kind: 'boss', sharedBoss: pool(1e7), seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged', 'statusApplied'], captureNoisy: true,
+      units: [{ chessId: TIPPI[0], row: 10, col: 7, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }, { chessId: BAIT, row: 11, col: 7 }],
+    });
+    h.step();
+    h.spawn(LAZERD, { pos: [3, 8.2], routeIndex: 0, mods: { speedMul: 0, hpMul: 1e4, atkMul: 0 } });
+    h.spawn(HELM, { pos: [3, 9], routeIndex: 0, mods: { speedMul: 0 }, tag: 'boss' }).profile.noAttack = true;
+    const u = h.unit(TIPPI[0]);
+    // the shell lands at ≈ 29 s, S1 ends at ≈ 32 s
+    const [up, down] = airborne(h, u, 40);
+    const st = h.hooksOf('statusApplied').filter((c) => c.status === 'stun');
+    assert.ok(st.some((c) => c.target === h.unit(BAIT)), 'the shell went to 角峰');
+    assert.ok(st.some((c) => c.target === u && tAt(c) > up && tAt(c) < down), 'she is stunned while airborne');
+    // (片场工作指南 may dodge one physical tick: her talent's dodge after a quiet spell)
+    const dot = h.hooksOf('damaged').filter((c) => c.target === u && (c.dmg?.tags || []).includes('helmShell') && tAt(c) > up && tAt(c) < down);
+    assert.ok(dot.length >= 1, `the DoT ticks on her while airborne: ${dot.length}`);
+    done(h);
+  }
+  // 斩胄之剑 掷剑 "选择…攻击力最低的1名我方单位（无视无法选择）": it dives at her while she is airborne, 胄 on the field
+  {
+    const H08 = 'act1autochess_h08_01';
+    const tpl = WAVES.getWave(H08);
+    const origin = tpl.extraRoutes[tpl.branches.left_hand_origin[0][0].routeIndex];
+    const h = makeBattle({
+      kind: 'boss', sharedBoss: pool(1e7), seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged', 'statusApplied'], captureNoisy: true,
+      setup(b) { b.opts.templateId = H08; },
+      units: [{ chessId: TIPPI[0], row: 12, col: 15, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }],
+    });
+    h.step();
+    h.spawn(LAZERD, { pos: [5, 16], routeIndex: 0, mods: { speedMul: 0, hpMul: 1e4, atkMul: 0 } });
+    h.spawn(HELM, { pos: [2, 9], routeIndex: 0, mods: { speedMul: 0 }, tag: 'boss' }).profile.noAttack = true;
+    h.spawn(BLADE, { pos: origin.start, routeIndex: 0, tag: 'part' });
+    const u = h.unit(TIPPI[0]);
+    const [up, down] = airborne(h, u, 40);                                // the dive lands at ≈ 29 s, S1 ends at ≈ 32 s
+    assert.ok(h.hooksOf('statusApplied').some((c) => c.status === 'stun' && c.target === u && tAt(c) > up && tAt(c) < down), 'the dive stuns her while airborne');
+    const dot = h.hooksOf('damaged').filter((c) => c.target === u && (c.dmg?.tags || []).includes('bladeDive') && tAt(c) > up && tAt(c) < down);
+    assert.ok(dot.length >= 1, `its DoT hurts her while airborne: ${dot.length}`);
+    done(h);
+  }
+});
+
+test('F3 review: one-shot area abilities of ground enemies skip an airborne 蒂比 — 烹泉 death blast and steam, 鼠王 【沙狱】, “帝国的甲胄” barrage', REAL, () => {
+  // 烹泉: dies next to her while she is airborne (PRTS "死亡爆炸（…无视迷彩，不可对空）": a selection, no 无视无法选择)
+  {
+    const h = makeBattle({
+      stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged'], captureNoisy: true,
+      units: [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }, { chessId: BAIT, row: 10, col: 5 }],
+      enemies: [{ key: SFHU, pos: [9, 6.5], mods: { hpMul: 0.4, speedMul: 0 } }],
+    });
+    const u = h.unit(TIPPI[0]), bait = h.unit(BAIT);
+    let slowAir = false, baitSlow = false;
+    for (let i = 0; i < 25 * 30; i++) { h.step(); if (u.s.flags.liftoff && u.findBuff('ab:teaBoom')) slowAir = true; if (bait.findBuff('ab:teaBoom')) baitSlow = true; }
+    assert.ok(!h.b.enemies.some((e) => e.alive && e.defId === SFHU), '烹泉 died');
+    assert.ok(u.s.flags.liftoff, 'she is still airborne');
+    const blast = (t) => h.hooksOf('damaged').filter((c) => c.target === t && (c.dmg?.tags || []).includes('teaBoom'));
+    assert.equal(blast(u).length, 0, 'no blast on her');
+    assert.ok(blast(bait).length > 0 && baitSlow, '角峰 takes the blast and the slow');
+    assert.ok(!slowAir, 'no 【烹泉减益】 on her');
+    done(h);
+  }
+  // 鼠王 【沙狱】 centred on 角峰 next to her: neither its ATK cut nor its DoT attaches to her
+  {
+    const h = makeBattle({
+      stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged'], captureNoisy: true,
+      units: [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }, { chessId: BAIT, row: 10, col: 5 }],
+      enemies: [{ key: MOUSEK, pos: [9, 8], mods: { hpMul: 1e4, speedMul: 0, atkMul: 0.01 } }, { key: LAZERD, pos: [9, 6.2], mods: { hpMul: 1e4, speedMul: 0, atkMul: 0 } }],
+    });
+    const u = h.unit(TIPPI[0]), bait = h.unit(BAIT);
+    assert.ok(h.runUntil(() => u.s.flags.liftoff, 3), 'takes off');
+    const m = h.b.enemies.find((e) => e.defId === MOUSEK);
+    const storm = m.mem.ab.list.find((a) => a && a.cd === m.mem.ab.sk.SandStorm.cd && a.fire);
+    storm.left = 0.1;                                                     // 【沙狱】 now (its initial cooldown is 60 s)
+    h.run(2);
+    assert.ok(bait.findBuff('ab:sandStorm'), '沙狱 on 角峰');
+    assert.ok(u.s.flags.liftoff && !u.findBuff('ab:sandStorm'), 'not on the airborne 蒂比 next to him');
+    done(h);
+  }
+  // “帝国的甲胄” entrance barrage: locks 角峰 (she cannot be selected) and hits the highest-HP unit she is not
+  {
+    const h = makeBattle({
+      stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged'], captureNoisy: true,
+      units: [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }, { chessId: BAIT, row: 10, col: 5 }],
+      enemies: [{ key: LAZERD, pos: [9, 7], mods: { hpMul: 1e4, speedMul: 0, atkMul: 0 } }],
+    });
+    const u = h.unit(TIPPI[0]), bait = h.unit(BAIT);
+    assert.ok(h.runUntil(() => u.s.flags.liftoff, 3), 'takes off');
+    bait.hp = Math.min(bait.hp, 100);                                     // she has the most HP in the 3×3
+    const e = h.spawn(VTSK, { pos: [9, 8], routeIndex: 0, mods: { speedMul: 0, atkMul: 0.01 } });
+    h.run(1.5);
+    const shots = (t) => h.hooksOf('damaged').filter((c) => c.target === t && c.source === e && !c.dmg.isAttack).length;
+    assert.equal(shots(u), 0, 'no shot on her');
+    assert.equal(shots(bait), ds.rawEnemy(VTSK).skills.find((s) => s.prefabKey === 'Appear').bb.times, 'every shot hits 角峰 instead of being wasted on her');
+    done(h);
+  }
+});
+
+// ---------------------------------------------------------------------------------------------------------------
+// Second review round: 萨卡兹悖谬暴虐兵长's 暴击 splash ("无视无法选择") and the ticks of debuffs already on her.
+
+const WDRRL = 'enemy_1320_wdrrl_2';      // 萨卡兹悖谬暴虐兵长 (ground, block ≥ 3): 暴击 "对目标和周围4格…（无视无法选择，无视迷彩）"
+const NHSTLK = 'enemy_1270_nhstlk';      // 逐腐兽 (ground melee): 出血 on hit — arts per second
+const LSLIME = 'enemy_1050_lslime';      // “庞贝” (ground): its hits leave a burning DoT
+
+test('F3 review 2: 萨卡兹悖谬暴虐兵长\'s 暴击 splash ("无视无法选择") reaches an airborne 蒂比 next to its blocker', REAL, () => {
+  const h = makeBattle({
+    stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['hit', 'damaged'], captureNoisy: true,
+    units: [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 999 }, skillIndex: skillIndex(TIPPI[0], S1) }, { chessId: BAIT, row: 9, col: 4 }],
+    enemies: [{ key: WDRRL, route: { motion: 'WALK', start: [9, 8], end: [9, 1], checkpoints: [] }, mods: { hpMul: 1e3, atkMul: 0.3 } }],
+  });
+  const u = h.unit(TIPPI[0]), bait = h.unit(BAIT);
+  let e = null, airAtBlock = null;
+  for (let i = 0; i < 14 * 30; i++) {                                     // it reaches 角峰 at ≈ 9 s, S1 lasts 32 s
+    h.step();
+    e ??= h.b.enemies.find((x) => x.defId === WDRRL) ?? null;
+    if (e && airAtBlock == null && e.blockedBy) airAtBlock = !!u.s.flags.liftoff;
+  }
+  assert.ok(e && e.blockedBy === bait, '角峰 (block 3) blocks it; she cannot (block < 3)');
+  assert.equal(airAtBlock, true, 'she is airborne when it reaches 角峰');
+  // the splash gets past 对地规避 to her `hit` (where her 片场工作指南 may dodge it: no damage for stack_time s), once
+  const reach = h.hooksOf('hit').filter((c) => c.target === u && c.source === e);
+  assert.equal(reach.length, 1, 'its one-off splash reaches her');
+  assert.ok(!reach[0].dmg.isAttack && reach[0].dmg.ignoreSelect && reach[0].dmg.tags.includes('aoeAttack'));
+  const landed = h.hooksOf('damaged').filter((c) => c.target === u && c.source === e);
+  assert.equal(landed.length, reach[0].dmg.cancel ? 0 : 1, 'it hurts her unless her talent dodged it');
+  assert.ok(landed.every((c) => c.amount > 0));
+  assert.ok(u.s.flags.liftoff, 'while airborne');
+  assert.ok(h.hooksOf('damaged').some((c) => c.target === bait && c.source === e && c.dmg.isAttack), 'its attack itself is on 角峰');
+  done(h);
+});
+
+test('F3 review 2: a debuff a ground enemy put on 蒂比 before she took off keeps ticking (no selection); its new attacks still skip her', REAL, () => {
+  // 鼠王 【沙狱】 (centred near 角峰 and her), 逐腐兽's 出血, “庞贝”'s burning DoT: attached on the ground, then S1
+  const cases = [
+    { key: MOUSEK, pos: [9, 8], buff: 'ab:sandStorm', bait: true, fire: (h, m) => { m.mem.ab.list.find((a) => a && a.cd === m.mem.ab.sk.SandStorm.cd && a.fire).left = 0.05; } },
+    { key: NHSTLK, pos: [9, 5.3], buff: 'ab:bleed' },
+    { key: LSLIME, pos: [9, 7], buff: 'ab:burnDot' },
+  ];
+  for (const k of cases) {
+    const units = [{ chessId: TIPPI[0], row: 9, col: 5, carryState: { sp: 0 }, skillIndex: skillIndex(TIPPI[0], S1) }];
+    if (k.bait) units.push({ chessId: BAIT, row: 10, col: 5 });
+    const h = makeBattle({
+      stageId: 'act2autochess_m02', seed: 3, autoFinish: false, timeLimit: 400, hooks: ['damaged'], captureNoisy: true, units,
+      enemies: [{ key: k.key, pos: k.pos, mods: { hpMul: 1e4, speedMul: 0, atkMul: k.bait ? 0.01 : 0.05 } }, { key: LAZERD, pos: [9, 7.2], mods: { hpMul: 1e4, speedMul: 0, atkMul: 0 } }],
+    });
+    const u = h.unit(TIPPI[0]);
+    h.step();
+    const e = h.b.enemies.find((x) => x.defId === k.key);
+    k.fire?.(h, e);
+    assert.ok(h.runUntil(() => u.findBuff(k.buff), 10), `${k.key}: ${k.buff} on her`);
+    assert.ok(!u.s.flags.liftoff, `${k.key}: before she takes off`);
+    u.skill.gainSp(999, 'init');
+    assert.ok(h.runUntil(() => u.s.flags.liftoff, 3), `${k.key}: takes off`);
+    const up = h.b.time;
+    h.run(4);
+    assert.ok(u.s.flags.liftoff && u.findBuff(k.buff), `${k.key}: still airborne with the debuff`);
+    const air = h.hooksOf('damaged').filter((c) => c.target === u && c.source === e && tAt(c) > up + 1e-6);
+    assert.ok(air.filter((c) => !c.dmg.isAttack).length >= 3, `${k.key}: its ticks land while airborne: ${air.length}`);
+    assert.deepEqual(air.filter((c) => c.dmg.isAttack).map((c) => Math.round(c.amount)), [], `${k.key}: no new attack on her`);
+    done(h);
+  }
+});