当前位置：首页 > news >正文

从零开始用AI开发游戏（二）代码实现

news 来源：原创 2025/5/18 2:57:28

在这里插入图片描述
以下是基于递归分割算法的迷宫生成与玩家移动控制的完整实现代码，包含详细注释：

// 迷宫生成器（递归分割算法实现）
class MazeGenerator {
  constructor(width, height) {
    this.width = width;
    this.height = height;
    this.grid = this.initGrid();
    this.recursiveDivision(0, 0, width, height);
  }

  // 初始化二维网格（全部设为墙）
  initGrid() {
    const grid = [];
    for (let y = 0; y < this.height; y++) {
      grid[y] = [];
      for (let x = 0; x < this.width; x++) {
        grid[y][x] = 1; // 1表示墙，0表示路
      }
    }
    return grid;
  }

  // 递归分割核心算法
  recursiveDivision(x, y, width, height) {
    // 终止条件：区域小于阈值
    if (width < 3 || height < 3) return;

    // 随机选择横向/纵向分割
    const isHorizontal = Math.random() > 0.5;
    
    // 分割线坐标（确保在范围内）
    const wx = x + (isHorizontal ? 0 : Math.floor(Math.random() * (width - 2)) + 1);
    const wy = y + (isHorizontal ? Math.floor(Math.random() * (height - 2)) + 1 : 0);
    
    // 开口位置（随机留通路）
    const px = wx + (isHorizontal ? Math.floor(Math.random() * width) : 0);
    const py = wy + (isHorizontal ? 0 : Math.floor(Math.random() * height));

    // 绘制分割墙
    const dx = isHorizontal ? 1 : 0;
    const dy = isHorizontal ? 0 : 1;
    for (let i = 0; i < (isHorizontal ? width : height); i++) {
      if (wx + dx*i !== px || wy + dy*i !== py) { // 跳过开口位置
        this.grid[wy + dy*i][wx + dx*i] = 1;
      }
    }

    // 递归处理子区域
    if (isHorizontal) {
      this.recursiveDivision(x, y, width, wy - y);
      this.recursiveDivision(x, wy + 1, width, y + height - wy - 1);
    } else {
      this.recursiveDivision(x, y, wx - x, height);
      this.recursiveDivision(wx + 1, y, x + width - wx - 1, height);
    }
  }
}

// 玩家控制器
class Player {
  constructor(maze) {
    this.maze = maze; // 迷宫二维数组引用
    this.x = 1;       // 初始位置（确保在路径上）
    this.y = 1;
  }

  // 计算下一个位置
  calculateNextPosition(direction) {
    switch(direction) {
      case 'up':    return { x: this.x, y: this.y - 1 };
      case 'down':  return { x: this.x, y: this.y + 1 };
      case 'left':  return { x: this.x - 1, y: this.y };
      case 'right': return { x: this.x + 1, y: this.y };
      default:      return { x: this.x, y: this.y };
    }
  }

  // 碰撞检测
  isCollidingWithWall(pos) {
    // 边界检查
    if (pos.x < 0 || pos.x >= this.maze[0].length || 
        pos.y < 0 || pos.y >= this.maze.length) {
      return true;
    }
    // 墙体检查（grid[y][x] === 1）
    return this.maze[pos.y][pos.x] === 1;
  }

  // 移动控制
  move(direction) {
    const nextPos = this.calculateNextPosition(direction);
    if (!this.isCollidingWithWall(nextPos)) {
      this.x = nextPos.x;
      this.y = nextPos.y;
      return true; // 移动成功
    }
    return false; // 碰撞发生
  }
}

/****************** 使用示例 ******************/
// 生成迷宫（建议奇数值）
const mazeGen = new MazeGenerator(21, 21);
const maze = mazeGen.grid;

// 创建玩家实例
const player = new Player(maze);

// 测试移动
player.move('right');  // 成功移动到(2,1)
player.move('down');   // 成功移动到(2,2)
player.move('left');   // 如果(1,2)是墙则失败

关键实现细节说明：

迷宫生成算法：

递归分割通过不断划分区域创建迷宫结构
随机选择横向/纵向分割（50%概率）
分割时总会留出一个随机开口保证路径连通
建议使用奇数值尺寸（保证墙/路的交替模式）

玩家移动控制：

基于网格的离散移动（每次移动1格）
四方向移动控制（WASD对应方向）
双重碰撞检测（边界检查+墙体检查）
返回移动结果用于游戏逻辑反馈

扩展建议：

// 可添加的扩展功能示例：
// 1. 终点检测
class Game {
  constructor() {
    this.exit = { x: maze[0].length-2, y: maze.length-2 };
  }
  
  checkWin() {
    return player.x === this.exit.x && player.y === this.exit.y;
  }
}

// 2. 动态生成可视化
function drawMaze(ctx, maze, cellSize) {
  for (let y = 0; y < maze.length; y++) {
    for (let x = 0; x < maze[y].length; x++) {
      ctx.fillStyle = maze[y][x] === 1 ? '#333' : '#fff';
      ctx.fillRect(x * cellSize, y * cellSize, cellSize, cellSize);
    }
  }
}