スイッチとオブジェクトの重複

nakomochi · nakomochi · commit e389f5f1a20b · 2025-05-10T18:01:59.000+09:00
diff --git a/src/ability.ts b/src/ability.ts
@@ -69,6 +69,8 @@ export function copy(cx: Context) {
   const movableObject = cx.grid.getMovableObject(cx, x, y);
   if (!movableObject) return;
 
+  movableObject.objectId = Math.random().toString();
+
   History.record(cx);
 
   cx.state.update((prev) => {
@@ -100,7 +102,7 @@ export function paste(cx: Context) {
     const positionX = x + i.x;
     const positionY = y + i.y;
     const target = cx.grid.getBlock(cx, positionX, positionY);
-    if (target !== Block.air) {
+    if (target !== Block.air && target !== Block.switch) {
       // すでに何かある場合は、ペーストできない
       return;
     }
@@ -126,7 +128,11 @@ export function cut(cx: Context) {
   const y = focus.y;
   const target = cx.grid.getBlock(cx, x, y);
   // removable 以外はカットできない
-  if (!target || target !== Block.movable) return;
+  if (
+    !target ||
+    (target !== Block.movable && target !== Block.switchWithObject)
+  )
+    return;
   const movableObject = cx.grid.getMovableObject(cx, x, y);
   if (!movableObject) return;
 
@@ -136,9 +142,19 @@ export function cut(cx: Context) {
     prev.inventory = movableObject;
     return prev;
   });
-  cx.grid.update(cx, (prev) =>
-    prev.objectId === movableObject.objectId ? { block: Block.air } : prev,
-  );
+  if (target === Block.movable) {
+    cx.grid.update(cx, (prev) =>
+      prev.objectId === movableObject.objectId ? { block: Block.air } : prev,
+    );
+  }
+  if (target === Block.switchWithObject) {
+    cx.grid.update(cx, (prev) => {
+      if (prev.objectId !== movableObject.objectId) return prev;
+      if (prev.block === Block.switchWithObject)
+        return { block: Block.switch, switchId: prev.switchId };
+      return { block: Block.air };
+    });
+  }
 
   printCells(createSnapshot(cx).game.cells, "cut");
   History.record(cx);
@@ -156,7 +172,7 @@ export function placeMovableObject(
     const positionX = x + i.x;
     const positionY = y + i.y;
     const target = grid.getBlock(cx, positionX, positionY);
-    if (target !== Block.air) {
+    if (target !== Block.air && target !== Block.switch) {
       // すでに何かある場合は、ペーストできない
       return;
     }
diff --git a/src/constants.ts b/src/constants.ts
@@ -12,6 +12,7 @@ export enum Block {
   movable = "movable",
   switch = "switch",
   switchBase = "switch-base",
+  switchWithObject = "switch-with-object",
 }
 export enum Facing {
   left = "left",
diff --git a/src/grid.ts b/src/grid.ts
@@ -31,11 +31,17 @@ export type GridCell =
     }
   | {
       block: Block.switch;
+      switchId?: string;
       objectId?: unknown;
     }
   | {
       block: Block.switchBase;
       objectId?: unknown;
+    }
+  | {
+      block: Block.switchWithObject;
+      switchId?: string;
+      objectId: string; // Block.movableのID
     };
 
 export class Grid {
@@ -207,7 +213,8 @@ export class Grid {
     const cells = get(cx.state).cells;
     const cell = cells[y]?.[x];
     if (!cell) return undefined;
-    if (cell.block !== Block.movable) return undefined;
+    if (cell.block !== Block.movable && cell.block !== Block.switchWithObject)
+      return undefined;
     const objectId = cell.objectId;
     const retrievedBlocks: { x: number; y: number }[] = [];
     for (let y = 0; y < cells.length; y++) {
@@ -225,7 +232,7 @@ export class Grid {
       .reduce((a, b) => Math.max(a, b), 0);
 
     const retrievedObject: MovableObject = {
-      block: cell.block,
+      block: Block.movable,
       objectId,
       relativePositions: retrievedBlocks.map((block) => ({
         x: block.x - minX,
@@ -257,56 +264,116 @@ export class Grid {
         "sprites is out of sync with cells: expected null, got sprite",
       );
     }
-    if (prev.block !== Block.air && prev.sprite === null) {
+    if (
+      prev.block !== Block.air &&
+      prev.block !== Block.switch &&
+      prev.sprite === null
+    ) {
       console.warn(
         "sprites is out of sync with cells: expected sprite, got null",
       );
     }
 
-    if (cell.block !== Block.movable && cell.objectId) {
+    if (
+      cell.block !== Block.movable &&
+      cell.block !== Block.switchWithObject &&
+      cell.objectId
+    ) {
       console.warn("Cell is not movable but has an objectId");
     }
 
-    switch (cell.block) {
-      case Block.air:
-        cells[y][x] = {
-          block: cell.block,
-          objectId: undefined,
-        };
-        prev.sprite = null;
-        prev.block = cell.block;
-        break;
-      case Block.block: {
-        const blockSprite = createSprite(blockSize, cell.block, x, y, marginY);
-        stage.addChild(blockSprite);
-        cells[y][x] = {
-          block: cell.block,
-          objectId: undefined,
-        };
-        prev.sprite = blockSprite;
-        prev.block = cell.block;
-        break;
+    if (prev.block === Block.switch) {
+      if (cell.block !== Block.movable) {
+        console.warn(
+          "No block other than movable cannot be placed on the switch",
+        );
+        return;
       }
-      case Block.movable: {
-        const movableSprite = createSprite(
-          blockSize,
-          cell.block,
-          x,
-          y,
-          marginY,
+      const movableSprite = createSprite(
+        blockSize,
+        Block.switchWithObject,
+        x,
+        y,
+        marginY,
+      );
+      stage.addChild(movableSprite);
+      assert(cell.objectId !== undefined, "movable block must have objectId");
+      if (cells[y][x].block !== Block.switch) return;
+      cells[y][x] = {
+        block: Block.switchWithObject,
+        switchId: cells[y][x].switchId,
+        objectId: cell.objectId,
+      };
+      prev.sprite = movableSprite;
+      prev.block = Block.switchWithObject;
+    } else if (prev.block === Block.switchWithObject) {
+      if (cell.block !== Block.switch) {
+        console.warn(
+          "No block other than switch cannot replace the switch with object",
         );
-        stage.addChild(movableSprite);
-        assert(cell.objectId !== undefined, "movable block must have objectId");
-        cells[y][x] = {
-          block: cell.block,
-          objectId: cell.objectId,
-        };
-        prev.sprite = movableSprite;
-        prev.block = cell.block;
-        break;
+        return;
+      }
+      const blockSprite = createSprite(blockSize, Block.switch, x, y, marginY);
+      stage.addChild(blockSprite);
+      if (cells[y][x].block !== Block.switchWithObject) return;
+      cells[y][x] = {
+        block: Block.switch,
+        switchId: cells[y][x].switchId,
+        objectId: undefined,
+      };
+      prev.sprite = blockSprite;
+      prev.block = Block.switch;
+    } else {
+      switch (cell.block) {
+        case Block.air:
+          cells[y][x] = {
+            block: cell.block,
+            objectId: undefined,
+          };
+          prev.sprite = null;
+          prev.block = cell.block;
+          break;
+        case Block.block: {
+          const blockSprite = createSprite(
+            blockSize,
+            cell.block,
+            x,
+            y,
+            marginY,
+          );
+          stage.addChild(blockSprite);
+          cells[y][x] = {
+            block: cell.block,
+            objectId: undefined,
+          };
+          prev.sprite = blockSprite;
+          prev.block = cell.block;
+          break;
+        }
+        case Block.movable: {
+          const movableSprite = createSprite(
+            blockSize,
+            cell.block,
+            x,
+            y,
+            marginY,
+          );
+          stage.addChild(movableSprite);
+          assert(
+            cell.objectId !== undefined,
+            "movable block must have objectId",
+          );
+          cells[y][x] = {
+            block: cell.block,
+            objectId: cell.objectId,
+          };
+          prev.sprite = movableSprite;
+          prev.block = cell.block;
+          break;
+        }
+        default:
+        // cell satisfies never;
       }
-      default:
-      // cell satisfies never;
     }
     cx.state.update((prev) => ({
       ...prev,
@@ -350,6 +417,7 @@ export function createCellsFromStageDefinition(
         case Block.switch: {
           const cell: GridCell = {
             block,
+            switchId: Math.random().toString(),
           };
           row.push(cell);
           break;
@@ -416,6 +484,12 @@ function createSprite(
       updateSprite(switchBaseSprite, blockSize, x, y, marginY);
       return switchBaseSprite;
     }
+    case Block.switchWithObject: {
+      const movableSprite = new Sprite(rockTexture);
+      movableSprite.tint = 0xff0000;
+      updateSprite(movableSprite, blockSize, x, y, marginY);
+      return movableSprite;
+    }
     default:
       throw new Error("no proper block");
   }
@@ -451,6 +525,8 @@ export function printCells(cells: GridCell[][], context?: string) {
                  return "s";
                case Block.switchBase:
                  return "S";
+               case Block.switchWithObject:
+                 return "M";
                default:
                  cell satisfies never;
              }
diff --git a/src/player.ts b/src/player.ts
@@ -159,7 +159,10 @@ export function tick(cx: Context, ticker: Ticker) {
 
   const isBlock = (x: number, y: number) =>
     cx.grid.getBlock(cx, Math.floor(x), Math.floor(y)) !== Block.air &&
+    cx.grid.getBlock(cx, Math.floor(x), Math.floor(y)) !== Block.switch &&
     cx.grid.getBlock(cx, Math.floor(x), Math.floor(y)) !== undefined;
+  const isSwitchBase = (x: number, y: number) =>
+    cx.grid.getBlock(cx, Math.floor(x), Math.floor(y)) === Block.switchBase;
   const isOutOfWorldLeft = (x: number) => x < 0;
   const isOutOfWorldRight = (x: number) => x >= gridX;
   const isOutOfWorldBottom = (y: number) => y >= gridY + marginY / blockSize;
@@ -230,6 +233,14 @@ export function tick(cx: Context, ticker: Ticker) {
     player.vy = 0;
   }
 
+  if (isSwitchBase(nextX, nextBottomY)) {
+    const switchBlock = cx.grid.getBlock(cx, nextX, nextTopY);
+    if (switchBlock !== Block.switchWithObject) {
+      // if (switchBlock !== Block.switch) throw new Error("Invalid switch block");
+      cx.state.set;
+    }
+  }
+
   // 当たり判定結果を反映する
   player.x += player.vx * ticker.deltaTime;
   player.y += player.vy * ticker.deltaTime;

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ export enum Block {`
`12`	`12`	`movable = "movable",`
`13`	`13`	`switch = "switch",`
`14`	`14`	`switchBase = "switch-base",`
	`15`	`+ switchWithObject = "switch-with-object",`
`15`	`16`	`}`
`16`	`17`	`export enum Facing {`
`17`	`18`	`left = "left",`