maze-test 0.2.0 → 0.4.0

package/dist/cli.cjs

@@ -59,6 +59,122 @@ function neighbors(value, rows, cols) {
   ].filter((item) => item.row >= 1 && item.row <= rows && item.col >= 1 && item.col <= cols);
 }
 
+// src/mechanisms.ts
+var MATERIALS = ["copper", "silver", "gold"];
+var TREASURE_TYPES = ["treasure", "coin", "gem", "relic"];
+var POTION_KINDS = ["healing", "poison", "antidote", "haste", "slow"];
+function mechanismPreset(complexity) {
+  if (complexity === "basic") {
+    return {
+      complexity,
+      trapDamages: [1],
+      potionKinds: ["healing"],
+      keyMaterials: [],
+      treasureTypes: ["treasure"],
+      poisonDamage: 1,
+      poisonDuration: 3,
+      speedDuration: 4,
+      movementTime: { normal: 1, fast: 1, slow: 1 }
+    };
+  }
+  if (complexity === "intermediate") {
+    return {
+      complexity,
+      trapDamages: [1, 2, 3],
+      potionKinds: ["healing", "poison", "antidote"],
+      keyMaterials: [],
+      treasureTypes: ["coin", "gem", "relic"],
+      poisonDamage: 1,
+      poisonDuration: 3,
+      speedDuration: 4,
+      movementTime: { normal: 1, fast: 1, slow: 1 }
+    };
+  }
+  return {
+    complexity,
+    trapDamages: [1, 2, 3],
+    potionKinds: ["healing", "poison", "antidote", "haste", "slow"],
+    keyMaterials: ["copper", "silver", "gold"],
+    treasureTypes: ["coin", "gem", "relic"],
+    poisonDamage: 1,
+    poisonDuration: 3,
+    speedDuration: 4,
+    movementTime: { normal: 2, fast: 1, slow: 3 }
+  };
+}
+function resolveMechanisms(options) {
+  const complexity = options.complexity ?? "basic";
+  if (!isComplexity(complexity)) throw new Error(`Unknown complexity: ${String(complexity)}`);
+  const preset = mechanismPreset(complexity);
+  const trapDamages = options.trapDamages ?? preset.trapDamages;
+  const potionKinds = options.potionKinds ?? preset.potionKinds;
+  const keyMaterials = options.keyMaterials ?? preset.keyMaterials;
+  const treasureTypes = options.treasureTypes ?? preset.treasureTypes;
+  validatePositiveList(trapDamages, "trapDamages");
+  validateEnumList(potionKinds, POTION_KINDS, "potionKinds");
+  validateEnumList(keyMaterials, MATERIALS, "keyMaterials", true);
+  validateEnumList(treasureTypes, TREASURE_TYPES, "treasureTypes");
+  if (complexity !== "advanced" && potionKinds.some((kind) => kind === "haste" || kind === "slow")) {
+    throw new Error("Haste and slow potions require advanced complexity so their movement-time costs are defined.");
+  }
+  if (complexity === "advanced" && keyMaterials.length === 0) {
+    throw new Error("Advanced complexity requires at least one key material.");
+  }
+  return {
+    ...preset,
+    trapDamages: [...trapDamages],
+    potionKinds: [...potionKinds],
+    keyMaterials: [...keyMaterials],
+    treasureTypes: [...treasureTypes],
+    poisonDamage: positiveInteger(options.poisonDamage ?? preset.poisonDamage, "poisonDamage"),
+    poisonDuration: positiveInteger(
+      options.poisonDuration ?? preset.poisonDuration,
+      "poisonDuration"
+    ),
+    speedDuration: positiveInteger(options.speedDuration ?? preset.speedDuration, "speedDuration")
+  };
+}
+function defaultObjectCounts(complexity) {
+  if (complexity === "basic") return { doors: 1, chests: 2, traps: 2, potions: 2 };
+  if (complexity === "intermediate") return { doors: 2, chests: 3, traps: 3, potions: 3 };
+  return { doors: 3, chests: 3, traps: 3, potions: 5 };
+}
+function emptyMaterialCounts(values = {}) {
+  return {
+    copper: values.copper ?? 0,
+    silver: values.silver ?? 0,
+    gold: values.gold ?? 0
+  };
+}
+function emptyTreasureCounts(values = {}) {
+  return {
+    treasure: values.treasure ?? 0,
+    coin: values.coin ?? 0,
+    gem: values.gem ?? 0,
+    relic: values.relic ?? 0
+  };
+}
+function totalMaterialKeys(counts) {
+  return counts.copper + counts.silver + counts.gold;
+}
+function isComplexity(value) {
+  return value === "basic" || value === "intermediate" || value === "advanced";
+}
+function positiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1) throw new Error(`${name} must be a positive integer.`);
+  return value;
+}
+function validatePositiveList(values, name) {
+  if (values.length === 0) throw new Error(`${name} must not be empty.`);
+  for (const value of values) positiveInteger(value, name);
+}
+function validateEnumList(values, allowed, name, allowEmpty = false) {
+  if (!allowEmpty && values.length === 0) throw new Error(`${name} must not be empty.`);
+  for (const value of values) {
+    if (!allowed.includes(value)) throw new Error(`Unknown ${name} value: ${value}`);
+  }
+}
+
 // src/maze.ts
 function generateSolidCellMaze(options = {}) {
   const rows = oddDimension(options.rows ?? 15, "rows");
@@ -66,6 +182,7 @@ function generateSolidCellMaze(options = {}) {
   const seed = integerOption(options.seed ?? 1, "seed", 0);
   const requestedSeed = integerOption(options.requestedSeed ?? seed, "requestedSeed", 0);
   const braid = numberOption(options.braid ?? 0, "braid", 0, 1);
+  const mechanisms = options.mechanisms ?? mechanismPreset("basic");
   const rng = mulberry32(seed);
   const grid = Array.from({ length: rows }, () => Array(cols).fill("#"));
   const logicalCells = [];
@@ -99,7 +216,7 @@ function generateSolidCellMaze(options = {}) {
   const first = farthestFloor(cell(2, 2), terrain).cell;
   const second = farthestFloor(first, terrain).cell;
   const maze = {
-    schemaVersion: "solid-cell-maze-v3@1",
+    schemaVersion: "solid-cell-maze-v4@1",
     id: options.id ?? `solid-maze-${rows}x${cols}-${requestedSeed}`,
     seed,
     requestedSeed,
@@ -111,6 +228,7 @@ function generateSolidCellMaze(options = {}) {
       columns: "letters-left-to-right",
       rows: "numbers-top-to-bottom"
     },
+    mechanisms: structuredClone(mechanisms),
     terrain,
     entry: first,
     goal: second,
@@ -123,6 +241,8 @@ function generateSolidCellMaze(options = {}) {
 }
 function decorateSolidCellMaze(maze, options = {}) {
   const result = structuredClone(maze);
+  const mechanisms = options.mechanisms ?? maze.mechanisms ?? mechanismPreset("basic");
+  result.mechanisms = structuredClone(mechanisms);
   const decorationSeed = integerOption(options.seed ?? maze.seed + 71311, "decoration seed", 0);
   const rng = mulberry32(decorationSeed);
   const mainPath = shortestPath(result, result.entry, result.goal);
@@ -134,13 +254,23 @@ function decorateSolidCellMaze(maze, options = {}) {
   );
   const chestCount = integerOption(options.chestCount ?? 2, "chestCount", 0);
   const trapCount = integerOption(options.trapCount ?? 2, "trapCount", 0);
-  const medicineCount = integerOption(options.medicineCount ?? 2, "medicineCount", 0);
+  const potionCount = integerOption(
+    options.potionCount ?? options.medicineCount ?? 2,
+    "potionCount",
+    0
+  );
   const doorIndices = selectGatingDoorIndices(result, mainPath, doorCount);
   result.doors = doorIndices.map((index, doorIndex) => {
     const position = mainPath[index];
     if (!position) throw new Error(`No path cell exists at door index ${index}.`);
     occupied.add(cellKey(position));
-    return { id: `door-${doorIndex + 1}`, position, state: "closed" };
+    const material = cyclicValue(mechanisms.keyMaterials, doorIndex + decorationSeed);
+    return {
+      id: `door-${doorIndex + 1}`,
+      position,
+      state: "closed",
+      ...material ? { material } : {}
+    };
   });
   const objects = [];
   for (let index = 0; index < result.doors.length; index += 1) {
@@ -149,7 +279,13 @@ function decorateSolidCellMaze(maze, options = {}) {
     const preferredIndex = Math.max(1, Math.floor(doorIndex * 0.55));
     const position = freePathCellBefore(mainPath, preferredIndex, occupied);
     occupied.add(cellKey(position));
-    const key = { id: `key-${index + 1}`, type: "key", position };
+    const door = result.doors[index];
+    const key = {
+      id: `key-${index + 1}`,
+      type: "key",
+      position,
+      ...door?.material ? { material: door.material } : {}
+    };
     objects.push(key);
   }
   const degrees = degreeMap(result);
@@ -162,11 +298,17 @@ function decorateSolidCellMaze(maze, options = {}) {
   for (let index = 0; index < chestCount; index += 1) {
     const position = takeFree(deadEnds, result, occupied, rng, "chest");
     occupied.add(cellKey(position));
+    const treasureType = cyclicValue(mechanisms.treasureTypes, index + decorationSeed);
+    if (!treasureType) throw new Error("At least one treasure type is required.");
+    const count = 1 + index % 3;
+    const lockMaterial = cyclicValue(mechanisms.keyMaterials, index + decorationSeed + 1);
     const chest = {
       id: `chest-${index + 1}`,
       type: "chest",
       position,
-      treasures: 1 + index % 3
+      treasures: count,
+      contents: [{ type: treasureType, count }],
+      ...lockMaterial ? { lockMaterial } : {}
     };
     objects.push(chest);
   }
@@ -178,21 +320,36 @@ function decorateSolidCellMaze(maze, options = {}) {
       id: `trap-${index + 1}`,
       type: "trap",
       position,
-      damage: 1
+      damage: mechanisms.trapDamages[index % mechanisms.trapDamages.length] ?? 1
     };
     objects.push(trap);
   }
-  const medicineCandidates = shuffle(rng, floorCells(result));
-  for (let index = 0; index < medicineCount; index += 1) {
-    const position = takeFree(medicineCandidates, result, occupied, rng, "medicine");
+  const potionCandidates = shuffle(rng, floorCells(result));
+  for (let index = 0; index < potionCount; index += 1) {
+    const position = takeFree(potionCandidates, result, occupied, rng, "potion");
     occupied.add(cellKey(position));
-    const medicine = {
-      id: `medicine-${index + 1}`,
-      type: "medicine",
+    if (mechanisms.complexity === "basic" && mechanisms.potionKinds.length === 1 && mechanisms.potionKinds[0] === "healing") {
+      const medicine = {
+        id: `medicine-${index + 1}`,
+        type: "medicine",
+        position,
+        recovery: 1
+      };
+      objects.push(medicine);
+      continue;
+    }
+    const kind = mechanisms.potionKinds[index % mechanisms.potionKinds.length];
+    if (!kind) throw new Error("At least one potion kind is required.");
+    const potion = {
+      id: `potion-${index + 1}`,
+      type: "potion",
       position,
-      recovery: 1
+      kind,
+      ...kind === "healing" ? { potency: 1 + index % 2 } : {},
+      ...kind === "poison" ? { potency: mechanisms.poisonDamage, duration: mechanisms.poisonDuration } : {},
+      ...kind === "haste" || kind === "slow" ? { duration: mechanisms.speedDuration } : {}
     };
-    objects.push(medicine);
+    objects.push(potion);
   }
   result.objects = objects;
   result.metrics = analyzeSolidCellMaze(result);
@@ -205,7 +362,8 @@ function analyzeSolidCellMaze(maze) {
   const distances = bfsDistances(maze.entry, graph);
   const degreeValues = [...graph.values()].map((items) => items.length);
   const edgeCount = degreeValues.reduce((sum, value) => sum + value, 0) / 2;
-  const mainPath = shortestPath(maze, maze.entry, maze.goal);
+  const mainPath = shortestPathInGraph(graph, maze.entry, maze.goal);
+  const entryGoalSeparators = separatingCellKeys(graph, maze.entry, maze.goal);
   const objectCounts = {};
   for (const object of maze.objects ?? []) {
     objectCounts[object.type] = (objectCounts[object.type] ?? 0) + 1;
@@ -223,7 +381,7 @@ function analyzeSolidCellMaze(maze) {
     entryGoalDistance: mainPath.length > 0 ? mainPath.length - 1 : null,
     doorCount: maze.doors.length,
     gatingDoorCount: maze.doors.filter(
-      (door) => shortestPath(maze, maze.entry, maze.goal, door.position).length === 0
+      (door) => entryGoalSeparators.has(cellKey(door.position))
     ).length,
     objectCounts
   };
@@ -284,6 +442,8 @@ function validateSolidCellMaze(maze) {
     if (!key) errors.push(`Missing a key for ${door.id}.`);
     else if (keyIndex === void 0 || doorIndex === void 0 || keyIndex >= doorIndex) {
       errors.push(`${key.id} is not before ${door.id} on the main path.`);
+    } else if (door.material !== (key.type === "key" ? key.material : void 0)) {
+      errors.push(`${key.id} does not match the material of ${door.id}.`);
     }
   }
   return { valid: errors.length === 0, errors, metrics };
@@ -291,6 +451,9 @@ function validateSolidCellMaze(maze) {
 function shortestPath(maze, start, goal, excludedCell = null) {
   if (excludedCell && (sameCell(start, excludedCell) || sameCell(goal, excludedCell))) return [];
   const graph = adjacency(maze, excludedCell);
+  return shortestPathInGraph(graph, start, goal);
+}
+function shortestPathInGraph(graph, start, goal) {
   const queue = [start];
   const parent = /* @__PURE__ */ new Map([[cellKey(start), null]]);
   const values = /* @__PURE__ */ new Map([[cellKey(start), start]]);
@@ -422,12 +585,14 @@ function degreeMap(maze) {
 }
 function selectGatingDoorIndices(maze, mainPath, count) {
   if (count === 0) return [];
-  const degrees = degreeMap(maze);
+  const graph = adjacency(maze);
+  const separators = separatingCellKeys(graph, maze.entry, maze.goal);
   const candidates = [];
   for (let index = 3; index < mainPath.length - 3; index += 1) {
     const pathCell = mainPath[index];
-    if (!pathCell || (degrees.get(cellKey(pathCell)) ?? 0) !== 2) continue;
-    if (shortestPath(maze, maze.entry, maze.goal, pathCell).length === 0) candidates.push(index);
+    if (!pathCell) continue;
+    const key = cellKey(pathCell);
+    if ((graph.get(key)?.length ?? 0) === 2 && separators.has(key)) candidates.push(index);
   }
   if (candidates.length < count) {
     throw new Error(`Only ${candidates.length} non-bypassable path cells are available for ${count} doors.`);
@@ -446,6 +611,59 @@ function selectGatingDoorIndices(maze, mainPath, count) {
   if (selected.length !== count) throw new Error(`Could not space ${count} doors along the main path.`);
   return selected.sort((left, right) => left - right);
 }
+function separatingCellKeys(graph, start, goal) {
+  const startKey = cellKey(start);
+  const goalKey = cellKey(goal);
+  if (!graph.has(startKey) || !graph.has(goalKey)) return /* @__PURE__ */ new Set();
+  const discovered = /* @__PURE__ */ new Map();
+  const low = /* @__PURE__ */ new Map();
+  const parent = /* @__PURE__ */ new Map([[startKey, null]]);
+  const stack = [
+    { key: startKey, nextNeighbor: 0 }
+  ];
+  let order = 1;
+  discovered.set(startKey, order);
+  low.set(startKey, order);
+  while (stack.length > 0) {
+    const frame = stack.at(-1);
+    if (!frame) break;
+    const adjacent = graph.get(frame.key) ?? [];
+    const next = adjacent[frame.nextNeighbor];
+    if (next) {
+      frame.nextNeighbor += 1;
+      const nextKey = cellKey(next);
+      if (!discovered.has(nextKey)) {
+        order += 1;
+        discovered.set(nextKey, order);
+        low.set(nextKey, order);
+        parent.set(nextKey, frame.key);
+        stack.push({ key: nextKey, nextNeighbor: 0 });
+        continue;
+      }
+      if (nextKey !== parent.get(frame.key)) {
+        low.set(frame.key, Math.min(low.get(frame.key) ?? order, discovered.get(nextKey) ?? order));
+      }
+      continue;
+    }
+    stack.pop();
+    const parentKey = parent.get(frame.key);
+    if (parentKey) {
+      low.set(parentKey, Math.min(low.get(parentKey) ?? order, low.get(frame.key) ?? order));
+    }
+  }
+  if (!discovered.has(goalKey)) return /* @__PURE__ */ new Set();
+  const separators = /* @__PURE__ */ new Set();
+  let childKey = goalKey;
+  while (childKey !== startKey) {
+    const parentKey = parent.get(childKey);
+    if (!parentKey) break;
+    if (parentKey !== startKey && (low.get(childKey) ?? Number.POSITIVE_INFINITY) >= (discovered.get(parentKey) ?? Number.NEGATIVE_INFINITY)) {
+      separators.add(parentKey);
+    }
+    childKey = parentKey;
+  }
+  return separators;
+}
 function freePathCellBefore(mainPath, preferredIndex, occupied) {
   for (let distance = 0; distance < mainPath.length; distance += 1) {
     for (const index of [preferredIndex - distance, preferredIndex + distance]) {
@@ -521,6 +739,10 @@ function shuffle(rng, input) {
   }
   return values;
 }
+function cyclicValue(values, index) {
+  if (values.length === 0) return void 0;
+  return values[(index % values.length + values.length) % values.length];
+}
 function mulberry32(seed) {
   let value = seed >>> 0;
   return () => {
@@ -551,40 +773,105 @@ function emptyMetrics(rows, cols) {
 
 // src/simulator.ts
 var DELTAS = {
-  up: [-1, 0],
-  down: [1, 0],
-  left: [0, -1],
-  right: [0, 1]
+  up: { row: -1, col: 0 },
+  down: { row: 1, col: 0 },
+  left: { row: 0, col: -1 },
+  right: { row: 0, col: 1 }
 };
 function simulateTrial(maze, actions, initial = {}) {
+  const mechanisms = maze.mechanisms ?? mechanismPreset("basic");
   const health = initial.health ?? 5;
   const state = {
     position: structuredClone(maze.entry),
     health,
     healthMax: initial.healthMax ?? health,
     keys: initial.keys ?? 0,
+    keysByMaterial: emptyMaterialCounts(initial.keysByMaterial),
     treasures: initial.treasures ?? 0,
+    treasuresByType: emptyTreasureCounts(initial.treasuresByType),
+    elapsedTime: initial.elapsedTime ?? 0,
+    speed: initial.speed ?? "normal",
+    speedRemaining: initial.speedRemaining ?? 0,
+    poisonDamage: initial.poisonDamage ?? 0,
+    poisonRemaining: initial.poisonRemaining ?? 0,
     alive: health > 0,
     reachedGoal: false,
     openedDoors: [],
     collectedKeys: [],
     openedChests: [],
     triggeredTraps: [],
-    usedMedicines: []
+    usedMedicines: [],
+    usedPotions: []
   };
   const trace = [];
   for (let index = 0; index < actions.length; index += 1) {
     const direction = actions[index];
     if (!direction) continue;
-    trace.push(executeStep(maze, state, direction, index + 1));
+    const before = cloneState(state);
+    const events = [];
+    if (!state.alive) {
+      trace.push({ step: index + 1, direction, before, moved: false, reason: "dead", events, after: cloneState(state) });
+      continue;
+    }
+    const context = {
+      speedAtStart: state.speed,
+      speedRemainingAtStart: state.speedRemaining,
+      poisonDamageAtStart: state.poisonDamage,
+      poisonRemainingAtStart: state.poisonRemaining,
+      speedReplaced: false,
+      poisonReplaced: false
+    };
+    const timeCost = mechanisms.movementTime[context.speedAtStart];
+    state.elapsedTime += timeCost;
+    const delta = DELTAS[direction];
+    const target = cell(state.position.row + delta.row, state.position.col + delta.col);
+    let moved = false;
+    let reason = null;
+    if (terrainAt(maze, target) !== ".") {
+      reason = "wall-or-outside";
+    } else {
+      const door = maze.doors.find((item) => cellKey(item.position) === cellKey(target));
+      if (door && !state.openedDoors.includes(door.id)) {
+        if (door.material) {
+          if (state.keysByMaterial[door.material] < 1) {
+            reason = "closed-door-without-matching-key";
+          } else {
+            state.keysByMaterial[door.material] -= 1;
+            state.openedDoors.push(door.id);
+            events.push({ type: "open-door", id: door.id, material: door.material, keyCost: 1, timeCost });
+          }
+        } else if (state.keys < 1) {
+          reason = "closed-door-without-key";
+        } else {
+          state.keys -= 1;
+          state.openedDoors.push(door.id);
+          events.push({ type: "open-door", id: door.id, keyCost: 1, timeCost });
+        }
+      }
+      if (!reason) {
+        state.position = target;
+        moved = true;
+        applyCellObjects(maze, state, events, context);
+        if (cellKey(state.position) === cellKey(maze.goal) && !state.reachedGoal) {
+          state.reachedGoal = true;
+          events.push({ type: "reach-goal" });
+        }
+      }
+    }
+    finishStatuses(state, events, context);
+    trace.push({ step: index + 1, direction, before, moved, reason, events, after: cloneState(state) });
   }
+  const blockedMoves = trace.filter((item) => !item.moved).length;
+  const blockedAfterDeath = trace.filter((item) => item.reason === "dead").length;
   return {
-    state: structuredClone(state),
+    state,
     trace,
     answers: {
       finalPosition: letterNumberCoordinate(state.position),
-      keys: state.keys,
+      keys: state.keys + totalMaterialKeys(state.keysByMaterial),
+      keysByMaterial: structuredClone(state.keysByMaterial),
       treasures: state.treasures,
+      treasuresByType: structuredClone(state.treasuresByType),
       health: state.health,
       alive: state.alive,
       reachedGoal: state.reachedGoal,
@@ -592,90 +879,135 @@ function simulateTrial(maze, actions, initial = {}) {
       openedChests: state.openedChests.length,
       triggeredTraps: state.triggeredTraps.length,
       usedMedicines: state.usedMedicines.length,
-      blockedMoves: trace.filter((item) => !item.moved).length,
-      blockedAfterDeath: trace.filter((item) => item.reason === "dead").length
+      usedPotions: state.usedPotions.length,
+      elapsedTime: state.elapsedTime,
+      finalSpeed: state.speed,
+      speedRemaining: state.speedRemaining,
+      poisonDamage: state.poisonDamage,
+      poisonRemaining: state.poisonRemaining,
+      blockedMoves,
+      blockedAfterDeath
     }
   };
 }
-function executeStep(maze, state, direction, step) {
-  const before = structuredClone(state);
-  const events = [];
-  if (!state.alive) return record(step, direction, before, state, false, "dead", events);
-  const [dr, dc] = DELTAS[direction];
-  const target = cell(state.position.row + dr, state.position.col + dc);
-  if (terrainAt(maze, target) !== ".") {
-    return record(step, direction, before, state, false, "wall-or-outside", events);
-  }
-  const door = maze.doors.find((item) => sameCell(item.position, target));
-  if (door && !state.openedDoors.includes(door.id)) {
-    if (state.keys <= 0) {
-      return record(
-        step,
-        direction,
-        before,
-        state,
-        false,
-        "closed-door-without-key",
-        events
-      );
-    }
-    state.keys -= 1;
-    state.openedDoors.push(door.id);
-    events.push({ type: "open-door", id: door.id, keyCost: 1 });
-  }
-  state.position = target;
-  const object = maze.objects.find((item) => sameCell(item.position, target));
-  if (object?.type === "key" && !state.collectedKeys.includes(object.id)) {
+function applyCellObjects(maze, state, events, context) {
+  const object = maze.objects.find((item) => cellKey(item.position) === cellKey(state.position));
+  if (!object) return;
+  if (object.type === "key" && !state.collectedKeys.includes(object.id)) {
     state.collectedKeys.push(object.id);
-    state.keys += 1;
-    events.push({ type: "collect-key", id: object.id });
-  }
-  if (object?.type === "chest" && !state.openedChests.includes(object.id)) {
-    if (state.keys > 0) {
-      state.keys -= 1;
-      state.openedChests.push(object.id);
-      state.treasures += object.treasures;
+    if (object.material) state.keysByMaterial[object.material] += 1;
+    else state.keys += 1;
+    events.push({
+      type: "collect-key",
+      id: object.id,
+      ...object.material ? { material: object.material } : {}
+    });
+    return;
+  }
+  if (object.type === "chest" && !state.openedChests.includes(object.id)) {
+    let canOpen = false;
+    if (object.lockMaterial) {
+      canOpen = state.keysByMaterial[object.lockMaterial] > 0;
+      if (canOpen) state.keysByMaterial[object.lockMaterial] -= 1;
+    } else {
+      canOpen = state.keys > 0;
+      if (canOpen) state.keys -= 1;
+    }
+    if (!canOpen) {
       events.push({
-        type: "open-chest",
+        type: "pass-closed-chest",
         id: object.id,
-        keyCost: 1,
-        treasures: object.treasures
+        ...object.lockMaterial ? { material: object.lockMaterial } : {}
       });
-    } else {
-      events.push({ type: "pass-closed-chest", id: object.id });
+      return;
+    }
+    state.openedChests.push(object.id);
+    const contents = object.contents?.length > 0 ? object.contents : [{ type: "treasure", count: object.treasures }];
+    for (const content of contents) {
+      state.treasures += content.count;
+      state.treasuresByType[content.type] += content.count;
     }
+    events.push({
+      type: "open-chest",
+      id: object.id,
+      ...object.lockMaterial ? { material: object.lockMaterial } : {},
+      keyCost: 1,
+      treasures: object.treasures,
+      contents: structuredClone(contents)
+    });
+    return;
   }
-  if (object?.type === "trap" && !state.triggeredTraps.includes(object.id)) {
+  if (object.type === "trap" && !state.triggeredTraps.includes(object.id)) {
     state.triggeredTraps.push(object.id);
     state.health = Math.max(0, state.health - object.damage);
     events.push({ type: "trigger-trap", id: object.id, damage: object.damage });
+    return;
   }
-  if (object?.type === "medicine" && !state.usedMedicines.includes(object.id)) {
+  if (object.type === "medicine" && !state.usedMedicines.includes(object.id)) {
     state.usedMedicines.push(object.id);
-    const prior = state.health;
+    const before = state.health;
     state.health = Math.min(state.healthMax, state.health + object.recovery);
-    events.push({ type: "use-medicine", id: object.id, recovery: state.health - prior });
+    events.push({ type: "use-medicine", id: object.id, recovery: state.health - before });
+    return;
+  }
+  if (object.type === "potion" && !state.usedPotions.includes(object.id)) {
+    state.usedPotions.push(object.id);
+    applyPotion(state, object, context);
+    const recovery = object.kind === "healing" ? object.potency ?? 1 : void 0;
+    const damage = object.kind === "poison" ? object.potency ?? maze.mechanisms.poisonDamage : void 0;
+    events.push({
+      type: "drink-potion",
+      id: object.id,
+      potionKind: object.kind,
+      ...recovery === void 0 ? {} : { recovery },
+      ...damage === void 0 ? {} : { damage },
+      ...object.duration === void 0 ? {} : { duration: object.duration }
+    });
+  }
+}
+function applyPotion(state, potion, context) {
+  if (potion.kind === "healing") {
+    state.health = Math.min(state.healthMax, state.health + (potion.potency ?? 1));
+  } else if (potion.kind === "poison") {
+    state.poisonDamage = potion.potency ?? 1;
+    state.poisonRemaining = potion.duration ?? 1;
+    context.poisonReplaced = true;
+  } else if (potion.kind === "antidote") {
+    state.poisonDamage = 0;
+    state.poisonRemaining = 0;
+    context.poisonReplaced = true;
+  } else if (potion.kind === "haste") {
+    state.speed = "fast";
+    state.speedRemaining = potion.duration ?? 1;
+    context.speedReplaced = true;
+  } else {
+    state.speed = "slow";
+    state.speedRemaining = potion.duration ?? 1;
+    context.speedReplaced = true;
+  }
+}
+function finishStatuses(state, events, context) {
+  if (!context.poisonReplaced && context.poisonRemainingAtStart > 0) {
+    state.health = Math.max(0, state.health - context.poisonDamageAtStart);
+    state.poisonRemaining = context.poisonRemainingAtStart - 1;
+    state.poisonDamage = state.poisonRemaining > 0 ? context.poisonDamageAtStart : 0;
+    events.push({ type: "poison-tick", damage: context.poisonDamageAtStart });
+  }
+  if (!context.speedReplaced && context.speedRemainingAtStart > 0) {
+    state.speedRemaining = context.speedRemainingAtStart - 1;
+    if (state.speedRemaining === 0) {
+      state.speed = "normal";
+      events.push({ type: "speed-expired" });
+    }
   }
   if (state.health <= 0 && state.alive) {
+    state.health = 0;
     state.alive = false;
     events.push({ type: "die" });
   }
-  if (sameCell(state.position, maze.goal) && !state.reachedGoal) {
-    state.reachedGoal = true;
-    events.push({ type: "reach-goal" });
-  }
-  return record(step, direction, before, state, true, null, events);
 }
-function record(step, direction, before, state, moved, reason, events) {
-  return {
-    step,
-    direction,
-    before,
-    moved,
-    reason,
-    events,
-    after: structuredClone(state)
-  };
+function cloneState(state) {
+  return structuredClone(state);
 }
 
 // src/trial.ts
@@ -685,54 +1017,29 @@ var DIRECTIONS = {
   left: { en: "left", zh: "\u5DE6" },
   right: { en: "right", zh: "\u53F3" }
 };
-var ENGLISH_RULES = [
-  "The explorer can move only one cell at a time to an orthogonally adjacent cell. An instruction to move several cells is executed as that many consecutive one-cell moves.",
-  "If the next cell is a wall or outside the map, the explorer stays in place, and the remaining actions continue.",
-  "A closed door occupies a whole cell. To enter it, the explorer must spend one key; the door then stays open. Without a key, the explorer stays in place.",
-  "The first time the explorer enters a cell containing a key, they collect it. A key cannot be collected twice.",
-  "The first time the explorer enters a cell containing an unopened chest, one key is spent to open it if a key is available. Without a key, the explorer may pass through but does not open the chest.",
-  "A trap removes one health point the first time it is entered and has no effect afterward.",
-  "A medicine room restores one health point the first time it is entered, without exceeding maximum health, and has no effect afterward.",
-  "When health reaches zero, the explorer dies. All remaining moves are still read but cannot change any state.",
-  "Once the explorer enters the goal cell, reached-goal remains true even if the explorer later leaves it."
-];
-var CHINESE_RULES = [
-  "\u63A2\u9669\u8005\u6BCF\u6B21\u53EA\u80FD\u5411\u4E0A\u3001\u4E0B\u3001\u5DE6\u3001\u53F3\u76F8\u90BB\u7684\u4E00\u683C\u79FB\u52A8\uFF1B\u201C\u5411\u67D0\u65B9\u5411\u79FB\u52A8\u82E5\u5E72\u683C\u201D\u4F9D\u6B21\u6267\u884C\u76F8\u5E94\u6B21\u6570\u7684\u5355\u683C\u79FB\u52A8\u3002",
-  "\u5982\u679C\u4E00\u6B21\u79FB\u52A8\u7684\u76EE\u6807\u662F\u5899\u683C\u6216\u8D85\u51FA\u5730\u56FE\uFF0C\u63A2\u9669\u8005\u505C\u5728\u539F\u5730\uFF0C\u4F46\u540E\u7EED\u884C\u52A8\u4ECD\u7136\u7EE7\u7EED\u3002",
-  "\u95E8\u5360\u636E\u4E00\u4E2A\u5B8C\u6574\u683C\u5B50\u3002\u76EE\u6807\u683C\u662F\u5173\u95ED\u7684\u95E8\u65F6\uFF0C\u63A2\u9669\u8005\u82E5\u6301\u6709\u94A5\u5319\uFF0C\u5C31\u6D88\u8017\u4E00\u628A\u94A5\u5319\u3001\u6253\u5F00\u8BE5\u95E8\u5E76\u8FDB\u5165\u95E8\u683C\uFF1B\u6CA1\u6709\u94A5\u5319\u5219\u505C\u5728\u539F\u5730\u3002\u5DF2\u7ECF\u6253\u5F00\u7684\u95E8\u53EF\u4EE5\u76F4\u63A5\u8FDB\u5165\u3002",
-  "\u63A2\u9669\u8005\u7B2C\u4E00\u6B21\u8FDB\u5165\u67D0\u628A\u94A5\u5319\u6240\u5728\u7684\u683C\u5B50\u65F6\u53D6\u5F97\u8BE5\u94A5\u5319\uFF0C\u94A5\u5319\u6570\u589E\u52A0\u4E00\uFF1B\u540C\u4E00\u628A\u94A5\u5319\u4E0D\u80FD\u91CD\u590D\u53D6\u5F97\u3002",
-  "\u63A2\u9669\u8005\u7B2C\u4E00\u6B21\u8FDB\u5165\u5C1A\u672A\u6253\u5F00\u7684\u5B9D\u7BB1\u683C\u4E14\u6301\u6709\u94A5\u5319\u65F6\uFF0C\u6D88\u8017\u4E00\u628A\u94A5\u5319\u3001\u6253\u5F00\u5B9D\u7BB1\u5E76\u53D6\u5F97\u5176\u4E2D\u5168\u90E8\u5B9D\u7269\uFF1B\u6CA1\u6709\u94A5\u5319\u65F6\u53EF\u4EE5\u7ECF\u8FC7\u8BE5\u683C\uFF0C\u4F46\u4E0D\u80FD\u6253\u5F00\u5B9D\u7BB1\u3002",
-  "\u63A2\u9669\u8005\u7B2C\u4E00\u6B21\u8FDB\u5165\u67D0\u4E2A\u9677\u9631\u683C\u65F6\u51CF\u5C11\u4E00\u70B9\u5065\u5EB7\u503C\uFF1B\u540C\u4E00\u9677\u9631\u4EE5\u540E\u4E0D\u518D\u751F\u6548\u3002",
-  "\u4ECD\u7136\u5B58\u6D3B\u7684\u63A2\u9669\u8005\u7B2C\u4E00\u6B21\u8FDB\u5165\u67D0\u4E2A\u836F\u54C1\u623F\u65F6\u6062\u590D\u4E00\u70B9\u5065\u5EB7\u503C\uFF0C\u4F46\u4E0D\u5F97\u8D85\u8FC7\u5065\u5EB7\u4E0A\u9650\uFF1B\u540C\u4E00\u836F\u54C1\u623F\u4EE5\u540E\u4E0D\u518D\u751F\u6548\u3002",
-  "\u5065\u5EB7\u503C\u964D\u4E3A\u96F6\u65F6\u63A2\u9669\u8005\u6B7B\u4EA1\u3002\u6B7B\u4EA1\u4EE5\u540E\uFF0C\u6240\u6709\u5C1A\u672A\u6267\u884C\u7684\u79FB\u52A8\u90FD\u4E0D\u518D\u6539\u53D8\u4EFB\u4F55\u72B6\u6001\u3002",
-  "\u63A2\u9669\u8005\u4E00\u65E6\u8FDB\u5165\u7EC8\u70B9\u683C\uFF0C\u5C31\u628A\u201C\u66FE\u7ECF\u5230\u8FBE\u7EC8\u70B9\u201D\u8BB0\u5F55\u4E3A\u771F\uFF1B\u4EE5\u540E\u5373\u4F7F\u79BB\u5F00\u7EC8\u70B9\uFF0C\u8BE5\u8BB0\u5F55\u4ECD\u7136\u4FDD\u6301\u4E3A\u771F\u3002"
-];
-var ENGLISH_QUESTIONS = [
-  "Which cell is the explorer in after all actions are complete?",
-  "How many keys does the explorer have at the end?",
-  "How many treasures has the explorer collected at the end?",
-  "How many health points does the explorer have at the end?",
-  "Is the explorer alive at the end?",
-  "Did the explorer ever reach the goal?",
-  "How many doors were opened?",
-  "How many chests were opened?",
-  "How many traps were triggered?",
-  "How many medicine rooms were used?",
-  "How many individual moves did not change the explorer's position?"
-];
-var CHINESE_QUESTIONS = [
-  "\u5168\u90E8\u884C\u52A8\u7ED3\u675F\u540E\uFF0C\u63A2\u9669\u8005\u4F4D\u4E8E\u54EA\u4E00\u683C\uFF1F",
-  "\u63A2\u9669\u8005\u6700\u540E\u6301\u6709\u51E0\u628A\u94A5\u5319\uFF1F",
-  "\u63A2\u9669\u8005\u6700\u540E\u53D6\u5F97\u4E86\u51E0\u4EF6\u5B9D\u7269\uFF1F",
-  "\u63A2\u9669\u8005\u6700\u540E\u8FD8\u5269\u51E0\u70B9\u5065\u5EB7\u503C\uFF1F",
-  "\u63A2\u9669\u8005\u6700\u540E\u662F\u5426\u4ECD\u7136\u5B58\u6D3B\uFF1F",
-  "\u884C\u52A8\u8FC7\u7A0B\u4E2D\uFF0C\u63A2\u9669\u8005\u662F\u5426\u66FE\u7ECF\u5230\u8FBE\u7EC8\u70B9\uFF1F",
-  "\u884C\u52A8\u8FC7\u7A0B\u4E2D\u4E00\u5171\u6253\u5F00\u4E86\u51E0\u9053\u95E8\uFF1F",
-  "\u884C\u52A8\u8FC7\u7A0B\u4E2D\u4E00\u5171\u6253\u5F00\u4E86\u51E0\u53EA\u5B9D\u7BB1\uFF1F",
-  "\u884C\u52A8\u8FC7\u7A0B\u4E2D\u4E00\u5171\u89E6\u53D1\u4E86\u51E0\u4E2A\u9677\u9631\uFF1F",
-  "\u884C\u52A8\u8FC7\u7A0B\u4E2D\u4E00\u5171\u4F7F\u7528\u4E86\u51E0\u4E2A\u836F\u54C1\u623F\uFF1F",
-  "\u884C\u52A8\u8FC7\u7A0B\u4E2D\u5171\u6709\u591A\u5C11\u6B21\u79FB\u52A8\u6CA1\u6709\u6539\u53D8\u63A2\u9669\u8005\u7684\u4F4D\u7F6E\uFF1F"
-];
+var MATERIAL_NAMES = {
+  copper: { en: "copper", zh: "\u94DC" },
+  silver: { en: "silver", zh: "\u94F6" },
+  gold: { en: "gold", zh: "\u91D1" }
+};
+var TREASURE_NAMES = {
+  treasure: { en: "treasure", zh: "\u5B9D\u7269" },
+  coin: { en: "coin", zh: "\u94B1\u5E01" },
+  gem: { en: "gem", zh: "\u5B9D\u77F3" },
+  relic: { en: "relic", zh: "\u9057\u7269" }
+};
+var POTION_NAMES = {
+  healing: { en: "healing potion", zh: "\u6CBB\u7597\u836F\u6C34" },
+  poison: { en: "poison potion", zh: "\u6BD2\u836F" },
+  antidote: { en: "antidote potion", zh: "\u89E3\u6BD2\u836F\u6C34" },
+  haste: { en: "haste potion", zh: "\u52A0\u901F\u836F\u6C34" },
+  slow: { en: "slow potion", zh: "\u51CF\u901F\u836F\u6C34" }
+};
+var SPEED_NAMES = {
+  normal: { en: "normal", zh: "\u6B63\u5E38" },
+  fast: { en: "fast", zh: "\u52A0\u901F" },
+  slow: { en: "slow", zh: "\u51CF\u901F" }
+};
 function generateTrial(options = {}) {
   const resolved = resolveTrialOptions(options);
   const maze = selectMaze(resolved);
@@ -741,82 +1048,72 @@ function generateTrial(options = {}) {
   verifyScenario(resolved.scenario, result.answers, maze);
   const sections = {
     map: renderMapDescription(maze, plan.initialState, resolved.language, resolved.style),
-    rules: renderRules(resolved.language),
+    rules: renderRules(maze, resolved.language),
     actions: renderActionDescription(plan.actions, resolved.language, resolved.style),
-    questions: renderQuestions(resolved.language)
+    questions: renderQuestions(maze, resolved.language)
   };
-  const question = renderQuestion(resolved, maze, sections);
-  const answer = renderAnswer(resolved, maze, result.answers, plan.actions.length);
   return {
-    schemaVersion: "maze-test-trial@1",
+    schemaVersion: "maze-test-trial@2",
     options: resolved,
     maze,
     initialState: plan.initialState,
     actions: plan.actions,
     sections,
-    question,
-    answer,
+    question: renderQuestion(resolved, maze, sections),
+    answer: renderAnswer(resolved, maze, result.answers, plan.actions.length),
     result
   };
 }
 function resolveTrialOptions(options = {}) {
   const scenario = options.scenario ?? "success";
   const language = options.language ?? "en";
-  if (!["success", "treasure-and-leave", "death-and-stop"].includes(scenario)) {
-    throw new Error(`Unknown scenario: ${scenario}`);
-  }
+  if (!["success", "treasure-and-leave", "death-and-stop", "mechanism-tour"].includes(scenario)) throw new Error(`Unknown scenario: ${scenario}`);
   if (language !== "en" && language !== "zh") throw new Error(`Unknown language: ${language}`);
+  const mechanisms = resolveMechanisms(options);
+  const defaults = defaultObjectCounts(mechanisms.complexity);
   const resolved = {
     seed: integer(options.seed ?? 1, "seed", 0),
     rows: oddInteger(options.rows ?? 15, "rows", 7),
     cols: oddInteger(options.cols ?? 15, "cols", 7),
     braid: finiteNumber(options.braid ?? 0, "braid", 0, 1),
-    doorCount: integer(options.doorCount ?? 1, "doorCount", 0),
-    chestCount: integer(options.chestCount ?? 2, "chestCount", 0),
-    trapCount: integer(options.trapCount ?? 2, "trapCount", 0),
-    medicineCount: integer(options.medicineCount ?? 2, "medicineCount", 0),
+    doorCount: integer(options.doorCount ?? defaults.doors, "doorCount", 0),
+    chestCount: integer(options.chestCount ?? defaults.chests, "chestCount", 0),
+    trapCount: integer(options.trapCount ?? defaults.traps, "trapCount", 0),
+    potionCount: integer(options.potionCount ?? options.medicineCount ?? defaults.potions, "potionCount", 0),
+    mechanisms,
     scenario,
     language,
     style: integer(options.style ?? 0, "style", 0),
     minDistance: integer(options.minDistance ?? 0, "minDistance", 0),
     maxAttempts: integer(options.maxAttempts ?? 500, "maxAttempts", 1)
   };
-  if (scenario === "treasure-and-leave" && resolved.chestCount < 1) {
-    throw new Error("The treasure-and-leave scenario requires at least one chest.");
-  }
-  if (scenario === "treasure-and-leave" && resolved.medicineCount < 1) {
-    throw new Error("The treasure-and-leave scenario requires at least one medicine room.");
+  validateScenarioOptions(resolved);
+  return resolved;
+}
+function validateScenarioOptions(options) {
+  if (options.scenario === "treasure-and-leave") {
+    if (options.chestCount < 1) throw new Error("The treasure-and-leave scenario requires at least one chest.");
+    if (!options.mechanisms.potionKinds.includes("healing")) throw new Error("The treasure-and-leave scenario requires healing in potionKinds.");
+    if (options.potionCount < 1) throw new Error("The treasure-and-leave scenario requires at least one potion.");
   }
-  if (scenario === "death-and-stop" && resolved.trapCount < 1) {
-    throw new Error("The death-and-stop scenario requires at least one trap.");
+  if (options.scenario === "death-and-stop" && options.trapCount < 1) throw new Error("The death-and-stop scenario requires at least one trap.");
+  if (options.scenario === "mechanism-tour") {
+    if (options.trapCount < options.mechanisms.trapDamages.length) throw new Error("The mechanism-tour scenario needs at least one trap for every configured trap damage.");
+    if (options.potionCount < options.mechanisms.potionKinds.length) throw new Error("The mechanism-tour scenario needs at least one potion for every configured potion kind.");
+    if (options.chestCount < options.mechanisms.treasureTypes.length) throw new Error("The mechanism-tour scenario needs at least one chest for every configured treasure type.");
+    if (options.doorCount < options.mechanisms.keyMaterials.length) throw new Error("The mechanism-tour scenario needs at least one door for every configured key material.");
   }
-  return resolved;
 }
 function selectMaze(options) {
   let lastError = null;
   for (let offset = 0; offset < options.maxAttempts; offset += 1) {
     const effectiveSeed = options.seed + offset;
     try {
-      const base = generateSolidCellMaze({
-        rows: options.rows,
-        cols: options.cols,
-        braid: options.braid,
-        seed: effectiveSeed,
-        requestedSeed: options.seed,
-        id: `maze-test-${options.rows}x${options.cols}-${options.seed}`
-      });
-      const maze = decorateSolidCellMaze(base, {
-        seed: effectiveSeed + 8e4,
-        doorCount: options.doorCount,
-        chestCount: options.chestCount,
-        trapCount: options.trapCount,
-        medicineCount: options.medicineCount
-      });
+      const base = generateSolidCellMaze({ rows: options.rows, cols: options.cols, braid: options.braid, seed: effectiveSeed, requestedSeed: options.seed, mechanisms: options.mechanisms, id: `maze-test-${options.rows}x${options.cols}-${options.seed}` });
+      const maze = decorateSolidCellMaze(base, { seed: effectiveSeed + 8e4, doorCount: options.doorCount, chestCount: options.chestCount, trapCount: options.trapCount, potionCount: options.potionCount, mechanisms: options.mechanisms });
       const validation = validateSolidCellMaze(maze);
       if (!validation.valid) throw new Error(validation.errors.join(" "));
-      if ((validation.metrics?.entryGoalDistance ?? 0) < options.minDistance) {
-        throw new Error(`The entry-goal distance is below ${options.minDistance}.`);
-      }
+      if ((validation.metrics?.entryGoalDistance ?? 0) < options.minDistance) throw new Error(`The entry-goal distance is below ${options.minDistance}.`);
       const plan = buildScenarioPlan(maze, options.scenario);
       const result = simulateTrial(maze, plan.actions, plan.initialState);
       verifyScenario(options.scenario, result.answers, maze);
@@ -826,172 +1123,82 @@ function selectMaze(options) {
     }
   }
   const detail = lastError instanceof Error ? ` Last error: ${lastError.message}` : "";
-  throw new Error(
-    `Could not generate a valid trial in ${options.maxAttempts} deterministic attempts.${detail}`
-  );
+  throw new Error(`Could not generate a valid trial in ${options.maxAttempts} deterministic attempts.${detail}`);
 }
 function buildScenarioPlan(maze, scenario) {
+  const ample = ampleInitialState(maze);
   if (scenario === "success") {
-    return {
-      initialState: { health: 5, healthMax: 5, keys: 0, treasures: 0 },
-      actions: pathToActions(shortestPath(maze, maze.entry, maze.goal))
-    };
+    const damage = maze.objects.filter((item) => item.type === "trap").reduce((sum, item) => sum + item.damage, 0);
+    const poisonBudget = maze.mechanisms.potionKinds.includes("poison") ? maze.mechanisms.poisonDamage * maze.mechanisms.poisonDuration : 0;
+    const health = Math.max(5, damage + poisonBudget + 1);
+    return { initialState: { health, healthMax: health, keys: 0, treasures: 0 }, actions: pathToActions(shortestPath(maze, maze.entry, maze.goal)) };
   }
   if (scenario === "treasure-and-leave") {
-    const medicine = maze.objects.find((item) => item.type === "medicine");
+    const healing = maze.objects.find((item) => item.type === "medicine" || item.type === "potion" && item.kind === "healing");
     const chest = maze.objects.find((item) => item.type === "chest");
-    if (!medicine || !chest) throw new Error("This scenario requires a medicine room and a chest.");
-    const path1 = shortestPath(maze, maze.entry, medicine.position);
-    const path2 = shortestPath(maze, medicine.position, chest.position);
-    const path3 = shortestPath(maze, chest.position, maze.goal);
-    const leavePath = [...path3].reverse().slice(0, Math.min(10, path3.length));
-    let actions = [
-      ...pathToActions(path1),
-      ...pathToActions(path2),
-      ...pathToActions(path3),
-      ...pathToActions(leavePath)
-    ];
-    const initialState = {
-      health: 3,
-      healthMax: 5,
-      keys: maze.doors.length + 2,
-      treasures: 0
-    };
-    const beforeBump = simulateTrial(maze, actions, initialState);
-    const bump = wallDirection(maze, beforeBump.state.position);
-    if (bump) actions = [...actions, bump, bump];
+    if (!healing || !chest) throw new Error("This scenario requires a healing object and a chest.");
+    let actions = routeThrough(maze, [maze.entry, healing.position, chest.position, maze.goal]);
+    const leavePath = shortestPath(maze, maze.goal, chest.position).slice(0, 10);
+    actions.push(...pathToActions(leavePath));
+    const initialState = { ...ample, health: 50, healthMax: 100 };
+    const bump = wallDirection(maze, simulateTrial(maze, actions, initialState).state.position);
+    if (bump) actions.push(bump, bump);
     return { initialState, actions };
   }
-  const trap = maze.objects.find((item) => item.type === "trap");
-  if (!trap) throw new Error("This scenario requires a trap.");
-  const toTrap = shortestPath(maze, maze.entry, trap.position);
-  const afterTrap = shortestPath(maze, trap.position, maze.goal).slice(0, 14);
-  return {
-    initialState: {
-      health: 1,
-      healthMax: 1,
-      keys: maze.doors.length + 1,
-      treasures: 0
-    },
-    actions: [...pathToActions(toTrap), ...pathToActions(afterTrap)]
-  };
-}
-function verifyScenario(scenario, answers, maze) {
-  if (scenario === "success" && (!answers.reachedGoal || !answers.alive || answers.finalPosition !== letterNumberCoordinate(maze.goal))) {
-    throw new Error("The success scenario did not finish alive at the goal.");
-  }
-  if (scenario === "treasure-and-leave" && (!answers.reachedGoal || answers.finalPosition === letterNumberCoordinate(maze.goal) || answers.openedChests < 1 || answers.usedMedicines < 1 || answers.blockedMoves < 2)) {
-    throw new Error("The treasure-and-leave scenario did not meet its invariants.");
+  if (scenario === "death-and-stop") {
+    const trap = maze.objects.find((item) => item.type === "trap");
+    if (!trap) throw new Error("This scenario requires a trap.");
+    const actions = [...pathToActions(shortestPath(maze, maze.entry, trap.position)), ...pathToActions(shortestPath(maze, trap.position, maze.goal).slice(0, 14))];
+    for (let health = 1; health <= 200; health += 1) {
+      const initialState = { ...ample, health, healthMax: health };
+      const result = simulateTrial(maze, actions, initialState);
+      if (result.trace.some((item) => item.events.some((event) => event.type === "trigger-trap" && event.id === trap.id) && item.events.some((event) => event.type === "die"))) return { initialState, actions };
+    }
+    throw new Error("Could not choose health that makes the death-and-stop scenario die on its target trap.");
   }
-  if (scenario === "death-and-stop" && (answers.alive || answers.blockedAfterDeath < 5)) {
-    throw new Error("The death-and-stop scenario did not meet its invariants.");
+  return { initialState: { ...ample, health: 1e3, healthMax: 1e3 }, actions: routeThrough(maze, [maze.entry, ...maze.objects.map((item) => item.position), maze.goal]) };
+}
+function ampleInitialState(maze) {
+  const material = emptyMaterialCounts();
+  for (const door of maze.doors) if (door.material) material[door.material] += 1;
+  for (const object of maze.objects) if (object.type === "chest" && object.lockMaterial) material[object.lockMaterial] += 1;
+  return { health: 100, healthMax: 100, keys: maze.doors.filter((door) => !door.material).length + maze.objects.filter((item) => item.type === "chest" && !item.lockMaterial).length, keysByMaterial: material, treasures: 0 };
+}
+function verifyScenario(scenario, a, maze) {
+  if (scenario === "success" && (!a.reachedGoal || !a.alive || a.finalPosition !== letterNumberCoordinate(maze.goal))) throw new Error("The success scenario did not finish alive at the goal.");
+  if (scenario === "treasure-and-leave" && (!a.reachedGoal || a.finalPosition === letterNumberCoordinate(maze.goal) || a.openedChests < 1 || a.usedMedicines + a.usedPotions < 1 || a.blockedMoves < 2)) throw new Error("The treasure-and-leave scenario did not meet its invariants.");
+  if (scenario === "death-and-stop" && (a.alive || a.triggeredTraps < 1 || a.blockedAfterDeath < 5)) throw new Error("The death-and-stop scenario did not meet its invariants.");
+  if (scenario === "mechanism-tour") {
+    const count = (type) => maze.objects.filter((item) => item.type === type).length;
+    if (!a.alive || !a.reachedGoal || a.openedDoors !== maze.doors.length || a.openedChests !== count("chest") || a.triggeredTraps !== count("trap") || a.usedPotions !== count("potion") || a.usedMedicines !== count("medicine")) throw new Error("The mechanism-tour scenario did not exercise every generated mechanism object.");
   }
 }
 function renderQuestion(options, maze, sections) {
-  const isZh = options.language === "zh";
-  const title = isZh ? "\u8FF7\u5BAB\u8BD5\u9898" : "Maze Trial";
-  const labels = isZh ? ["\u5730\u56FE\u63CF\u8FF0", "\u673A\u5236\u63CF\u8FF0", "\u884C\u52A8\u63CF\u8FF0", "\u95EE\u9898"] : ["Map", "Rules", "Actions", "Questions"];
-  const seedLine = maze.seed === options.seed ? `${isZh ? "\u79CD\u5B50" : "Seed"}: ${options.seed}` : `${isZh ? "\u79CD\u5B50" : "Seed"}: ${options.seed} (${isZh ? "\u6709\u6548\u8FF7\u5BAB\u79CD\u5B50" : "effective maze seed"}: ${maze.seed})`;
-  return [
-    `# ${title}`,
-    "",
-    seedLine,
-    "",
-    `## 1. ${labels[0]}`,
-    "",
-    sections.map,
-    "",
-    `## 2. ${labels[1]}`,
-    "",
-    sections.rules,
-    "",
-    `## 3. ${labels[2]}`,
-    "",
-    sections.actions,
-    "",
-    `## 4. ${labels[3]}`,
-    "",
-    sections.questions,
-    ""
-  ].join("\n");
-}
-function renderAnswer(options, maze, answers, actionCount) {
   const zh = options.language === "zh";
-  const rows = zh ? [
-    ["\u6700\u7EC8\u4F4D\u7F6E", answers.finalPosition],
-    ["\u6700\u7EC8\u94A5\u5319\u6570", answers.keys],
-    ["\u6700\u7EC8\u5B9D\u7269\u6570", answers.treasures],
-    ["\u6700\u7EC8\u5065\u5EB7\u503C", answers.health],
-    ["\u662F\u5426\u5B58\u6D3B", answers.alive ? "\u662F" : "\u5426"],
-    ["\u662F\u5426\u66FE\u5230\u8FBE\u7EC8\u70B9", answers.reachedGoal ? "\u662F" : "\u5426"],
-    ["\u6253\u5F00\u7684\u95E8", answers.openedDoors],
-    ["\u6253\u5F00\u7684\u5B9D\u7BB1", answers.openedChests],
-    ["\u89E6\u53D1\u7684\u9677\u9631", answers.triggeredTraps],
-    ["\u4F7F\u7528\u7684\u836F\u54C1\u623F", answers.usedMedicines],
-    ["\u672A\u6539\u53D8\u4F4D\u7F6E\u7684\u79FB\u52A8", answers.blockedMoves]
-  ] : [
-    ["Final position", answers.finalPosition],
-    ["Keys remaining", answers.keys],
-    ["Treasures collected", answers.treasures],
-    ["Health remaining", answers.health],
-    ["Alive", answers.alive ? "Yes" : "No"],
-    ["Ever reached the goal", answers.reachedGoal ? "Yes" : "No"],
-    ["Doors opened", answers.openedDoors],
-    ["Chests opened", answers.openedChests],
-    ["Traps triggered", answers.triggeredTraps],
-    ["Medicine rooms used", answers.usedMedicines],
-    ["Moves that did not change position", answers.blockedMoves]
-  ];
-  return [
-    `# ${zh ? "\u6807\u51C6\u7B54\u6848" : "Answer Key"}`,
-    "",
-    `${zh ? "\u79CD\u5B50" : "Seed"}: ${options.seed}`,
-    ...maze.seed === options.seed ? [] : [
-      `${zh ? "\u6709\u6548\u8FF7\u5BAB\u79CD\u5B50" : "Effective maze seed"}: ${maze.seed}`
-    ],
-    "",
-    `| ${zh ? "\u95EE\u9898" : "Item"} | ${zh ? "\u7B54\u6848" : "Answer"} |`,
-    "|---|---|",
-    ...rows.map(([label, value]) => `| ${label} | ${String(value)} |`),
-    "",
-    `${zh ? "\u539F\u5B50\u884C\u52A8\u6570" : "Atomic action count"}: ${actionCount}`,
-    ""
-  ].join("\n");
+  const labels = zh ? ["\u5730\u56FE\u63CF\u8FF0", "\u673A\u5236\u63CF\u8FF0", "\u884C\u52A8\u63CF\u8FF0", "\u95EE\u9898"] : ["Map", "Rules", "Actions", "Questions"];
+  const seedLine = maze.seed === options.seed ? `${zh ? "\u79CD\u5B50" : "Seed"}: ${options.seed}` : `${zh ? "\u79CD\u5B50" : "Seed"}: ${options.seed} (${zh ? "\u6709\u6548\u8FF7\u5BAB\u79CD\u5B50" : "effective maze seed"}: ${maze.seed})`;
+  return [`# ${zh ? "\u8FF7\u5BAB\u8BD5\u9898" : "Maze Trial"}`, "", seedLine, `${zh ? "\u673A\u5236\u590D\u6742\u5EA6" : "Mechanism complexity"}: ${options.mechanisms.complexity}`, "", `## 1. ${labels[0]}`, "", sections.map, "", `## 2. ${labels[1]}`, "", sections.rules, "", `## 3. ${labels[2]}`, "", sections.actions, "", `## 4. ${labels[3]}`, "", sections.questions, ""].join("\n");
+}
+function renderAnswer(options, maze, a, actionCount) {
+  const zh = options.language === "zh";
+  const rows = zh ? [["\u6700\u7EC8\u4F4D\u7F6E", a.finalPosition], ["\u6700\u7EC8\u94A5\u5319\u603B\u6570", a.keys], ["\u6700\u7EC8\u5B9D\u7269\u603B\u6570", a.treasures], ["\u6700\u7EC8\u5065\u5EB7\u503C", a.health], ["\u662F\u5426\u5B58\u6D3B", a.alive ? "\u662F" : "\u5426"], ["\u662F\u5426\u66FE\u5230\u8FBE\u7EC8\u70B9", a.reachedGoal ? "\u662F" : "\u5426"], ["\u6253\u5F00\u7684\u95E8", a.openedDoors], ["\u6253\u5F00\u7684\u5B9D\u7BB1", a.openedChests], ["\u89E6\u53D1\u7684\u9677\u9631", a.triggeredTraps]] : [["Final position", a.finalPosition], ["Keys remaining in total", a.keys], ["Treasures collected in total", a.treasures], ["Health remaining", a.health], ["Alive", a.alive ? "Yes" : "No"], ["Ever reached the goal", a.reachedGoal ? "Yes" : "No"], ["Doors opened", a.openedDoors], ["Chests opened", a.openedChests], ["Traps triggered", a.triggeredTraps]];
+  if (maze.objects.some((item) => item.type === "medicine")) rows.push([zh ? "\u4F7F\u7528\u7684\u836F\u54C1\u623F" : "Medicine rooms used", a.usedMedicines]);
+  if (maze.objects.some((item) => item.type === "potion")) rows.push([zh ? "\u996E\u7528\u7684\u836F\u6C34" : "Potions drunk", a.usedPotions]);
+  rows.push([zh ? "\u672A\u6539\u53D8\u4F4D\u7F6E\u7684\u539F\u5B50\u79FB\u52A8\u6307\u4EE4" : "Atomic movement instructions that did not change position", a.blockedMoves]);
+  for (const material of maze.mechanisms.keyMaterials) rows.push([zh ? `\u5269\u4F59${MATERIAL_NAMES[material].zh}\u94A5\u5319` : `${capitalize(MATERIAL_NAMES[material].en)} keys remaining`, a.keysByMaterial[material]]);
+  if (maze.mechanisms.treasureTypes.some((type) => type !== "treasure")) for (const type of maze.mechanisms.treasureTypes) rows.push([zh ? `${TREASURE_NAMES[type].zh}\u6570\u91CF` : `${capitalize(TREASURE_NAMES[type].en)}s collected`, a.treasuresByType[type]]);
+  if (maze.mechanisms.complexity === "advanced") rows.push([zh ? "\u7D2F\u8BA1\u8017\u65F6\uFF08\u65F6\u95F4\u5355\u4F4D\uFF09" : "Elapsed time (time units)", a.elapsedTime], [zh ? "\u6700\u7EC8\u901F\u5EA6\u72B6\u6001" : "Final speed state", SPEED_NAMES[a.finalSpeed][zh ? "zh" : "en"]], [zh ? "\u901F\u5EA6\u6548\u679C\u5269\u4F59\u6307\u4EE4\u6570" : "Speed-effect instructions remaining", a.speedRemaining], [zh ? "\u4E2D\u6BD2\u5269\u4F59\u6307\u4EE4\u6570" : "Poison instructions remaining", a.poisonRemaining]);
+  return [`# ${zh ? "\u6807\u51C6\u7B54\u6848" : "Answer Key"}`, "", `${zh ? "\u79CD\u5B50" : "Seed"}: ${options.seed}`, ...maze.seed === options.seed ? [] : [`${zh ? "\u6709\u6548\u8FF7\u5BAB\u79CD\u5B50" : "Effective maze seed"}: ${maze.seed}`], "", `| ${zh ? "\u95EE\u9898" : "Item"} | ${zh ? "\u7B54\u6848" : "Answer"} |`, "|---|---|", ...rows.map(([label, value]) => `| ${label} | ${String(value)} |`), "", `${zh ? "\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u6570" : "Atomic movement instruction count"}: ${actionCount}`, ""].join("\n");
 }
 function renderMapDescription(maze, initial, language, style) {
   const terrain = renderTerrainDescription(maze, language, style);
   const objects = renderObjectDescription(maze, language);
-  if (language === "zh") {
-    return [
-      `\u8FD9\u662F\u4E00\u5EA7${maze.rows}\u884C${maze.cols}\u5217\u7684\u8FF7\u5BAB\u3002\u5DE6\u4E0A\u89D2\u4E3AA1\uFF0C\u5217\u4ECE\u5DE6\u5411\u53F3\u4F9D\u6B21\u6807\u4E3AA\u81F3${columnLabel(maze.cols)}\uFF0C\u884C\u4ECE\u4E0A\u5411\u4E0B\u7F16\u53F7\u4E3A1\u81F3${maze.rows}\u3002`,
-      `\u5165\u53E3\u4F4D\u4E8E${letterNumberCoordinate(maze.entry)}\uFF0C\u7EC8\u70B9\u4F4D\u4E8E${letterNumberCoordinate(maze.goal)}\u3002`,
-      "",
-      terrain,
-      "",
-      "\u8FF7\u5BAB\u4E2D\u7684\u95E8\u548C\u5176\u4ED6\u5BF9\u8C61\u5206\u5E03\u5982\u4E0B\u3002\u95E8\u672C\u8EAB\u5360\u636E\u4E00\u4E2A\u5B8C\u6574\u683C\u5B50\u3002",
-      objects,
-      "",
-      `\u8FF7\u5BAB\u4E2D\u6709\u4E00\u540D\u63A2\u9669\u8005\u3002\u4ED6\u4ECE\u5165\u53E3\u51FA\u53D1\uFF0C\u521D\u59CB\u5065\u5EB7\u503C\u4E3A${numberZh(initial.health)}\u70B9\uFF0C\u5065\u5EB7\u4E0A\u9650\u4E3A${numberZh(initial.healthMax)}\u70B9\uFF1B${initialPossessions(initial, language)}\uFF0C\u5C1A\u672A\u5230\u8FBE\u7EC8\u70B9\u3002`
-    ].join("\n");
-  }
-  return [
-    `This maze has ${maze.rows} rows and ${maze.cols} columns. The top-left cell is A1. Columns run left to right from A to ${columnLabel(maze.cols)}, and rows run top to bottom from 1 to ${maze.rows}.`,
-    `The entry is at ${letterNumberCoordinate(maze.entry)}, and the goal is at ${letterNumberCoordinate(maze.goal)}.`,
-    "",
-    terrain,
-    "",
-    "Doors and other objects are distributed as follows. Each door occupies a whole cell.",
-    objects,
-    "",
-    `An explorer starts at the entry with ${initial.health} health point${plural(initial.health)}, a maximum health of ${initial.healthMax}, ${initialPossessions(initial, language)}, and reached-goal set to false.`
-  ].join("\n");
+  if (language === "zh") return [`\u8FD9\u662F\u4E00\u5EA7${maze.rows}\u884C${maze.cols}\u5217\u7684\u8FF7\u5BAB\u3002\u5DE6\u4E0A\u89D2\u4E3AA1\uFF0C\u5217\u4ECE\u5DE6\u5411\u53F3\u4F9D\u6B21\u6807\u4E3AA\u81F3${columnLabel(maze.cols)}\uFF0C\u884C\u4ECE\u4E0A\u5411\u4E0B\u7F16\u53F7\u4E3A1\u81F3${maze.rows}\u3002`, `\u5165\u53E3\u4F4D\u4E8E${letterNumberCoordinate(maze.entry)}\uFF0C\u7EC8\u70B9\u4F4D\u4E8E${letterNumberCoordinate(maze.goal)}\u3002`, "", terrain, "", "\u95E8\u548C\u5BF9\u8C61\u7684\u4F4D\u7F6E\u5982\u4E0B\uFF1B\u95E8\u4E0E\u5BF9\u8C61\u6240\u5728\u683C\u4ECD\u662F\u53EF\u4EE5\u8FDB\u5165\u7684\u901A\u8DEF\u683C\u3002", objects, "", `\u63A2\u9669\u8005\u4ECE\u5165\u53E3\u51FA\u53D1\uFF0C\u521D\u59CB\u5065\u5EB7\u503C\u4E3A${initial.health}\uFF0C\u5065\u5EB7\u4E0A\u9650\u4E3A${initial.healthMax}\uFF1B${initialPossessions(initial, language)}\uFF1B\u521D\u59CB\u672A\u4E2D\u6BD2\u3001\u901F\u5EA6\u4E3A\u6B63\u5E38\uFF1B\u201C\u66FE\u7ECF\u5230\u8FBE\u7EC8\u70B9\u201D\u8BB0\u5F55\u4E3A\u5047\u3002`].join("\n");
+  return [`This maze has ${maze.rows} rows and ${maze.cols} columns. The top-left cell is A1. Columns run left to right from A to ${columnLabel(maze.cols)}, and rows run top to bottom from 1 to ${maze.rows}.`, `The entry is at ${letterNumberCoordinate(maze.entry)}, and the goal is at ${letterNumberCoordinate(maze.goal)}.`, "", terrain, "", "Door and object locations follow. A cell containing a door or object is still a passage cell that may be entered, subject to the door rule.", objects, "", `The explorer starts at the entry with ${initial.health} health, a maximum health of ${initial.healthMax}, ${initialPossessions(initial, language)}, no poison, normal speed, and reached-goal set to false.`].join("\n");
 }
 function renderTerrainDescription(maze, language, style) {
   const clauses = Array.from({ length: maze.rows }, (_, index) => index + 1).map((row) => {
-    const kinds = Array.from(
-      { length: maze.cols },
-      (_, index) => terrainAt(maze, cell(row, index + 1)) === "." ? "floor" : "wall"
-    );
+    const kinds = Array.from({ length: maze.cols }, (_, index) => terrainAt(maze, cell(row, index + 1)) === "." ? "floor" : "wall");
     const label = language === "zh" ? [`\u7B2C${row}\u884C`, `${row}\u3001`, `\uFF08${row}\uFF09`][style % 3] : `Row ${row}: `;
     return `${label ?? `\u7B2C${row}\u884C`}${describeTerrainLine(kinds, language)}`;
   });
@@ -1000,9 +1207,7 @@ function renderTerrainDescription(maze, language, style) {
 function describeTerrainLine(kinds, language) {
   const walls = [];
   const floors = [];
-  for (let index = 0; index < kinds.length; index += 1) {
-    (kinds[index] === "wall" ? walls : floors).push(index + 1);
-  }
+  for (let index = 0; index < kinds.length; index += 1) (kinds[index] === "wall" ? walls : floors).push(index + 1);
   if (language === "zh") {
     if (walls.length === 0) return "\u90FD\u662F\u901A\u8DEF";
     if (floors.length === 0) return "\u90FD\u662F\u5899\u58C1";
@@ -1033,76 +1238,110 @@ function positionList(indices, language) {
     end = value;
   }
   ranges.push([start, end]);
-  const parts = ranges.map(
-    ([from, to]) => language === "zh" ? from === to ? `\u7B2C${from}\u683C` : `\u7B2C${from}\u683C\u81F3\u7B2C${to}\u683C` : from === to ? `cell ${from}` : `cells ${from}-${to}`
-  );
+  const parts = ranges.map(([from, to]) => language === "zh" ? from === to ? `\u7B2C${from}\u683C` : `\u7B2C${from}\u683C\u81F3\u7B2C${to}\u683C` : from === to ? `cell ${from}` : `cells ${from}-${to}`);
   if (parts.length === 1) return parts[0] ?? "";
-  const last = parts.at(-1);
-  return language === "zh" ? `${parts.slice(0, -1).join("\u3001")}\u548C${last}` : `${parts.slice(0, -1).join(", ")} and ${last}`;
+  return language === "zh" ? `${parts.slice(0, -1).join("\u3001")}\u548C${parts.at(-1)}` : `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
 }
 function renderObjectDescription(maze, language) {
-  const sentences = [];
-  const doorPositions = maze.doors.map((item) => letterNumberCoordinate(item.position));
-  const keys = maze.objects.filter((item) => item.type === "key");
-  const chests = maze.objects.filter((item) => item.type === "chest");
-  const traps = maze.objects.filter((item) => item.type === "trap");
-  const medicines = maze.objects.filter((item) => item.type === "medicine");
-  if (language === "zh") {
-    if (doorPositions.length > 0) sentences.push(`${coordinateList(doorPositions, language)}${doorPositions.length > 1 ? "\u5404" : ""}\u6709\u4E00\u9053\u521D\u59CB\u5173\u95ED\u7684\u95E8\u3002`);
-    const keyPositions = keys.map((item) => letterNumberCoordinate(item.position));
-    if (keyPositions.length > 0) sentences.push(`${coordinateList(keyPositions, language)}${keyPositions.length > 1 ? "\u5404" : ""}\u653E\u7740\u4E00\u628A\u94A5\u5319\u3002`);
-    for (const chest of chests) sentences.push(`${letterNumberCoordinate(chest.position)}\u653E\u7740\u4E00\u53EA\u521D\u59CB\u5173\u95ED\u7684\u5B9D\u7BB1\uFF0C\u7BB1\u5185\u6709${numberZh(chest.treasures)}\u4EF6\u5B9D\u7269\u3002`);
-    const trapPositions = traps.map((item) => letterNumberCoordinate(item.position));
-    if (trapPositions.length > 0) sentences.push(`${coordinateList(trapPositions, language)}${trapPositions.length > 1 ? "\u5404" : ""}\u8BBE\u6709\u4E00\u4E2A\u5C1A\u672A\u89E6\u53D1\u7684\u9677\u9631\u3002`);
-    const medicinePositions = medicines.map((item) => letterNumberCoordinate(item.position));
-    if (medicinePositions.length > 0) sentences.push(`${coordinateList(medicinePositions, language)}${medicinePositions.length > 1 ? "\u5404" : ""}\u6709\u4E00\u4E2A\u5C1A\u672A\u4F7F\u7528\u7684\u836F\u54C1\u623F\u3002`);
-  } else {
-    if (doorPositions.length > 0) sentences.push(`${coordinateList(doorPositions, language)} ${doorPositions.length === 1 ? "contains a closed door" : "each contain a closed door"}.`);
-    const keyPositions = keys.map((item) => letterNumberCoordinate(item.position));
-    if (keyPositions.length > 0) sentences.push(`${coordinateList(keyPositions, language)} ${keyPositions.length === 1 ? "contains a key" : "each contain a key"}.`);
-    for (const chest of chests) sentences.push(`${letterNumberCoordinate(chest.position)} contains a closed chest with ${chest.treasures} treasure${plural(chest.treasures)}.`);
-    const trapPositions = traps.map((item) => letterNumberCoordinate(item.position));
-    if (trapPositions.length > 0) sentences.push(`${coordinateList(trapPositions, language)} ${trapPositions.length === 1 ? "contains an untriggered trap" : "each contain an untriggered trap"}.`);
-    const medicinePositions = medicines.map((item) => letterNumberCoordinate(item.position));
-    if (medicinePositions.length > 0) sentences.push(`${coordinateList(medicinePositions, language)} ${medicinePositions.length === 1 ? "contains an unused medicine room" : "each contain an unused medicine room"}.`);
+  const lines = [];
+  for (const door of maze.doors) {
+    const at = letterNumberCoordinate(door.position);
+    lines.push(language === "zh" ? `${at}\u6709\u4E00\u9053\u521D\u59CB\u5173\u95ED\u7684${door.material ? MATERIAL_NAMES[door.material].zh : "\u666E\u901A"}\u95E8\u3002` : `${at} contains an initially closed ${door.material ? `${MATERIAL_NAMES[door.material].en} ` : "ordinary "}door.`);
   }
-  return sentences.length > 0 ? sentences.join("\n") : language === "zh" ? "\u6CA1\u6709\u95E8\u6216\u5176\u4ED6\u5BF9\u8C61\u3002" : "There are no doors or other objects.";
-}
-function renderRules(language) {
-  return (language === "zh" ? CHINESE_RULES : ENGLISH_RULES).join("\n");
+  for (const object of maze.objects) {
+    const at = letterNumberCoordinate(object.position);
+    if (object.type === "key") lines.push(language === "zh" ? `${at}\u653E\u7740\u4E00\u628A${object.material ? MATERIAL_NAMES[object.material].zh : "\u666E\u901A"}\u94A5\u5319\u3002` : `${at} contains one ${object.material ? `${MATERIAL_NAMES[object.material].en} ` : "ordinary "}key.`);
+    else if (object.type === "chest") {
+      const contents = (object.contents ?? [{ type: "treasure", count: object.treasures }]).map((item) => language === "zh" ? `${item.count}${treasureUnit(item.type)}${TREASURE_NAMES[item.type].zh}` : `${item.count} ${TREASURE_NAMES[item.type].en}${plural(item.count)}`).join(language === "zh" ? "\u3001" : " and ");
+      const lock = object.lockMaterial ? `a ${MATERIAL_NAMES[object.lockMaterial].en} lock` : "an ordinary lock";
+      lines.push(language === "zh" ? `${at}\u6709\u4E00\u53EA\u521D\u59CB\u5173\u95ED\u7684${object.lockMaterial ? MATERIAL_NAMES[object.lockMaterial].zh : "\u666E\u901A"}\u9501\u5B9D\u7BB1\uFF0C\u5185\u6709${contents}\u3002` : `${at} contains an initially closed chest with ${lock}, containing ${contents}.`);
+    } else if (object.type === "trap") lines.push(language === "zh" ? `${at}\u6709\u4E00\u4E2A\u5C1A\u672A\u89E6\u53D1\u7684\u9677\u9631\uFF0C\u4F24\u5BB3\u4E3A${object.damage}\u70B9\u3002` : `${at} contains an untriggered trap that deals ${object.damage} damage.`);
+    else if (object.type === "medicine") lines.push(language === "zh" ? `${at}\u6709\u4E00\u4E2A\u5C1A\u672A\u4F7F\u7528\u7684\u836F\u54C1\u623F\uFF0C\u53EF\u6062\u590D${object.recovery}\u70B9\u5065\u5EB7\u503C\u3002` : `${at} contains an unused medicine room that restores ${object.recovery} health.`);
+    else {
+      const details = potionDetails(object.kind, object.potency, object.duration, language);
+      lines.push(language === "zh" ? `${at}\u6709\u4E00\u74F6\u5C1A\u672A\u996E\u7528\u7684${POTION_NAMES[object.kind].zh}${details}\u3002` : `${at} contains an unused ${POTION_NAMES[object.kind].en}${details}.`);
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : language === "zh" ? "\u6CA1\u6709\u95E8\u6216\u5176\u4ED6\u5BF9\u8C61\u3002" : "There are no doors or other objects.";
 }
-function renderQuestions(language) {
-  return (language === "zh" ? CHINESE_QUESTIONS : ENGLISH_QUESTIONS).join("\n");
+function potionDetails(kind, potency, duration, language) {
+  if (language === "zh") {
+    if (kind === "healing") return `\uFF0C\u6062\u590D${potency ?? 1}\u70B9\u5065\u5EB7\u503C\uFF0C\u4F46\u4E0D\u8D85\u8FC7\u5065\u5EB7\u4E0A\u9650`;
+    if (kind === "poison") return `\uFF0C\u4F7F\u996E\u7528\u8005\u5728\u4E4B\u540E${duration ?? 1}\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u5404\u635F\u5931${potency ?? 1}\u70B9\u5065\u5EB7\u503C`;
+    if (kind === "haste" || kind === "slow") return `\uFF0C\u6548\u679C\u6301\u7EED\u4E4B\u540E${duration ?? 1}\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4`;
+    return "\uFF0C\u53EF\u7ACB\u5373\u6E05\u9664\u4E2D\u6BD2\u72B6\u6001";
+  }
+  if (kind === "healing") return ` that restores ${potency ?? 1} health without exceeding maximum health`;
+  if (kind === "poison") return ` that causes ${potency ?? 1} damage after each of the next ${duration ?? 1} atomic movement instructions`;
+  if (kind === "haste" || kind === "slow") return ` whose effect lasts for the next ${duration ?? 1} atomic movement instructions`;
+  return " that immediately clears poison";
+}
+function renderRules(maze, language) {
+  const m = maze.mechanisms;
+  const usesPotionObjects = maze.objects.some((item) => item.type === "potion");
+  const usesPoison = usesPotionObjects && m.potionKinds.some((kind) => kind === "poison" || kind === "antidote");
+  const usesMaterials = m.keyMaterials.length > 0;
+  const doorRuleZh = usesMaterials ? "\u76EE\u6807\u683C\u662F\u5173\u95ED\u7684\u95E8\u65F6\uFF0C\u5FC5\u987B\u6D88\u8017\u4E00\u628A\u4E0E\u95E8\u6750\u8D28\u76F8\u540C\u7684\u94A5\u5319\uFF1B\u94A5\u5319\u4E0D\u8DB3\u6216\u6750\u8D28\u4E0D\u7B26\u65F6\u505C\u5728\u539F\u5730\u3002\u94A5\u5319\u5339\u914D\u65F6\uFF0C\u5728\u540C\u4E00\u6761\u6307\u4EE4\u4E2D\u5F00\u95E8\u5E76\u8FDB\u5165\u95E8\u683C\u3002\u95E8\u4E00\u7ECF\u6253\u5F00\u4FBF\u6C38\u4E45\u4FDD\u6301\u6253\u5F00\u3002" : "\u76EE\u6807\u683C\u662F\u5173\u95ED\u7684\u666E\u901A\u95E8\u65F6\uFF0C\u5FC5\u987B\u6D88\u8017\u4E00\u628A\u666E\u901A\u94A5\u5319\uFF1B\u6CA1\u6709\u666E\u901A\u94A5\u5319\u65F6\u505C\u5728\u539F\u5730\u3002\u6709\u94A5\u5319\u65F6\uFF0C\u5728\u540C\u4E00\u6761\u6307\u4EE4\u4E2D\u5F00\u95E8\u5E76\u8FDB\u5165\u95E8\u683C\u3002\u95E8\u4E00\u7ECF\u6253\u5F00\u4FBF\u6C38\u4E45\u4FDD\u6301\u6253\u5F00\u3002";
+  const doorRuleEn = usesMaterials ? "If the target cell contains a closed door, the explorer must spend one key whose material matches the door. Without a matching key, the explorer stays in place. With a matching key, the door opens and the explorer enters the door cell in the same instruction. Once opened, a door remains open." : "If the target cell contains a closed ordinary door, the explorer must spend one ordinary key. Without an ordinary key, the explorer stays in place. With one, the door opens and the explorer enters the door cell in the same instruction. Once opened, a door remains open.";
+  const chestRuleZh = usesMaterials ? "\u6BCF\u6B21\u8FDB\u5165\u542B\u6709\u5C1A\u672A\u6253\u5F00\u5B9D\u7BB1\u7684\u683C\u5B50\u65F6\uFF0C\u82E5\u6301\u6709\u4E0E\u9501\u6750\u8D28\u76F8\u540C\u7684\u94A5\u5319\uFF0C\u5219\u6D88\u8017\u4E00\u628A\u8BE5\u94A5\u5319\u3001\u6253\u5F00\u5B9D\u7BB1\u5E76\u53D6\u5F97\u7BB1\u4E2D\u5168\u90E8\u7269\u54C1\uFF1B\u5426\u5219\u5B9D\u7BB1\u4FDD\u6301\u5173\u95ED\u3002\u5B9D\u7BB1\u683C\u65E0\u8BBA\u662F\u5426\u6253\u5F00\u90FD\u53EF\u4EE5\u8FDB\u5165\u6216\u7ECF\u8FC7\u3002\u7BB1\u5185\u6BCF\u4E00\u679A\u94B1\u5E01\u3001\u6BCF\u4E00\u9897\u5B9D\u77F3\u6216\u6BCF\u4E00\u4EF6\u9057\u7269\u90FD\u5206\u522B\u8BA1\u4E3A\u4E00\u4EF6\u5B9D\u7269\u3002" : "\u6BCF\u6B21\u8FDB\u5165\u542B\u6709\u5C1A\u672A\u6253\u5F00\u666E\u901A\u9501\u5B9D\u7BB1\u7684\u683C\u5B50\u65F6\uFF0C\u82E5\u6301\u6709\u666E\u901A\u94A5\u5319\uFF0C\u5219\u6D88\u8017\u4E00\u628A\u666E\u901A\u94A5\u5319\u3001\u6253\u5F00\u5B9D\u7BB1\u5E76\u53D6\u5F97\u7BB1\u4E2D\u5168\u90E8\u7269\u54C1\uFF1B\u5426\u5219\u5B9D\u7BB1\u4FDD\u6301\u5173\u95ED\u3002\u5B9D\u7BB1\u683C\u65E0\u8BBA\u662F\u5426\u6253\u5F00\u90FD\u53EF\u4EE5\u8FDB\u5165\u6216\u7ECF\u8FC7\u3002\u7BB1\u5185\u6BCF\u4EF6\u7269\u54C1\u8BA1\u4E3A\u4E00\u4EF6\u5B9D\u7269\u3002";
+  const chestRuleEn = usesMaterials ? "Whenever the explorer enters a cell containing an unopened chest, if a key matching its lock is available, one such key is spent, the chest opens, and all its contents are collected; otherwise, the chest remains closed. A chest cell may be entered or crossed whether or not the chest is open. Each coin, gem, or relic counts as one treasure." : "Whenever the explorer enters a cell containing an unopened chest with an ordinary lock, if an ordinary key is available, one ordinary key is spent, the chest opens, and all its contents are collected; otherwise, the chest remains closed. A chest cell may be entered or crossed whether or not the chest is open. Each item inside counts as one treasure.";
+  const orderRuleZh = m.complexity === "advanced" ? "\u4E00\u6761\u6307\u4EE4\u4E2D\uFF0C\u4F9D\u6B21\u7ED3\u7B97\u8017\u65F6\u3001\u79FB\u52A8\u4E0E\u76EE\u6807\u683C\u6548\u679C\u3001\u5230\u8FBE\u7EC8\u70B9\u8BB0\u5F55\u3001\u8BE5\u6307\u4EE4\u5F00\u59CB\u65F6\u5DF2\u6709\u7684\u4E2D\u6BD2\u4E0E\u901F\u5EA6\u72B6\u6001\uFF0C\u6700\u540E\u5224\u65AD\u662F\u5426\u6B7B\u4EA1\u3002" : usesPoison ? "\u4E00\u6761\u6307\u4EE4\u4E2D\uFF0C\u4F9D\u6B21\u7ED3\u7B97\u79FB\u52A8\u4E0E\u76EE\u6807\u683C\u6548\u679C\u3001\u5230\u8FBE\u7EC8\u70B9\u8BB0\u5F55\u3001\u8BE5\u6307\u4EE4\u5F00\u59CB\u65F6\u5DF2\u6709\u7684\u4E2D\u6BD2\u72B6\u6001\uFF0C\u6700\u540E\u5224\u65AD\u662F\u5426\u6B7B\u4EA1\u3002" : "\u4E00\u6761\u6307\u4EE4\u4E2D\uFF0C\u4F9D\u6B21\u7ED3\u7B97\u79FB\u52A8\u4E0E\u76EE\u6807\u683C\u6548\u679C\u3001\u5230\u8FBE\u7EC8\u70B9\u8BB0\u5F55\uFF0C\u6700\u540E\u5224\u65AD\u662F\u5426\u6B7B\u4EA1\u3002";
+  const orderRuleEn = m.complexity === "advanced" ? "Within one instruction, resolve time cost first, then movement and target-cell effects, then the reached-goal record, then poison and speed states that were active at the instruction's start, and finally death." : usesPoison ? "Within one instruction, resolve movement and target-cell effects, then the reached-goal record, then poison that was active at the instruction's start, and finally death." : "Within one instruction, resolve movement and target-cell effects, then the reached-goal record, and finally death.";
+  const poisonRuleZh = "\u6BD2\u836F\u4ECE\u996E\u7528\u540E\u7684\u4E0B\u4E00\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u5F00\u59CB\u751F\u6548\u3002\u6BCF\u6761\u6307\u4EE4\uFF08\u5305\u62EC\u56E0\u5899\u3001\u5730\u56FE\u8FB9\u754C\u6216\u95E8\u800C\u672A\u79FB\u52A8\u7684\u6307\u4EE4\uFF09\u7ED3\u675F\u65F6\u6263\u9664\u6307\u5B9A\u5065\u5EB7\u503C\u5E76\u51CF\u5C11\u4E00\u6B21\u5269\u4F59\u6B21\u6570\u3002\u996E\u7528\u65B0\u7684\u6BD2\u836F\u4F1A\u8986\u76D6\u539F\u4E2D\u6BD2\u72B6\u6001\uFF1B\u996E\u7528\u6BD2\u836F\u6216\u89E3\u6BD2\u836F\u6C34\u7684\u5F53\u524D\u6307\u4EE4\u90FD\u4E0D\u4F1A\u89E6\u53D1\u539F\u6709\u6BD2\u7D20\u3002";
+  const poisonRuleEn = "Poison starts with the instruction after it is drunk. At the end of each such instruction\u2014including one blocked by a wall, map boundary, or door\u2014it deals the stated damage and consumes one remaining instruction. New poison replaces any previous poison; neither a poison potion nor an antidote potion lets the previous poison tick on the instruction in which it is drunk.";
+  const speedRuleZh = `\u6BCF\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u5728\u5F00\u59CB\u65F6\u6309\u5F53\u65F6\u901F\u5EA6\u8BA1\u5165\u65F6\u95F4\u5355\u4F4D\uFF1A\u6B63\u5E38${m.movementTime.normal}\u3001\u52A0\u901F${m.movementTime.fast}\u3001\u51CF\u901F${m.movementTime.slow}\u3002\u996E\u7528\u52A0\u901F\u836F\u6C34\u4F1A\u628A\u901F\u5EA6\u8BBE\u4E3A\u52A0\u901F\uFF0C\u996E\u7528\u51CF\u901F\u836F\u6C34\u4F1A\u628A\u901F\u5EA6\u8BBE\u4E3A\u51CF\u901F\uFF1B\u4E24\u79CD\u6548\u679C\u90FD\u4ECE\u996E\u7528\u540E\u7684\u4E0B\u4E00\u6761\u6307\u4EE4\u5F00\u59CB\uFF0C\u6301\u7EED\u6307\u5B9A\u6570\u91CF\u7684\u6307\u4EE4\u3002\u649E\u5899\u6216\u88AB\u95E8\u6321\u4F4F\u4E5F\u4F1A\u6D88\u8017\u4E00\u6B21\u6301\u7EED\u6B21\u6570\u3002\u996E\u7528\u901F\u5EA6\u836F\u6C34\u7684\u5F53\u524D\u6307\u4EE4\u6309\u996E\u7528\u524D\u7684\u901F\u5EA6\u8BA1\u65F6\uFF1B\u65B0\u901F\u5EA6\u836F\u6C34\u8986\u76D6\u65E7\u901F\u5EA6\u72B6\u6001\uFF0C\u5F53\u524D\u6307\u4EE4\u4E0D\u6D88\u8017\u65E7\u72B6\u6001\u6216\u65B0\u72B6\u6001\u7684\u6301\u7EED\u6B21\u6570\u3002\u6301\u7EED\u6B21\u6570\u8017\u5C3D\u540E\uFF0C\u901F\u5EA6\u6062\u590D\u4E3A\u6B63\u5E38\uFF0C\u5269\u4F59\u6307\u4EE4\u6570\u4E3A0\u3002`;
+  const speedRuleEn = `At the start of each atomic movement instruction, add time units according to the current speed: normal ${m.movementTime.normal}, fast ${m.movementTime.fast}, slow ${m.movementTime.slow}. A haste potion sets speed to fast, and a slow potion sets speed to slow; either effect starts with the instruction after it is drunk and lasts for its stated number of instructions. Blocked instructions also consume one duration. The instruction that drinks a speed potion uses the pre-drink speed for time. A new speed potion replaces the previous speed state, and that instruction consumes neither the old nor the new duration. When the duration is exhausted, speed returns to normal with 0 speed-effect instructions remaining.`;
+  const rules = language === "zh" ? [
+    "\u6BCF\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u53EA\u5C1D\u8BD5\u5411\u4E0A\u3001\u4E0B\u3001\u5DE6\u6216\u53F3\u76F8\u90BB\u7684\u4E00\u683C\u79FB\u52A8\u3002\u884C\u52A8\u63CF\u8FF0\u4E2D\u7684\u201C\u79FB\u52A8N\u683C\u201D\u8868\u793A\u8FDE\u7EED\u6267\u884CN\u6761\u540C\u65B9\u5411\u7684\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u3002\u521D\u59CB\u4F4D\u4E8E\u5165\u53E3\u4E0D\u89C6\u4E3A\u8FDB\u5165\u8BE5\u683C\uFF1B\u53EA\u6709\u6210\u529F\u79FB\u52A8\u8FDB\u5165\u76EE\u6807\u683C\u65F6\uFF0C\u624D\u7ED3\u7B97\u8BE5\u683C\u7684\u6548\u679C\u3002",
+    "\u82E5\u76EE\u6807\u683C\u662F\u5899\u683C\u6216\u5728\u5730\u56FE\u5916\uFF0C\u63A2\u9669\u8005\u505C\u5728\u539F\u5730\uFF0C\u4F46\u8BE5\u6307\u4EE4\u4ECD\u7B97\u4F5C\u4E00\u6761\u5DF2\u6267\u884C\u7684\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\uFF0C\u4E4B\u540E\u7684\u6307\u4EE4\u7EE7\u7EED\u6267\u884C\u3002",
+    doorRuleZh,
+    "\u7B2C\u4E00\u6B21\u8FDB\u5165\u94A5\u5319\u683C\u65F6\u53D6\u5F97\u8BE5\u94A5\u5319\uFF1B\u540C\u4E00\u628A\u94A5\u5319\u4E0D\u80FD\u91CD\u590D\u53D6\u5F97\u3002",
+    chestRuleZh,
+    "\u7B2C\u4E00\u6B21\u8FDB\u5165\u9677\u9631\u683C\u65F6\u53D7\u5230\u8BE5\u9677\u9631\u6807\u660E\u7684\u4F24\u5BB3\uFF1B\u540C\u4E00\u9677\u9631\u4EE5\u540E\u4E0D\u518D\u751F\u6548\u3002",
+    usesPotionObjects ? "\u836F\u6C34\u683C\u662F\u6307\u542B\u6709\u6CBB\u7597\u836F\u6C34\u3001\u6BD2\u836F\u3001\u89E3\u6BD2\u836F\u6C34\u3001\u52A0\u901F\u836F\u6C34\u6216\u51CF\u901F\u836F\u6C34\u7684\u683C\u5B50\u3002\u7B2C\u4E00\u6B21\u8FDB\u5165\u836F\u6C34\u683C\u65F6\u7ACB\u5373\u996E\u7528\u5176\u4E2D\u7684\u836F\u6C34\u5E76\u5E94\u7528\u5176\u6548\u679C\uFF1B\u540C\u4E00\u74F6\u836F\u6C34\u4E0D\u80FD\u91CD\u590D\u996E\u7528\u3002" : "\u7B2C\u4E00\u6B21\u8FDB\u5165\u836F\u54C1\u623F\u65F6\u6062\u590D\u5176\u6807\u660E\u7684\u5065\u5EB7\u503C\uFF0C\u4F46\u4E0D\u8D85\u8FC7\u5065\u5EB7\u4E0A\u9650\uFF1B\u540C\u4E00\u836F\u54C1\u623F\u4EE5\u540E\u4E0D\u518D\u751F\u6548\u3002",
+    orderRuleZh,
+    ...usesPoison ? [poisonRuleZh] : [],
+    ...m.complexity === "advanced" ? [speedRuleZh] : [],
+    "\u5065\u5EB7\u503C\u964D\u81F30\u6216\u4EE5\u4E0B\u65F6\uFF0C\u5C06\u5065\u5EB7\u503C\u8BB0\u4E3A0\uFF0C\u63A2\u9669\u8005\u6B7B\u4EA1\u3002\u6B7B\u4EA1\u540E\u5C1A\u672A\u6267\u884C\u7684\u6307\u4EE4\u4ECD\u88AB\u8BFB\u53D6\uFF0C\u4F46\u4E0D\u79FB\u52A8\u3001\u4E0D\u8017\u65F6\uFF0C\u4E5F\u4E0D\u6539\u53D8\u4EFB\u4F55\u72B6\u6001\u3002",
+    "\u4E00\u65E6\u8FDB\u5165\u7EC8\u70B9\u683C\uFF0C\u201C\u66FE\u7ECF\u5230\u8FBE\u7EC8\u70B9\u201D\u6C38\u4E45\u8BB0\u4E3A\u771F\uFF0C\u5373\u4F7F\u540E\u6765\u79BB\u5F00\u6216\u6B7B\u4EA1\u4E5F\u4E0D\u64A4\u9500\u3002"
+  ] : [
+    "Each atomic movement instruction attempts to move exactly one cell up, down, left, or right. A direction followed by N cells means N consecutive atomic movement instructions in that direction. Starting at the entry does not count as entering its cell; target-cell effects are resolved only after a successful movement into that cell.",
+    "If the target is a wall or outside the map, the explorer stays in place. The instruction still counts as executed, and later instructions continue.",
+    doorRuleEn,
+    "The first time the explorer enters a key cell, that key is collected. A key cannot be collected twice.",
+    chestRuleEn,
+    "The first time the explorer enters a trap cell, the trap reduces health by its stated amount. That trap has no effect afterward.",
+    usesPotionObjects ? "A potion cell contains a healing, poison, antidote, haste, or slow potion. The first time the explorer enters a potion cell, its potion is drunk immediately and its effect is applied. A potion cannot be drunk twice." : "The first time the explorer enters a medicine room, it restores the stated health without exceeding maximum health. It has no effect afterward.",
+    orderRuleEn,
+    ...usesPoison ? [poisonRuleEn] : [],
+    ...m.complexity === "advanced" ? [speedRuleEn] : [],
+    "If health becomes 0 or less, set it to 0 and the explorer dies. Remaining instructions are still read but cause no movement, consume no time, and change no state.",
+    "Once the explorer enters the goal, ever-reached-goal remains true even if the explorer later leaves or dies."
+  ];
+  return rules.map((rule, index) => `${index + 1}. ${rule}`).join("\n");
+}
+function renderQuestions(maze, language) {
+  const materialKeys = maze.mechanisms.keyMaterials.length > 0;
+  const questions = language === "zh" ? ["\u5168\u90E8\u6307\u4EE4\u5904\u7406\u5B8C\u6BD5\u540E\uFF0C\u63A2\u9669\u8005\u4F4D\u4E8E\u54EA\u4E00\u683C\uFF1F", materialKeys ? "\u6700\u540E\u6301\u6709\u7684\u94A5\u5319\u603B\u6570\uFF08\u6240\u6709\u6750\u8D28\u5408\u8BA1\uFF09\u662F\u591A\u5C11\uFF1F" : "\u6700\u540E\u6301\u6709\u51E0\u628A\u666E\u901A\u94A5\u5319\uFF1F", "\u6700\u540E\u53D6\u5F97\u7684\u5B9D\u7269\u603B\u6570\uFF08\u6240\u6709\u7C7B\u578B\u5408\u8BA1\uFF09\u662F\u591A\u5C11\uFF1F", "\u6700\u540E\u5269\u4F59\u591A\u5C11\u5065\u5EB7\u503C\uFF1F", "\u6700\u540E\u662F\u5426\u5B58\u6D3B\uFF1F", "\u662F\u5426\u66FE\u7ECF\u5230\u8FBE\u7EC8\u70B9\uFF1F", "\u5171\u6253\u5F00\u51E0\u9053\u95E8\uFF1F", "\u5171\u6253\u5F00\u51E0\u53EA\u5B9D\u7BB1\uFF1F", "\u5171\u89E6\u53D1\u51E0\u4E2A\u9677\u9631\uFF1F"] : ["Which cell contains the explorer after all instructions have been processed?", materialKeys ? "How many keys remain in total across all key materials?" : "How many ordinary keys remain?", "How many treasures were collected in total across all treasure types?", "How much health remains?", "Is the explorer alive at the end?", "Did the explorer ever reach the goal?", "How many doors were opened?", "How many chests were opened?", "How many traps were triggered?"];
+  if (maze.objects.some((item) => item.type === "medicine")) questions.push(language === "zh" ? "\u5171\u4F7F\u7528\u51E0\u4E2A\u836F\u54C1\u623F\uFF1F" : "How many medicine rooms were used?");
+  if (maze.objects.some((item) => item.type === "potion")) questions.push(language === "zh" ? "\u5171\u996E\u7528\u51E0\u74F6\u836F\u6C34\uFF1F" : "How many potions were drunk?");
+  questions.push(language === "zh" ? "\u6309\u5168\u90E8\u5217\u51FA\u7684\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u8BA1\u6570\uFF08\u5305\u62EC\u6B7B\u4EA1\u540E\u4ECD\u88AB\u8BFB\u53D6\u7684\u6307\u4EE4\uFF09\uFF0C\u5176\u4E2D\u591A\u5C11\u6761\u6CA1\u6709\u6539\u53D8\u63A2\u9669\u8005\u7684\u4F4D\u7F6E\uFF1F" : "Counting every listed atomic movement instruction, including instructions read after death, how many did not change the explorer's position?");
+  for (const material of maze.mechanisms.keyMaterials) questions.push(language === "zh" ? `\u6700\u540E\u5269\u4F59\u51E0\u628A${MATERIAL_NAMES[material].zh}\u94A5\u5319\uFF1F` : `How many ${MATERIAL_NAMES[material].en} keys remain?`);
+  if (maze.mechanisms.treasureTypes.some((type) => type !== "treasure")) for (const type of maze.mechanisms.treasureTypes) questions.push(language === "zh" ? `\u5171\u53D6\u5F97\u591A\u5C11${treasureUnit(type)}${TREASURE_NAMES[type].zh}\uFF1F` : `How many ${TREASURE_NAMES[type].en}s were collected?`);
+  if (maze.mechanisms.complexity === "advanced") questions.push(language === "zh" ? "\u7D2F\u8BA1\u8017\u65F6\u662F\u591A\u5C11\u4E2A\u65F6\u95F4\u5355\u4F4D\uFF1F" : "What is the total elapsed time in time units?", language === "zh" ? "\u6700\u7EC8\u901F\u5EA6\u72B6\u6001\uFF08\u6B63\u5E38\u3001\u52A0\u901F\u6216\u51CF\u901F\uFF09\u53CA\u901F\u5EA6\u6548\u679C\u5269\u4F59\u6307\u4EE4\u6570\u5206\u522B\u662F\u4EC0\u4E48\uFF1F" : "What are the final speed state (normal, fast, or slow) and the number of speed-effect instructions remaining?", language === "zh" ? "\u6700\u7EC8\u4E2D\u6BD2\u72B6\u6001\u8FD8\u5269\u51E0\u6761\u6307\u4EE4\uFF1F" : "How many poison instructions remain at the end?");
+  return questions.map((item, index) => `${index + 1}. ${item}`).join("\n");
 }
 function renderActionDescription(actions, language, style) {
   const runs = compressActions(actions);
   if (language === "zh") {
     const connectors = ["\u968F\u540E", "\u63A5\u7740", "\u7136\u540E", "\u518D", "\u4E4B\u540E"];
-    const clauses2 = runs.map((run, index) => {
-      const connector = index === 0 ? "\u63A2\u9669\u8005\u5148" : connectors[(style + index) % connectors.length];
-      return `${connector ?? "\u7136\u540E"}\u5411${DIRECTIONS[run.direction].zh}\u79FB\u52A8${numberZh(run.count)}\u683C`;
-    });
-    return paragraphize(clauses2, "\uFF0C", "\u3002");
-  }
-  const clauses = runs.map((run, index) => {
-    const connector = index === 0 ? "First, the explorer moves" : index % 4 === 0 ? "The explorer then moves" : "then moves";
-    const directionForms = {
-      up: ["up", "upward"],
-      down: ["down", "downward"],
-      left: ["left", "to the left"],
-      right: ["right", "to the right"]
-    };
-    const forms = directionForms[run.direction];
-    const direction = forms[(style + index) % forms.length] ?? DIRECTIONS[run.direction].en;
-    return `${connector} ${direction} ${run.count} cell${plural(run.count)}`;
-  });
-  return paragraphize(clauses, ", ", ".");
+    return paragraphize(runs.map((run, index) => `${index === 0 ? "\u63A2\u9669\u8005\u5148" : connectors[(style + index) % connectors.length] ?? "\u7136\u540E"}\u5411${DIRECTIONS[run.direction].zh}\u79FB\u52A8${run.count}\u683C`), "\uFF0C", "\u3002");
+  }
+  return paragraphize(runs.map((run, index) => `${index === 0 ? "First, the explorer moves" : index % 4 === 0 ? "The explorer then moves" : "then moves"} ${DIRECTIONS[run.direction].en} ${run.count} cell${plural(run.count)}`), ", ", ".");
 }
 function paragraphize(clauses, separator, terminator) {
   const sentences = [];
-  for (let index = 0; index < clauses.length; index += 4) {
-    sentences.push(`${clauses.slice(index, index + 4).join(separator)}${terminator}`);
-  }
+  for (let index = 0; index < clauses.length; index += 4) sentences.push(`${clauses.slice(index, index + 4).join(separator)}${terminator}`);
   return sentences.join("\n");
 }
 function compressActions(actions) {
@@ -1114,6 +1353,18 @@ function compressActions(actions) {
   }
   return runs;
 }
+function routeThrough(maze, points) {
+  const actions = [];
+  for (let index = 1; index < points.length; index += 1) {
+    const from = points[index - 1];
+    const to = points[index];
+    if (!from || !to) continue;
+    const path = shortestPath(maze, from, to);
+    if (path.length === 0) throw new Error("Could not connect scenario waypoints.");
+    actions.push(...pathToActions(path));
+  }
+  return actions;
+}
 function pathToActions(path) {
   const actions = [];
   for (let index = 1; index < path.length; index += 1) {
@@ -1127,40 +1378,28 @@ function pathToActions(path) {
   return actions;
 }
 function wallDirection(maze, position) {
-  const candidates = [
-    ["up", cell(position.row - 1, position.col)],
-    ["down", cell(position.row + 1, position.col)],
-    ["left", cell(position.row, position.col - 1)],
-    ["right", cell(position.row, position.col + 1)]
-  ];
+  const candidates = [["up", cell(position.row - 1, position.col)], ["down", cell(position.row + 1, position.col)], ["left", cell(position.row, position.col - 1)], ["right", cell(position.row, position.col + 1)]];
   return candidates.find(([, target]) => terrainAt(maze, target) !== ".")?.[0] ?? null;
 }
-function coordinateList(values, language) {
-  if (values.length <= 1) return values[0] ?? "";
-  const last = values.at(-1);
-  return language === "zh" ? `${values.slice(0, -1).join("\u3001")}\u548C${last}` : `${values.slice(0, -1).join(", ")} and ${last}`;
-}
 function initialPossessions(state, language) {
-  if (language === "zh") {
-    const keys2 = state.keys > 0 ? `\u8D77\u521D\u6301\u6709${numberZh(state.keys)}\u628A\u94A5\u5319` : "\u8D77\u521D\u6CA1\u6709\u94A5\u5319";
-    const treasures2 = state.treasures > 0 ? `\u6301\u6709${numberZh(state.treasures)}\u4EF6\u5B9D\u7269` : "\u6CA1\u6709\u5B9D\u7269";
-    return `${keys2}\uFF0C${treasures2}`;
-  }
-  const keys = state.keys > 0 ? `${state.keys} key${plural(state.keys)}` : "no keys";
-  const treasures = state.treasures > 0 ? `${state.treasures} treasure${plural(state.treasures)}` : "no treasures";
-  return `${keys} and ${treasures}`;
+  const materials = emptyMaterialCounts(state.keysByMaterial);
+  const parts = Object.keys(materials).filter((key) => materials[key] > 0).map((key) => language === "zh" ? `${materials[key]}\u628A${MATERIAL_NAMES[key].zh}\u94A5\u5319` : `${materials[key]} ${MATERIAL_NAMES[key].en} key${plural(materials[key])}`);
+  if (state.keys > 0) parts.unshift(language === "zh" ? `${state.keys}\u628A\u666E\u901A\u94A5\u5319` : `${state.keys} ordinary key${plural(state.keys)}`);
+  const keys = parts.length > 0 ? parts.join(language === "zh" ? "\u3001" : ", ") : language === "zh" ? "\u6CA1\u6709\u94A5\u5319" : "no keys";
+  const treasures = state.treasures > 0 ? language === "zh" ? `${state.treasures}\u4EF6\u5B9D\u7269` : `${state.treasures} treasure${plural(state.treasures)}` : language === "zh" ? "\u6CA1\u6709\u5B9D\u7269" : "no treasures";
+  return language === "zh" ? `\u6301\u6709${keys}\uFF0C${treasures}` : `${keys} and ${treasures}`;
 }
-function numberZh(value) {
-  const forms = ["\u96F6", "\u4E00", "\u4E24", "\u4E09", "\u56DB", "\u4E94", "\u516D", "\u4E03", "\u516B", "\u4E5D", "\u5341"];
-  return forms[value] ?? String(value);
+function treasureUnit(type) {
+  return type === "coin" ? "\u679A" : type === "gem" ? "\u9897" : "\u4EF6";
 }
 function plural(value) {
   return value === 1 ? "" : "s";
 }
+function capitalize(value) {
+  return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
+}
 function integer(value, name, minimum) {
-  if (!Number.isInteger(value) || value < minimum) {
-    throw new Error(`${name} must be an integer greater than or equal to ${minimum}.`);
-  }
+  if (!Number.isInteger(value) || value < minimum) throw new Error(`${name} must be an integer greater than or equal to ${minimum}.`);
   return value;
 }
 function oddInteger(value, name, minimum) {
@@ -1169,14 +1408,12 @@ function oddInteger(value, name, minimum) {
   return value;
 }
 function finiteNumber(value, name, minimum, maximum) {
-  if (!Number.isFinite(value) || value < minimum || value > maximum) {
-    throw new Error(`${name} must be between ${minimum} and ${maximum}.`);
-  }
+  if (!Number.isFinite(value) || value < minimum || value > maximum) throw new Error(`${name} must be between ${minimum} and ${maximum}.`);
   return value;
 }
 
 // src/cli.ts
-var VERSION = "0.2.0";
+var VERSION = "0.3.0";
 try {
   const parsed = parseArguments(import_node_process.default.argv.slice(2));
   if (parsed === "help") {
@@ -1290,6 +1527,33 @@ function parseArguments(args) {
       case "--medicines":
         trial.medicineCount = parseInteger(value, flag);
         break;
+      case "--potions":
+        trial.potionCount = parseInteger(value, flag);
+        break;
+      case "--complexity":
+        trial.complexity = value;
+        break;
+      case "--trap-damage":
+        trial.trapDamages = parseIntegerList(value, flag);
+        break;
+      case "--potion-kinds":
+        trial.potionKinds = parseList(value, flag);
+        break;
+      case "--key-materials":
+        trial.keyMaterials = parseList(value, flag);
+        break;
+      case "--treasure-types":
+        trial.treasureTypes = parseList(value, flag);
+        break;
+      case "--poison-damage":
+        trial.poisonDamage = parseInteger(value, flag);
+        break;
+      case "--poison-duration":
+        trial.poisonDuration = parseInteger(value, flag);
+        break;
+      case "--speed-duration":
+        trial.speedDuration = parseInteger(value, flag);
+        break;
       case "--scenario":
         trial.scenario = value;
         break;
@@ -1325,6 +1589,14 @@ function parseNumber(value, flag) {
   if (!Number.isFinite(parsed)) throw new Error(`${flag} requires a number.`);
   return parsed;
 }
+function parseList(value, flag) {
+  const values = value.split(",").map((item) => item.trim()).filter(Boolean);
+  if (values.length === 0) throw new Error(`${flag} requires a non-empty comma-separated list.`);
+  return values;
+}
+function parseIntegerList(value, flag) {
+  return parseList(value, flag).map((item) => parseInteger(item, flag));
+}
 function helpText() {
   return `maze-test ${VERSION}
 
@@ -1343,11 +1615,20 @@ Options:
   --rows <odd integer>     Number of rows (default: 15)
   --cols <odd integer>     Number of columns (default: 15)
   --braid <0..1>           Chance to remove a dead end (default: 0)
-  --doors <integer>        Number of doors and keys (default: 1)
-  --chests <integer>       Number of chests (default: 2)
-  --traps <integer>        Number of traps (default: 2)
-  --medicines <integer>    Number of medicine rooms (default: 2)
-  --scenario <name>        success | treasure-and-leave | death-and-stop
+  --complexity <level>     basic | intermediate | advanced (default: basic)
+  --doors <integer>        Number of doors and keys (preset-dependent)
+  --chests <integer>       Number of chests (preset-dependent)
+  --traps <integer>        Number of traps (preset-dependent)
+  --potions <integer>      Number of potions (preset-dependent)
+  --medicines <integer>    Legacy alias for --potions
+  --trap-damage <list>     Comma-separated positive damage values
+  --potion-kinds <list>    healing,poison,antidote,haste,slow
+  --key-materials <list>   copper,silver,gold
+  --treasure-types <list>  treasure,coin,gem,relic
+  --poison-damage <int>    Damage per poison tick
+  --poison-duration <int>  Poisoned instruction count
+  --speed-duration <int>   Fast/slow instruction count
+  --scenario <name>        success | treasure-and-leave | death-and-stop | mechanism-tour
                            (default: success)
   --lang <language>        en | zh (default: en)
   --style <integer>        Deterministic wording variation (default: 0)
@@ -1362,6 +1643,7 @@ Examples:
   npx maze-test question --seed 42 --rows 15 --cols 15
   npx maze-test answer --seed 42 --rows 15 --cols 15
   npx maze-test question --seed 42 --lang zh
+  npx maze-test question --seed 42 --complexity advanced --scenario mechanism-tour
   npx maze-test answer --seed 42 --format json
 `;
 }