@myclaw163/clawclaw-cli 0.6.70 → 0.6.74

package/src/strategies/goals/lone-kill-task-top.ts

@@ -1,133 +1,133 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import {
-  emergencyRushDecision,
-  firstAvailableTask,
-  killCooldownSecs,
-  killYieldsToEmergencyRepair,
-  nonTeammatesVisible,
-  PatrolState,
-  PROGRESS_INTERVAL_MS,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import { LoneKillCore } from './lone-kill-core.js';
-import { LoneKillGoal } from './lone-kill-goal.js';
-import { WanderTaskGoal } from './wander-task-goal.js';
-import { emitLeaf, EMERGENCY_GOAL_PRIORITY, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
-import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-octopus-reflexes.js';
-
-/**
- * 章鱼（中立带刀）的「落单猎杀 + 任务伪装」编排 top。本身不产决策，每 tick 只判定该走哪个行为、
- * 把对应**叶子子目标**挂为唯一子目标（产出动作的是叶子，优先级标注紧急/游走，供 ConversationGoal 判断）：
- *
- * 0. 反射（crab-octopus-reflexes，URGENT，抢在落单猎杀编排之前）：落单非队友贴脸(出刀范围内)且刀好 →
- *    立刻出刀；否则有尸体且附近有非队友 → 报警/靠近报警（不管尸体是谁造成的）。
- * 1. 落单猎杀（LoneKillGoal，URGENT）：core.assess() 判 hunt（刀好且有落单目标）→ 叶子 pursue() 靠近 / 出刀。
- *    刀在冷却时 assess 返回 idle，不追不等，直接下沉到任务伪装。**残局抢修期例外**：落单目标紧挨紧急维修点
- *    （同房间或避尸距离内，killYieldsToEmergencyRepair）时跳过反射刀/落单猎杀，让位给第 2 步去修——虾群都
- *    涌向维修点，在那儿动手必被围观、还会撇下维修把破坏倒计时取胜线让给蟹；远离维修点的目标照常猎杀。
- * 2. 残局抢修紧急任务（EMERGENCY，仅已知存活≤6）：低于落单猎杀（击杀优先），高于伪装任务——
- *    紧急任务超时则蟹阵营直接获胜，中立章鱼靠活到最后取胜，故残局抢着把维修做掉、掐断蟹的破坏取胜线。
- * 3. 任务伪装 / 巡逻（WanderTaskGoal，WANDER）：做已分配的伪装任务（排除当前紧急任务，那个走第 2 步），
- *    跳过紧挨已知尸体（含看见过、已离开视野的）的任务，没任务就按房间巡逻，绝不停在原地。
- */
-export class LoneKillTaskTop extends Goal {
-  private readonly killCore = new LoneKillCore();
-  private readonly patrol = new PatrolState();
-  private readonly loneKillGoal = new LoneKillGoal(this.killCore);
-  private readonly wanderGoal = new WanderTaskGoal(
-    // 排除当前紧急任务：它由 tick 里的残局抢修分支按 EMERGENCY 优先级处理，不在此当普通伪装任务做。
-    (state, ctx) => firstAvailableTask(
-      ctx.taskData,
-      t => t.task_name !== ctx.emergency?.task_name,
-      undefined,
-      ctx.blockedMoveTarget,
-      ctx.knownCorpses,
-    ),
-    () => this.killCore.patrolStopOnPlayer(),
-    this.patrol,
-  );
-
-  onMeetingResume(): void {
-    this.killCore.reset();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    // 残局抢修期：紧急维修点附近不杀人。虾群都涌向维修点，在那儿动手必被围观、还会撇下维修把破坏
-    // 倒计时取胜线让给蟹。落单目标紧挨维修点（同房间或避尸距离内）时跳过反射刀与落单猎杀，让位给下面
-    // 的抢修分支；远离维修点的目标照常猎杀（抢修仍低于猎杀的设定不变）。
-    const yieldsToRepair = (t: PlayerInfo) => killYieldsToEmergencyRepair(state, ctx, t);
-
-    const immediateKill = immediateLoneKillDecision(state, ctx, yieldsToRepair);
-    if (immediateKill) {
-      this.emitProgress(state, ctx, false);
-      return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
-    }
-
-    const corpseReport = corpseReportWithNonTeammate(state, ctx);
-    if (corpseReport) {
-      this.emitProgress(state, ctx, false);
-      return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
-    }
-
-    const target = this.killCore.assess(state, ctx);
-    const sparedNearRepair = target.kind === 'hunt' && yieldsToRepair(target.target);
-    if (target.kind === 'hunt' && !sparedNearRepair) {
-      this.emitProgress(state, ctx, false);
-      this.loneKillGoal.setTarget(target.target);
-      return setBehavior(this, this.loneKillGoal, URGENT_GOAL_PRIORITY);
-    }
-
-    // 残局抢修紧急任务（已知存活≤6）：高于伪装任务，低于上面的落单猎杀/反射。
-    const emergency = emergencyRushDecision(state, ctx);
-    if (emergency) {
-      this.emitProgress(state, ctx, true, sparedNearRepair ? target.target.name : null);
-      return emitLeaf(this, [emergency], EMERGENCY_GOAL_PRIORITY);
-    }
-
-    this.emitProgress(state, ctx, false);
-    return setBehavior(this, this.wanderGoal, WANDER_GOAL_PRIORITY);
-  }
-
-  private emitProgress(
-    state: GameState,
-    ctx: StrategyContext,
-    emergencyRush: boolean,
-    sparedNearRepair: string | null = null,
-  ): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知';
-    if (emergencyRush) {
-      const name = ctx.emergency?.task_name ?? '紧急维修';
-      let msg = `[进度] 当前在${room}，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`;
-      if (sparedNearRepair) {
-        msg += ` 落单目标${sparedNearRepair}就在维修点附近，先修不杀，免得在虾群涌入的维修点暴露自己。`;
-      }
-      ctx.notifications.push(msg);
-      return;
-    }
-    const cd = killCooldownSecs(state);
-    const killsRemaining = state.you.kills_remaining;
-    const nonTeammates = nonTeammatesVisible(state, ctx);
-
-    let msg = `[进度] 当前在${room}`;
-    if (nonTeammates.length === 0) {
-      msg += '，视野内没有落单目标，继续做任务伪装。';
-    } else if (nonTeammates.length === 1) {
-      msg += `，视野内发现落单目标${nonTeammates[0].name}。`;
-      if (cd > 0) msg += `攻击冷却中(${cd}s)，先做任务、冷却好再下手。`;
-      if (killsRemaining === 0) msg += '出刀次数已用完，继续做任务伪装。';
-    } else {
-      msg += `，视野内有${nonTeammates.length}人，不适合动手。`;
-    }
-
-    const completed = ctx.taskData.filter(t => t.status === 'completed').length;
-    const total = ctx.taskData.length;
-    msg += ` 任务进度 ${completed}/${total}。`;
-
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import {
+  emergencyRushDecision,
+  firstAvailableTask,
+  killCooldownSecs,
+  killYieldsToEmergencyRepair,
+  nonTeammatesVisible,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { LoneKillCore } from './lone-kill-core.js';
+import { LoneKillGoal } from './lone-kill-goal.js';
+import { WanderTaskGoal } from './wander-task-goal.js';
+import { emitLeaf, EMERGENCY_GOAL_PRIORITY, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
+import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-octopus-reflexes.js';
+
+/**
+ * 章鱼（中立带刀）的「落单猎杀 + 任务伪装」编排 top。本身不产决策，每 tick 只判定该走哪个行为、
+ * 把对应**叶子子目标**挂为唯一子目标（产出动作的是叶子，优先级标注紧急/游走，供 ConversationGoal 判断）：
+ *
+ * 0. 反射（crab-octopus-reflexes，URGENT，抢在落单猎杀编排之前）：落单非队友贴脸(出刀范围内)且刀好 →
+ *    立刻出刀；否则有尸体且附近有非队友 → 报警/靠近报警（不管尸体是谁造成的）。
+ * 1. 落单猎杀（LoneKillGoal，URGENT）：core.assess() 判 hunt（刀好且有落单目标）→ 叶子 pursue() 靠近 / 出刀。
+ *    刀在冷却时 assess 返回 idle，不追不等，直接下沉到任务伪装。**残局抢修期例外**：落单目标紧挨紧急维修点
+ *    （同房间或避尸距离内，killYieldsToEmergencyRepair）时跳过反射刀/落单猎杀，让位给第 2 步去修——虾群都
+ *    涌向维修点，在那儿动手必被围观、还会撇下维修把破坏倒计时取胜线让给蟹；远离维修点的目标照常猎杀。
+ * 2. 残局抢修紧急任务（EMERGENCY，仅已知存活≤6）：低于落单猎杀（击杀优先），高于伪装任务——
+ *    紧急任务超时则蟹阵营直接获胜，中立章鱼靠活到最后取胜，故残局抢着把维修做掉、掐断蟹的破坏取胜线。
+ * 3. 任务伪装 / 巡逻（WanderTaskGoal，WANDER）：做已分配的伪装任务（排除当前紧急任务，那个走第 2 步），
+ *    跳过紧挨已知尸体（含看见过、已离开视野的）的任务，没任务就按房间巡逻，绝不停在原地。
+ */
+export class LoneKillTaskTop extends Goal {
+  private readonly killCore = new LoneKillCore();
+  private readonly patrol = new PatrolState();
+  private readonly loneKillGoal = new LoneKillGoal(this.killCore);
+  private readonly wanderGoal = new WanderTaskGoal(
+    // 排除当前紧急任务：它由 tick 里的残局抢修分支按 EMERGENCY 优先级处理，不在此当普通伪装任务做。
+    (state, ctx) => firstAvailableTask(
+      ctx.taskData,
+      t => t.task_name !== ctx.emergency?.task_name,
+      undefined,
+      ctx.blockedMoveTarget,
+      ctx.knownCorpses,
+    ),
+    () => this.killCore.patrolStopOnPlayer(),
+    this.patrol,
+  );
+
+  onMeetingResume(): void {
+    this.killCore.reset();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    // 残局抢修期：紧急维修点附近不杀人。虾群都涌向维修点，在那儿动手必被围观、还会撇下维修把破坏
+    // 倒计时取胜线让给蟹。落单目标紧挨维修点（同房间或避尸距离内）时跳过反射刀与落单猎杀，让位给下面
+    // 的抢修分支；远离维修点的目标照常猎杀（抢修仍低于猎杀的设定不变）。
+    const yieldsToRepair = (t: PlayerInfo) => killYieldsToEmergencyRepair(state, ctx, t);
+
+    const immediateKill = immediateLoneKillDecision(state, ctx, yieldsToRepair);
+    if (immediateKill) {
+      this.emitProgress(state, ctx, false);
+      return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
+    }
+
+    const corpseReport = corpseReportWithNonTeammate(state, ctx);
+    if (corpseReport) {
+      this.emitProgress(state, ctx, false);
+      return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
+    }
+
+    const target = this.killCore.assess(state, ctx);
+    const sparedNearRepair = target.kind === 'hunt' && yieldsToRepair(target.target);
+    if (target.kind === 'hunt' && !sparedNearRepair) {
+      this.emitProgress(state, ctx, false);
+      this.loneKillGoal.setTarget(target.target);
+      return setBehavior(this, this.loneKillGoal, URGENT_GOAL_PRIORITY);
+    }
+
+    // 残局抢修紧急任务（已知存活≤6）：高于伪装任务，低于上面的落单猎杀/反射。
+    const emergency = emergencyRushDecision(state, ctx);
+    if (emergency) {
+      this.emitProgress(state, ctx, true, sparedNearRepair ? target.target.name : null);
+      return emitLeaf(this, [emergency], EMERGENCY_GOAL_PRIORITY);
+    }
+
+    this.emitProgress(state, ctx, false);
+    return setBehavior(this, this.wanderGoal, WANDER_GOAL_PRIORITY);
+  }
+
+  private emitProgress(
+    state: GameState,
+    ctx: StrategyContext,
+    emergencyRush: boolean,
+    sparedNearRepair: string | null = null,
+  ): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    if (emergencyRush) {
+      const name = ctx.emergency?.task_name ?? '紧急维修';
+      let msg = `[进度] 当前在${room}，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`;
+      if (sparedNearRepair) {
+        msg += ` 落单目标${sparedNearRepair}就在维修点附近，先修不杀，免得在虾群涌入的维修点暴露自己。`;
+      }
+      ctx.notifications.push(msg);
+      return;
+    }
+    const cd = killCooldownSecs(state);
+    const killsRemaining = state.you.kills_remaining;
+    const nonTeammates = nonTeammatesVisible(state, ctx);
+
+    let msg = `[进度] 当前在${room}`;
+    if (nonTeammates.length === 0) {
+      msg += '，视野内没有落单目标，继续做任务伪装。';
+    } else if (nonTeammates.length === 1) {
+      msg += `，视野内发现落单目标${nonTeammates[0].name}。`;
+      if (cd > 0) msg += `攻击冷却中(${cd}s)，先做任务、冷却好再下手。`;
+      if (killsRemaining === 0) msg += '出刀次数已用完，继续做任务伪装。';
+    } else {
+      msg += `，视野内有${nonTeammates.length}人，不适合动手。`;
+    }
+
+    const completed = ctx.taskData.filter(t => t.status === 'completed').length;
+    const total = ctx.taskData.length;
+    msg += ` 任务进度 ${completed}/${total}。`;
+
+    ctx.notifications.push(msg);
+  }
+}

package/src/strategies/goals/move-room-goal.ts

@@ -1,60 +1,60 @@
-import type { GameState } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import { isInRoom, PROGRESS_INTERVAL_MS, resolveRoom } from '../game-utils.js';
-import type { BehaviorDecision, RoomTarget, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-
-export type RoomArrival = (state: GameState, target: RoomTarget) => boolean;
-
-const arrivedByRoomName: RoomArrival = (state, target) => isInRoom(target.name, state);
-
-export interface MoveRoomGoalOptions {
-  emitProgress?: boolean;
-  stopOnPlayer?: boolean;
-}
-
-export class MoveRoomGoal extends Goal {
-  constructor(
-    public readonly room: string,
-    private readonly hasArrived: RoomArrival = arrivedByRoomName,
-    private readonly options: MoveRoomGoalOptions = {},
-  ) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const target = resolveRoom(this.room, ctx);
-    this.emitProgress(state, ctx, target);
-    if (!target || this.hasArrived(state, target)) return [];
-    return [{ action: Action.move({ x: target.x, y: target.y }, this.options.stopOnPlayer ?? false) }];
-  }
-
-  isFinish(state: GameState, ctx: StrategyContext): boolean {
-    const target = resolveRoom(this.room, ctx);
-    if (target == null) return false;
-    const finished = this.hasArrived(state, target);
-    if (finished) this.emitProgress(state, ctx, target);
-    return finished;
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext, target: RoomTarget | null): void {
-    if (this.options.emitProgress === false) return;
-
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知房间';
-    if (!target) {
-      const available = ctx.rooms.map(room => room.name).join(', ') || '地图尚未加载';
-      ctx.notifications.push(`[进度] 当前在${room}，找不到目标房间「${this.room}」。可用房间: ${available}。`);
-      return;
-    }
-
-    if (state.you.room === target.name) {
-      ctx.notifications.push(`[进度] 已到达目标房间「${target.name}」，当前位置${room}。`);
-    } else {
-      ctx.notifications.push(`[进度] 当前在${room}，正在前往目标房间「${target.name}」。`);
-    }
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import { isInRoom, PROGRESS_INTERVAL_MS, resolveRoom } from '../game-utils.js';
+import type { BehaviorDecision, RoomTarget, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+export type RoomArrival = (state: GameState, target: RoomTarget) => boolean;
+
+const arrivedByRoomName: RoomArrival = (state, target) => isInRoom(target.name, state);
+
+export interface MoveRoomGoalOptions {
+  emitProgress?: boolean;
+  stopOnPlayer?: boolean;
+}
+
+export class MoveRoomGoal extends Goal {
+  constructor(
+    public readonly room: string,
+    private readonly hasArrived: RoomArrival = arrivedByRoomName,
+    private readonly options: MoveRoomGoalOptions = {},
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const target = resolveRoom(this.room, ctx);
+    this.emitProgress(state, ctx, target);
+    if (!target || this.hasArrived(state, target)) return [];
+    return [{ action: Action.move({ x: target.x, y: target.y }, this.options.stopOnPlayer ?? false) }];
+  }
+
+  isFinish(state: GameState, ctx: StrategyContext): boolean {
+    const target = resolveRoom(this.room, ctx);
+    if (target == null) return false;
+    const finished = this.hasArrived(state, target);
+    if (finished) this.emitProgress(state, ctx, target);
+    return finished;
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, target: RoomTarget | null): void {
+    if (this.options.emitProgress === false) return;
+
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知房间';
+    if (!target) {
+      const available = ctx.rooms.map(room => room.name).join(', ') || '地图尚未加载';
+      ctx.notifications.push(`[进度] 当前在${room}，找不到目标房间「${this.room}」。可用房间: ${available}。`);
+      return;
+    }
+
+    if (state.you.room === target.name) {
+      ctx.notifications.push(`[进度] 已到达目标房间「${target.name}」，当前位置${room}。`);
+    } else {
+      ctx.notifications.push(`[进度] 当前在${room}，正在前往目标房间「${target.name}」。`);
+    }
+  }
+}

package/src/strategies/goals/normal-shrimp-top.test.ts

@@ -1,80 +1,80 @@
-import { describe, expect, it } from 'vitest';
-import type { GameState } from '../../sdk/types.js';
-import type { StrategyContext } from '../types.js';
-import { KeepAwayGoal } from './keep-away-goal.js';
-import { NormalShrimpTop } from './normal-shrimp-top.js';
-
-function stateWithStranger(distance: number): GameState {
-  return {
-    phase: 'wandering',
-    tick: 1,
-    you: {
-      name: 'shrimp',
-      x: 0,
-      y: 0,
-      room: 'control',
-      role: 'shrimp',
-      faction: 'lobster',
-      is_alive: true,
-    },
-    your_tasks: [],
-    players: [{ name: 'stranger', seat: 2, x: distance, y: 0, room: 'control', distance }],
-    all_players: [{ name: 'stranger', seat: 2, role: 'unknown', is_alive: true }],
-    corpses: [],
-    stale: false,
-  };
-}
-
-function context(overrides: Partial<StrategyContext> = {}): StrategyContext {
-  return {
-    taskData: [],
-    emergency: null,
-    taskLocalBlockedUntil: 0,
-    reportCorpseTarget: null,
-    reportBlockedUntil: 0,
-    notifications: [],
-    lastProgressNotifyAt: Date.now(),
-    teammates: new Set(),
-    alarmDone: false,
-    rooms: [],
-    playerNamesBySeat: { '2': 'stranger' },
-    forcePatrolAdvance: false,
-    blockedMoveTarget: null,
-    mySeat: 1,
-    speechNotifications: [],
-    agentAlerts: [],
-    ...overrides,
-  };
-}
-
-describe('NormalShrimpTop vision thresholds', () => {
-  it('starts backing off at the shrimp vision range', () => {
-    const top = new NormalShrimpTop();
-
-    top.tick(stateWithStranger(270), context());
-
-    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
-  });
-
-  it('does not start backing off just outside the vision enter range', () => {
-    const top = new NormalShrimpTop();
-
-    top.tick(stateWithStranger(271), context());
-
-    expect(top.subGoal).not.toBeInstanceOf(KeepAwayGoal);
-  });
-
-  it('keeps backing off through the vision exit buffer', () => {
-    const top = new NormalShrimpTop();
-    const ctx = context();
-
-    top.tick(stateWithStranger(270), ctx);
-    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
-
-    top.tick(stateWithStranger(299), ctx);
-    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
-
-    top.tick(stateWithStranger(300), ctx);
-    expect(top.subGoal).not.toBeInstanceOf(KeepAwayGoal);
-  });
-});
+import { describe, expect, it } from 'vitest';
+import type { GameState } from '../../sdk/types.js';
+import type { StrategyContext } from '../types.js';
+import { KeepAwayGoal } from './keep-away-goal.js';
+import { NormalShrimpTop } from './normal-shrimp-top.js';
+
+function stateWithStranger(distance: number): GameState {
+  return {
+    phase: 'wandering',
+    tick: 1,
+    you: {
+      name: 'shrimp',
+      x: 0,
+      y: 0,
+      room: 'control',
+      role: 'shrimp',
+      faction: 'lobster',
+      is_alive: true,
+    },
+    your_tasks: [],
+    players: [{ name: 'stranger', seat: 2, x: distance, y: 0, room: 'control', distance }],
+    all_players: [{ name: 'stranger', seat: 2, role: 'unknown', is_alive: true }],
+    corpses: [],
+    stale: false,
+  };
+}
+
+function context(overrides: Partial<StrategyContext> = {}): StrategyContext {
+  return {
+    taskData: [],
+    emergency: null,
+    taskLocalBlockedUntil: 0,
+    reportCorpseTarget: null,
+    reportBlockedUntil: 0,
+    notifications: [],
+    lastProgressNotifyAt: Date.now(),
+    teammates: new Set(),
+    alarmDone: false,
+    rooms: [],
+    playerNamesBySeat: { '2': 'stranger' },
+    forcePatrolAdvance: false,
+    blockedMoveTarget: null,
+    mySeat: 1,
+    speechNotifications: [],
+    agentAlerts: [],
+    ...overrides,
+  };
+}
+
+describe('NormalShrimpTop vision thresholds', () => {
+  it('starts backing off at the shrimp vision range', () => {
+    const top = new NormalShrimpTop();
+
+    top.tick(stateWithStranger(270), context());
+
+    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
+  });
+
+  it('does not start backing off just outside the vision enter range', () => {
+    const top = new NormalShrimpTop();
+
+    top.tick(stateWithStranger(271), context());
+
+    expect(top.subGoal).not.toBeInstanceOf(KeepAwayGoal);
+  });
+
+  it('keeps backing off through the vision exit buffer', () => {
+    const top = new NormalShrimpTop();
+    const ctx = context();
+
+    top.tick(stateWithStranger(270), ctx);
+    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
+
+    top.tick(stateWithStranger(299), ctx);
+    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
+
+    top.tick(stateWithStranger(300), ctx);
+    expect(top.subGoal).not.toBeInstanceOf(KeepAwayGoal);
+  });
+});