第07章 - 玩法模板库详解

// packages/templates/src/scrub.logic.ts
export function scrubAt(
  state: ScrubState,
  level: ScrubLevel,
  x: number,
  y: number,
): ScrubHit {
  let hit: (typeof level.spots)[number] | null = null;
  let best = Number.POSITIVE_INFINITY;
  for (const spot of level.spots) {
    const radius = 0.11 * spot.size;
    const dist = Math.hypot(x - spot.x, y - spot.y);
    if (dist <= radius && dist < best) { best = dist; hit = spot; }
  }
  if (!hit) return { state, hitId: null, cleanedNow: [] };
  if ((state.cleaned[hit.id] ?? 0) >= level.rubs) return { state, hitId: hit.id, cleanedNow: [] };
  const cleanedNow: string[] = [];
  const cleaned = { ...state.cleaned, [hit.id]: (state.cleaned[hit.id] ?? 0) + 1 };
  if (cleaned[hit.id]! >= level.rubs) cleanedNow.push(hit.id);
  return { state: { ...state, cleaned }, hitId: hit.id, cleanedNow };
}

export function createScrubScene(ctx: GameContext, level: ScrubLevel): Phaser.Types.Scenes.SceneType {
  return class ScrubScene extends BaseScene {
    private readonly level = level;
    constructor() { super(SCENE_KEYS.scrub, ctx); }
    create(): void {
      this.ctx.emit('scene:enter', { scene: SCENE_KEYS.scrub });
      this.ctx.emit('session:start', { at: this.ctx.services.now() });
      // …
    }
  };
}

// packages/templates/src/core.ts
/**
 * 场景走 '@bamboo/templates/<id>' 子路径，一个游戏只 import 自己用到的场景，
 * 避免 barrel 把全部模板拖进共享 chunk（CHAGS 实测约 90 KB gzip 的教训）。
 */
export { defineGame } from './defineGame';
export type { GameDefinition } from './defineGame';
export * from './layout';

/** 逻辑分辨率 750×1334（竖屏）；Phaser 的 Scale.FIT 负责适配真机 */
export const DESIGN = { width: 750, height: 1334 } as const;

export const SCRUB_LAYOUT = {
  /** 内容 JSON 的 spots 0–1 坐标映射到这个矩形（刷牙=牙齿区，洗手=手部区，洗澡=身体区） */
  stage: { x: 250, y: 760, w: 260, h: 220 } satisfies Rect,
  /** 冲水 / 擦干按钮中心（finish 全部完成后才可点） */
  finish: { x: 375, y: 1215 } satisfies Point,
  /** 工具初始位置（拖拽起点） */
  toolHome: { x: 110, y: 1190 } satisfies Point,
} as const;

export interface ScrubState {
  cleaned: Record<string, number>;
  finishTaps: number;
  done: boolean;
}

export function scrubProgress(state: ScrubState, level: ScrubLevel): number {
  const total = level.spots.length * level.rubs;
  const current = level.spots.reduce((sum, spot) => sum + Math.min(level.rubs, state.cleaned[spot.id] ?? 0), 0);
  return total === 0 ? 1 : current / total;
}

export function feedProgress(state: FeedState, level: FeedLevel): FeedProgress {
  const finishedFoods: string[] = [];
  const kinds = new Set<string>();
  let eatenBites = 0;
  for (const food of level.foods) {
    const left = state[food.id];
    const remaining = left === undefined ? food.bites : left;
    eatenBites += food.bites - remaining;
    if (remaining <= 0) { finishedFoods.push(food.id); kinds.add(food.kind); }
  }
  const total = totalBites(level);
  return {
    totalBites: total,
    eatenBites,
    finishedFoods,
    kinds: [...kinds],
    complete: eatenBites >= total,
    balanced: level.needKinds.every((kind) => kinds.has(kind)),
  };
}

export function tryDress(state: DressState, level: DressLevel, itemId: string, slot: ClothingKind): DressResult {
  const item = dressItem(level, itemId);
  if (!item) return { state, status: 'wrong' };
  if (state[itemId] === item.slot) return { state, status: 'already' };
  if (item.slot !== slot) return { state, status: 'wrong' };
  return { state: { ...state, [itemId]: item.slot }, status: 'correct' };
}

export function dressComplete(state: DressState, level: DressLevel): boolean {
  return level.items.every((item) => state[item.id] === item.slot);
}

const slot = this.slotAt(node.x, node.y);
if (slot === item.slot) { this.wear(item, node); return; }

// 只有「放进别的部位」才算放错；随手放在空地上只是弹回去，不打击孩子
if (slot !== null) {
  this.noteMistake('dress');
  this.say(ctx.task.retry, 1800);
}
node.setDepth(30);
springBack(this, node, home.x, home.y);

export function tapStep(state: OrderState, level: OrderLevel, stepId: string): { state: OrderState; status: OrderStatus } {
  const step = currentStep(state, level);
  if (!step) return { state, status: 'complete' };
  if (step.id !== stepId) return { state, status: 'wrong' };
  const completed = [...state.completed, step.id];
  const next = state.next + 1;
  if (next >= level.steps.length) return { state: { next, completed }, status: 'complete' };
  return { state: { next, completed }, status: 'correct' };
}

/**
 * 整理：把地上的玩具按类别放回箱子（球 / 积木 / 书 / 小车）。
 * 颜色只是装饰，类别靠「形状 + 箱子上的图标」区分 —— 不靠颜色单独传达信息（色盲友好）。
 */
export const tidyLevelSchema = z.object({
  room: z.enum(ROOMS),
  bins: z.array(z.object({
    kind: z.enum(TOY_KINDS),
    label: z.string().min(1).max(12),
    color: hexSchema,
  })).min(2).max(4),
  items: z.array(z.object({
    id: z.string().min(1),
    kind: z.enum(TOY_KINDS),
    color: hexSchema,
    x: normalized,
    y: normalized,
  })).min(4).max(10),
});

export function cycleMs(level: RhythmLevel): number {
  return (60_000 / level.bpm) * 2;
}

export function pointerPosition(elapsedMs: number, level: RhythmLevel): number {
  const cycle = cycleMs(level);
  const phase = ((elapsedMs % cycle) + cycle) % cycle;
  const half = cycle / 2;
  return phase <= half ? phase / half : 1 - (phase - half) / half;
}

export function isInZone(elapsedMs: number, level: RhythmLevel): boolean {
  const pos = pointerPosition(elapsedMs, level);
  return Math.abs(pos - 0.5) <= level.zone / 2;
}

create(): void {
  this.startAt = this.ctx.services.now() - cycleMs(this.level) / 4;   // 进场就在窗口正中
  // …
  if (this.autoplay) {
    this.handleTap();
    if (!this.done) this.autoTimer = window.setTimeout(() => this.autoStep(), 24);
  }
}

private autoStep(): void {
  const elapsed = this.ctx.services.now() - this.startAt;
  if (isInZone(elapsed, this.level)) {
    this.handleTap();
    if (!this.done) this.autoTimer = window.setTimeout(() => this.autoStep(), 24);
    return;
  }
  const toCenter = this.nextCenterDelay(elapsed);
  const toRisingCenter = nextHitDelay(elapsed, this.level);
  const halfWindow = (this.level.zone / 2) * (cycleMs(this.level) / 2);
  const sleep = Math.min(toCenter, toRisingCenter) - halfWindow;
  this.autoTimer = window.setTimeout(() => this.autoStep(), Math.max(16, sleep));
}

export interface PickState {
  round: number;
  phase: 'choose' | 'comfort';
  done: boolean;
}

export function chooseEmotion(state: PickState, level: PickLevel, emotion: Emotion): { state: PickState; status: ChooseStatus } {
  if (state.phase !== 'choose') return { state, status: state.done ? 'done' : 'comfort' };
  const round = currentRound(state, level);
  if (!round) return { state: { ...state, done: true, phase: 'comfort' }, status: 'done' };
  if (emotion !== round.target) return { state, status: 'wrong' };   // 不推进，也不换题
  return { state: { ...state, phase: 'comfort' }, status: 'comfort' };
}

export function chooseOption(state: LearnState, level: LearnLevel, index: number): { state: LearnState; status: LearnStatus } {
  if (state.done) return { state, status: 'done' };
  const question = currentQuestion(state, level);
  if (!question) return { state: { ...state, done: true }, status: 'done' };
  if (index !== question.answer) return { state, status: 'wrong' };
  const nextRound = state.round + 1;
  if (nextRound >= level.rounds.length) {
    return { state: { ...state, round: nextRound, done: true }, status: 'done' };
  }
  return { state: { ...state, round: nextRound }, status: 'correct' };
}

// 答对后 600ms 才换下一题 —— 给孩子一点时间看见自己答对了
const wait = this.instant ? 150 : 600;