@myclaw163/clawclaw-cli 0.6.66 → 0.6.67

package/src/strategies/goals/goal-root-strategy.ts

@@ -1,49 +1,49 @@
-import type { GameState } from '../../sdk/types.js';
-import type { BehaviorDecision, CustomModule, Strategy, StrategyContext } from '../types.js';
-import type { Goal } from './goal.js';
-import { GoalManager } from './goal-manager.js';
-
-export interface GoalRootStrategyOptions {
-  resetOnMeetingResume?: boolean;
-  customModules?: CustomModule[];
-  onUpdateRole?: (role: string) => void;
-}
-
-export class GoalRootStrategy implements Strategy {
-  readonly name: string;
-  private readonly mgr = new GoalManager();
-  private readonly makeTop: () => Goal;
-  private readonly resetOnMeetingResume: boolean;
-  private readonly modules: CustomModule[];
-  private readonly onUpdateRole?: (role: string) => void;
-
-  constructor(name: string, makeTop: () => Goal, options?: GoalRootStrategyOptions) {
-    this.name = name;
-    this.makeTop = makeTop;
-    this.resetOnMeetingResume = options?.resetOnMeetingResume ?? true;
-    this.modules = options?.customModules ?? [];
-    this.onUpdateRole = options?.onUpdateRole;
-    this.mgr.setTop(makeTop());
-  }
-
-  decide(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    if (this.mgr.getTop() === null) this.mgr.setTop(this.makeTop());
-    return this.mgr.tick(state, ctx);
-  }
-
-  onMeetingResume(): void {
-    if (this.resetOnMeetingResume) {
-      this.mgr.setTop(this.makeTop());
-      return;
-    }
-    this.mgr.getTop()?.onMeetingResume();
-  }
-
-  customModules(): CustomModule[] {
-    return this.modules;
-  }
-
-  updateRole(role: string): void {
-    this.onUpdateRole?.(role);
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import type { BehaviorDecision, CustomModule, Strategy, StrategyContext } from '../types.js';
+import type { Goal } from './goal.js';
+import { GoalManager } from './goal-manager.js';
+
+export interface GoalRootStrategyOptions {
+  resetOnMeetingResume?: boolean;
+  customModules?: CustomModule[];
+  onUpdateRole?: (role: string) => void;
+}
+
+export class GoalRootStrategy implements Strategy {
+  readonly name: string;
+  private readonly mgr = new GoalManager();
+  private readonly makeTop: () => Goal;
+  private readonly resetOnMeetingResume: boolean;
+  private readonly modules: CustomModule[];
+  private readonly onUpdateRole?: (role: string) => void;
+
+  constructor(name: string, makeTop: () => Goal, options?: GoalRootStrategyOptions) {
+    this.name = name;
+    this.makeTop = makeTop;
+    this.resetOnMeetingResume = options?.resetOnMeetingResume ?? true;
+    this.modules = options?.customModules ?? [];
+    this.onUpdateRole = options?.onUpdateRole;
+    this.mgr.setTop(makeTop());
+  }
+
+  decide(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    if (this.mgr.getTop() === null) this.mgr.setTop(this.makeTop());
+    return this.mgr.tick(state, ctx);
+  }
+
+  onMeetingResume(): void {
+    if (this.resetOnMeetingResume) {
+      this.mgr.setTop(this.makeTop());
+      return;
+    }
+    this.mgr.getTop()?.onMeetingResume();
+  }
+
+  customModules(): CustomModule[] {
+    return this.modules;
+  }
+
+  updateRole(role: string): void {
+    this.onUpdateRole?.(role);
+  }
+}

package/src/strategies/goals/goal.ts

@@ -1,28 +1,28 @@
-import type { GameState } from '../../sdk/types.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-
-export abstract class Goal {
-  subGoal: Goal | null = null;
-  priority = 0;
-
-  abstract tick(state: GameState, ctx: StrategyContext): BehaviorDecision[];
-
-  isFinish(_state: GameState, _ctx: StrategyContext): boolean {
-    return false;
-  }
-
-  onMeetingResume(): void {}
-
-  setSubGoal(child: Goal, priority: number): boolean {
-    if (this.subGoal !== null && this.subGoal.priority >= priority) {
-      return false;
-    }
-    child.priority = priority;
-    this.subGoal = child;
-    return true;
-  }
-
-  removeSubGoal(): void {
-    this.subGoal = null;
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+
+export abstract class Goal {
+  subGoal: Goal | null = null;
+  priority = 0;
+
+  abstract tick(state: GameState, ctx: StrategyContext): BehaviorDecision[];
+
+  isFinish(_state: GameState, _ctx: StrategyContext): boolean {
+    return false;
+  }
+
+  onMeetingResume(): void {}
+
+  setSubGoal(child: Goal, priority: number): boolean {
+    if (this.subGoal !== null && this.subGoal.priority >= priority) {
+      return false;
+    }
+    child.priority = priority;
+    this.subGoal = child;
+    return true;
+  }
+
+  removeSubGoal(): void {
+    this.subGoal = null;
+  }
+}

package/src/strategies/goals/hide-top.ts

@@ -1,197 +1,197 @@
-import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  canUseKill,
-  dist,
-  killCommitRange,
-  nonTeammatesVisible,
-  PROGRESS_INTERVAL_MS,
-  SHRIMP_KILL_RANGE,
-} from '../game-utils.js';
-import { nearestSafeHideSpot, type HideSpot } from '../hide-spots.js';
-import { planEscape, type EscapeOptions } from '../pathfind/escape-planner.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import { KeepAwayGoal } from './keep-away-goal.js';
-
-const SUB_PRIORITY = 0.5;
-const FLEE_KEY = 'hide-flee';
-/** 走到躲藏点这个距离内就算到位，原地潜伏不动。 */
-const REACHED_DISTANCE = 40;
-/** 威胁离开视野后，其位置仍在选点时被回避这么久——逃完不会立刻又选回威胁刚待过的点。 */
-const THREAT_MEMORY_MS = 5_000;
-/**
- * 「无处可逃」用的逃跑推演参数：与 KeepAwayGoal 同款保守模型（killRange=160，按枪虾/武士虾兜底）。
- * 理由是「连我自己用来逃跑的同一套推演都判定必被追上，逃就没意义，才出刀自保」，判据自洽。
- */
-const ESCAPE_OPTS: EscapeOptions = { killRange: SHRIMP_KILL_RANGE, steps: 7, beamWidth: 8, directions: 16, fieldRadius: 900 };
-
-type ProgressTier = 'flee' | 'relocate' | 'hidden';
-type ThreatPointResolver = () => Position[];
-
-/**
- * 躲藏点劳作循环：与 SafeTaskOrPatrolGoal 同构——planSpot 边逃边预重算（粘性、威胁硬排除），
- * tick 执行（走向躲藏点；到位则原地不动）。没有可用点时不动。
- */
-class HideSpotGoal extends Goal {
-  private current: HideSpot | null = null;
-
-  constructor(private readonly threatPoints: ThreatPointResolver) {
-    super();
-  }
-
-  get currentSpot(): HideSpot | null {
-    return this.current;
-  }
-
-  reset(): void {
-    this.current = null;
-  }
-
-  /** 重算并记住安全躲藏点，不发移动指令（逃跑期间可安全调用）。 */
-  planSpot(state: GameState, ctx: StrategyContext): HideSpot | null {
-    const spot = nearestSafeHideSpot(
-      { x: state.you.x, y: state.you.y },
-      this.threatPoints(),
-      { stickyTo: this.current, blockedTarget: ctx.blockedMoveTarget },
-    );
-    this.current = spot;
-    return spot;
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const spot = this.planSpot(state, ctx);
-    if (!spot) return [];
-    if (dist(state.you.x, state.you.y, spot.x, spot.y) <= REACHED_DISTANCE) return []; // 到位，原地潜伏
-    return [{ action: Action.move({ x: spot.x, y: spot.y }).withThinking(`前往躲藏点${spot.room}潜伏`) }];
-  }
-}
-
-/**
- * 躲藏策略顶层：在离线算好的藏身角落里选测地最近且不挨威胁的一个潜伏不动，直到有人进入视野。
- * 有人来就 ① 用 KeepAwayGoal 保持距离甩开，② 边逃边重算排除该威胁的新躲藏点——与 shrimp-memory 的
- * 「躲人 + 重选任务」同构，只是把任务换成躲藏点。蟹不躲队友（威胁统一用 nonTeammatesVisible 过滤队友）。
- *
- * killWhenCornered：被**单个**对手逼进出刀距离、且 planEscape 判定无路可逃时才出刀自保。
- * null = 按角色默认：蟹 / 章鱼开，武士虾 / 枪虾（及无刀角色）关。
- */
-export class HideTop extends Goal {
-  private readonly spotGoal = new HideSpotGoal(() => this.threatPointsFor());
-  private readonly recentThreats = new Map<string, { x: number; y: number; until: number }>();
-
-  constructor(private readonly killWhenCornered: boolean | null = null) {
-    super();
-  }
-
-  onMeetingResume(): void {
-    this.spotGoal.reset();
-    this.recentThreats.clear();
-    if (this.subGoal) this.removeSubGoal();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const visible = nonTeammatesVisible(state, ctx);
-    this.rememberThreats(visible);
-
-    // ── 被单个对手逼到死角且刀好 → 出刀自保（按角色 / 参数开关） ──
-    if (this.killEnabled(state) && canUseKill(state)) {
-      const victim = this.corneredVictim(state, visible);
-      if (victim) {
-        if (this.subGoal) this.removeSubGoal();
-        ctx.notifications.push(`被${victim.name}逼到无处可逃，出刀自保！`);
-        return [{ action: Action.kill(victim.name).withThinking(`被${victim.name}逼进出刀距离又逃不掉，先下手自保。`) }];
-      }
-    }
-
-    // ── 视野里有人 → 保持距离甩开 + 边逃边重算安全躲藏点 ──
-    if (visible.length > 0) {
-      this.spotGoal.planSpot(state, ctx); // 重算（排除威胁），逃完落到新点
-      this.setFlee();
-      this.emitProgress(state, ctx, visible, 'flee');
-      return [];
-    }
-
-    // ── 无人 → 走向最近安全躲藏点并潜伏 ──
-    if (this.subGoal) this.removeSubGoal();
-    const decisions = this.spotGoal.tick(state, ctx);
-    this.emitProgress(state, ctx, visible, decisions.length === 0 ? 'hidden' : 'relocate');
-    return decisions;
-  }
-
-  private killEnabled(state: GameState): boolean {
-    if (!roleHasKnife(state)) return false; // 无刀角色（普通虾）永不出刀，传 kill 参数也不行
-    return this.killWhenCornered ?? defaultKillWhenCornered(state);
-  }
-
-  /** 单个对手、进入出刀距离、且 planEscape 判定必被追上 → 返回该对手，否则 null。 */
-  private corneredVictim(state: GameState, visible: PlayerInfo[]): PlayerInfo | null {
-    // 只在单个追兵时自保：2 人以上当众动手仍会被另一人举报，逃跑（推演偏悲观，真人有视野盲区）反而更优。
-    if (visible.length !== 1) return null;
-    const target = visible[0];
-    const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-    if (d > killCommitRange(state.you.role)) return null;
-    const plan = planEscape({ x: state.you.x, y: state.you.y }, [{ x: target.x, y: target.y }], ESCAPE_OPTS);
-    return plan.caught ? target : null;
-  }
-
-  private setFlee(): void {
-    const worker = this.subGoal;
-    if (worker instanceof KeepAwayGoal && worker.key === FLEE_KEY) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KeepAwayGoal(FLEE_KEY, (s, c) => nonTeammatesVisible(s, c), {
-      threatRadius: Infinity,
-      noun: '靠近的人',
-    }), SUB_PRIORITY);
-  }
-
-  /** 记住近期见过的非队友位置（按名字去重 + TTL），供威胁离开视野后选点继续回避。 */
-  private rememberThreats(visible: PlayerInfo[]): void {
-    const now = Date.now();
-    for (const p of visible) {
-      const key = p.name || String(p.seat ?? '');
-      if (key) this.recentThreats.set(key, { x: p.x, y: p.y, until: now + THREAT_MEMORY_MS });
-    }
-    for (const [key, v] of this.recentThreats) if (v.until <= now) this.recentThreats.delete(key);
-  }
-
-  private threatPointsFor(): Position[] {
-    const now = Date.now();
-    const out: Position[] = [];
-    for (const v of this.recentThreats.values()) if (v.until > now) out.push({ x: v.x, y: v.y });
-    return out;
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: ProgressTier): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知';
-    const spot = this.spotGoal.currentSpot;
-    let msg = `[进度] 当前在${room}`;
-    if (tier === 'flee') {
-      const names = visible.map(p => p.name).join('、');
-      msg += `，${names}靠近，保持距离甩开${spot ? `，改藏到${spot.room}` : ''}。`;
-    } else if (tier === 'relocate') {
-      msg += spot ? `，前往躲藏点${spot.room}潜伏。` : '，寻找躲藏点。';
-    } else {
-      msg += spot ? `，已在${spot.room}潜伏，按兵不动。` : '，附近无可用躲藏点，原地待命。';
-    }
-    ctx.notifications.push(msg);
-  }
-}
-
-/** 是否带刀（有击杀能力）：蟹 / 章鱼 / 武士虾 / 枪虾。普通虾无刀。 */
-function roleHasKnife(state: GameState): boolean {
-  const role = state.you.role ?? '';
-  const faction = state.you.faction ?? '';
-  return faction === 'crab' || role.includes('crab') || role.includes('octopus')
-    || role === 'shrimp_warrior' || role === 'shrimp_pistol';
-}
-
-/** 角色默认是否「死角自保出刀」：蟹 / 章鱼开；武士虾 / 枪虾及其余关。 */
-function defaultKillWhenCornered(state: GameState): boolean {
-  const role = state.you.role ?? '';
-  const faction = state.you.faction ?? '';
-  return faction === 'crab' || role.includes('crab') || role.includes('octopus');
-}
+import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  dist,
+  killCommitRange,
+  nonTeammatesVisible,
+  PROGRESS_INTERVAL_MS,
+  SHRIMP_KILL_RANGE,
+} from '../game-utils.js';
+import { nearestSafeHideSpot, type HideSpot } from '../hide-spots.js';
+import { planEscape, type EscapeOptions } from '../pathfind/escape-planner.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal } from './keep-away-goal.js';
+
+const SUB_PRIORITY = 0.5;
+const FLEE_KEY = 'hide-flee';
+/** 走到躲藏点这个距离内就算到位，原地潜伏不动。 */
+const REACHED_DISTANCE = 40;
+/** 威胁离开视野后，其位置仍在选点时被回避这么久——逃完不会立刻又选回威胁刚待过的点。 */
+const THREAT_MEMORY_MS = 5_000;
+/**
+ * 「无处可逃」用的逃跑推演参数：与 KeepAwayGoal 同款保守模型（killRange=160，按枪虾/武士虾兜底）。
+ * 理由是「连我自己用来逃跑的同一套推演都判定必被追上，逃就没意义，才出刀自保」，判据自洽。
+ */
+const ESCAPE_OPTS: EscapeOptions = { killRange: SHRIMP_KILL_RANGE, steps: 7, beamWidth: 8, directions: 16, fieldRadius: 900 };
+
+type ProgressTier = 'flee' | 'relocate' | 'hidden';
+type ThreatPointResolver = () => Position[];
+
+/**
+ * 躲藏点劳作循环：与 SafeTaskOrPatrolGoal 同构——planSpot 边逃边预重算（粘性、威胁硬排除），
+ * tick 执行（走向躲藏点；到位则原地不动）。没有可用点时不动。
+ */
+class HideSpotGoal extends Goal {
+  private current: HideSpot | null = null;
+
+  constructor(private readonly threatPoints: ThreatPointResolver) {
+    super();
+  }
+
+  get currentSpot(): HideSpot | null {
+    return this.current;
+  }
+
+  reset(): void {
+    this.current = null;
+  }
+
+  /** 重算并记住安全躲藏点，不发移动指令（逃跑期间可安全调用）。 */
+  planSpot(state: GameState, ctx: StrategyContext): HideSpot | null {
+    const spot = nearestSafeHideSpot(
+      { x: state.you.x, y: state.you.y },
+      this.threatPoints(),
+      { stickyTo: this.current, blockedTarget: ctx.blockedMoveTarget },
+    );
+    this.current = spot;
+    return spot;
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const spot = this.planSpot(state, ctx);
+    if (!spot) return [];
+    if (dist(state.you.x, state.you.y, spot.x, spot.y) <= REACHED_DISTANCE) return []; // 到位，原地潜伏
+    return [{ action: Action.move({ x: spot.x, y: spot.y }).withThinking(`前往躲藏点${spot.room}潜伏`) }];
+  }
+}
+
+/**
+ * 躲藏策略顶层：在离线算好的藏身角落里选测地最近且不挨威胁的一个潜伏不动，直到有人进入视野。
+ * 有人来就 ① 用 KeepAwayGoal 保持距离甩开，② 边逃边重算排除该威胁的新躲藏点——与 shrimp-memory 的
+ * 「躲人 + 重选任务」同构，只是把任务换成躲藏点。蟹不躲队友（威胁统一用 nonTeammatesVisible 过滤队友）。
+ *
+ * killWhenCornered：被**单个**对手逼进出刀距离、且 planEscape 判定无路可逃时才出刀自保。
+ * null = 按角色默认：蟹 / 章鱼开，武士虾 / 枪虾（及无刀角色）关。
+ */
+export class HideTop extends Goal {
+  private readonly spotGoal = new HideSpotGoal(() => this.threatPointsFor());
+  private readonly recentThreats = new Map<string, { x: number; y: number; until: number }>();
+
+  constructor(private readonly killWhenCornered: boolean | null = null) {
+    super();
+  }
+
+  onMeetingResume(): void {
+    this.spotGoal.reset();
+    this.recentThreats.clear();
+    if (this.subGoal) this.removeSubGoal();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    this.rememberThreats(visible);
+
+    // ── 被单个对手逼到死角且刀好 → 出刀自保（按角色 / 参数开关） ──
+    if (this.killEnabled(state) && canUseKill(state)) {
+      const victim = this.corneredVictim(state, visible);
+      if (victim) {
+        if (this.subGoal) this.removeSubGoal();
+        ctx.notifications.push(`被${victim.name}逼到无处可逃，出刀自保！`);
+        return [{ action: Action.kill(victim.name).withThinking(`被${victim.name}逼进出刀距离又逃不掉，先下手自保。`) }];
+      }
+    }
+
+    // ── 视野里有人 → 保持距离甩开 + 边逃边重算安全躲藏点 ──
+    if (visible.length > 0) {
+      this.spotGoal.planSpot(state, ctx); // 重算（排除威胁），逃完落到新点
+      this.setFlee();
+      this.emitProgress(state, ctx, visible, 'flee');
+      return [];
+    }
+
+    // ── 无人 → 走向最近安全躲藏点并潜伏 ──
+    if (this.subGoal) this.removeSubGoal();
+    const decisions = this.spotGoal.tick(state, ctx);
+    this.emitProgress(state, ctx, visible, decisions.length === 0 ? 'hidden' : 'relocate');
+    return decisions;
+  }
+
+  private killEnabled(state: GameState): boolean {
+    if (!roleHasKnife(state)) return false; // 无刀角色（普通虾）永不出刀，传 kill 参数也不行
+    return this.killWhenCornered ?? defaultKillWhenCornered(state);
+  }
+
+  /** 单个对手、进入出刀距离、且 planEscape 判定必被追上 → 返回该对手，否则 null。 */
+  private corneredVictim(state: GameState, visible: PlayerInfo[]): PlayerInfo | null {
+    // 只在单个追兵时自保：2 人以上当众动手仍会被另一人举报，逃跑（推演偏悲观，真人有视野盲区）反而更优。
+    if (visible.length !== 1) return null;
+    const target = visible[0];
+    const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
+    if (d > killCommitRange(state.you.role)) return null;
+    const plan = planEscape({ x: state.you.x, y: state.you.y }, [{ x: target.x, y: target.y }], ESCAPE_OPTS);
+    return plan.caught ? target : null;
+  }
+
+  private setFlee(): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === FLEE_KEY) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(FLEE_KEY, (s, c) => nonTeammatesVisible(s, c), {
+      threatRadius: Infinity,
+      noun: '靠近的人',
+    }), SUB_PRIORITY);
+  }
+
+  /** 记住近期见过的非队友位置（按名字去重 + TTL），供威胁离开视野后选点继续回避。 */
+  private rememberThreats(visible: PlayerInfo[]): void {
+    const now = Date.now();
+    for (const p of visible) {
+      const key = p.name || String(p.seat ?? '');
+      if (key) this.recentThreats.set(key, { x: p.x, y: p.y, until: now + THREAT_MEMORY_MS });
+    }
+    for (const [key, v] of this.recentThreats) if (v.until <= now) this.recentThreats.delete(key);
+  }
+
+  private threatPointsFor(): Position[] {
+    const now = Date.now();
+    const out: Position[] = [];
+    for (const v of this.recentThreats.values()) if (v.until > now) out.push({ x: v.x, y: v.y });
+    return out;
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: ProgressTier): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    const spot = this.spotGoal.currentSpot;
+    let msg = `[进度] 当前在${room}`;
+    if (tier === 'flee') {
+      const names = visible.map(p => p.name).join('、');
+      msg += `，${names}靠近，保持距离甩开${spot ? `，改藏到${spot.room}` : ''}。`;
+    } else if (tier === 'relocate') {
+      msg += spot ? `，前往躲藏点${spot.room}潜伏。` : '，寻找躲藏点。';
+    } else {
+      msg += spot ? `，已在${spot.room}潜伏，按兵不动。` : '，附近无可用躲藏点，原地待命。';
+    }
+    ctx.notifications.push(msg);
+  }
+}
+
+/** 是否带刀（有击杀能力）：蟹 / 章鱼 / 武士虾 / 枪虾。普通虾无刀。 */
+function roleHasKnife(state: GameState): boolean {
+  const role = state.you.role ?? '';
+  const faction = state.you.faction ?? '';
+  return faction === 'crab' || role.includes('crab') || role.includes('octopus')
+    || role === 'shrimp_warrior' || role === 'shrimp_pistol';
+}
+
+/** 角色默认是否「死角自保出刀」：蟹 / 章鱼开；武士虾 / 枪虾及其余关。 */
+function defaultKillWhenCornered(state: GameState): boolean {
+  const role = state.you.role ?? '';
+  const faction = state.you.faction ?? '';
+  return faction === 'crab' || role.includes('crab') || role.includes('octopus');
+}