JavaScript游戏开发入门:用Canvas实现贪吃蛇

作者:微光

时间:2026-11-18

浏览:107

本文介绍如何使用HTML5 Canvas和原生JavaScript从零实现经典贪吃蛇游戏。深入讲解网格坐标映射、游戏主循环、蛇身队列数据结构、碰撞检测与按键方向锁定机制,并提供完整可运行代码。

文章目录
Web 开发基础 / 2D Canvas 实战
适用对象:前端初学者、游戏逻辑入门 技术栈:HTML5 Canvas / 原生 JavaScript 前置依赖:无第三方游戏引擎
JavaScript游戏开发入门:用Canvas实现贪吃蛇

制作贪吃蛇是理解 2D 游戏开发底层运行机制最经典的实践项目。不需要依赖 PixiJS、Phaser 等重型游戏引擎,仅依靠 HTML5 提供的 <canvas> 绘图上下文与原生 JavaScript,就能完整构建出包含“网格坐标映射、单向主循环驱动、队列式蛇身管理以及边界碰撞检测”的完整游戏系统。本文将从最核心的数学与数据结构设计讲起,逐步拆解状态推进流程,并提供一份开箱即用、无任何冗余代码的完整实现方案。

一、底层机制:网格坐标体系与数据结构设计

开发 2D 游戏的第一步是建立坐标系认知。在 Canvas 原生 API 中,所有绘制函数(如 ctx.fillRect)均以像素(Pixel)为单位。但如果在贪吃蛇游戏中直接操作连续的像素坐标,会导致极大的逻辑复杂度:不仅难以精准判定蛇头是否刚好吞下食物,还极易在转向时出现蛇身关节无法对齐的锯齿现象。

因此,规范的解法是将物理像素画布离散化为逻辑网格(Grid)。例如,将一个 400 × 400 像素的画布划分为每个格子 20 × 20 像素的网格系统,那么整张地图便由 20 × 20 个逻辑单元格构成。

JavaScript游戏开发入门:用Canvas实现贪吃蛇
图 1:Canvas 屏幕像素坐标与逻辑网格单元的换算映射关系

1. 坐标换算公式

在内存中,所有游戏对象的运动判断完全使用网格整数坐标 (gridX, gridY) 进行计算。只有当进入渲染阶段时,才通过乘法换算为 Canvas 物理像素:

// 逻辑坐标转物理像素坐标
const pixelX = gridX * CELL_SIZE;
const pixelY = gridY * CELL_SIZE;
ctx.fillRect(pixelX, pixelY, CELL_SIZE - 2, CELL_SIZE - 2); // 保留 2px 缝隙提升视觉质感

2. 蛇身的数据结构:坐标队列(Array Queue)

蛇不是一个单独的矩形,而是一组有序排列的身体分节。在 JavaScript 中,最适合表示蛇身结构的是包含坐标对象的数组:

  • 蛇头永远位于数组的索引 0:snake[0] = { x: 10, y: 10 },它决定了前进的方向和碰撞判断。
  • 身体关节依次排列在后续索引中:snake[1]、snake[2]……
  • 单次位移的本质:计算新蛇头位置并通过 snake.unshift(newHead) 压入数组最前端;如果此时没有吃到食物,则调用 snake.pop() 丢弃尾部单元;若吃到食物,则跳过 pop(),蛇身自然增长一节。

二、游戏引擎核心:时钟驱动与主循环(Game Loop)

常规网页应用由用户交互事件驱动界面更新(例如点击按钮触发回调),而游戏则依赖持续不断运行的主循环(Game Loop)。

在现代化浏览器中,requestAnimationFrame 能够提供与屏幕刷新率对齐(通常为 60Hz、120Hz 甚至 144Hz)的高性能重绘。但贪吃蛇属于低频离散步进游戏,如果直接在 60FPS 下每次循环都移动一格,蛇的移动速度将达到每秒 60 格,人类根本无法控制。

JavaScript游戏开发入门:用Canvas实现贪吃蛇
图 2:单周期游戏主循环驱动模型与状态转移架构

因此,游戏循环必须引入时间节流机制。通常有两种实现方式:

  1. 受控定时器驱动(经典简洁):使用固定周期的 setInterval(例如每 100ms~150ms 触发一次主更新)。这种方法适合新手入门,逻辑完全受控且易于暂停与重置。
  2. 高精时间差驱动(工程进阶):在 requestAnimationFrame 内部比对 currentTime - lastTime,累积时间超过设定的步长时间阈值后,才执行一次物理逻辑步进,其余时间仅维持渲染或等待。

三、分步实现拆解与核心模块解析

构建整个贪吃蛇项目可以系统性地分解为五个独立递进的模块。各模块职责清晰,前后依赖紧密。

JavaScript游戏开发入门:用Canvas实现贪吃蛇
图 3:Canvas 贪吃蛇自底向上的五步开发实施路线

1 步骤一:画布搭建与上下文初始化

在 HTML 中声明具有明确宽度与高度的 <canvas> 容器,通过 JavaScript 获取 CanvasRenderingContext2D 对象。注意必须使用 Canvas 的内部属性 width="400" height="400",而不能仅依赖 CSS 缩放,否则会导致画布拉伸失真。

2 步骤二:状态常量与数据模型配置

集中定义网格尺寸 GRID_SIZE = 20 与格子大小 CELL_SIZE = 20,初始化蛇身坐标数组、食物坐标 { x, y }、当前移动增量向量 (dx, dy) 以及游戏计分变量。

3 步骤三:键盘输入监听与“防反向锁定”

监听全局 keydown 事件。当蛇向右移动(dx === 1)时,按“向左”键必须被严格拦截,否则蛇会瞬间原路折返吞噬自身。此外,引入 isDirectionLocked 标志位,确保在当前时钟周期完成更新前,只采纳一次转向指令,杜绝连续按键导致的同一帧反向自杀漏洞。

4 步骤四:位移步进与吃食逻辑

在每个时钟脉冲触发时,计算新蛇头坐标 newHead = { x: snake[0].x + dx, y: snake[0].y + dy }。比对 newHead 是否与食物坐标完全重合:若命中则积分增加并重新随机生成食物;若未命中则剔除数组末尾元素。

5 步骤五:边界碰撞、自身碰撞与清屏重绘

校验新蛇头是否超出 [0, GRID_SIZE - 1] 边界,或者是否与已有身躯分节坐标重叠。若发生碰撞,立即清空主循环定时器并显示“游戏结束”;若无碰撞,先调用 ctx.clearRect(0, 0, width, height) 清屏,再依次绘制食物与所有蛇身分节。

四、完整可运行源码实现

以下是整合了上述所有核心机制的单文件完整代码。代码包含必要的界面布局与控制逻辑,读者可以直接保存为 .html 文件并在任何现代浏览器中双击打开运行。

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <title>Canvas 贪吃蛇</title>
  <style>
    body {
      margin: 0;
      background: #F8F7F3;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      min-height: 100vh;
      font-family: -apple-system, BlinkMacSystemFont, "PingFang SC", sans-serif;
      color: #30363C;
    }
    .header-panel {
      margin-bottom: 12px;
      display: flex;
      gap: 30px;
      font-size: 18px;
      font-weight: bold;
    }
    #game-canvas {
      background: #FFFFFF;
      border: 2px solid #30363C;
      box-shadow: 0 8px 24px rgba(48, 54, 60, 0.08);
      border-radius: 4px;
    }
    .controls-hint {
      margin-top: 14px;
      font-size: 13px;
      color: #78808A;
    }
    button {
      margin-top: 10px;
      padding: 6px 16px;
      background: #B96555;
      color: white;
      border: none;
      border-radius: 4px;
      cursor: pointer;
      font-weight: 600;
    }
    button:hover { background: #9E5243; }
  </style>
</head>
<body>

  <div class="header-panel">
    <div>得分: <span id="score-display">0</span></div>
    <div>最高分: <span id="high-score">0</span></div>
  </div>

  <canvas id="game-canvas" width="400" height="400"></canvas>

  <div class="controls-hint">操作说明:方向键或 W/A/S/D 控制移动,空格键暂停</div>
  <button id="btn-restart" onclick="restartGame()">重新开始</button>

  <script>
    const canvas = document.getElementById('game-canvas');
    const ctx = canvas.getContext('2d');
    const scoreEl = document.getElementById('score-display');
    const highScoreEl = document.getElementById('high-score');

    // 1. 基础常量与网格规格
    const GRID_SIZE = 20;       // 20x20 个格子
    const CELL_SIZE = 20;       // 每个单元格 20x20 像素
    const TICK_INTERVAL = 120;  // 游戏时钟频率:每 120 毫秒移动一格

    // 2. 状态变量
    let snake = [];
    let food = { x: 0, y: 0 };
    let dx = 1;                 // 水平运动增量 (1:右, -1:左, 0:不移动)
    let dy = 0;                 // 垂直运动增量 (1:下, -1:上, 0:不移动)
    let isDirectionLocked = false; // 防同帧连按反向死锁标志
    let score = 0;
    let highScore = 0;
    let timerId = null;
    let isPaused = false;
    let isGameOver = false;

    // 3. 初始化并启动
    function initGame() {
      snake = [
        { x: 8, y: 10 },
        { x: 7, y: 10 },
        { x: 6, y: 10 }
      ];
      dx = 1;
      dy = 0;
      isDirectionLocked = false;
      score = 0;
      isGameOver = false;
      isPaused = false;
      scoreEl.innerText = score;
      spawnFood();
      draw();

      if (timerId) clearInterval(timerId);
      timerId = setInterval(gameTick, TICK_INTERVAL);
    }

    // 4. 食物生成算法(严格排查重叠)
    function spawnFood() {
      while (true) {
        const rx = Math.floor(Math.random() * GRID_SIZE);
        const ry = Math.floor(Math.random() * GRID_SIZE);
        const hitSnake = snake.some(seg => seg.x === rx && seg.y === ry);
        if (!hitSnake) {
          food = { x: rx, y: ry };
          break;
        }
      }
    }

    // 5. 主循环单步推进
    function gameTick() {
      if (isPaused || isGameOver) return;

      // 5.1 演算新蛇头
      const newHead = { x: snake[0].x + dx, y: snake[0].y + dy };

      // 5.2 边界与撞身碰撞检测
      if (
        newHead.x < 0 || newHead.x >= GRID_SIZE ||
        newHead.y < 0 || newHead.y >= GRID_SIZE ||
        snake.some(seg => seg.x === newHead.x && seg.y === newHead.y)
      ) {
        handleGameOver();
        return;
      }

      // 5.3 推进蛇身
      snake.unshift(newHead);
      isDirectionLocked = false; // 解除当前帧方向锁

      // 5.4 吃食判定
      if (newHead.x === food.x && newHead.y === food.y) {
        score += 10;
        scoreEl.innerText = score;
        if (score > highScore) {
          highScore = score;
          highScoreEl.innerText = highScore;
        }
        spawnFood();
      } else {
        snake.pop(); // 未吃到食物,正常弹出尾巴
      }

      // 5.5 渲染视图
      draw();
    }

    // 6. 绘图渲染管线
    function draw() {
      // 清屏
      ctx.clearRect(0, 0, canvas.width, canvas.height);

      // 绘制浅色背景网格
      ctx.strokeStyle = '#F0ECE4';
      ctx.lineWidth = 1;
      for (let i = 0; i <= GRID_SIZE; i++) {
        ctx.beginPath();
        ctx.moveTo(i * CELL_SIZE, 0);
        ctx.lineTo(i * CELL_SIZE, canvas.height);
        ctx.stroke();
        ctx.beginPath();
        ctx.moveTo(0, i * CELL_SIZE);
        ctx.lineTo(canvas.width, i * CELL_SIZE);
        ctx.stroke();
      }

      // 绘制食物
      ctx.fillStyle = '#B96555';
      ctx.beginPath();
      const foodRadius = CELL_SIZE / 2 - 2;
      ctx.arc(
        food.x * CELL_SIZE + CELL_SIZE / 2,
        food.y * CELL_SIZE + CELL_SIZE / 2,
        foodRadius, 0, Math.PI * 2
      );
      ctx.fill();

      // 绘制蛇身
      snake.forEach((seg, index) => {
        if (index === 0) {
          ctx.fillStyle = '#30363C'; // 蛇头用深炭灰
        } else {
          ctx.fillStyle = '#4B535C'; // 身体分节
        }
        // 留 2px 缝隙,呈现分节质感
        ctx.fillRect(
          seg.x * CELL_SIZE + 1,
          seg.y * CELL_SIZE + 1,
          CELL_SIZE - 2,
          CELL_SIZE - 2
        );
      });
    }

    // 7. 键盘交互与防逆向拦截
    window.addEventListener('keydown', (e) => {
      // 空格键切换暂停
      if (e.code === 'Space') {
        isPaused = !isPaused;
        return;
      }

      // 避免当前物理帧尚未结算前多次响应方向按键
      if (isDirectionLocked) return;

      const key = e.key.toLowerCase();
      const isUp = key === 'arrowup' || key === 'w';
      const isDown = key === 'arrowdown' || key === 's';
      const isLeft = key === 'arrowleft' || key === 'a';
      const isRight = key === 'arrowright' || key === 'd';

      // 拦截 180 度反向操作
      if (isUp && dy === 0) { dx = 0; dy = -1; isDirectionLocked = true; }
      else if (isDown && dy === 0) { dx = 0; dy = 1; isDirectionLocked = true; }
      else if (isLeft && dx === 0) { dx = -1; dy = 0; isDirectionLocked = true; }
      else if (isRight && dx === 0) { dx = 1; dy = 0; isDirectionLocked = true; }
    });

    function handleGameOver() {
      isGameOver = true;
      clearInterval(timerId);
      ctx.fillStyle = 'rgba(48, 54, 60, 0.75)';
      ctx.fillRect(0, 0, canvas.width, canvas.height);

      ctx.fillStyle = '#FFFFFF';
      ctx.font = 'bold 24px -apple-system, BlinkMacSystemFont, "PingFang SC"';
      ctx.textAlign = 'center';
      ctx.fillText('游戏结束', canvas.width / 2, canvas.height / 2 - 10);

      ctx.font = '14px -apple-system, BlinkMacSystemFont, "PingFang SC"';
      ctx.fillStyle = '#E2DDD5';
      ctx.fillText(`最终得分: ${score},点击下方按钮重玩`, canvas.width / 2, canvas.height / 2 + 20);
    }

    function restartGame() {
      initGame();
    }

    // 启动游戏
    initGame();
  </script>
</body>
</html>

五、难点避坑与工程化优化

初学者在完成基础绘制后,往往会遭遇几类隐蔽的逻辑缺陷。这些问题在代码层面语法完全正确,却会在实际游玩体验中导致严重的非预期行为。

JavaScript游戏开发入门:用Canvas实现贪吃蛇
图 4:Canvas 贪吃蛇开发中三大常见缺陷与规范防御策略对比

1. 同物理帧内连续按键导致“反向自杀”

现象复现:假设蛇当前正在向右移动(dx=1, dy=0)。玩家在 100ms 周期内迅速依次按下了“向下”和“向左”。如果代码仅仅判断 if (isLeft && dx !== 1),那么在按“下”时 dy 变为 1、dx 变为 0;紧接着按“左”时,由于 dx 已经是 0,向左的修改也被立即执行。当该时钟周期结算物理位置时,蛇头直接向左移动,正好迎面撞上自身的颈部导致暴毙。

解决方案:引入状态锁 isDirectionLocked = true。在键盘监听器中一旦接纳了一次转向,立即关闭接收通道,直到物理循环 gameTick() 结算完成后才重新将其置为 false。对于要求更高手感的游戏,也可以维护一个长度为 2 的输入缓冲队列(Input Buffer Queue),按时间先后逐帧消化。

2. 食物随机生成死循环与重叠防范

随着贪吃蛇不断吞食,蛇身长度会占据网格的大部分空间。如果仅使用简单的随机重抽法,在游戏后期极易产生高频重试开销,甚至当蛇身填满所有格子时导致 while(true) 彻底卡死浏览器。

工程级防御策略

当蛇身长度超过地图总网格数的 70% 时,建议摒弃随机抽取重试,转为基于剩余空闲格子的采样法:先遍历过滤出所有未被蛇身占据的空闲单元格集合 emptyCells,再通过 emptyCells[Math.floor(Math.random() * emptyCells.length)] 直接精准拾取,算法复杂度从不确定的重抽变为可控的单次扫描。

3. 物理像素模糊与 1px 细线锯齿

在绘制背景网格线时,若坐标刚好处于整数像素(如 moveTo(20, 0)),由于浏览器绘制 1px 边线时会向坐标两侧各扩展 0.5px,导致跨越两个物理像素而呈现出发虚发灰的抗锯齿效果。解决方法有两种:

  • 在线条坐标上增加 0.5px 偏移(如 moveTo(x + 0.5, 0));
  • 在高分屏(Retina / HiDPI)设备上,检测 window.devicePixelRatio,将 Canvas 物理尺寸放大对应倍数,再通过 CSS 缩小至显示尺寸,配合 ctx.scale(dpr, dpr) 实现高清视网膜渲染。

六、总结与功能扩展方向

通过本文的拆解与实现,可以提炼出 2D 游戏开发的核心设计模式:

  • 模型与视图分离:蛇的物理位置、运动向量、食物分布完全由数组和整数状态维护,Canvas 仅负责作为“纯渲染器”将状态投影在屏幕上。
  • 离散网格化:将复杂的浮点碰撞降维为整数相等的比对,大幅降低系统复杂度。
  • 单向确定性循环:由固定时钟脉冲推动“输入 -> 更新 -> 判定 -> 重绘”,确保游戏行为的可预测性。

在掌握了基础闭环后,读者可以尝试在此代码基础上进行后续扩展,例如:增加随分数提高而自动缩短的 TICK_INTERVAL 实现渐进式加速;在网格中引入不可穿越的障碍物地图;或者支持两名玩家分别使用 WASD 与方向键同屏对抗的经典双人模式。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章