feedback1 integrate: WA per-copy 拉普兰德 refresh counter; 突变细胞 reusable

server/match/PlayerState.js

@@ -30,6 +30,12 @@
 //     the one that deploys first — board.js mergeTile, [ASSUMED]); it replaces a deployed copy, so the deploy count
 //     never grows, and it gets its own summon stack (grantTokensFor). Otherwise to the hand, overflow temp — also
 //     outside PREP (a SETTLE merge's elite waits in temp for the next prep).
+//   * Per-piece round counters (pieceRoundCount, piece.meta.round): an operator's own counts of the current round
+//     (拉普兰德: the manual refreshes she witnessed — player feedback after 0.1.0); a new piece starts at 0, an elite
+//     merged this round keeps the highest of its copies' [ASSUMED].
+//   * Transformations (transformChess, 突变细胞): the new chess keeps the tile when legal; `returnItems` sends the old
+//     piece's equipment to the hand (overflow temp) like a destroyed operator's — before the new piece's summon stack,
+//     as in a merge, so a summon card never pushes the returned 突变细胞 into temp.
 //   * Items: equip max 2 (a 3rd replaces the equipped item the player picks — g.equip replaceUid, the oldest when
 //     absent; equipped items are otherwise locked: g.destroy refuses them),
 //     2 identical normal items (hand/temp/equipped) merge into the golden item in the hand, items are never sold
@@ -353,6 +359,27 @@ export class PlayerState {
     return null;
   }
 
+  /**
+   * Per-piece counter of the current round (`piece.meta.round` = { r, n: { key: count } }): 0 for a key not counted yet
+   * this round. The counters belong to the operator: a move keeps them, a new piece (bought, granted, transformed)
+   * starts at 0, and an elite merged this round keeps the highest count of its copies (_mergeChess) — 拉普兰德's
+   * "本回合首次主动刷新" is the first manual refresh she witnesses (player feedback after 0.1.0, garrisons/meta.js).
+   */
+  pieceRoundCount(piece, key) {
+    const rc = piece && piece.meta && piece.meta.round;
+    return rc && rc.r === this.m.round && Number.isFinite(rc.n[key]) ? rc.n[key] : 0;
+  }
+
+  /** Add `n` to a piece's counter of the current round (pieceRoundCount); returns the new count. */
+  bumpPieceRoundCount(piece, key, n = 1) {
+    if (!piece || typeof key !== 'string' || !Number.isFinite(n)) return 0;
+    if (!piece.meta || typeof piece.meta !== 'object') piece.meta = {};
+    const v = this.pieceRoundCount(piece, key) + n;
+    if (!piece.meta.round || piece.meta.round.r !== this.m.round) piece.meta.round = { r: this.m.round, n: {} };
+    piece.meta.round.n[key] = v;
+    return v;
+  }
+
   /** Return a piece's pool copies (and its equipped items are handled by the caller). */
   returnCopies(piece) {
     if (piece && piece.kind === 'chess' && piece.poolCopies > 0) {
@@ -503,6 +530,12 @@ export class PlayerState {
       l.piece.items = [];
     }
     const elite = this.newPiece('chess', goldenId, { poolCopies: copies });
+    // this round's per-piece counters: the highest of the copies' (an elite made from 拉普兰德 that already saw their
+    // first refresh this round does not fire again this round — [ASSUMED] conservative, pieceRoundCount)
+    for (const l of consumed) {
+      const rc = l.piece.meta && l.piece.meta.round;
+      if (rc && rc.r === this.m.round) for (const [k, v] of Object.entries(rc.n)) this.bumpPieceRoundCount(elite, k, Math.max(0, v - this.pieceRoundCount(elite, k)));
+    }
     const deployed = consumed.filter((l) => l.key && !this.board.has(l.key)).map((l) => ({ key: l.key, dir: l.area === 'new' ? l.dir : pieceDir(l.piece) }));
     const toTile = (t) => { elite.dir = parseDir(t.dir) || 'RIGHT'; this.board.set(t.key, elite); return 'board'; };
     const tile = mergeTile(deployed, (r, c) => this._legal(elite, r, c));
@@ -548,10 +581,17 @@ export class PlayerState {
 
   /**
    * Replace a chess piece by another chess (突变细胞 and similar). The new piece keeps the tile when legal (else goes
-   * to the hand/temp) and keeps the equipment; pool copies are swapped; completes a merge when possible — a deployed
-   * piece's tile then counts as a consumed copy's for the elite (_mergeChess fromKey, when legal for it).
+   * to the hand/temp) and keeps the equipment — or, with `returnItems`, the equipment returns to the hand like the
+   * equipment of a destroyed / promoted operator (突变细胞: PRTS 备注 "生效时，原干员销毁，获得一名高一阶的随机初始干员"; the
+   * cell itself comes back, player feedback after 0.1.0), overflowing into temp; with both full an item stays on the new
+   * piece up to its equipPerChess slots (any further one is destroyed with a log warning, as in a merge). Pool copies are
+   * swapped; completes a merge when possible — a deployed piece's tile then counts as a consumed copy's for the elite
+   * (_mergeChess fromKey, when legal for it), and the merge returns the equipment itself. A new piece on the board gets
+   * its summon stack only after the equipment came back (like _mergeChess: a summon card must not push the returned
+   * equipment — 突变细胞 — into temp, where it would be lost at the deadline).
+   * @param {{ returnItems?: boolean }} [opts]
    */
-  transformChess(piece, newId) {
+  transformChess(piece, newId, { returnItems = false } = {}) {
     const loc = this.find(piece.uid);
     const rec = this.gd.chess(newId);
     if (!loc || loc.piece.kind !== 'chess' || !rec) return null;
@@ -563,14 +603,26 @@ export class PlayerState {
     const base = this.gd.baseIdOf(newId);
     const taken = this.m.pool.take(base, rec.isGolden ? this.gd.goldenCopies : 1);
     let np = this.newPiece('chess', newId, { poolCopies: taken });
-    np.items = items;
-    if (!rec.isGolden && this.completesChessMerge(newId)) {
+    const merging = !rec.isGolden && this.completesChessMerge(newId);
+    // a merge returns the consumed copies' equipment (this one's too) before the elite's summons (_mergeChess)
+    const pending = returnItems && !merging ? items : [];
+    np.items = returnItems && !merging ? [] : items;
+    let deployed = false;
+    if (merging) {
       np = this._mergeChess(base, np, loc.area === 'board' ? { fromKey: loc.key, fromDir: pieceDir(piece) } : undefined);
-      if (!np) { this.recompute(); return null; }
     } else if (loc.area === 'board') {
       const [r, c] = parseKey(loc.key);
-      if (this._legal(np, r, c)) { np.dir = pieceDir(piece); this.board.set(loc.key, np); this.grantTokensFor(np); } else if (!this.stow(np, { allowTemp: true })) { this.returnCopies(np); np = null; }
+      if (this._legal(np, r, c)) { np.dir = pieceDir(piece); this.board.set(loc.key, np); deployed = true; } else if (!this.stow(np, { allowTemp: true })) { this.returnCopies(np); np = null; }
     } else if (!this._putBack(loc, np)) { this.returnCopies(np); np = null; }
+    // after the new piece took its place (a hand piece keeps its slot), its predecessor's equipment comes off
+    for (const it of pending) {
+      if (this.stow(it, { allowTemp: true })) continue;
+      if (np && np.items.length < this.gd.equipPerChess) { np.items.push(it); continue; }
+      this.m.log.warn?.(`[match ${this.m.roomCode}] ${this.playerId}: returned item ${it.id} destroyed (no space)`);
+    }
+    if (returnItems) this.checkItemMerges();
+    // deployed in its predecessor's place: its manually deployable summons join the hand, after the returned equipment
+    if (deployed) this.grantTokensFor(np);
     this.recompute();
     if (np) this.m.dispatch(this, 'onGain', { piece: np, kind: 'chess', source: 'transform' });
     return np;

server/match/bot.js

@@ -35,8 +35,11 @@
 //      order as the one-shot functions (runSteps), hence the same rng draws and decisions.
 //      The summon cards of the placed operators (赫默's 医疗探机, 伺夜's 狼群 …; user playtest #6) are placed after
 //      them on the best remaining tiles, 凯瑟琳's 支援装置 next to the best operator no device faces yet, facing it.
-//   5. equip items on the strongest deployed damage dealers (consume-on-equip items / Arts only with a handler)
-//   6. resolve the temp slots, keep one hand slot free, then Ready.
+//   5. equip items on the strongest deployed damage dealers (consume-on-equip items / Arts only with a handler);
+//      突变细胞 (it comes back after every transformation) on the least valuable single normal operator below 6阶 —
+//      never an elite or one of a merge pair (cellTarget)
+//   6. resolve the temp slots (a 突变细胞 left there gets a hand slot made for it — makeHandRoom — instead of being
+//      destroyed), keep one hand slot free, then Ready.
 // Placement quality (tools/matchrun sweeps, research-faithful waves): the planner beats random layouts by ≈ 8 points
 // of kill rate and rehearsal adds ≈ 5 more; see docs/META.md §1.5.
 
@@ -804,12 +807,15 @@ function context(m, ps) {
   return { owned, focus: focusBond(m, ps, owned), roles: roles(m, ps), fly: model.flyTotal, model };
 }
 
-/** Sell the weakest bench chess that is not part of a merge pair (or anything when keepPairs is false). */
-function sellWeakestHand(m, ps, { keepPairs = true, below = Infinity } = {}) {
+/**
+ * Sell the weakest bench chess (temp and hand; the hand only with `handOnly`) that is not part of a merge pair (or
+ * anything when keepPairs is false).
+ */
+function sellWeakestHand(m, ps, { keepPairs = true, below = Infinity, handOnly = false } = {}) {
   const ctx = context(m, ps);
   let worst = null;
   let worstV = Infinity;
-  for (const p of [...ps.temp, ...ps.hand]) {
+  for (const p of handOnly ? ps.hand : [...ps.temp, ...ps.hand]) {
     if (!p || p.kind !== 'chess') continue;
     const base = m.gd.baseIdOf(p.id);
     if (keepPairs && !m.gd.isGolden(p.id) && ps.countCopies(base) >= 2) continue;
@@ -1159,6 +1165,27 @@ function* placeTokensSteps(m, ps) {
   }
 }
 
+/** 突变细胞 (buff char_chess_transformation_equip): after the battle its carrier becomes a random operator one tier higher. */
+const isMutationCell = (gd, itemId) => { const rec = gd.item(itemId); return !!(rec && Array.isArray(rec.buffs) && rec.buffs.some((b) => b && b.key === 'char_chess_transformation_equip')); };
+
+/**
+ * Whom the bot injects with 突变细胞 (after the battle the carrier is replaced by a random NORMAL operator one tier
+ * higher and the cell comes back — builtinMeta char_chess_transformation_equip): its least valuable normal operator
+ * below 6阶 with a free equip slot — never an elite or one of a merge pair (both would be lost), nobody already carrying
+ * a cell. null: the cell waits in the hand.
+ */
+export function cellTarget(m, ps, ctx = context(m, ps)) {
+  const gd = m.gd;
+  const cands = ps.allChess().filter((p) => !gd.isGolden(p.id) && gd.tierOf(p.id) < 6 && (p.items || []).length < gd.equipPerChess
+    && !(p.items || []).some((it) => isMutationCell(gd, it.id)) && ps.countCopies(gd.baseIdOf(p.id)) < 2);
+  let best = null, bv = Infinity;
+  for (const p of cands) {
+    const v = pieceValue(m, ps, p, ctx);
+    if (v < bv) { bv = v; best = p; }
+  }
+  return best;
+}
+
 function equipItems(m, ps) {
   const gd = m.gd;
   const ctx = context(m, ps);
@@ -1168,6 +1195,11 @@ function equipItems(m, ps) {
     const item = [...ps.hand, ...ps.temp].find((p) => p && p.kind === 'item' && canUseItem(m, ps, p) && !tried.has(p.uid));
     if (!item) break;
     tried.add(item.uid);
+    if (isMutationCell(gd, item.id)) {
+      const target = cellTarget(m, ps, ctx);
+      if (target) tryDo(() => ps.equip(item.uid, target.uid));
+      continue;
+    }
     const rec = gd.item(item.id);
     if (rec && rec.itemType === 'MAGIC') {
       const board = [...ps.board.entries()].filter(([, p]) => p.kind === 'chess');
@@ -1187,6 +1219,20 @@ function equipItems(m, ps) {
   }
 }
 
+/**
+ * Free a hand slot for an item worth keeping (突变细胞): sell the weakest single hand chess, else destroy the cheapest
+ * other hand item, else sell the weakest hand chess even of a pair. false: the hand stays full (summon cards only).
+ */
+function makeHandRoom(m, ps) {
+  if (freeSlot(ps.hand) >= 0) return true;
+  if (sellWeakestHand(m, ps, { handOnly: true }) && freeSlot(ps.hand) >= 0) return true;
+  const gd = m.gd;
+  const junk = ps.hand.filter((p) => p && p.kind === 'item' && !isMutationCell(gd, p.id))
+    .sort((a, b) => ((gd.item(a.id) || {}).price || 0) - ((gd.item(b.id) || {}).price || 0) || a.uid - b.uid)[0];
+  if (junk && tryDo(() => ps.destroy(junk.uid)) && freeSlot(ps.hand) >= 0) return true;
+  return sellWeakestHand(m, ps, { handOnly: true, keepPairs: false }) && freeSlot(ps.hand) >= 0;
+}
+
 function resolveTemp(m, ps) {
   for (let i = 0; i < ps.temp.length; i++) {
     const p = ps.temp[i];
@@ -1200,6 +1246,11 @@ function resolveTemp(m, ps) {
         if (j >= 0) tryDo(() => ps.move(p.uid, { area: 'hand', idx: j }));
       }
     } else if (p.kind === 'item') {
+      // 突变细胞 comes back after every transformation (昆图斯's strategy item): make room in the hand rather than lose it
+      if (isMutationCell(m.gd, p.id) && makeHandRoom(m, ps)) {
+        const j = freeSlot(ps.hand);
+        if (j >= 0 && tryDo(() => ps.move(p.uid, { area: 'hand', idx: j }))) continue;
+      }
       tryDo(() => ps.destroy(p.uid));
     }
   }

server/match/builtinMeta.js

@@ -17,11 +17,13 @@
 //   use_equip_recruit_new_char_and_give_char_to_player_most_bond {refresh_cnt} 信标 destroy target, offer N same-tier
 //                                                                                chess, gift the original next prep
 //   sell_char_count_gain_equip_owner_bond {count}         商业包装方案           every `count` sells → same-bond chess
-//   char_chess_transformation_equip                       突变细胞               after battle: holder → random tier+1
+//   char_chess_transformation_equip                       突变细胞               after battle: holder → random NORMAL tier+1
+//                                                                                (max 6); its equipment, the cell included,
+//                                                                                returns to the hand (not consumed)
 //   trap_copy_front_char                                  画卷 (Art)            copy the chess on the tile / in front
 //   trap_create_self_choice {choice_event}                教鞭 / 神秘顾客 (Art)  add a random bounty to your next battle
-// [ASSUMED simplifications, documented in docs/META.md: 教鞭/神秘顾客 pick the bounty for the player instead of opening
-//  a personal choice overlay; 突变细胞 consumes itself.]
+// [ASSUMED simplification, documented in docs/META.md: 教鞭/神秘顾客 pick the bounty for the player instead of opening
+//  a personal choice overlay.]
 
 import { getData } from '../data.js';
 import { itemKey } from './gamedata.js';
@@ -175,15 +177,20 @@ const ITEM_HANDLERS = {
       }
     },
   },
+  // 突变细胞 "战斗结束后，装备者替换为高一阶的随机干员": the carrier is replaced by a random NORMAL operator one tier higher
+  // (at most 6; an elite carrier too — PRTS 卫戍协议：盟约 下半/PRTS盟约记录 备注 "生效时，原干员销毁，获得一名高一阶的随机
+  // 初始干员（最高六阶）"); the destroyed operator's equipment, the cell included, returns to the hand (PRTS 卫戍协议/帮助
+  // "佩戴的装备无法手动卸除，在失去该干员（干员出售、销毁、合并等）或装备合并为进阶品质时自动卸除"; the official text never
+  // says 销毁 for the cell — unlike every consumable item —, and players re-inject it every round: "之后就是一直打针，扎到
+  // 核心卡…就换人扎", bilibili cv47000418; player feedback after 0.1.0). The new operator keeps the tile when legal.
   char_chess_transformation_equip: {
     onBattleResult(ctx) {
       const { piece, holder } = ctx.source;
-      if (!piece || !holder) return;
+      if (!piece || !holder || !ctx.piece(holder.uid)) return;
       const tier = Math.min(6, ctx.gd.tierOf(holder.id) + 1);
       const id = ctx.rollChess({ tier });
       if (!id) return;
-      ctx.destroyPiece(piece.uid);
-      ctx.transform(holder.uid, id);
+      ctx.transform(holder.uid, ctx.gd.baseIdOf(id), { returnItems: true });
     },
   },
   trap_copy_front_char: {

server/match/effectsMeta.js

@@ -440,6 +440,10 @@ export function makeCtx(m, ps, source, hook, ev = null) {
     counter: (k) => (Number.isFinite(ps.counters[k]) ? ps.counters[k] : 0),
     setCounter: (k, v) => { if (typeof k === 'string' && Number.isFinite(v)) ps.counters[k] = v; return ps.counters[k] ?? 0; },
     incCounter: (k, n = 1) => { if (typeof k !== 'string' || !Number.isFinite(n)) return 0; ps.counters[k] = (Number.isFinite(ps.counters[k]) ? ps.counters[k] : 0) + n; return ps.counters[k]; },
+    /** Per-piece counter of the current round (0 in a new round / for a new piece; an elite merged this round keeps the
+     *  highest of its copies' — PlayerState.pieceRoundCount). */
+    pieceCounter: (uid, k) => { const l = ps.find(uid); return l ? ps.pieceRoundCount(l.piece, k) : 0; },
+    incPieceCounter: (uid, k, n = 1) => { const l = ps.find(uid); return l ? ps.bumpPieceRoundCount(l.piece, k, n) : 0; },
 
     // ---- economy
     addFunds: (n, reason = '') => ps.addFunds(finiteInt(n), { reason }),
@@ -498,8 +502,9 @@ export function makeCtx(m, ps, source, hook, ev = null) {
       return m.dispatcher.triggerGarrisons(ps, l.piece, eventType, { asPiece: as ? as.piece : null, triggeredBy: source.key || null });
     },
     promote: (uid) => { const l = ps.find(uid); return l ? ps.promote(l.piece) : false; },
-    /** Replace a chess piece by another chess (keeps its tile when legal, keeps its equipment). */
-    transform: (uid, chessId) => { const l = ps.find(uid); if (!l || l.piece.kind !== 'chess') return null; const p = ps.transformChess(l.piece, chessId); return p ? view(p) : null; },
+    /** Replace a chess piece by another chess (keeps its tile when legal, keeps its equipment — `{ returnItems: true }`:
+     *  the equipment returns to the hand instead, as from a destroyed operator; PlayerState.transformChess). */
+    transform: (uid, chessId, opts = {}) => { const l = ps.find(uid); if (!l || l.piece.kind !== 'chess') return null; const p = ps.transformChess(l.piece, chessId, { returnItems: !!(opts && opts.returnItems) }); return p ? view(p) : null; },
     /** Normal item piece → its golden version in place. */
     upgradeItem: (uid) => { const l = ps.find(uid); return l && l.piece.kind === 'item' ? ps.upgradeItem(l.piece) : false; },
     /** Attach an owned hand/temp item to an owned chess without equip effects (copies, restores). */