第09章 - rule模板-程序化规则

// packages/game-kit/src/runtime.ts
export interface ProgramBlock {
  id: string;
  op: 'forward' | 'left' | 'right' | 'collect' | 'repeat' | 'if-wall';
  n?: number;
  children?: ProgramBlock[];
}

export const MAX_REPEAT = 20;
export const MAX_NESTING = 4;

export const programBlockSchema: z.ZodType<ProgramNode> = z.lazy(() =>
  z.object({
    id: z.string().min(1).max(24),
    op: z.enum(BLOCK_OPS),
    n: z.number().int().min(1).max(MAX_REPEAT).optional(),
    children: z.array(programBlockSchema).max(8).optional(),
  }),
);

export const programSchema = z.array(programBlockSchema).max(64);

export const ruleScriptSchema = z.object({
  grid: z.object({
    width: z.number().int().min(3).max(12),
    height: z.number().int().min(3).max(12),
    start: z.object({ x: coord, y: coord, dir: z.enum(DIRECTIONS) }),
    goal: cellSchema,
  }),
  walls: z.array(cellSchema).max(64),
  stars: z.array(cellSchema).max(12),
  maxBlocks: z.number().int().min(1).max(64),
  maxSteps: z.number().int().min(4).max(400),
});

/** 墙包含网格边界：越界等同于撞墙。 */
export function isBlocked(script: RuleScript, cell: Cell): boolean {
  if (cell.x < 0 || cell.y < 0 || cell.x >= script.grid.width || cell.y >= script.grid.height) {
    return true;
  }
  return script.walls.some((wall) => sameCell(wall, cell));
}

// packages/templates/src/rule/engine.ts
export function executeProgram(script: RuleScript, program: readonly ProgramBlock[]): RuleTrace

function advance(): boolean {
  if (steps >= script.maxSteps) {
    fail('rule-loop', steps + 1);
    return false;
  }
  steps += 1;
  return true;
}

function settle(): void {
  if (collectedKeys.size === starKeys.size && pos.x === goal.x && pos.y === goal.y) {
    reachedGoal = true;
    stopped = true;
  }
}

export function validateArtifact(source: ScriptSource, variant: RuleVariant, artifact: unknown): Verdict {
  const script = applyVariant(source, variant);
  const program = readProgram(artifact);
  const artifacts = summarizeProgram(program);

  if (program.length === 0) {
    return fail(variant, 'rule-empty', [
      { kind: 'constraint', ref: 'program', messageKey: 'level.rule.empty.message' },
    ], artifacts);
  }

  const trace = executeProgram(script, program);
  // ... 撞墙 / 绕圈直接取自 trace.failureClass，漏星与未到终点在这里复算
}

const stamps: Verdict['stamps'] = ['constraint'];
if (program.length <= 14) stamps.push('simple');
return {
  passed: true,
  stamps,
  missingEvidence: [],
  artifacts,
  metrics: { steps: trace.steps, blocks: program.length, collected: trace.collected.length },
};

summary: program.length + ' 块程序 / ' + countBlocks(program) + ' 个格子'

// packages/templates/src/rule/runtime.ts
export interface RuleState {
  program: ProgramBlock[];
  selectedId?: string;
  committed: boolean;
  lastTrace?: TraceSummary;
}

case 'rule/place': {
  const block = normalizeBlock(action.payload.block);
  if (!block) return { state, error: '这一块还不完整：先拼好再放进去。' };
  const at = clampIndex(action.payload.at, state.program.length);
  const next = [...state.program.slice(0, at), block, ...state.program.slice(at)];
  if (countBlocks(next) > script.maxBlocks) {
    return { state, error: '程序格子到上限了：先用重复把路线缩短。' };
  }
  return {
    state: withProgram(next, block.id),
    evidence: { phase: 'construct', tool: 'rule', action: action.type },
  };
}

// 程序拼好就是答案（docs/12 T1-rule）：「提交程序」按钮已删，宿主「完成」一次性校验，
// 所以产物不再要求 committed —— 有程序就交给验证器判定。
artifact(state: RuleState): unknown | null {
  if (state.program.length === 0) return null;
  return { program: state.program };
}

checkpoints(state: RuleState, ctx) {
  return {
    build: state.program.length > 0,
    run: state.program.length > 0 || ctx.runs > 0,
  };
}

// packages/templates/src/rule/index.ts
export function defineRuleLevel(manifest: LevelManifest): LevelModule {
  let game: { destroy(removeCanvas: boolean): void; loop: { sleep(): void; wake(): void } } | null = null;

  return {
    manifest,
    createRuntime(detail, opts) { return createRuleRuntime(detail, opts); },
    async mount(ctx, runtime) {
      if (!ctx.canvasHost) return;
      game = createPhaserGame(ctx.canvasHost, {
        designSize: manifest.designSize,
        scenes: [createRuleScene(ctx, runtime)],
      });
    },
    async unmount() {
      game?.destroy(true);
      game = null;
    },
    pause() { game?.loop.sleep(); },
    resume() { game?.loop.wake(); },
  };
}

export function planRouteClick(
  script: RuleScript,
  program: readonly ProgramBlock[],
  target: Cell,
  options: { idPrefix?: string } = {},
): RouteClickResult

const trace = executeProgram(script, program);
const from: Cell = { x: trace.end.x, y: trace.end.y };
const facing = trace.end.dir;
if (target.x === from.x && target.y === from.y) return { ok: false, reason: 'same-cell' };

let dir: Direction;
if (target.x === from.x) dir = target.y > from.y ? 'north' : 'south';
else if (target.y === from.y) dir = target.x > from.x ? 'east' : 'west';
else return { ok: false, reason: 'not-straight' };

const delta = (CLOCKWISE.indexOf(dir) - CLOCKWISE.indexOf(facing) + 4) % 4;
if (delta === 2) return { ok: false, reason: 'behind' };
const turn: 'left' | 'right' | null = delta === 0 ? null : delta === 1 ? 'right' : 'left';

// 产物永远是展开版：不生成 repeat / if-wall，简洁印章仍归手拼压缩版。

private handlePointerDown(pointer: Phaser.Input.Pointer): void {
  const cell = this.cellAt(pointer.worldX, pointer.worldY);
  if (!cell || this.dispatching) return;
  this.clickSeq += 1;
  const planned = this.planAt(cell, 'c' + this.clickSeq);
  if (!planned || !planned.result.ok) {
    // 点车头/不可达：不发动作，只闪一下红环 + 叉（不弹模态）。
    this.flashReject(cell);
    return;
  }
  // ...
}

/**
 * rule 模板的失败类。
 * 迁移门（旋转变体）已按 docs/12 T2-3 删掉：旋转是刚体变换，程序通过母本必然通过，
 * 那个门恒真、rule-not-general 永不可达。这里不再保留死失败类。
 */

it('exposes no transfer gate: the rotation gate was provably tautological', () => {
  const adapter = createRuleAdapter(detail) as unknown as Record<string, unknown>;
  expect(adapter.transferVariants).toBeUndefined();
  expect(adapter.transferFailureClass).toBeUndefined();
});

// scripts/audit-levels.ts
// ---- A6 变体：补丁可解析；迁移变体由 verifier 逐条验证 ----
if (detail.variants.length < 2) fail(id + ' A6：变体少于 2 个');
for (const variant of detail.variants) {
  try { verifier.applyVariant(detail, variant); } catch (cause) {
    fail(id + ' A6：变体补丁不可解析 ' + variant.id);
  }
}

if (trace.failureClass) {
  const wall = trace.failureClass === 'rule-wall';
  return fail(variant, trace.failureClass, [{
    kind: wall ? 'cell' : 'step',
    ref: String(trace.failureStep ?? trace.steps),
    messageKey: wall ? 'level.rule.wall.message' : 'level.rule.loop.message',
  }], artifacts);
}