devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用js代码实现贪吃蛇小游戏_js贪吃蛇

作者：Guff_9hys | 2024-08-19 08:13:18

赞

踩

js贪吃蛇

js已经学了大部分了，现在就利用我所学的js知识试试做贪吃蛇小游戏吧

以下部分相关图片以及思路笔记均出自渡一陈老师的视频

首先制作简单的静态页面，添加贪吃蛇移动的背景和相关图片，比如开始游戏等等

将各个功能均封装在函数中，利用主函数调用分函数会使结构更清晰

初始化游戏

初始化地图

地图坐标

 

  1.   //1.初始化地图
  2.   for(let i=0;i<tr;i++){
  3.     for(let j=0;j<td;j++){
  4.       gridData.push({
  5.         x:j,
  6.         y:i
  7.       })
  8.     }
  9.   }

绘制蛇

  • 在游戏相关配置文件（js文件）中定义蛇的身体大小，以及蛇的相关位置信息（位置坐标，对应身体还是头部标志，身体元素相关元素标签）
  • 在index.js文件中遍历snake的位置信息，若domContent(身体元素相关元素标签)为空，就添加元素标签，给标签设置定位，并设置每个元素的left和top为身体大小*x或者*y，并且判断身体元素是蛇头还是身体，是蛇头就添加蛇头的背景，是身体就添加背景颜色并设置圆角边框
  • 判断是否第一次创建蛇后，在容器中append创建的元素
  1. // 蛇的身体大小
  2. let snakeBody=20
  3. // 蛇相关的配置信息
  4. let snake={
  5.   // 蛇的初始位置
  6.   snakePos:[//domContent为蛇的相应dom元素 flag根据身体还是蛇头分别渲染
  7.     {x:0,y:0,domContent:"",flag:'body'},
  8.     {x:1,y:0,domContent:"",flag:'body'},
  9.     {x:2,y:0,domContent:"",flag:'body'},
  10.     {x:3,y:0,domContent:"",flag:'head'}
  11.   ]
  12. }
  13. /**
  14.  *绘制蛇的方法
  15.  *  @param {*} snake
  16.  * */
  17. function drawSnake(snake){
  18.   for(let i=0;i<snake.snakePos.length;i++){
  19.     if(!snake.snakePos[i].domContent){
  20.       // 如果进入此if，说明是第一次创建蛇
  21.       snake.snakePos[i].domContent=document.createElement("div")
  22.       snake.snakePos[i].domContent.style.position="absolute"
  23.       snake.snakePos[i].domContent.style.width=snakeBody+"px"
  24.       snake.snakePos[i].domContent.style.height=snakeBody+"px"
  25.       snake.snakePos[i].domContent.style.left=snake.snakePos[i].x*snakeBody+"px"
  26.       snake.snakePos[i].domContent.style.top=snake.snakePos[i].y*snakeBody+"px"
  27.       if(snake.snakePos[i].flag==='head'){
  28.         // 说明当前是蛇头
  29.         snake.snakePos[i].domContent.style.background=`url("../images/snake.png") center/contain no-repeat`
  30.       }else{
  31.         // 说明是蛇身
  32.         snake.snakePos[i].domContent.style.background="#9ddbb1"
  33.         snake.snakePos[i].domContent.style.borderRadius='50%'
  34.       }
  35.     }
  36.     // 需要将创建的DOM元素添加到container 容器上面
  37.     document.querySelector(".container").append(snake.snakePos[i].domContent)
  38.   }
  39. }
'
运行

添加几个蛇身后效果如图所示：

绘制食物

  • 其过程和绘制蛇过程基本类似，先在配置文件中声明食物的相关配置信息，食物对象中不需要标志元素
  • 要求食物不可出现在蛇头蛇身以及container外面区域，生成随机数在while中循环无限循环，直到坐标符合条件退出循环，利用一个变量判断是否需要退出循环
  • 生成正确的坐标后，就创建一个新的变量，设置绝对定位，宽高，背景，最后append到container中，当然，要先判断food.domContent是否为空，为空才可创建，创建之后只是改变食物的位置，不会再继续创建元素，故设置食物的elft和top要在判断条件外执行
  1. // 整个网格的行与列
  2. const tr=30
  3. const td=30// 食物相关的配置信息
  4. let food={
  5.   x:0,y:0,domContent:""
  6. }function drawFood(){
  7.   // 食物的坐标是随机的 但食物不可生成在蛇头 蛇身 以及container之外的区域
  8.   while(true){
  9.     // 构成一个死循环，直到生成符合要求的坐标才能退出该循环
  10.     let isRepeat=false //默认生成的坐标符合要求
  11.     // 随机生成一个坐标
  12.     food.x=Math.floor(Math.random()*tr)
  13.     food.y=Math.floor(Math.random()*td)
  14.     // 查看坐标是否符合要求（遍历蛇）
  15.     for(let i=0;i<snake.snakePos.length;i++){
  16.       if(snake.snakePos[i].x===food.x&&snake.snakePos[i].y===food.y){
  17.         // 进入此if 说明当前生成的食物坐标和蛇的位置冲突
  18.         isRepeat=true
  19.         break
  20.       }
  21.      
  22.     }
  23.     if(!isRepeat){
  24.       break
  25.     }
  26.  
  27.   }
  28.     // 整个while 循环跳出之后，食物的坐标一定是OK的
  29.  
  30.   if(!food.domContent){
  31.     food.domContent=document.createElement("div")
  32.     food.domContent.style.width=snakeBody+"px"
  33.     food.domContent.style.height=snakeBody+"px"
  34.     food.domContent.style.position="absolute"
  35.     food.domContent.style.background=`url("../images/food.png") center/contain no-repeat`
  36.     document.querySelector('.container').append(food.domContent)
  37.  
  38.   }
  39.   food.domContent.style.left=food.x*snakeBody+"px"
  40.   food.domContent.style.top=food.y*snakeBody+"px"
  41. }

绑定事件

  • 按下键盘的上下左右时，蛇会上下左右移动，此时要添加相关配置信息，明确新蛇头和旧蛇头之间的位置关系，在确定新的蛇头坐标时，会用一个对象和旧蛇头进行计算
  • 绑定事件keydown
  • 同时在蛇的相关配置信息中添加方向
  1. // 要明确新的蛇头和旧的蛇头之间的位置关系
  2. // 我们在确定新的蛇头坐标的时候，会那下面的对象和旧蛇头做一个计算
  3.  
  4. const directionNum={
  5.   left:{x:-1,y:0,flag:'left'},
  6.   right:{x:1,y:0,flag:'right'},
  7.   top:{x:0,y:-1,flag:'top'},
  8.   bottom:{x:0,y:1,flag:'bottom'}
  9. }
  10. // 蛇相关的配置信息
  11. let snake={
  12.   // 蛇一开始移动的方向
  13.   direction:directionNum.right,//一开始向右边移动
  14.   // 蛇的初始位置
  15.   snakePos:[//domContent为蛇的相应dom元素 flag根据身体还是蛇头分别渲染
  16.     {x:0,y:0,domContent:"",flag:'body'},
  17.     {x:1,y:0,domContent:"",flag:'body'},
  18.     {x:2,y:0,domContent:"",flag:'body'},
  19.     {x:3,y:0,domContent:"",flag:'head'}
  20.   ]
  21. }
  22. /**
  23.  * 绑定事件
  24.  */
  25.  
  26. function bindEvent(){
  27.   document.addEventListener('keydown',function(e){
  28.     // console.log(e.key)
  29.     if(e.key==='ArrowUp'||e.key.toLocaleLowerCase()==='w'){
  30.       // 用户按的是上
  31.       snake.direction=directionNum.top
  32.     }
  33.     if(e.key==='ArrowDown'||e.key.toLocaleLowerCase()==='s'){
  34.       // 用户按的是下
  35.       snake.direction=directionNum.bottom
  36.  
  37.     }
  38.     if(e.key==='ArrowLeft'||e.key.toLocaleLowerCase()==='a'){
  39.       // 用户按的是左
  40.       snake.direction=directionNum.left
  41.  
  42.     }
  43.     if(e.key==='ArrowRight'||e.key.toLocaleLowerCase()==='d'){
  44.       // 用户按的是右
  45.       snake.direction=directionNum.right
  46.  
  47.     }
  48.     snakeMove()
  49.   })
  50. }
'
运行

移动蛇

  • 声明一个新蛇头，新蛇头对象中包含snakePos中的所有，移动时要将新蛇头添加至snake.snakePos中，将旧蛇头变为蛇身，即把flag变为body,并将其相关属性变为身体的属性，最后重新绘制蛇即可
  • 注意，蛇头会随着方向的变化而变化，在drawSnack中添加switch，若方向为上，蛇头逆时针旋转90deg，其余以此类推
  • 碰撞检测：声明一个判断对象，里面包含两个判断，一个为是否吃到食物，一个判断是否碰撞墙壁或者碰到蛇身
  • 碰到墙壁即为新蛇头的位置坐标越界，碰到蛇身即为判断新蛇头是否和蛇身位置坐标冲突，冲突就说明碰到自己，吃到东西则为新蛇头的坐标和食物的坐标一致，吃到食物之后就重新生成食物的位置坐标
  • 蛇整体移动的过程为：每次触发键盘事件，蛇头改变，旧蛇头变为蛇身，若吃到苹果，不删除最后一个蛇身，若没有吃到苹果，则删除最后一个蛇身，即为snake.snakePos[0].domContent。
  1. /***
  2.  * 碰撞检测
  3.  */
  4. function isCollide(newHead){
  5.   let collideCheckInfo={
  6.     isCollide:false,//是否碰撞墙壁 蛇身
  7.     isEat:false//是否吃到食物
  8.   }
  9.   // 1.检测是否碰到墙壁
  10.   if(newHead.x<0||newHead.x>=td||newHead.y<0||newHead.y>=tr){
  11.     collideCheckInfo.isCollide=true
  12.     return collideCheckInfo
  13.   }
  14.   // 检测是是否碰到自己
  15.   for(let i=0;i<snake.snakePos.length;i++){
  16.     if(snake.snakePos[i].x===newHead.x&&snake.snakePos[i].y===newHead.y){
  17.       collideCheckInfo.isCollide=true
  18.       return collideCheckInfo
  19.     }
  20.   }
  21.   // 检测是否吃到东西
  22.   if(newHead.x===food.x&&newHead.y===food.y){
  23.     collideCheckInfo.isEat=true
  24.     score++
  25.   }
  26.   return collideCheckInfo
  27. }
  28.  
  29. /**
  30.  * 蛇的移动方法
  31.  */
  32. function snakeMove(){
  33.   let oldHead=snake.snakePos[snake.snakePos.length-1]
  34.   // 根据方向计算出新的蛇头的坐标
  35.   let newHead={
  36.     domContent:"",
  37.     x:oldHead.x+snake.direction.x,
  38.     y:oldHead.y+snake.direction.y,
  39.     flag:'head'
  40.   }
  41.   // 接下来我们首先要做碰撞检测
  42.   // 看计算出来的蛇头有没有碰上食物
  43.   let collideCheckResult=isCollide(newHead)
  44.   if(collideCheckResult.isCollide){
  45.     //进入此if 说明撞墙了
  46.     window.confirm(`游戏结束，您当前的得分为${score}分，是否要重新开始游戏`)
  47.     alert("撞墙了")
  48.   }
  49.   // 将旧的头修改为身体
  50.   oldHead.flag='body'
  51.   oldHead.domContent.style.background="#9ddbb1"
  52.   oldHead.domContent.style.borderRadius="50%"
  53.   snake.snakePos.push(newHead)
  54.   // 判断是否吃到东西
  55.   if(collideCheckResult.isEat){
  56.     // 1.重新生成新的食物
  57.     drawFood()
  58.   }
  59.   else{
  60.     // 说明没有吃到食物
  61.     // 移除最后一个元素
  62.     document.querySelector(".container").removeChild(snake.snakePos[0].domContent)
  63.     snake.snakePos.shift();//删除第一个元素
  64.   }
  65.   drawSnake(snake)
  66. }
'
运行
  • 当游戏开始时，要让蛇自动沿着当前方向移动，使用间歇函数定时器来决定蛇移动的速度
  • 给用户选择当游戏结束时，是继续游戏还是结束游戏，继续游戏就初始化游戏，结束游戏就取消键盘事件，并停止计时器
  • 游戏进行中若点击container区域就先暂停游戏，暂停游戏时，要用到事件委托，因为当用户点击确定重新开始游戏时，会将container里的内容重置，此时的绑定事件已经不存在了，通过父亲找到儿子进行相关操作可避免直接给儿子添加绑定事件的缺点，暂停游戏时记得清除定时器，开始时再打开

相关效果如下所示：

代码：

index.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.   <link rel="stylesheet" href="../css/index.css">
  7.   <title>Document</title>
  8. </head>
  9. <body>
  10.   <!-- 整个游戏按钮 -->
  11.   <div class="container">
  12.     <!-- 开始按钮 -->
  13.     <button class="startBtn"></button>
  14.     <!-- 暂停按钮 -->
  15.     <button class="pauseBtn"></button>
  16.   </div>
  17.   <script src="../js/config.js"></script>
  18.   <script src="../js/index.js"></script>
  19. </body>
  20. </html>

index.css

  1. *{
  2.   /* 去除内外边距 */
  3.   margin: 0;
  4.   padding: 0;
  5. }
  6. /* 整体游戏容器样式 */
  7. .container {
  8.   position: relative;
  9.   display: flex;
  10.   justify-content: center;
  11.   align-items: center;
  12.   width: 600px;
  13.   height: 600px;
  14.   background-color: #225675;
  15.   border: 20px solid #7dd9ff;
  16.   margin: 20px auto;
  17. }
  18. .container button {
  19.   border: none;
  20.   outline: none;
  21. }
  22. /* 开始按钮 */
  23. .startBtn {
  24.   width: 200px;
  25.   height: 80px;
  26.   background: url(../images/startGame.png) center/contain no-repeat;
  27.   display: block;
  28. }
  29. /* 暂停按钮 */
  30. .pauseBtn {
  31.   width: 70px;
  32.   height: 70px;
  33.   background: url(../images/start.png) center/contain no-repeat;
  34.   display: none;
  35. }

index.js

  1. /**
  2.  *绘制蛇的方法
  3.  *  @param {*} snake
  4.  * */
  5. function drawSnake(snake){
  6.   for(let i=0;i<snake.snakePos.length;i++){
  7.     if(!snake.snakePos[i].domContent){
  8.       // 如果进入此if，说明是第一次创建蛇
  9.       snake.snakePos[i].domContent=document.createElement("div")
  10.       snake.snakePos[i].domContent.style.position="absolute"
  11.       snake.snakePos[i].domContent.style.width=snakeBody+"px"
  12.       snake.snakePos[i].domContent.style.height=snakeBody+"px"
  13.       snake.snakePos[i].domContent.style.left=snake.snakePos[i].x*snakeBody+"px"
  14.       snake.snakePos[i].domContent.style.top=snake.snakePos[i].y*snakeBody+"px"
  15.       if(snake.snakePos[i].flag==='head'){
  16.         // 说明当前是蛇头
  17.         snake.snakePos[i].domContent.style.background=`url("../images/snake.png") center/contain no-repeat`
  18.         // 根据方向进行一个旋转
  19.         switch(snake.direction.flag){
  20.           case 'top':{
  21.             snake.snakePos[i].domContent.style.transform=`rotate(-90deg)`
  22.             break
  23.           }
  24.           case 'bottom':{
  25.             snake.snakePos[i].domContent.style.transform=`rotate(90deg)`
  26.             break
  27.           }
  28.           case 'left':{
  29.             snake.snakePos[i].domContent.style.transform=`rotate(-180deg)`
  30.             break
  31.           }
  32.           case 'right':{
  33.             snake.snakePos[i].domContent.style.transform=`rotate(0deg)`
  34.             break
  35.           }
  36.         }
  37.       }else{
  38.         // 说明是蛇身
  39.         snake.snakePos[i].domContent.style.background="#9ddbb1"
  40.         snake.snakePos[i].domContent.style.borderRadius='50%'
  41.       }
  42.     }
  43.     // 需要将创建的DOM元素添加到container 容器上面
  44.     document.querySelector(".container").append(snake.snakePos[i].domContent)
  45.   }
  46. }
  47. function drawFood(){
  48.   // 食物的坐标是随机的 但食物不可生成在蛇头 蛇身 以及container之外的区域
  49.   while(true){
  50.     // 构成一个死循环，直到生成符合要求的坐标才能退出该循环
  51.     let isRepeat=false //默认生成的坐标符合要求
  52.     // 随机生成一个坐标
  53.     food.x=Math.floor(Math.random()*tr)
  54.     food.y=Math.floor(Math.random()*td)
  55.     // 查看坐标是否符合要求（遍历蛇）
  56.     for(let i=0;i<snake.snakePos.length;i++){
  57.       if(snake.snakePos[i].x===food.x&&snake.snakePos[i].y===food.y){
  58.         // 进入此if 说明当前生成的食物坐标和蛇的位置冲突
  59.         isRepeat=true
  60.         break
  61.       }
  62.      
  63.     }
  64.     if(!isRepeat){
  65.       break
  66.     }
  67.  
  68.   }
  69.     // 整个while 循环跳出之后，食物的坐标一定是OK的
  70.  
  71.   if(!food.domContent){
  72.     food.domContent=document.createElement("div")
  73.     food.domContent.style.width=snakeBody+"px"
  74.     food.domContent.style.height=snakeBody+"px"
  75.     food.domContent.style.position="absolute"
  76.     food.domContent.style.background=`url("../images/food.png") center/contain no-repeat`
  77.     document.querySelector('.container').append(food.domContent)
  78.  
  79.   }
  80.   food.domContent.style.left=food.x*snakeBody+"px"
  81.   food.domContent.style.top=food.y*snakeBody+"px"
  82. }
  83. /***
  84.  * 碰撞检测
  85.  * @param {*} newHead 新计算出来的蛇头坐标
  86.  */
  87. function isCollide(newHead){
  88.   let collideCheckInfo={
  89.     isCollide:false,//是否碰撞墙壁 蛇身
  90.     isEat:false//是否吃到食物
  91.   }
  92.   // 1.检测是否碰到墙壁
  93.   if(newHead.x<0||newHead.x>=td||newHead.y<0||newHead.y>=tr){
  94.     collideCheckInfo.isCollide=true
  95.     return collideCheckInfo
  96.   }
  97.   // 检测是是否碰到自己
  98.   for(let i=0;i<snake.snakePos.length;i++){
  99.     if(snake.snakePos[i].x===newHead.x&&snake.snakePos[i].y===newHead.y){
  100.       collideCheckInfo.isCollide=true
  101.       return collideCheckInfo
  102.     }
  103.   }
  104.   // 检测是否吃到东西
  105.   if(newHead.x===food.x&&newHead.y===food.y){
  106.     collideCheckInfo.isEat=true
  107.     score++
  108.   }
  109.   return collideCheckInfo
  110. }
  111. function move(e){
  112.   console.log(e.key)
  113.   if((e.key==='ArrowUp'||e.key.toLocaleLowerCase()==='w')&&snake.direction.flag!=="bottom"){
  114.     // 用户按的是上
  115.     snake.direction=directionNum.top
  116.   }
  117.   if((e.key==='ArrowDown'||e.key.toLocaleLowerCase()==='s')&&snake.direction.flag!=="top"){
  118.     // 用户按的是下
  119.     snake.direction=directionNum.bottom
  120.  
  121.   }
  122.   if((e.key==='ArrowLeft'||e.key.toLocaleLowerCase()==='a')&&snake.direction.flag!=="right"){
  123.     // 用户按的是左
  124.     snake.direction=directionNum.left
  125.  
  126.   }
  127.   if((e.key==='ArrowRight'||e.key.toLocaleLowerCase()==='d')&&snake.direction.flag!=="left"){
  128.     // 用户按的是右
  129.     snake.direction=directionNum.right
  130.  
  131.   }
  132.   snakeMove()
  133. }
  134. /**
  135.  * 蛇的移动方法
  136.  */
  137. function snakeMove(){
  138.   let oldHead=snake.snakePos[snake.snakePos.length-1]
  139.   // 根据方向计算出新的蛇头的坐标
  140.   let newHead={
  141.     domContent:"",
  142.     x:oldHead.x+snake.direction.x,
  143.     y:oldHead.y+snake.direction.y,
  144.     flag:'head'
  145.   }
  146.   // 接下来我们首先要做碰撞检测
  147.   // 看计算出来的蛇头有没有碰上食物
  148.   let collideCheckResult=isCollide(newHead)
  149.   if(collideCheckResult.isCollide){
  150.     //进入此if 说明撞墙了
  151.     if(window.confirm(`游戏结束，您当前的得分为${score}分，是否要重新开始游戏`)){
  152.       // 重新开始游戏
  153.       document.querySelector('.container').innerHTML=`
  154.       <!-- 开始按钮 -->
  155.       <button class="startBtn" style="display:none"></button>
  156.       <!-- 暂停按钮 -->
  157.       <button class="pauseBtn" style="display:none"></button>
  158.       `
  159.       score=0
  160.       console.log(score)
  161.       // gridData=[]
  162.       snake={
  163.         // 蛇一开始移动的方向
  164.         direction:directionNum.right,//一开始向右边移动
  165.         // 蛇的初始位置
  166.         snakePos:[//domContent为蛇的相应dom元素 flag根据身体还是蛇头分别渲染
  167.           {x:0,y:0,domContent:"",flag:'body'},
  168.           {x:1,y:0,domContent:"",flag:'body'},
  169.           {x:2,y:0,domContent:"",flag:'body'},
  170.           {x:3,y:0,domContent:"",flag:'head'}
  171.         ]
  172.       }
  173.       food={
  174.         x:0,y:0,domContent:""
  175.       }
  176.       console.log("已初始化")
  177.       initGame()
  178.       return
  179.       // drawSnake(snake)
  180.     }else {
  181.       // 结束游戏
  182.       document.removeEventListener('keydown',move)
  183.       // console.log("取消")
  184.       clearInterval(timerStop)
  185.       return
  186.  
  187.     }
  188.     // alert("撞墙了")
  189.   }
  190.   // 将旧的头修改为身体
  191.   oldHead.flag='body'
  192.   oldHead.domContent.style.background="#9ddbb1"
  193.   oldHead.domContent.style.borderRadius="50%"
  194.   snake.snakePos.push(newHead)
  195.   // 判断是否吃到东西
  196.   if(collideCheckResult.isEat){
  197.     // 1.重新生成新的食物
  198.     drawFood()
  199.   }
  200.   else{
  201.     // 说明没有吃到食物
  202.     // 移除最后一个元素
  203.     document.querySelector(".container").removeChild(snake.snakePos[0].domContent)
  204.     snake.snakePos.shift();//删除第一个元素
  205.   }
  206.   drawSnake(snake)
  207. }
  208.  
  209.  
  210. /**
  211.  * 初始化游戏方法
  212.  */
  213. function initGame(){
  214.   //1.初始化地图
  215.   for(let i=0;i<tr;i++){
  216.     for(let j=0;j<td;j++){
  217.       gridData.push({
  218.         x:j,
  219.         y:i
  220.       })
  221.     }
  222.   }
  223.   // 2.绘制蛇
  224.   drawSnake(snake)
  225.   // 3.绘制食物
  226.   drawFood()
  227. }
  228. function startGame(){
  229.   timerStop=setInterval(function(){
  230.     snakeMove()
  231.   },time)
  232. }
  233. /**
  234.  * 绑定事件
  235.  */
  236.  
  237. function bindEvent(){
  238.   // 1.键盘事件
  239.   document.addEventListener('keydown',move)
  240.   // 2.计时器自动调用蛇移动的方法
  241.   startGame();
  242.   // 3.点击整个容器的时候,可以暂停和重新开始游戏
  243.   document.querySelector('.container').addEventListener('click',function(e){
  244.     // 通过事件委托的形式,判断用户点击的是container还是暂停按钮
  245.     if(e.target.className ==="container"){
  246.     document.querySelector('.pauseBtn').style.display='block'
  247.     clearInterval(timerStop)
  248.  
  249.     }else {
  250.       document.querySelector('.pauseBtn').style.display='none'
  251.       startGame()
  252.     }
  253.   })
  254.   // 4.给暂停按钮绑定事件
  255.   // 点击子元素事件,冒泡后也会触发父元素点击事件
  256. //   document.querySelector('.pauseBtn').addEventListener('click',function(e){
  257. //     e.stopPropagation()
  258.     
  259. //   })
  260. }
  261. /**
  262.  * 游戏的主方法
  263.  */
  264. function main(){
  265.   // 用户点击了开始游戏之后,再做后续工作
  266.   document.querySelector('.startBtn').addEventListener('click',function(e){
  267.     e.stopPropagation()
  268.     document.querySelector('.startBtn').style.display="none"
  269.     // 1.首先初始化游戏
  270.     initGame()
  271.     // 2.绑定事件
  272.     bindEvent()
  273.   })
  274. }
  275.  
  276. main()

config.js

  1. // 游戏相关配置文件
  2. let gridData=[]//存储地图对象
  3. // 整个网格的行与列
  4. const tr=30
  5. const td=30
  6. // 蛇的身体大小
  7. let snakeBody=20
  8.  
  9. // 要明确新的蛇头和旧的蛇头之间的位置关系
  10. // 我们在确定新的蛇头坐标的时候，会那下面的对象和旧蛇头做一个计算
  11.  
  12. const directionNum={
  13.   left:{x:-1,y:0,flag:'left'},
  14.   right:{x:1,y:0,flag:'right'},
  15.   top:{x:0,y:-1,flag:'top'},
  16.   bottom:{x:0,y:1,flag:'bottom'}
  17. }
  18.  
  19.  
  20. // 蛇相关的配置信息
  21. let snake={
  22.   // 蛇一开始移动的方向
  23.   direction:directionNum.right,//一开始向右边移动
  24.   // 蛇的初始位置
  25.   snakePos:[//domContent为蛇的相应dom元素 flag根据身体还是蛇头分别渲染
  26.     {x:0,y:0,domContent:"",flag:'body'},
  27.     {x:1,y:0,domContent:"",flag:'body'},
  28.     {x:2,y:0,domContent:"",flag:'body'},
  29.     {x:3,y:0,domContent:"",flag:'head'}
  30.   ]
  31. }
  32. // 食物相关的配置信息
  33. let food={
  34.   x:0,y:0,domContent:""
  35. }
  36. // 游戏分数
  37. let score=0
  38. // 停止计时器
  39. let timerStop=null
  40. // 计时器事件
  41. let time=300
'
运行

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/1001438
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号