pac-man-phaser 1.0.8 → 1.0.10

package/dist/index.js

@@ -1,3 +1,1230 @@
-import { PacMan } from './pac-man';
-export { PacMan };
-//# sourceMappingURL=index.js.map
+// src/pac-man.tsx
+import { useEffect, useRef } from "react";
+
+// src/game/_scenes/pac-man-scene.ts
+import { Scene } from "phaser";
+
+// src/game/sprites/wall.ts
+var Wall = class extends Phaser.Physics.Arcade.Sprite {
+  constructor(scene, x, y) {
+    super(scene, x * 32, y * 32, "wall");
+    this.setOrigin(0, 0);
+    scene.add.existing(this);
+  }
+  static addWallGraphics(scene) {
+    const graphics = scene.add.graphics();
+    graphics.fillStyle(3355443, 1);
+    graphics.fillRect(0, 0, 32, 32);
+    graphics.generateTexture("wall", 32, 32);
+    graphics.destroy();
+  }
+};
+
+// src/game/_scenes/pac-man-scene.ts
+import { generateMap } from "pac-man-map-generator";
+
+// src/game/sprites/abstracts/item.ts
+var Item = class extends Phaser.Physics.Arcade.Sprite {
+  coords;
+  constructor(scene, x, y, sizeOffset, texture) {
+    const adjustedX = x * 32 + sizeOffset;
+    const adjustedY = y * 32 + sizeOffset;
+    super(scene, adjustedX, adjustedY, texture);
+    this.coords = { x, y };
+    this.setOrigin(0, 0);
+    scene.add.existing(this);
+  }
+};
+
+// src/game/sprites/pellet.ts
+var Pellet = class extends Item {
+  points = 10;
+  constructor(scene, x, y) {
+    super(scene, x, y, 12, "pellet");
+  }
+  static addPelletGraphics(scene) {
+    const graphics = scene.add.graphics();
+    graphics.fillStyle(16777215, 1);
+    graphics.fillCircle(4, 4, 4);
+    graphics.generateTexture("pellet", 8, 8);
+    graphics.destroy();
+  }
+};
+
+// src/game/constants.ts
+var directions = {
+  LEFT: 0,
+  RIGHT: 1,
+  UP: 2,
+  DOWN: 3
+};
+var directionsArray = [
+  { x: 0, y: -1, dir: directions.UP },
+  { x: 0, y: 1, dir: directions.DOWN },
+  { x: -1, y: 0, dir: directions.LEFT },
+  { x: 1, y: 0, dir: directions.RIGHT }
+];
+var BASE_SPEED = 120;
+var PAC_MAN_SPEED = BASE_SPEED;
+var PAC_MAN_SPEED_SCATTER = BASE_SPEED * 1.25;
+var PAC_MAN_SPEED_EATING = BASE_SPEED * 0.9;
+var PAC_MAN_SPEED_TUNNEL = BASE_SPEED * 0.5;
+var GHOST_SPEED = BASE_SPEED * 0.9375;
+var GHOST_SPEED_FRIGHTENED = BASE_SPEED * 0.625;
+
+// src/game/sprites/characters/character.ts
+var Character = class extends Phaser.Physics.Arcade.Sprite {
+  position = { x: 0, y: 0 };
+  gridPosition = { x: 0, y: 0 };
+  direction = -1;
+  gameMap;
+  textureMap;
+  constructor(scene, gameMap, x, y, textureMap, texture, startingFrame) {
+    super(scene, x, y, texture, startingFrame);
+    this.gameMap = gameMap;
+    this.position = { x, y };
+    this.gridPosition = { x: Math.floor(x / 32), y: Math.floor(y / 32) };
+    this.textureMap = textureMap;
+    scene.add.existing(this);
+    scene.physics.add.existing(this);
+    this.setCollideWorldBounds(false);
+  }
+  update() {
+    const cell = {
+      x: Math.floor(this.x / 32),
+      y: Math.floor(this.y / 32)
+    };
+    const center = {
+      x: cell.x * 32 + 16,
+      y: cell.y * 32 + 16
+    };
+    const tolerance = 4;
+    const inCenterX = Math.abs(this.x - center.x) < tolerance;
+    const inCenterY = Math.abs(this.y - center.y) < tolerance;
+    if ((this.direction === directions.RIGHT || this.direction === directions.LEFT) && !inCenterY) {
+      this.setPosition(this.x, this.position.y);
+    }
+    if ((this.direction === directions.UP || this.direction === directions.DOWN) && !inCenterX) {
+      this.setPosition(this.position.x, this.y);
+    }
+    if (inCenterX && inCenterY) {
+      this.position = center;
+      this.gridPosition = cell;
+      if (cell.x < -1) {
+        this.setPosition(32 * 28, this.y);
+      } else if (cell.x > 27) {
+        this.setPosition(-32, this.y);
+      }
+      if (!this.gameMap[cell.y]?.[cell.x] || this.gameMap[cell.y]?.[cell.x]?.type === "teleporter") {
+        return;
+      }
+      this.onCenter(cell);
+    }
+  }
+  canMove(cell, direction) {
+    const targetCell = { x: cell.x, y: cell.y };
+    switch (direction) {
+      case directions.LEFT:
+        targetCell.x -= 1;
+        break;
+      case directions.RIGHT:
+        targetCell.x += 1;
+        break;
+      case directions.UP:
+        targetCell.y -= 1;
+        break;
+      case directions.DOWN:
+        targetCell.y += 1;
+        break;
+      default:
+        return false;
+    }
+    if (targetCell.x < 0 || targetCell.x > 27) {
+      return true;
+    }
+    const type = this.gameMap[targetCell.y]?.[targetCell.x]?.type;
+    return type === "empty" || type === "teleporter";
+  }
+  changeDirection(direction) {
+    this.direction = direction;
+    switch (direction) {
+      case directions.LEFT:
+        this.setVelocity(-this.speed, 0);
+        break;
+      case directions.RIGHT:
+        this.setVelocity(this.speed, 0);
+        break;
+      case directions.UP:
+        this.setVelocity(0, -this.speed);
+        break;
+      case directions.DOWN:
+        this.setVelocity(0, this.speed);
+        break;
+    }
+    const tex = this.textureMap[direction];
+    if (tex) {
+      this.anims.stop();
+      if (tex.startsWith("frame:")) {
+        this.setFrame(tex.replace("frame:", ""));
+      } else {
+        this.anims.play(tex);
+      }
+    }
+  }
+  getOppositeDirection(direction) {
+    switch (direction) {
+      case directions.LEFT:
+        return directions.RIGHT;
+      case directions.RIGHT:
+        return directions.LEFT;
+      case directions.UP:
+        return directions.DOWN;
+      case directions.DOWN:
+        return directions.UP;
+      default:
+        return -1;
+    }
+  }
+};
+
+// src/game/sprites/pac-man.ts
+var Pacman = class extends Character {
+  nextDir = -1;
+  eatCoords = null;
+  speed = PAC_MAN_SPEED;
+  hasMoved = false;
+  constructor(scene, gameMap) {
+    const x = 14 * 32;
+    const y = 17 * 32 + 16;
+    const texMap = {
+      [directions.LEFT]: "pacman-left",
+      [directions.RIGHT]: "pacman-right",
+      [directions.UP]: "pacman-up",
+      [directions.DOWN]: "pacman-down"
+    };
+    super(scene, gameMap, x, y, texMap, "spritesheet", "pacman-whole");
+    if (scene.input.keyboard) {
+      this.setEventListeners(scene.input.keyboard);
+    }
+  }
+  handleDeath() {
+    this.setVelocity(0, 0);
+    this.anims.play("pacman-death", false);
+    const animDuration = 11 / 8 * 1e3;
+    this.scene.time.delayedCall(animDuration, () => {
+      this.scene.events.emit("game-over");
+    });
+  }
+  update() {
+    if (this.nextDir !== -1 && !this.hasMoved) {
+      this.changeDirection(this.nextDir);
+      this.nextDir = -1;
+      this.hasMoved = true;
+    }
+    super.update();
+  }
+  eatPellet(x, y) {
+    this.eatCoords = `${x},${y}`;
+  }
+  onCenter(cell) {
+    const key = `${cell.x},${cell.y}`;
+    if (this.eatCoords === key) {
+      this.speed = PAC_MAN_SPEED_EATING;
+      this.changeDirection(this.direction);
+    } else if (this.gameMap[cell.y]?.[cell.x]?.type === "teleporter") {
+      this.speed = PAC_MAN_SPEED_TUNNEL;
+      this.changeDirection(this.direction);
+    } else {
+      this.eatCoords = null;
+      this.speed = PAC_MAN_SPEED;
+      this.changeDirection(this.direction);
+    }
+    if (this.nextDir !== -1 && this.canMove(cell, this.nextDir)) {
+      this.changeDirection(this.nextDir);
+      this.nextDir = -1;
+    } else if (!this.canMove(cell, this.direction)) {
+      this.setVelocity(0, 0);
+      this.anims.stop();
+    }
+  }
+  setEventListeners(input) {
+    const left = () => {
+      this.nextDir = directions.LEFT;
+    };
+    const right = () => {
+      this.nextDir = directions.RIGHT;
+    };
+    const up = () => {
+      this.nextDir = directions.UP;
+    };
+    const down = () => {
+      this.nextDir = directions.DOWN;
+    };
+    input.on("keydown-LEFT", left);
+    input.on("keydown-A", left);
+    input.on("keydown-RIGHT", right);
+    input.on("keydown-D", right);
+    input.on("keydown-UP", up);
+    input.on("keydown-W", up);
+    input.on("keydown-DOWN", down);
+    input.on("keydown-S", down);
+  }
+  static loadTextures(textures) {
+    const tex = textures.get("spritesheet");
+    const pacManSprites = [
+      {
+        key: "pacman-left-small",
+        xPos: 0,
+        yPos: 0
+      },
+      {
+        key: "pacman-left-large",
+        xPos: 0,
+        yPos: 2
+      },
+      {
+        key: "pacman-right-small",
+        xPos: 2,
+        yPos: 0
+      },
+      {
+        key: "pacman-right-large",
+        xPos: 2,
+        yPos: 2
+      },
+      {
+        key: "pacman-down-small",
+        xPos: 4,
+        yPos: 0
+      },
+      {
+        key: "pacman-down-large",
+        xPos: 4,
+        yPos: 2
+      },
+      {
+        key: "pacman-up-small",
+        xPos: 6,
+        yPos: 0
+      },
+      {
+        key: "pacman-up-large",
+        xPos: 6,
+        yPos: 2
+      },
+      {
+        key: "pacman-whole",
+        xPos: 8,
+        yPos: 0
+      },
+      {
+        key: "pacman-dead-1",
+        xPos: 0,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-2",
+        xPos: 2,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-3",
+        xPos: 4,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-4",
+        xPos: 6,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-5",
+        xPos: 8,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-6",
+        xPos: 10,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-7",
+        xPos: 12,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-8",
+        xPos: 14,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-9",
+        xPos: 16,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-10",
+        xPos: 18,
+        yPos: 12
+      },
+      {
+        key: "pacman-dead-11",
+        xPos: 20,
+        yPos: 12
+      }
+    ];
+    for (let i = 0; i < pacManSprites.length; i++) {
+      const { key, xPos, yPos } = pacManSprites[i];
+      tex.add(key, 0, xPos * 16, yPos * 16, 32, 32);
+    }
+  }
+  static loadAnimations(anims) {
+    anims.create({
+      key: "pacman-left",
+      frames: [
+        { key: "spritesheet", frame: "pacman-left-small" },
+        { key: "spritesheet", frame: "pacman-left-large" },
+        { key: "spritesheet", frame: "pacman-left-small" },
+        { key: "spritesheet", frame: "pacman-whole" }
+      ],
+      repeat: -1,
+      frameRate: 16
+    });
+    anims.create({
+      key: "pacman-right",
+      frames: [
+        { key: "spritesheet", frame: "pacman-right-small" },
+        { key: "spritesheet", frame: "pacman-right-large" },
+        { key: "spritesheet", frame: "pacman-right-small" },
+        { key: "spritesheet", frame: "pacman-whole" }
+      ],
+      repeat: -1,
+      frameRate: 16
+    });
+    anims.create({
+      key: "pacman-down",
+      frames: [
+        { key: "spritesheet", frame: "pacman-down-small" },
+        { key: "spritesheet", frame: "pacman-down-large" },
+        { key: "spritesheet", frame: "pacman-down-small" },
+        { key: "spritesheet", frame: "pacman-whole" }
+      ],
+      repeat: -1,
+      frameRate: 16
+    });
+    anims.create({
+      key: "pacman-up",
+      frames: [
+        { key: "spritesheet", frame: "pacman-up-small" },
+        { key: "spritesheet", frame: "pacman-up-large" },
+        { key: "spritesheet", frame: "pacman-up-small" },
+        { key: "spritesheet", frame: "pacman-whole" }
+      ],
+      repeat: -1,
+      frameRate: 16
+    });
+    anims.create({
+      key: "pacman-death",
+      frames: [
+        { key: "spritesheet", frame: "pacman-dead-1" },
+        { key: "spritesheet", frame: "pacman-dead-2" },
+        { key: "spritesheet", frame: "pacman-dead-3" },
+        { key: "spritesheet", frame: "pacman-dead-4" },
+        { key: "spritesheet", frame: "pacman-dead-5" },
+        { key: "spritesheet", frame: "pacman-dead-6" },
+        { key: "spritesheet", frame: "pacman-dead-7" },
+        { key: "spritesheet", frame: "pacman-dead-8" },
+        { key: "spritesheet", frame: "pacman-dead-9" },
+        { key: "spritesheet", frame: "pacman-dead-10" },
+        { key: "spritesheet", frame: "pacman-dead-11" }
+      ],
+      frameRate: 10,
+      repeat: 0
+    });
+  }
+};
+
+// src/game/ui/score-display.ts
+var ScoreDisplay = class extends Phaser.GameObjects.Text {
+  score = 0;
+  constructor(scene, x, y) {
+    super(scene, x, y, "Score: 0", {
+      fontFamily: "Arial",
+      fontSize: "24px",
+      color: "#ffffff"
+    });
+    scene.add.existing(this);
+  }
+  addPoints(points) {
+    this.score += points;
+    this.setText(`Score: ${this.score}`);
+  }
+  getScore() {
+    return this.score;
+  }
+};
+
+// src/game/sprites/abstracts/action-item.ts
+var ActionItem = class extends Item {
+};
+
+// src/game/sprites/super-pellet.ts
+var SuperPellet = class extends ActionItem {
+  points = 50;
+  constructor(scene, x, y) {
+    super(scene, x, y, 8, "super-pellet");
+  }
+  onCollect() {
+    this.destroy();
+  }
+  static addSuperPelletGraphics(scene) {
+    const graphics = scene.add.graphics();
+    graphics.fillStyle(16777215, 1);
+    graphics.fillCircle(8, 8, 8);
+    graphics.generateTexture("super-pellet", 16, 16);
+    graphics.destroy();
+  }
+  // Since we use a random map generator,
+  // the location of the four corners is not fixed.
+  // This function finds the four 'corners' of the map,
+  // defined as the four empty spaces closest to each corner of the map.
+  static getFourCorners(gameMap) {
+    const corners = [
+      { x: 1, y: 1 },
+      // Top-left
+      { x: gameMap[0].length - 2, y: 1 },
+      // Top-right
+      { x: 1, y: gameMap.length - 2 },
+      // Bottom-left
+      { x: gameMap[0].length - 2, y: gameMap.length - 2 }
+      // Bottom-right
+    ];
+    const cornerPelletPositions = [];
+    corners.forEach((corner) => {
+      const queue = [corner];
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(`${corner.x},${corner.y}`);
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+          continue;
+        }
+        const cell = gameMap[current.y][current.x];
+        if (cell?.type === "empty") {
+          cornerPelletPositions.push({ x: current.x, y: current.y });
+          break;
+        }
+        const directions2 = [
+          { x: 0, y: -1 },
+          { x: 1, y: 0 },
+          { x: 0, y: 1 },
+          { x: -1, y: 0 }
+        ];
+        directions2.forEach((dir) => {
+          const nextX = current.x + dir.x;
+          const nextY = current.y + dir.y;
+          if (nextX >= 0 && nextX < gameMap[0].length && nextY >= 0 && nextY < gameMap.length && !visited.has(`${nextX},${nextY}`)) {
+            visited.add(`${nextX},${nextY}`);
+            queue.push({ x: nextX, y: nextY });
+          }
+        });
+      }
+    });
+    return cornerPelletPositions;
+  }
+};
+
+// src/game/sprites/ghosts/ghost.ts
+var Ghost = class extends Character {
+  ghostState = 1 /* SCATTER */;
+  pelletCount = 0;
+  speed = GHOST_SPEED;
+  pacman;
+  gameMap;
+  scatterTarget = {
+    x: 0,
+    y: 0
+  };
+  target = { x: 0, y: 0 };
+  previousGridCoords = { x: 0, y: 0 };
+  hasLeftHouse = false;
+  isLeavingHouse = false;
+  sequenceIndex = 0;
+  sequenceTimer;
+  frightenedTimer;
+  modeSequences = [
+    { state: 1 /* SCATTER */, duration: 5e3 },
+    { state: 0 /* CHASE */, duration: 2e4 },
+    { state: 1 /* SCATTER */, duration: 5e3 },
+    { state: 0 /* CHASE */, duration: 2e4 },
+    { state: 1 /* SCATTER */, duration: 5e3 },
+    { state: 0 /* CHASE */, duration: 2e4 },
+    { state: 1 /* SCATTER */, duration: 5e3 },
+    { state: 0 /* CHASE */, duration: null }
+    // -1 means indefinite
+  ];
+  directionPriority;
+  defTextureMap;
+  startingCoords;
+  frightenedTextureMap = {
+    [directions.LEFT]: "frame:frightened",
+    [directions.RIGHT]: "frame:frightened",
+    [directions.UP]: "frame:frightened",
+    [directions.DOWN]: "frame:frightened"
+  };
+  frightenedEndTextureMap = {
+    [directions.LEFT]: "frightened-end",
+    [directions.RIGHT]: "frightened-end",
+    [directions.UP]: "frightened-end",
+    [directions.DOWN]: "frightened-end"
+  };
+  constructor(scene, gameMap, x, y, scatterTarget, pacman, ghostName, directionPriority) {
+    const startingFrame = `frame:${ghostName}-up`;
+    const textureMap = {
+      [directions.LEFT]: `frame:${ghostName}-left`,
+      [directions.RIGHT]: `frame:${ghostName}-right`,
+      [directions.UP]: `frame:${ghostName}-up`,
+      [directions.DOWN]: `frame:${ghostName}-down`
+    };
+    super(scene, gameMap, x, y, textureMap, "spritesheet", startingFrame);
+    this.startingCoords = { x, y };
+    this.directionPriority = directionPriority;
+    this.previousGridCoords = this.gridPosition;
+    this.defTextureMap = textureMap;
+    this.pacman = pacman;
+    this.gameMap = gameMap;
+    this.scatterTarget = scatterTarget;
+    this.frightenedTimer?.destroy();
+    this.frightenedTimer = void 0;
+    this.sequenceTimer?.destroy();
+    this.sequenceTimer = void 0;
+    this.sequenceIndex = 0;
+    this.target = this.scatterTarget;
+  }
+  countPellet() {
+    this.pelletCount++;
+    if (this.pelletCount === this.pelletCountToLeaveHouse) {
+      this.leaveHouse();
+    }
+  }
+  scare() {
+    this.ghostState = 2 /* FRIGHTENED */;
+    this.speed = GHOST_SPEED_FRIGHTENED;
+    let newDirection = this.getOppositeDirection(this.direction);
+    const canMoveInOppositeDirection = this.canMove(
+      this.gridPosition,
+      newDirection
+    );
+    if (!canMoveInOppositeDirection) {
+      newDirection = this.getRandomDirection();
+    }
+    this.changeDirection(newDirection);
+    this.textureMap = this.frightenedTextureMap;
+    this.setFrame("frightened");
+    this.sequenceTimer?.destroy();
+    this.frightenedTimer?.destroy();
+    this.frightenedTimer = this.scene.time.delayedCall(6e3, () => {
+      this.textureMap = this.frightenedEndTextureMap;
+      this.anims.play("frightened-end", true);
+      this.frightenedTimer = this.scene.time.delayedCall(2e3, () => {
+        this.speed = GHOST_SPEED;
+        this.textureMap = this.defTextureMap;
+        this.changeDirection(this.direction);
+        this.startSequence();
+      });
+    });
+  }
+  startSequence() {
+    if (this.sequenceIndex >= this.modeSequences.length) {
+      return;
+    }
+    const sequence = this.modeSequences[this.sequenceIndex];
+    this.ghostState = sequence.state;
+    if (sequence.duration !== null) {
+      this.sequenceTimer = this.scene.time.delayedCall(
+        sequence.duration,
+        () => {
+          this.sequenceIndex++;
+          this.startSequence();
+        }
+      );
+    }
+  }
+  // Ghosts start moving after a delay
+  setStartTimer() {
+    this.scene.time.delayedCall(this.timerToLeaveHouse, () => {
+      this.leaveHouse();
+    });
+  }
+  leaveHouse() {
+    if (this.hasLeftHouse) {
+      return;
+    }
+    this.hasLeftHouse = true;
+    this.isLeavingHouse = true;
+    const x = 14 * 32;
+    const y = 11 * 32 + 16;
+    if (this.x <= x) {
+      this.changeDirection(directions.RIGHT);
+    } else if (this.x >= x) {
+      this.changeDirection(directions.LEFT);
+    } else if (this.y >= y) {
+      this.changeDirection(directions.UP);
+    } else {
+      this.gridPosition = { x: 14, y: 11 };
+      this.previousGridCoords = this.gridPosition;
+      this.mapPathToTarget(this.target);
+      this.isLeavingHouse = false;
+      this.startSequence();
+    }
+  }
+  update() {
+    if (!this.hasLeftHouse) {
+      return;
+    }
+    if (this.isLeavingHouse) {
+      const targetX = 14 * 32;
+      const targetY = 11 * 32 + 16;
+      if (this.direction === directions.UP && this.y <= targetY) {
+        this.gridPosition = { x: 14, y: 11 };
+        this.previousGridCoords = this.gridPosition;
+        this.isLeavingHouse = false;
+        this.setPosition(targetX, targetY);
+        this.mapPathToTarget(this.target);
+        this.startSequence();
+      } else if (this.direction === directions.RIGHT && this.x >= targetX || this.direction === directions.LEFT && this.x <= targetX) {
+        this.setPosition(targetX, this.y);
+        this.changeDirection(directions.UP);
+      }
+      return;
+    }
+    super.update();
+  }
+  onCenter() {
+    const newCoords = this.gridPosition;
+    if (newCoords.x === this.previousGridCoords.x && newCoords.y === this.previousGridCoords.y) {
+      return;
+    }
+    this.previousGridCoords = newCoords;
+    if (this.direction === -1 || this.isAtIntersection()) {
+      switch (this.ghostState) {
+        case 1 /* SCATTER */:
+          this.target = this.scatterTarget;
+          break;
+        case 2 /* FRIGHTENED */:
+          this.changeDirection(this.getRandomDirection());
+          return;
+      }
+      this.mapPathToTarget(this.target);
+      return;
+    }
+    this.checkForWall();
+  }
+  handleDeath() {
+    if (this.body) {
+      this.body.stop();
+      this.body.enable = false;
+    }
+    this.setAlpha(0);
+    this.speed = 0;
+    this.ghostState = 3 /* DEAD */;
+    this.scene.time.delayedCall(3e3, () => {
+      this.setAlpha(1);
+      if (this.body) {
+        this.body.enable = true;
+      }
+      this.reset();
+    });
+  }
+  reset() {
+    this.frightenedTimer?.destroy();
+    this.sequenceTimer?.destroy();
+    this.ghostState = 1 /* SCATTER */;
+    this.speed = GHOST_SPEED;
+    this.hasLeftHouse = false;
+    this.isLeavingHouse = false;
+    this.textureMap = this.defTextureMap;
+    this.setPosition(this.startingCoords.x, this.startingCoords.y);
+    this.gridPosition = {
+      x: Math.floor(this.startingCoords.x / 32),
+      y: Math.floor(this.startingCoords.y / 32)
+    };
+    this.previousGridCoords = this.gridPosition;
+    this.direction = -1;
+    this.setStartTimer();
+  }
+  getRandomDirection() {
+    const possibleDirections = directionsArray.filter(
+      (d) => d.dir !== this.getOppositeDirection(this.direction)
+    );
+    const validDirections = possibleDirections.filter((d) => {
+      const newX = this.previousGridCoords.x + d.x;
+      const newY = this.previousGridCoords.y + d.y;
+      return this.gameMap[newY]?.[newX]?.type !== "wall" && this.gameMap[newY]?.[newX]?.type !== "ghost-house";
+    });
+    if (validDirections.length === 0) {
+      return this.getOppositeDirection(this.direction);
+    }
+    return Phaser.Utils.Array.GetRandom(validDirections).dir;
+  }
+  mapPathToTarget(target) {
+    const directionsToCheck = this.directionPriority.filter((d) => d !== this.getOppositeDirection(this.direction)).map((dir) => {
+      return directionsArray.find((d) => d.dir === dir);
+    }).filter((d) => d !== void 0);
+    let shortestDistance = Infinity;
+    let bestDirection = this.direction;
+    directionsToCheck.forEach((d) => {
+      const newX = this.gridPosition.x + d.x;
+      const newY = this.gridPosition.y + d.y;
+      const block = this.gameMap[newY]?.[newX];
+      if (block && this.gameMap[newY]?.[newX]?.type !== "wall" && this.gameMap[newY]?.[newX]?.type !== "ghost-house") {
+        const distance = Math.hypot(target.x - newX, target.y - newY);
+        if (distance < shortestDistance) {
+          shortestDistance = distance;
+          bestDirection = d.dir;
+        } else if (distance === shortestDistance && bestDirection === this.direction) {
+          bestDirection = d.dir;
+        }
+      }
+    });
+    this.changeDirection(bestDirection);
+  }
+  isAtIntersection() {
+    const cell = {
+      x: Math.floor(this.position.x / 32),
+      y: Math.floor(this.position.y / 32)
+    };
+    let paths = 0;
+    directionsArray.forEach((dir) => {
+      const newX = cell.x + dir.x;
+      const newY = cell.y + dir.y;
+      if (this.gameMap[newY]?.[newX]?.type !== "wall" && this.gameMap[newY]?.[newX]?.type !== "ghost-house") {
+        paths++;
+      }
+    });
+    return paths > 2;
+  }
+  checkForWall() {
+    if (!this.canMove(this.previousGridCoords, this.direction)) {
+      this.mapPathToTarget(this.target);
+    }
+  }
+  static loadTextures(textures) {
+    const tex = textures.get("spritesheet");
+    const ghosts = ["blinky", "pinky", "inky", "clyde", "eyes"];
+    const spriteMaps = [];
+    for (let i = 0; i < ghosts.length; i++) {
+      const ghost = ghosts[i];
+      spriteMaps.push(
+        { key: `${ghost}-up`, xPos: i * 2, yPos: 4 },
+        { key: `${ghost}-down`, xPos: i * 2, yPos: 6 },
+        { key: `${ghost}-left`, xPos: i * 2, yPos: 8 },
+        { key: `${ghost}-right`, xPos: i * 2, yPos: 10 }
+      );
+    }
+    spriteMaps.push({ key: `frightened`, xPos: 10, yPos: 4 });
+    spriteMaps.push({ key: `frightened-flash`, xPos: 10, yPos: 6 });
+    for (let i = 0; i < spriteMaps.length; i++) {
+      const { key, xPos, yPos } = spriteMaps[i];
+      tex.add(key, 0, xPos * 16, yPos * 16, 32, 32);
+    }
+  }
+  static loadAnimations(anims) {
+    anims.create({
+      key: "frightened-end",
+      frames: [
+        { key: "spritesheet", frame: "frightened-flash" },
+        { key: "spritesheet", frame: "frightened" }
+      ],
+      repeat: -1,
+      frameRate: 5
+    });
+  }
+};
+
+// src/game/sprites/ghosts/blinky.ts
+var Blinky = class extends Ghost {
+  pelletCountToLeaveHouse = 0;
+  timerToLeaveHouse = 0;
+  // milliseconds
+  randomId = Math.random().toString(36).substring(2, 15);
+  constructor(scene, gameMap, pacman, scatterTarget) {
+    const x = 14 * 32;
+    const y = 11 * 32 + 16;
+    super(scene, gameMap, x, y, scatterTarget, pacman, "blinky", [
+      directions.UP,
+      directions.RIGHT,
+      directions.DOWN,
+      directions.LEFT
+    ]);
+    this.setStartTimer();
+    this.setFrame("blinky-left");
+  }
+  // Blinky always chases Pac-Man directly
+  onCenter() {
+    this.target = this.pacman.gridPosition;
+    super.onCenter();
+  }
+};
+
+// src/game/sprites/ghosts/clyde.ts
+var Clyde = class extends Ghost {
+  pelletCountToLeaveHouse = 60;
+  timerToLeaveHouse = 11e3;
+  // milliseconds
+  constructor(scene, gameMap, pacman, scatterTarget) {
+    const x = 15.25 * 32;
+    const y = 13.5 * 32;
+    super(scene, gameMap, x, y, scatterTarget, pacman, "clyde", [
+      directions.DOWN,
+      directions.LEFT,
+      directions.UP,
+      directions.RIGHT
+    ]);
+    this.setFrame("clyde-left");
+    this.setStartTimer();
+  }
+  // Clyde always chases Pac-Man directly
+  // However, if he gets within 8 tiles of Pac-Man, he will stop moving toward him
+  // and instead target his "home" position in the bottom-left corner of the map
+  onCenter() {
+    this.target = this.pacman.gridPosition;
+    const distance = Math.abs(this.gridPosition.x - this.pacman.gridPosition.x) + Math.abs(this.gridPosition.y - this.pacman.gridPosition.y);
+    if (distance < 8) {
+      this.target = this.scatterTarget;
+    }
+    super.onCenter();
+  }
+};
+
+// src/game/sprites/ghosts/inky.ts
+var Inky = class extends Ghost {
+  pelletCountToLeaveHouse = 30;
+  timerToLeaveHouse = 5e3;
+  // milliseconds
+  blinky;
+  constructor(scene, gameMap, pacman, blinky, scatterTarget) {
+    const x = 12.75 * 32;
+    const y = 13.5 * 32;
+    super(scene, gameMap, x, y, scatterTarget, pacman, "inky", [
+      directions.RIGHT,
+      directions.DOWN,
+      directions.LEFT,
+      directions.UP
+    ]);
+    this.blinky = blinky;
+    this.setFrame("inky-right");
+    this.setStartTimer();
+  }
+  // Inky tries to position itself based on both Blinky's and Pac-Man's positions
+  // First, it picks a tile two spaces in front of Pac-Man
+  // Then, it draws a vector from Blinky to that tile and doubles it
+  // Inky then targets the end of that new vector
+  onCenter() {
+    this.target = this.pacman.gridPosition;
+    switch (this.pacman.direction) {
+      case directions.LEFT:
+        this.target.x -= 2;
+        break;
+      case directions.UP:
+        this.target.x -= 2;
+        this.target.y -= 2;
+        break;
+      case directions.RIGHT:
+        this.target.x += 2;
+        break;
+      case directions.DOWN:
+        this.target.y += 2;
+        break;
+    }
+    const vectorX = (this.target.x - this.blinky.gridPosition.x) * 2;
+    const vectorY = (this.target.y - this.blinky.gridPosition.y) * 2;
+    this.target.x += vectorX;
+    this.target.y += vectorY;
+    super.onCenter();
+  }
+};
+
+// src/game/sprites/ghosts/pinky.ts
+var Pinky = class extends Ghost {
+  pelletCountToLeaveHouse = 0;
+  timerToLeaveHouse = 0;
+  // milliseconds
+  constructor(scene, gameMap, pacman, scatterTarget) {
+    const x = 14 * 32;
+    const y = 13.5 * 32;
+    super(scene, gameMap, x, y, scatterTarget, pacman, "pinky", [
+      directions.UP,
+      directions.LEFT,
+      directions.DOWN,
+      directions.RIGHT
+    ]);
+    this.setFrame("pinky-up");
+    this.setStartTimer();
+  }
+  // Pinky tries to position itself 4 tiles ahead of Pac-Man
+  onCenter() {
+    this.target = this.pacman.gridPosition;
+    switch (this.pacman.direction) {
+      case directions.LEFT:
+        this.target.x -= 4;
+        break;
+      case directions.UP:
+        this.target.y -= 4;
+        this.target.x -= 4;
+        break;
+      case directions.RIGHT:
+        this.target.x += 4;
+        break;
+      case directions.DOWN:
+        this.target.y += 4;
+        break;
+    }
+    super.onCenter();
+  }
+};
+
+// src/game/_scenes/pause-scene.ts
+var PauseMenu = class extends Phaser.Scene {
+  constructor() {
+    super({ key: "PauseMenu" });
+  }
+  create() {
+    const { width, height } = this.scale;
+    this.add.text(width / 2, height / 2 - 40, "Game Paused", {
+      fontSize: "32px",
+      color: "#fff"
+    }).setOrigin(0.5);
+    const resumeButton = this.add.text(width / 2, height / 2, "Resume", {
+      fontSize: "24px",
+      color: "#0f0"
+    }).setOrigin(0.5).setInteractive();
+    const resume = () => {
+      this.scene.stop();
+      this.scene.resume("PacManScene");
+    };
+    resumeButton.on("pointerdown", resume);
+    this.input.keyboard?.on("keydown-P", resume);
+  }
+};
+
+// src/game/_scenes/game-over-scene.ts
+var GameOverScene = class extends Phaser.Scene {
+  constructor() {
+    super({ key: "GameOverScene" });
+  }
+  create({ score }) {
+    const { width, height } = this.scale;
+    this.add.text(width / 2, height / 2 - 40, "Game Over!", {
+      fontSize: "32px",
+      color: "#fff",
+      shadow: {
+        offsetX: 2,
+        offsetY: 2,
+        color: "#000",
+        blur: 10,
+        fill: true
+      }
+    }).setOrigin(0.5);
+    this.add.text(width / 2, height / 2, `Final Score: ${score}`, {
+      fontSize: "32px",
+      color: "#fff",
+      shadow: {
+        offsetX: 2,
+        offsetY: 2,
+        color: "#000",
+        blur: 10,
+        fill: true
+      }
+    }).setOrigin(0.5);
+    const restart = () => {
+      this.scene.stop();
+      const pacManScene = this.scene.get("PacManScene");
+      if (pacManScene) {
+        pacManScene.scene.restart();
+      }
+    };
+    this.add.text(width / 2, height / 2 + 40, "Restart", {
+      fontSize: "24px",
+      color: "#fff",
+      padding: { x: 10, y: 5 },
+      shadow: {
+        offsetX: 2,
+        offsetY: 2,
+        color: "#000",
+        blur: 10,
+        fill: true
+      }
+    }).setOrigin(0.5).setInteractive({ useHandCursor: true }).on("pointerdown", restart);
+  }
+};
+
+// assets/spritesheet.webp
+var spritesheet_default = "data:image/webp;base64,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";
+
+// src/game/_scenes/pac-man-scene.ts
+var PacManScene = class extends Scene {
+  pacman;
+  ghosts = [];
+  scoreDisplay;
+  gameOver = false;
+  constructor() {
+    super("PacManScene");
+  }
+  preload() {
+    this.load.image("spritesheet", spritesheet_default);
+  }
+  create() {
+    this.gameOver = false;
+    this.physics.world.colliders.destroy();
+    this.input.keyboard?.on("keydown-P", () => {
+      this.scene.pause();
+      this.scene.launch("PauseMenu");
+    });
+    this.events.on("game-over", () => {
+      this.gameOver = true;
+      this.physics.pause();
+      this.scene.launch("GameOverScene", {
+        score: this.scoreDisplay.getScore()
+      });
+    });
+    this.createGraphics();
+    const map = generateMap();
+    const items = this.physics.add.staticGroup();
+    const fourCorners = SuperPellet.getFourCorners(map);
+    map.forEach((row, y) => {
+      row.forEach((block, x) => {
+        if (block?.type === "wall") {
+          new Wall(this, x, y);
+        } else if (block?.type === "empty" && (x !== 14 || y !== 19)) {
+          if (fourCorners.some((corner) => corner.x === x && corner.y === y)) {
+            items.add(new SuperPellet(this, x, y));
+            return;
+          }
+          const surroundingBlocks = [
+            map[y - 1]?.[x],
+            // Up
+            map[y + 1]?.[x],
+            // Down
+            map[y]?.[x - 1],
+            // Left
+            map[y]?.[x + 1],
+            // Right
+            map[y - 1]?.[x - 1],
+            // Up-Left
+            map[y - 1]?.[x + 1],
+            // Up-Right
+            map[y + 1]?.[x - 1],
+            // Down-Left
+            map[y + 1]?.[x + 1]
+            // Down-Right
+          ];
+          if (surroundingBlocks.some((b) => b?.type === "ghost-house")) {
+            return;
+          }
+          items.add(new Pellet(this, x, y));
+        }
+      });
+    });
+    const ghostCollisionGroup = this.physics.add.group([]);
+    this.pacman = new Pacman(this, map);
+    ghostCollisionGroup.add(this.pacman);
+    this.scoreDisplay = new ScoreDisplay(this, 4, 4);
+    this.physics.add.overlap(
+      this.pacman,
+      items,
+      (_pacman, item) => {
+        if (!(item instanceof Item)) {
+          return;
+        }
+        if (item instanceof SuperPellet) {
+          this.ghosts.forEach((ghost) => ghost.scare());
+        }
+        this.scoreDisplay.addPoints(item.points);
+        item.destroy();
+        this.pacman.eatPellet(item.coords.x, item.coords.y);
+        this.ghosts.forEach((ghost) => ghost.countPellet());
+      },
+      void 0,
+      this
+    );
+    const blinky = new Blinky(this, map, this.pacman, fourCorners[1]);
+    this.ghosts.push(
+      new Pinky(this, map, this.pacman, fourCorners[0]),
+      blinky,
+      new Clyde(this, map, this.pacman, fourCorners[2])
+    );
+    this.ghosts.push(new Inky(this, map, this.pacman, blinky, fourCorners[3]));
+    this.ghosts.forEach((ghost) => ghostCollisionGroup.add(ghost));
+    this.physics.add.overlap(this.pacman, ghostCollisionGroup, (_, o2) => {
+      const ghost = o2;
+      if (ghost.ghostState === 2 /* FRIGHTENED */) {
+        this.scoreDisplay.addPoints(200);
+        ghost.handleDeath();
+      } else {
+        this.pacman.handleDeath();
+      }
+    });
+  }
+  update() {
+    if (this.gameOver) {
+      return;
+    }
+    this.pacman.update();
+    this.ghosts.forEach((ghost) => {
+      if (ghost.ghostState !== 3 /* DEAD */) ghost.update();
+    });
+  }
+  createGraphics() {
+    Pacman.loadTextures(this.textures);
+    Pacman.loadAnimations(this.anims);
+    Ghost.loadTextures(this.textures);
+    Ghost.loadAnimations(this.anims);
+    Wall.addWallGraphics(this);
+    Pellet.addPelletGraphics(this);
+    SuperPellet.addSuperPelletGraphics(this);
+  }
+};
+function createPacManScene(container) {
+  const config = {
+    type: Phaser.AUTO,
+    parent: container,
+    backgroundColor: "#5e5f60ff",
+    width: 896,
+    height: 992,
+    physics: {
+      default: "arcade",
+      arcade: {
+        gravity: { x: 0, y: 0 },
+        debug: false
+      }
+    },
+    scale: {
+      mode: Phaser.Scale.FIT,
+      autoCenter: Phaser.Scale.CENTER_BOTH
+    },
+    scene: [PacManScene, PauseMenu, GameOverScene]
+  };
+  return new Phaser.Game(config);
+}
+
+// src/pac-man.tsx
+import { jsx } from "react/jsx-runtime";
+function PacMan() {
+  const container = useRef(null);
+  const gameRef = useRef(null);
+  useEffect(() => {
+    if (gameRef.current || !container.current) {
+      return;
+    }
+    gameRef.current = createPacManScene(container.current);
+    return () => {
+      gameRef.current?.destroy(true);
+      gameRef.current = null;
+    };
+  }, []);
+  return /* @__PURE__ */ jsx("div", { style: { width: "448px", height: "496px" }, ref: container });
+}
+export {
+  PacMan
+};