react-native-games 1.0.0 → 1.2.0

package/lib/module/games/maze-runner/MazeRunnerService.js

@@ -1,586 +1 @@
-"use strict";
-
-export class MazeRunnerService {
-  gameTimer = null;
-  constructor(gridSize = 15, gameAreaWidth = 350, gameAreaHeight = 500, gameDuration = 120) {
-    this.gameConfig = {
-      GRID_SIZE: gridSize,
-      CELL_SIZE: Math.min(gameAreaWidth, gameAreaHeight) / gridSize,
-      BALL_SIZE: 18,
-      PIPE_WIDTH: 8,
-      GAME_AREA_WIDTH: gameAreaWidth,
-      GAME_AREA_HEIGHT: gameAreaHeight,
-      COLLISION_TOLERANCE: 5,
-      SCORE_PER_COMPLETION: 100,
-      TIME_BONUS_MULTIPLIER: 10,
-      GAME_DURATION: gameDuration
-    };
-    this.gameState = {
-      isPlaying: false,
-      isPaused: false,
-      score: 0,
-      timeElapsed: 0,
-      // Start from 0 and count up
-      ballPosition: {
-        x: 0,
-        y: 0
-      },
-      targetPosition: {
-        x: 0,
-        y: 0
-      },
-      isCompleted: false,
-      gameOver: false
-    };
-    this.maze = [];
-    this.walls = [];
-    this.initializeMaze();
-    // Generate initial maze on service creation
-    this.generateMazeWithBacktracking();
-    this.generateWalls();
-    this.setStartAndEndPositions();
-  }
-  setGameStateChangeCallback(callback) {
-    this.onGameStateChange = callback;
-  }
-  notifyGameStateChange() {
-    if (this.onGameStateChange) {
-      this.onGameStateChange({
-        ...this.gameState
-      });
-    }
-  }
-  initializeMaze() {
-    // Initialize maze grid
-    this.maze = [];
-    for (let y = 0; y < this.gameConfig.GRID_SIZE; y++) {
-      this.maze[y] = [];
-      for (let x = 0; x < this.gameConfig.GRID_SIZE; x++) {
-        if (this.maze[y]) {
-          this.maze[y][x] = {
-            x,
-            y,
-            walls: {
-              top: true,
-              right: true,
-              bottom: true,
-              left: true
-            },
-            visited: false
-          };
-        }
-      }
-    }
-  }
-  generateNewMaze() {
-    this.initializeMaze();
-    this.generateMazeWithBacktracking();
-    this.generateWalls();
-    this.setStartAndEndPositions();
-
-    // Reset game state for new maze
-    this.gameState.isCompleted = false;
-    this.gameState.isPlaying = false; // Don't auto-start, let user click start
-    this.gameState.isPaused = false;
-    this.gameState.gameOver = false;
-    this.gameState.score = 0; // Reset score for new maze
-    this.gameState.timeElapsed = 0; // Start from 0 and count up
-
-    this.notifyGameStateChange();
-  }
-  generateMazeWithBacktracking() {
-    // Create a proper maze using recursive backtracking algorithm
-    const stack = [];
-    const startCell = this.maze[0]?.[0];
-    if (startCell) {
-      startCell.visited = true;
-      stack.push(startCell);
-    }
-    while (stack.length > 0) {
-      const current = stack[stack.length - 1];
-      const neighbors = current ? this.getUnvisitedNeighbors(current) : [];
-      if (neighbors.length > 0) {
-        // Completely random neighbor selection for unpredictable maze generation
-        const next = neighbors[Math.floor(Math.random() * neighbors.length)];
-        if (current && next) this.removeWallBetween(current, next);
-        if (next) {
-          next.visited = true;
-          stack.push(next);
-        }
-      } else {
-        stack.pop();
-      }
-    }
-
-    // Only minimal simplification to ensure connectivity
-    this.ensureConnectivity();
-  }
-  ensureConnectivity() {
-    // Only ensure basic connectivity without creating obvious paths
-    // Check if there's a path from start to end using BFS
-    if (!this.hasPathFromStartToEnd()) {
-      // If no path exists, create minimal connections
-      this.createMinimalPath();
-    }
-  }
-  hasPathFromStartToEnd() {
-    // Use BFS to check if there's a path from start (0,0) to end (GRID_SIZE-1, GRID_SIZE-1)
-    const visited = Array(this.gameConfig.GRID_SIZE).fill(null).map(() => Array(this.gameConfig.GRID_SIZE).fill(false));
-    const queue = [{
-      x: 0,
-      y: 0
-    }];
-    if (visited[0]) visited[0][0] = true;
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current.x === this.gameConfig.GRID_SIZE - 1 && current.y === this.gameConfig.GRID_SIZE - 1) {
-        return true; // Found path to end
-      }
-
-      // Check all four directions
-      const directions = [{
-        dx: 0,
-        dy: -1,
-        wall: 'top'
-      },
-      // Up
-      {
-        dx: 1,
-        dy: 0,
-        wall: 'right'
-      },
-      // Right
-      {
-        dx: 0,
-        dy: 1,
-        wall: 'bottom'
-      },
-      // Down
-      {
-        dx: -1,
-        dy: 0,
-        wall: 'left'
-      } // Left
-      ];
-      for (const dir of directions) {
-        const newX = current.x + dir.dx;
-        const newY = current.y + dir.dy;
-        if (newX >= 0 && newX < this.gameConfig.GRID_SIZE && newY >= 0 && newY < this.gameConfig.GRID_SIZE && !visited[newY]?.[newX]) {
-          // Check if there's no wall blocking this direction
-          const currentCell = this.maze[current.y]?.[current.x];
-          if (currentCell && !currentCell.walls[dir.wall]) {
-            if (visited[newY]) visited[newY][newX] = true;
-            queue.push({
-              x: newX,
-              y: newY
-            });
-          }
-        }
-      }
-    }
-    return false; // No path found
-  }
-  createMinimalPath() {
-    // Create a winding, unpredictable path from start to end
-    // This should only be called if no path exists after maze generation
-    let currentX = 0;
-    let currentY = 0;
-    const endX = this.gameConfig.GRID_SIZE - 1;
-    const endY = this.gameConfig.GRID_SIZE - 1;
-    const visited = new Set();
-    while (currentX !== endX || currentY !== endY) {
-      const key = `${currentX},${currentY}`;
-      if (visited.has(key)) {
-        // Prevent infinite loops - break out and create direct path
-        break;
-      }
-      visited.add(key);
-
-      // Randomly choose direction, but prefer moving towards target occasionally
-      const possibleMoves = [];
-      if (currentX < endX) possibleMoves.push('right');
-      if (currentY < endY) possibleMoves.push('down');
-      if (currentX > 0) possibleMoves.push('left');
-      if (currentY > 0) possibleMoves.push('up');
-      if (possibleMoves.length === 0) break;
-
-      // 60% chance to move towards target, 40% chance random direction
-      let direction;
-      if (Math.random() < 0.6 && (currentX !== endX || currentY !== endY)) {
-        // Move towards target
-        if (currentX < endX && Math.random() < 0.5) {
-          direction = 'right';
-        } else if (currentY < endY) {
-          direction = 'down';
-        } else if (currentX < endX) {
-          direction = 'right';
-        } else {
-          direction = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
-        }
-      } else {
-        // Random direction
-        direction = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
-      }
-
-      // Remove wall in chosen direction
-      const cell = this.maze[currentY]?.[currentX];
-      if (direction === 'right' && currentX < this.gameConfig.GRID_SIZE - 1 && cell) {
-        cell.walls.right = false;
-        const rightCell = this.maze[currentY]?.[currentX + 1];
-        if (rightCell) rightCell.walls.left = false;
-        currentX++;
-      } else if (direction === 'down' && currentY < this.gameConfig.GRID_SIZE - 1 && cell) {
-        cell.walls.bottom = false;
-        const bottomCell = this.maze[currentY + 1]?.[currentX];
-        if (bottomCell) bottomCell.walls.top = false;
-        currentY++;
-      } else if (direction === 'left' && currentX > 0 && cell) {
-        cell.walls.left = false;
-        const leftCell = this.maze[currentY]?.[currentX - 1];
-        if (leftCell) leftCell.walls.right = false;
-        currentX--;
-      } else if (direction === 'up' && currentY > 0 && cell) {
-        cell.walls.top = false;
-        const topCell = this.maze[currentY - 1]?.[currentX];
-        if (topCell) topCell.walls.bottom = false;
-        currentY--;
-      }
-    }
-  }
-  getUnvisitedNeighbors(cell) {
-    const neighbors = [];
-    const {
-      x,
-      y
-    } = cell;
-
-    // Top
-    if (y > 0 && this.maze[y - 1]?.[x] && !this.maze[y - 1]?.[x]?.visited) {
-      const topCell = this.maze[y - 1]?.[x];
-      if (topCell) {
-        neighbors.push(topCell);
-      }
-    }
-    // Right
-    if (x < this.gameConfig.GRID_SIZE - 1 && this.maze[y]?.[x + 1] && !this.maze[y]?.[x + 1]?.visited) {
-      const rightCell = this.maze[y]?.[x + 1];
-      if (rightCell) {
-        neighbors.push(rightCell);
-      }
-    }
-    // Bottom
-    if (y < this.gameConfig.GRID_SIZE - 1 && this.maze[y + 1]?.[x] && !this.maze[y + 1]?.[x]?.visited) {
-      const bottomCell = this.maze[y + 1]?.[x];
-      if (bottomCell) {
-        neighbors.push(bottomCell);
-      }
-    }
-    // Left
-    if (x > 0 && this.maze[y]?.[x - 1] && !this.maze[y]?.[x - 1]?.visited) {
-      const leftCell = this.maze[y]?.[x - 1];
-      if (leftCell) {
-        neighbors.push(leftCell);
-      }
-    }
-    return neighbors;
-  }
-  removeWallBetween(current, next) {
-    const dx = current.x - next.x;
-    const dy = current.y - next.y;
-    if (dx === 1) {
-      // Next is to the left
-      current.walls.left = false;
-      next.walls.right = false;
-    } else if (dx === -1) {
-      // Next is to the right
-      current.walls.right = false;
-      next.walls.left = false;
-    } else if (dy === 1) {
-      // Next is above
-      current.walls.top = false;
-      next.walls.bottom = false;
-    } else if (dy === -1) {
-      // Next is below
-      current.walls.bottom = false;
-      next.walls.top = false;
-    }
-  }
-  generateWalls() {
-    this.walls = [];
-    const wallThickness = 4;
-    const cellSize = this.gameConfig.CELL_SIZE;
-    const mazeWidth = this.gameConfig.GRID_SIZE * cellSize;
-    const mazeHeight = this.gameConfig.GRID_SIZE * cellSize;
-
-    // Create outer boundary walls (solid perimeter around the maze area)
-    // Top boundary
-    this.walls.push({
-      x: 0,
-      y: 0,
-      width: mazeWidth,
-      height: wallThickness,
-      type: 'horizontal'
-    });
-
-    // Bottom boundary
-    this.walls.push({
-      x: 0,
-      y: mazeHeight - wallThickness,
-      width: mazeWidth,
-      height: wallThickness,
-      type: 'horizontal'
-    });
-
-    // Left boundary
-    this.walls.push({
-      x: 0,
-      y: 0,
-      width: wallThickness,
-      height: mazeHeight,
-      type: 'vertical'
-    });
-
-    // Right boundary
-    this.walls.push({
-      x: mazeWidth - wallThickness,
-      y: 0,
-      width: wallThickness,
-      height: mazeHeight,
-      type: 'vertical'
-    });
-
-    // Generate internal walls based on maze cells
-    // Only add walls where they are needed to avoid duplicates
-    for (let y = 0; y < this.gameConfig.GRID_SIZE; y++) {
-      for (let x = 0; x < this.gameConfig.GRID_SIZE; x++) {
-        const cell = this.maze[y]?.[x];
-        if (!cell) continue;
-        const cellX = x * cellSize;
-        const cellY = y * cellSize;
-
-        // Add horizontal walls (only add each wall once)
-        // Add top wall if this cell has a top wall and we're not at the top edge
-        if (cell.walls.top && y > 0) {
-          this.walls.push({
-            x: cellX,
-            y: cellY,
-            width: cellSize,
-            height: wallThickness,
-            type: 'horizontal'
-          });
-        }
-
-        // Add vertical walls (only add each wall once)
-        // Add left wall if this cell has a left wall and we're not at the left edge
-        if (cell.walls.left && x > 0) {
-          this.walls.push({
-            x: cellX,
-            y: cellY,
-            width: wallThickness,
-            height: cellSize,
-            type: 'vertical'
-          });
-        }
-      }
-    }
-  }
-  setStartAndEndPositions() {
-    const cellSize = this.gameConfig.CELL_SIZE;
-
-    // Start position (top-left)
-    this.gameState.ballPosition = {
-      x: cellSize / 2,
-      y: cellSize / 2
-    };
-
-    // End position (bottom-right)
-    this.gameState.targetPosition = {
-      x: (this.gameConfig.GRID_SIZE - 1) * cellSize + cellSize / 2,
-      y: (this.gameConfig.GRID_SIZE - 1) * cellSize + cellSize / 2
-    };
-  }
-  updateSettings(gridSize, gameDuration, gameAreaWidth, gameAreaHeight) {
-    // Update game configuration with new settings
-    const newGameAreaWidth = gameAreaWidth || this.gameConfig.GAME_AREA_WIDTH;
-    const newGameAreaHeight = gameAreaHeight || this.gameConfig.GAME_AREA_HEIGHT;
-    this.gameConfig.GRID_SIZE = gridSize;
-    this.gameConfig.GAME_AREA_WIDTH = newGameAreaWidth;
-    this.gameConfig.GAME_AREA_HEIGHT = newGameAreaHeight;
-    this.gameConfig.CELL_SIZE = Math.min(newGameAreaWidth, newGameAreaHeight) / gridSize;
-    this.gameConfig.GAME_DURATION = gameDuration; // Update game duration
-
-    // Generate new maze with updated settings
-    this.generateNewMaze();
-
-    // Reset game state
-    this.gameState.isPlaying = false;
-    this.gameState.isPaused = false;
-    this.gameState.timeElapsed = 0; // Start from 0 and count up
-    this.gameState.isCompleted = false;
-    this.gameState.gameOver = false;
-    this.stopTimer();
-    this.notifyGameStateChange();
-  }
-  resetGame() {
-    // Generate a completely new maze for fresh gameplay
-    this.generateNewMaze();
-
-    // Reset game state without starting - just prepare for a new game
-    this.gameState.isPlaying = false; // Don't auto-start
-    this.gameState.isPaused = false;
-    this.gameState.score = 0; // Reset score for new game
-    this.gameState.timeElapsed = 0; // Start from 0 and count up
-    this.gameState.isCompleted = false;
-    this.gameState.gameOver = false;
-    this.stopTimer(); // Make sure timer is stopped
-    this.notifyGameStateChange();
-  }
-  startGame() {
-    // Start the game with current maze (don't regenerate here since resetGame already did)
-    this.gameState.ballPosition = {
-      x: this.gameConfig.CELL_SIZE / 2,
-      y: this.gameConfig.CELL_SIZE / 2
-    };
-    this.gameState.targetPosition = {
-      x: (this.gameConfig.GRID_SIZE - 1) * this.gameConfig.CELL_SIZE + this.gameConfig.CELL_SIZE / 2,
-      y: (this.gameConfig.GRID_SIZE - 1) * this.gameConfig.CELL_SIZE + this.gameConfig.CELL_SIZE / 2
-    };
-    this.gameState.isPlaying = true;
-    this.gameState.isPaused = false;
-    this.gameState.score = 0; // Reset score when starting new game
-    this.gameState.timeElapsed = 0; // Start from 0 and count up
-    this.gameState.isCompleted = false;
-    this.gameState.gameOver = false;
-    this.startTimer();
-    this.notifyGameStateChange();
-  }
-  pauseGame() {
-    this.gameState.isPaused = true;
-    this.stopTimer();
-    this.notifyGameStateChange();
-  }
-  resumeGame() {
-    this.gameState.isPaused = false;
-    this.startTimer();
-    this.notifyGameStateChange();
-  }
-  stopGame() {
-    this.gameState.isPlaying = false;
-    this.gameState.isPaused = false;
-    this.stopTimer();
-    this.notifyGameStateChange();
-  }
-  startTimer() {
-    this.stopTimer();
-    this.gameTimer = setInterval(() => {
-      if (!this.gameState.isPaused && this.gameState.isPlaying) {
-        this.gameState.timeElapsed += 1; // Count up from 0
-
-        // No time limit - player can take as long as they need
-        // Timer just tracks how long they've been playing
-
-        this.notifyGameStateChange();
-      }
-    }, 1000);
-  }
-  stopTimer() {
-    if (this.gameTimer) {
-      clearInterval(this.gameTimer);
-      this.gameTimer = null;
-    }
-  }
-  updateBallPosition(newPosition) {
-    if (!this.gameState.isPlaying || this.gameState.isPaused) {
-      return false;
-    }
-
-    // Check if the new position is valid (within maze path)
-    if (this.isValidPosition(newPosition)) {
-      this.gameState.ballPosition = newPosition;
-
-      // Check if reached target (only if not already completed)
-      if (!this.gameState.isCompleted && this.isNearTarget(newPosition)) {
-        this.completeLevel();
-      }
-      this.notifyGameStateChange();
-      return true;
-    }
-    return false;
-  }
-  isValidPosition(position) {
-    const {
-      x,
-      y
-    } = position;
-    const ballRadius = this.gameConfig.BALL_SIZE / 2;
-
-    // Check if ball would collide with any wall
-    for (const wall of this.walls) {
-      if (this.ballCollidesWithWall(x, y, ballRadius, wall)) {
-        return false;
-      }
-    }
-
-    // Check game area boundaries (with some padding)
-    const padding = ballRadius + 2;
-    if (x - ballRadius < padding || x + ballRadius > this.gameConfig.GAME_AREA_WIDTH - padding || y - ballRadius < padding || y + ballRadius > this.gameConfig.GAME_AREA_HEIGHT - padding) {
-      return false;
-    }
-    return true;
-  }
-  ballCollidesWithWall(ballX, ballY, ballRadius, wall) {
-    // Calculate the closest point on the wall rectangle to the ball center
-    const closestX = Math.max(wall.x, Math.min(ballX, wall.x + wall.width));
-    const closestY = Math.max(wall.y, Math.min(ballY, wall.y + wall.height));
-
-    // Calculate the distance from the ball center to this closest point
-    const distanceX = ballX - closestX;
-    const distanceY = ballY - closestY;
-    const distanceSquared = distanceX * distanceX + distanceY * distanceY;
-
-    // Check if the distance is less than the ball radius
-    return distanceSquared < ballRadius * ballRadius;
-  }
-  isNearTarget(position) {
-    const distance = Math.sqrt(Math.pow(position.x - this.gameState.targetPosition.x, 2) + Math.pow(position.y - this.gameState.targetPosition.y, 2));
-    // Make target detection more generous - use 1.5x ball size for easier completion
-    return distance < this.gameConfig.BALL_SIZE * 1.5;
-  }
-  completeLevel() {
-    // No time bonus - faster completion is the goal
-    this.gameState.score += this.gameConfig.SCORE_PER_COMPLETION;
-    this.gameState.isCompleted = true;
-    this.gameState.isPlaying = false; // Stop the game when maze is completed
-    this.stopTimer();
-    this.notifyGameStateChange();
-  }
-  getGameState() {
-    return {
-      ...this.gameState
-    };
-  }
-  getGameConfig() {
-    return {
-      ...this.gameConfig
-    };
-  }
-  getWalls() {
-    return [...this.walls];
-  }
-  getMaze() {
-    return this.maze.map(row => row.map(cell => ({
-      ...cell
-    })));
-  }
-
-  // Format time for display (MM:SS format)
-  formatTime(seconds) {
-    const minutes = Math.floor(seconds / 60);
-    const remainingSeconds = seconds % 60;
-    return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
-  }
-  cleanup() {
-    this.stopTimer();
-  }
-}
-//# sourceMappingURL=MazeRunnerService.js.map
+"use strict";export class MazeRunnerService{gameTimer = null;constructor(gridSize = 15,gameAreaWidth = 350,gameAreaHeight = 500,gameDuration = 120){this.gameConfig ={GRID_SIZE:gridSize,CELL_SIZE:Math.min(gameAreaWidth,gameAreaHeight)/ gridSize,BALL_SIZE:18,PIPE_WIDTH:8,GAME_AREA_WIDTH:gameAreaWidth,GAME_AREA_HEIGHT:gameAreaHeight,COLLISION_TOLERANCE:5,SCORE_PER_COMPLETION:100,TIME_BONUS_MULTIPLIER:10,GAME_DURATION:gameDuration};this.gameState ={isPlaying:false,isPaused:false,score:0,timeElapsed:0,ballPosition:{x:0,y:0},targetPosition:{x:0,y:0},isCompleted:false,gameOver:false};this.maze = [];this.walls = [];this.initializeMaze();this.generateMazeWithBacktracking();this.generateWalls();this.setStartAndEndPositions();}setGameStateChangeCallback(callback){this.onGameStateChange = callback;}notifyGameStateChange(){if(this.onGameStateChange){this.onGameStateChange({...this.gameState});}}initializeMaze(){this.maze = [];for(let y = 0;y < this.gameConfig.GRID_SIZE;y++){this.maze[y] = [];for(let x = 0;x < this.gameConfig.GRID_SIZE;x++){if(this.maze[y]){this.maze[y][x] ={x,y,walls:{top:true,right:true,bottom:true,left:true},visited:false};}}}}generateNewMaze(){this.initializeMaze();this.generateMazeWithBacktracking();this.generateWalls();this.setStartAndEndPositions();this.gameState.isCompleted = false;this.gameState.isPlaying = false;this.gameState.isPaused = false;this.gameState.gameOver = false;this.gameState.score = 0;this.gameState.timeElapsed = 0;this.notifyGameStateChange();}generateMazeWithBacktracking(){const stack = [];const startCell = this.maze[0]?.[0];if(startCell){startCell.visited = true;stack.push(startCell);}while(stack.length > 0){const current = stack[stack.length - 1];const neighbors = current ? this.getUnvisitedNeighbors(current):[];if(neighbors.length > 0){const next = neighbors[Math.floor(Math.random()* neighbors.length)];if(current && next)this.removeWallBetween(current,next);if(next){next.visited = true;stack.push(next);}}else{stack.pop();}}this.ensureConnectivity();}ensureConnectivity(){if(!this.hasPathFromStartToEnd()){this.createMinimalPath();}}hasPathFromStartToEnd(){const visited = Array(this.gameConfig.GRID_SIZE).fill(null).map(()=> Array(this.gameConfig.GRID_SIZE).fill(false));const queue = [{x:0,y:0}];if(visited[0])visited[0][0] = true;while(queue.length > 0){const current = queue.shift();if(current.x === this.gameConfig.GRID_SIZE - 1 && current.y === this.gameConfig.GRID_SIZE - 1){return true;}const directions = [{dx:0,dy:-1,wall:'top'},{dx:1,dy:0,wall:'right'},{dx:0,dy:1,wall:'bottom'},{dx:-1,dy:0,wall:'left'}];for(const dir of directions){const newX = current.x + dir.dx;const newY = current.y + dir.dy;if(newX >= 0 && newX < this.gameConfig.GRID_SIZE && newY >= 0 && newY < this.gameConfig.GRID_SIZE && !visited[newY]?.[newX]){const currentCell = this.maze[current.y]?.[current.x];if(currentCell && !currentCell.walls[dir.wall]){if(visited[newY])visited[newY][newX] = true;queue.push({x:newX,y:newY});}}}}return false;}createMinimalPath(){let currentX = 0;let currentY = 0;const endX = this.gameConfig.GRID_SIZE - 1;const endY = this.gameConfig.GRID_SIZE - 1;const visited = new Set();while(currentX !== endX || currentY !== endY){const key = `${currentX},${currentY}`;if(visited.has(key)){break;}visited.add(key);const possibleMoves = [];if(currentX < endX)possibleMoves.push('right');if(currentY < endY)possibleMoves.push('down');if(currentX > 0)possibleMoves.push('left');if(currentY > 0)possibleMoves.push('up');if(possibleMoves.length === 0)break;let direction;if(Math.random()< 0.6 &&(currentX !== endX || currentY !== endY)){if(currentX < endX && Math.random()< 0.5){direction = 'right';}else if(currentY < endY){direction = 'down';}else if(currentX < endX){direction = 'right';}else{direction = possibleMoves[Math.floor(Math.random()* possibleMoves.length)];}}else{direction = possibleMoves[Math.floor(Math.random()* possibleMoves.length)];}const cell = this.maze[currentY]?.[currentX];if(direction === 'right' && currentX < this.gameConfig.GRID_SIZE - 1 && cell){cell.walls.right = false;const rightCell = this.maze[currentY]?.[currentX + 1];if(rightCell)rightCell.walls.left = false;currentX++;}else if(direction === 'down' && currentY < this.gameConfig.GRID_SIZE - 1 && cell){cell.walls.bottom = false;const bottomCell = this.maze[currentY + 1]?.[currentX];if(bottomCell)bottomCell.walls.top = false;currentY++;}else if(direction === 'left' && currentX > 0 && cell){cell.walls.left = false;const leftCell = this.maze[currentY]?.[currentX - 1];if(leftCell)leftCell.walls.right = false;currentX--;}else if(direction === 'up' && currentY > 0 && cell){cell.walls.top = false;const topCell = this.maze[currentY - 1]?.[currentX];if(topCell)topCell.walls.bottom = false;currentY--;}}}getUnvisitedNeighbors(cell){const neighbors = [];const{x,y}= cell;if(y > 0 && this.maze[y - 1]?.[x] && !this.maze[y - 1]?.[x]?.visited){const topCell = this.maze[y - 1]?.[x];if(topCell){neighbors.push(topCell);}}if(x < this.gameConfig.GRID_SIZE - 1 && this.maze[y]?.[x + 1] && !this.maze[y]?.[x + 1]?.visited){const rightCell = this.maze[y]?.[x + 1];if(rightCell){neighbors.push(rightCell);}}if(y < this.gameConfig.GRID_SIZE - 1 && this.maze[y + 1]?.[x] && !this.maze[y + 1]?.[x]?.visited){const bottomCell = this.maze[y + 1]?.[x];if(bottomCell){neighbors.push(bottomCell);}}if(x > 0 && this.maze[y]?.[x - 1] && !this.maze[y]?.[x - 1]?.visited){const leftCell = this.maze[y]?.[x - 1];if(leftCell){neighbors.push(leftCell);}}return neighbors;}removeWallBetween(current,next){const dx = current.x - next.x;const dy = current.y - next.y;if(dx === 1){current.walls.left = false;next.walls.right = false;}else if(dx === -1){current.walls.right = false;next.walls.left = false;}else if(dy === 1){current.walls.top = false;next.walls.bottom = false;}else if(dy === -1){current.walls.bottom = false;next.walls.top = false;}}generateWalls(){this.walls = [];const wallThickness = 4;const cellSize = this.gameConfig.CELL_SIZE;const mazeWidth = this.gameConfig.GRID_SIZE * cellSize;const mazeHeight = this.gameConfig.GRID_SIZE * cellSize;this.walls.push({x:0,y:0,width:mazeWidth,height:wallThickness,type:'horizontal'});this.walls.push({x:0,y:mazeHeight - wallThickness,width:mazeWidth,height:wallThickness,type:'horizontal'});this.walls.push({x:0,y:0,width:wallThickness,height:mazeHeight,type:'vertical'});this.walls.push({x:mazeWidth - wallThickness,y:0,width:wallThickness,height:mazeHeight,type:'vertical'});for(let y = 0;y < this.gameConfig.GRID_SIZE;y++){for(let x = 0;x < this.gameConfig.GRID_SIZE;x++){const cell = this.maze[y]?.[x];if(!cell)continue;const cellX = x * cellSize;const cellY = y * cellSize;if(cell.walls.top && y > 0){this.walls.push({x:cellX,y:cellY,width:cellSize,height:wallThickness,type:'horizontal'});}if(cell.walls.left && x > 0){this.walls.push({x:cellX,y:cellY,width:wallThickness,height:cellSize,type:'vertical'});}}}}setStartAndEndPositions(){const cellSize = this.gameConfig.CELL_SIZE;this.gameState.ballPosition ={x:cellSize / 2,y:cellSize / 2};this.gameState.targetPosition ={x:(this.gameConfig.GRID_SIZE - 1)* cellSize + cellSize / 2,y:(this.gameConfig.GRID_SIZE - 1)* cellSize + cellSize / 2};}updateSettings(gridSize,gameDuration,gameAreaWidth,gameAreaHeight){const newGameAreaWidth = gameAreaWidth || this.gameConfig.GAME_AREA_WIDTH;const newGameAreaHeight = gameAreaHeight || this.gameConfig.GAME_AREA_HEIGHT;this.gameConfig.GRID_SIZE = gridSize;this.gameConfig.GAME_AREA_WIDTH = newGameAreaWidth;this.gameConfig.GAME_AREA_HEIGHT = newGameAreaHeight;this.gameConfig.CELL_SIZE = Math.min(newGameAreaWidth,newGameAreaHeight)/ gridSize;this.gameConfig.GAME_DURATION = gameDuration;this.generateNewMaze();this.gameState.isPlaying = false;this.gameState.isPaused = false;this.gameState.timeElapsed = 0;this.gameState.isCompleted = false;this.gameState.gameOver = false;this.stopTimer();this.notifyGameStateChange();}resetGame(){this.generateNewMaze();this.gameState.isPlaying = false;this.gameState.isPaused = false;this.gameState.score = 0;this.gameState.timeElapsed = 0;this.gameState.isCompleted = false;this.gameState.gameOver = false;this.stopTimer();this.notifyGameStateChange();}startGame(){this.gameState.ballPosition ={x:this.gameConfig.CELL_SIZE / 2,y:this.gameConfig.CELL_SIZE / 2};this.gameState.targetPosition ={x:(this.gameConfig.GRID_SIZE - 1)* this.gameConfig.CELL_SIZE + this.gameConfig.CELL_SIZE / 2,y:(this.gameConfig.GRID_SIZE - 1)* this.gameConfig.CELL_SIZE + this.gameConfig.CELL_SIZE / 2};this.gameState.isPlaying = true;this.gameState.isPaused = false;this.gameState.score = 0;this.gameState.timeElapsed = 0;this.gameState.isCompleted = false;this.gameState.gameOver = false;this.startTimer();this.notifyGameStateChange();}pauseGame(){this.gameState.isPaused = true;this.stopTimer();this.notifyGameStateChange();}resumeGame(){this.gameState.isPaused = false;this.startTimer();this.notifyGameStateChange();}stopGame(){this.gameState.isPlaying = false;this.gameState.isPaused = false;this.stopTimer();this.notifyGameStateChange();}startTimer(){this.stopTimer();this.gameTimer = setInterval(()=>{if(!this.gameState.isPaused && this.gameState.isPlaying){this.gameState.timeElapsed += 1;this.notifyGameStateChange();}},1000);}stopTimer(){if(this.gameTimer){clearInterval(this.gameTimer);this.gameTimer = null;}}updateBallPosition(newPosition){if(!this.gameState.isPlaying || this.gameState.isPaused){return false;}if(this.isValidPosition(newPosition)){this.gameState.ballPosition = newPosition;if(!this.gameState.isCompleted && this.isNearTarget(newPosition)){this.completeLevel();}this.notifyGameStateChange();return true;}return false;}isValidPosition(position){const{x,y}= position;const ballRadius = this.gameConfig.BALL_SIZE / 2;for(const wall of this.walls){if(this.ballCollidesWithWall(x,y,ballRadius,wall)){return false;}}const padding = ballRadius + 2;if(x - ballRadius < padding || x + ballRadius > this.gameConfig.GAME_AREA_WIDTH - padding || y - ballRadius < padding || y + ballRadius > this.gameConfig.GAME_AREA_HEIGHT - padding){return false;}return true;}ballCollidesWithWall(ballX,ballY,ballRadius,wall){const closestX = Math.max(wall.x,Math.min(ballX,wall.x + wall.width));const closestY = Math.max(wall.y,Math.min(ballY,wall.y + wall.height));const distanceX = ballX - closestX;const distanceY = ballY - closestY;const distanceSquared = distanceX * distanceX + distanceY * distanceY;return distanceSquared < ballRadius * ballRadius;}isNearTarget(position){const distance = Math.sqrt(Math.pow(position.x - this.gameState.targetPosition.x,2)+ Math.pow(position.y - this.gameState.targetPosition.y,2));return distance < this.gameConfig.BALL_SIZE * 1.5;}completeLevel(){this.gameState.score += this.gameConfig.SCORE_PER_COMPLETION;this.gameState.isCompleted = true;this.gameState.isPlaying = false;this.stopTimer();this.notifyGameStateChange();}getGameState(){return{...this.gameState};}getGameConfig(){return{...this.gameConfig};}getWalls(){return [...this.walls];}getMaze(){return this.maze.map(row => row.map(cell =>({...cell})));}formatTime(seconds){const minutes = Math.floor(seconds / 60);const remainingSeconds = seconds % 60;return `${minutes}:${remainingSeconds.toString().padStart(2,'0')}`;}cleanup(){this.stopTimer();}}