0.2.5-dev: 驭械术师 normal attacks keep the operator's own hit plus one drone hit, the drone multiplier and per-target map reset on redeploy, 洛洛 S2 keeps its lock until a kill or the skill ends (PRs #537 / #536 / #535 by @Xinglan233, ported); hit tiles use the official round-half-to-even with an edge inset (PR #520 by @Cloudnyco, ported); bots softly avoid living teammates' opening factions until they are eliminated (PR #518 by @IceCodeNew, ported with changes); golden: 43 more scenarios move, each named in docs/history/0.2.5.md

server/sim/content/kits/ops/chess_char_2_10-rockr.js

@@ -1,21 +1,30 @@
 // server/sim/content/kits/ops/chess_char_2_10-rockr.js — 洛洛 (char_4040_rockr) kit, tier 2.
 // Conventions of the tier-2 kits: ../shared/tier2.js; kit contract and rules: ../README.md.
 
-import { canTargetEnemy } from '../../../targeting.js';
-import { bodyInKeys } from '../../../body.js';
+import { canTargetEnemy, sortEnemyTargets } from '../../../targeting.js';
 import { num, talentBb, up } from '../shared/tier1.js';
-import { onDefaultSkill } from '../shared/tier2.js';
+
+export const DRONE_TAG = 'rockr:drone';
+
+const firstTarget = (battle, unit) => {
+  const prof = unit.profile;
+  const candidates = battle.enemiesInKeys(unit.rangeKeys, unit, prof);
+  for (const e of battle.blockedTargets(unit, prof)) if (!candidates.includes(e)) candidates.push(e);
+  sortEnemyTargets(battle, unit, candidates, prof.priority);
+  return candidates[0] ?? null;
+};
 
 export default {
   // ---------------------------------------------------------------------------------------------------------------
-  // 2_10 洛洛 自负此轭: ASPD +attack_speed; the drones lock on their target until it dies or the skill ends.
+  // 2_10 洛洛 自负此轭: ASPD +attack_speed. The skill releases its drone, which keeps the lock after the target leaves
+  // her range and returns only when that enemy dies or the skill ends (docs/research/03-operators.md, skchr_rockr_2).
+  // While it is out, the unreleased drone's additional damage is off and the drone's own hits are skill damage.
   // 过载 (term ba.overdrive "技能进行到一半时触发额外效果"): the second half of the duration — ATK +atk and the funnel cap
   // ×scale; when the skill ends she is stunned as long as the overload lasted. 立于磐石: ATK +atk per `interval` s on the
   // field, up to max_stack_cnt stacks.
   // S1 战术咏唱·γ型 (alt): ASPD +attack_speed; the target lock belongs to 自负此轭 only.
   chess_char_2_10_a: (bb, chess) => {
     const t = talentBb(chess, 0);
-    const s2 = onDefaultSkill(chess);
     const endOverload = (battle, unit) => {
       if (unit.mem.rockFunnel) { unit.profile.funnel = unit.mem.rockFunnel; unit.mem.rockFunnel = null; }
       battle.removeBuff(unit, 'rockr:overload');
@@ -26,19 +35,53 @@ export default {
         onStart({ battle, unit, skill }) {
           unit.mem.rockOverAt = battle.time + skill.duration / 2;
           unit.mem.rockOver = false;
-          unit.mem.rockLock = null;
+          // The released drone inherits the trait's ramp; the body still attacks only inside its own range.
+          // `funnelMul` separates the addition; older profiles fold it into `dmgMul`. Keep launched shots unchanged.
+          const key = typeof unit.profile.funnelMul === 'function' ? 'funnelMul' : 'dmgMul';
+          const mul = unit.profile[key];
+          unit.profile = { ...unit.profile, [key]: null };
+          const lock = firstTarget(battle, unit);
+          unit.mem.rockDrone = { lock, cd: 0, key, mul,
+            target: unit.trait.funnelTarget, scale: unit.trait.funnelScale };
+          unit.mem.rockLock = lock;
         },
-        onTick({ battle, unit }) {
-          if (unit.mem.rockOver || battle.time + 1e-9 < unit.mem.rockOverAt) return;
-          unit.mem.rockOver = true;
+        onTick({ battle, unit, dt }) {
+          if (!unit.mem.rockOver && battle.time + 1e-9 >= unit.mem.rockOverAt) {
+            unit.mem.rockOver = true;
+            const f = unit.profile.funnel;
+            if (f) { unit.mem.rockFunnel = f; unit.profile.funnel = { ...f, max: f.max * num(bb.scale, 1) }; }
+            battle.addBuff(unit, { key: 'rockr:overload', mods: { atkPct: num(bb.atk) }, visible: true, tags: ['skill'] });
+            battle.fx('overload', { x: unit.x, y: unit.y, id: unit.id });
+          }
+          const d = unit.mem.rockDrone;
+          if (!d || !unit.alive || !unit.skill.active) return;
+          d.cd = Math.max(0, d.cd - dt);
+          // [ASSUMED] A newly unselectable lock is dropped and the drone retargets. No flight delay, and body control
+          // (stun and the like) does not pause the released drone — same as the other independent skill drones.
+          if (d.lock && !canTargetEnemy(unit, d.lock, unit.profile)) d.lock = null;
+          if (!d.lock) d.lock = firstTarget(battle, unit);
+          unit.mem.rockLock = d.lock;
+          if (!d.lock || d.cd > 1e-9) return;
+          d.cd = unit.s.interval;
+          // Official S2 releases one drone (1 + attack@cnt = 1 at both ranks). The ramp lives on the drone, so a
+          // pre-skill projectile that lands later cannot change it.
           const f = unit.profile.funnel;
-          if (f) { unit.mem.rockFunnel = f; unit.profile.funnel = { ...f, max: f.max * num(bb.scale, 1) }; }
-          battle.addBuff(unit, { key: 'rockr:overload', mods: { atkPct: num(bb.atk) }, visible: true, tags: ['skill'] });
-          battle.fx('overload', { x: unit.x, y: unit.y, id: unit.id });
+          d.scale = d.target === d.lock.id ? Math.min(f.max, (d.scale ?? f.init) + f.delta) : f.init;
+          d.target = d.lock.id;
+          battle.fx('drone', { x: d.lock.x, y: d.lock.y, id: unit.id });
+          battle.dealDamage(unit, d.lock, { amount: unit.s.atk * unit.s.atkScaleMul * d.scale,
+            type: 'arts', isSkill: true, isAttack: false, tags: ['skill', 'drone', DRONE_TAG] });
         },
         onEnd({ battle, unit, reason }) {
           const over = unit.mem.rockOver ? battle.time - unit.mem.rockOverAt : 0;
+          const d = unit.mem.rockDrone;
+          unit.mem.rockDrone = null;
           endOverload(battle, unit);
+          if (d) {
+            unit.trait.funnelTarget = d.target;
+            unit.trait.funnelScale = d.scale;
+            unit.profile = { ...unit.profile, [d.key]: d.mul };
+          }
           unit.mem.rockOver = false;
           unit.mem.rockLock = null;
           if (over > 0 && reason !== 'death' && unit.alive) battle.applyStatus(unit, 'stun', { duration: over, source: unit });
@@ -46,12 +89,6 @@ export default {
       },
       skills: { 'skcom_magic_rage[3]': { kind: 'duration', mods: { aspd: num(bb.attack_speed) } } },
       talents: [{ install(battle, unit) {
-        if (s2) battle.on('beforeAttack', (ctx) => {
-          if (ctx.attacker !== unit || !unit.skill?.active) return;
-          const L = unit.mem.rockLock;
-          if (L && L.alive && bodyInKeys(L, unit.rangeKeySet) && canTargetEnemy(unit, L, ctx.profile || unit.profile)) ctx.targets = [L];
-          else unit.mem.rockLock = ctx.targets[0] ?? null;
-        }, { owner: unit });
         const iv = num(t.interval), max = Math.floor(num(t.max_stack_cnt)), v = num(t.atk);
         if (!(iv > 0) || !(max > 0) || !v) return;
         battle.on('tick', () => {

server/sim/content/kits/ops/chess_char_3_13-malist.js

@@ -12,10 +12,10 @@ export default {
     const hits = textNum(d.skill?.description, /连续攻击(\d+|[一二两三四五])次/, 2);
     const insight = (battle) => (battle.rng.chance(num(t0.prob, 0)) ? num(t0.atk_scale, 1) : 1);
     return {
-      trait: { dmgMul: (battle, unit, target) => funnelMap(battle, unit, target) * insight(battle) },
+      trait: { funnelMul: funnelMap, dmgMul: insight },
       skill: {
         kind: charges > 1 ? 'charges' : 'instant',
-        attack: { atkScale: num(bb.atk_scale, 1), hits, dmgType: 'arts', dmgMul: (battle) => insight(battle) },
+        attack: { atkScale: num(bb.atk_scale, 1), hits, funnelBodyHits: hits, dmgType: 'arts', dmgMul: insight },
       },
       // S1 迅捷打击·γ型: ATK / ASPD + (the drones' ramp and 忽有所悟 stay on every attack through the trait)
       skills: altSkills(chess, d, bb, { 'skcom_quickattack[3]': statSkill }),

server/sim/content/kits/ops/chess_char_3_20-kjera.js

@@ -13,7 +13,7 @@ export default {
     const extra = Math.floor(num(bb['attack@cnt'], 0));
     const prob = num(bb['attack@prob'], 0), cold = num(bb['attack@cold'], 0);
     const kit = {
-      trait: { dmgMul: funnelMap },
+      trait: { funnelMul: funnelMap },
       skill: {
         kind: 'duration',
         mods: { atkPct: num(bb.atk) },

server/sim/content/kits/ops/chess_char_4_03-kjera.js

@@ -20,7 +20,7 @@ export default withDefaults({
         attack: {
           // every drone ramps on its own locked target (trait init/delta/max): the multipliers are queued per target
           // by the beforeAttack hook below (two drones on the same enemy ramp independently)
-          dmgMul: (battle, unit, target) => {
+          funnelMul: (battle, unit, target) => {
             const q = unit.mem.kjeraQueue && unit.mem.kjeraQueue.get(target.id);
             return q && q.length ? q.shift() : funnel(unit).init;
           },

server/sim/content/kits/ops/chess_char_6_18-whitw2.js

@@ -143,7 +143,7 @@ function whitw2(bb, chess, def) {
       ...(skillGridW ? { targeting: { rangeGrid: skillGridW } } : {}),
       attack: {
         hits: 1,
-        dmgMul(battle, unit, target) {
+        funnelMul(battle, unit, target) {
           const f = unit.profile?.funnel || { init: 0.2, delta: 0.15, max: 1.1 };
           const m = unit.mem.hunt;
           if (!m) return f.init;

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

@@ -17,7 +17,7 @@
 // projectile_chr_gdglow_funnel_s1_1 … s3_3 (`_lifeTimeType` 2: until stopped, `_stopWhenSourceInvalid`, its crash
 // AdvancedApplyDamage MAGICAL at atk_scale_2) and their s12 / s3 blast projectiles.
 // - Trait (驭械术师) "操作浮游单元造成法术伤害；单元攻击同一敌人伤害提升（最高造成干员110%攻击力的伤害）" (trait bb init / delta /
-//   max_atk_scale): the engine's funnel profile (professions.js: her normal attack = one drone hit at init → +delta per hit on
+//   max_atk_scale): the engine's funnel profile (professions.js: her normal attack = a body hit plus one drone addition at init → +delta per hit on
 //   the same target → max). FUN-X: init 0.35 ("单元初始伤害提高"); FUN-Y: max 1.2. Ranged arts, 3-1, hits air (PRTS "可对空"),
 //   blocks 1, ground enemies target her.
 // - Skill drones (the three skills "浮游单元+N，释放浮游单元锁定敌人攻击 … 锁敌后直至敌人被击杀、自爆或技能结束后返回干员身边"): while a