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

【JavaScript】贪吃蛇_js 贪食蛇

作者：运维做开发 | 2024-08-19 08:18:01

赞

踩

js 贪食蛇

看起来好像很复杂的贪吃蛇，到底是怎么用JavaScript去实现的？

其实你只要会用setInterval去现实一个时钟，

会使用JavaScript的键盘响应事件

会使用JavaScript去操作html节点

也就是HTML DOM与BOM，这个问题应该不会有太大的问题。

下面就来一步一步地，剖析怎么用JavaScript，也就是说完全可以记事本写一个html文件，放在任意一个浏览器中，把贪吃蛇搞起来！

 

一、基本目标

写一个贪吃蛇游戏，相信不用介绍了，这个游戏实在是太出名了，

能用wasd、上下左右与网页上的button按钮组件，来控制蛇的移动方向

按P可以暂停。

 

二、制作过程

1、布置场景。

这个实在是太简单。就用纯HTML语言布置几行文本，一个纯黑色的400x300的map图层，与一个放置上下左右按钮的key图层。

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. 	<head>
  4. 		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  5. 		<title>贪吃蛇</title>
  6. 	</head>
  7.  
  8. 	<body>
  9. 		<p>
  10. 			<strong>贪吃蛇~</strong>
  11. 		</p>
  12. 		<p>
  13. 			按P暂停~wasd或↑↓←→可控制方向~
  14. 		</p>
  15. 		<p>
  16. 			积分：
  17. 			<span id="count"></span>
  18. 		</p>
  19. 		<div id="map"
  20. 			style="background-color: #000000; width: 400px; height: 300px; position: absolute;"></div>
  21. 		<div id="key"
  22. 			style="margin-top: 300px; margin-left: 150px; position: absolute;">
  23. 			<table>
  24. 				<tr align="center">
  25. 					<td colspan="3">
  26. 						<input type="button" value="↑" οnclick="snake.setKey(38);" />
  27. 					</td>
  28. 				</tr>
  29. 				<tr>
  30. 					<td>
  31. 						<input type="button" value="←" οnclick="snake.setKey(37);" />
  32. 					</td>
  33. 					<td>
  34. 						<input type="button" value="↓" οnclick="snake.setKey(40);" />
  35. 					</td>
  36. 					<td>
  37. 						<input type="button" value="→" οnclick="snake.setKey(39);" />
  38. 					</td>
  39. 				</tr>
  40. 			</table>
  41. 		</div>
  42. 	</body>
  43. </html>


上下左右的输入应该为＆uarr；＆darr；＆larr；＆rarr；

 

2、脚本的基本框架

之后，在</html>下面怒写下<script></script>，然后在这两个标签中间，对此网页进行编程

脚本脚本，按常理就应该在网页的脚下，但现在根据需要都基本镶嵌在网页之中了。

 

3、键盘响应事件

说这个之前，必须提及部分关于Javascript理论知识，

虽然翻阅两门语言的产生背景，可以发现Javascript跟Java一点关系都没有，但Javascript中同样存在类似C语言函数与主函数的概念。

window.onload = function() {...}相当于主函数，网页一载入就执行此函数中的内容，而其余的function，如function snake() {...}，则相当于等待被调用的函数，

如果你需要在主函数中调用此函数，那么必须此前使用函数声明，比如我要使用snake()函数，就必须在window.onload = function() {...}函数之前，使用var snake = new snake();声明此函数。

函数中，调用函数内变量需要在之前加this.，使用函数内变量同样需要用到this.

在函数中，声明一个方法需要使用类似于this.setKey = function(code) {}的形式。

  1. /*声明使用snake()函数*/
  2. var snake = new snake();
  3. window.onload = function() {
  4. 	/*键盘响应事件，javascript的特定写法，为了兼容所有浏览器，code是用户所按键位的键值*/
  5. 	document.onkeydown = function(event) {
  6. 		var code;
  7. 		if (window.event) {
  8. 			code = window.event.keyCode;
  9. 		} else {
  10. 			code = event.keyCode;
  11. 		}
  12. 		if (code == 80)
  13. 			alert("pause");
  14. 			/*调用snake函数中的setKey方法*/
  15. 		snake.setKey(code);
  16. 	}
  17. 	
  18. }
  19. function snake() {
  20. 	/*蛇前进方向默认为向右，传过来的键值的不同，可以改变蛇的前进方向*/
  21. 	this.direct = 'right';
  22. 	this.setKey = function(code) {
  23. 		switch (code) {
  24. 		case 37:
  25. 			this.direct = 'left';
  26. 			break;
  27. 		case 38:
  28. 			this.direct = 'top';
  29. 			break;
  30. 		case 39:
  31. 			this.direct = 'right';
  32. 			break;
  33. 		case 40:
  34. 			this.direct = 'bottom';
  35. 			break;
  36. 		case 65:
  37. 			this.direct = 'left';
  38. 			break;
  39. 		case 87:
  40. 			this.direct = 'top';
  41. 			break;
  42. 		case 68:
  43. 			this.direct = 'right';
  44. 			break;
  45. 		case 83:
  46. 			this.direct = 'bottom';
  47. 		default:
  48. 			break;
  49. 		}
  50. 	}
  51. }

 

4.蛇的绘制，定义一条最基本的蛇

定义“蛇”是由若干个10x10方块组成，

视图把整个400x300的场景想象为是20x10个10x10的方格组成，为一个横轴为0-20，纵轴为0-10的坐标系

组成“蛇”的每个方块都有自己的横坐标与纵坐标。

那么蛇就在场景移动。

其中蛇尾是需要与背景蛇同样颜色的方块，这与蛇的移动有关，在蛇的移动中会详细解释。

具体到程序中就是一个二维数组，是由若干个：第一个元素为方块的横坐标，第二个元素为方块的纵坐标 ，第三个元素为方块的颜色的数组，组成的数组。

在function snake() {}定义二维数组body，this.body = [ [ 3, 2, '#ffffff' ], [ 2, 2, '#ffffff' ], [ 1, 2, '#ffffff' ], [ 0, 2, '#000000' ] ];与this.display = function() {}方法，

在window.onload = function() {}  “主函数”中，声明调用函数snake中的snake.display()方法。

于是<script></script>中的代码就变成如下情况：

  1. var snake = new snake();
  2. window.onload = function() {
  3. 	snake.display();	
  4. 	document.onkeydown = function(event) {
  5. 		var code;
  6. 		if (window.event) {
  7. 			code = window.event.keyCode;
  8. 		} else {
  9. 			code = event.keyCode;
  10. 		}
  11. 		if (code == 80)
  12. 			alert("pause");
  13. 		snake.setKey(code);
  14. 	}
  15. 	
  16. }
  17.  
  18.  
  19.  
  20. function snake() {
  21. 	this.direct = 'right';
  22. 	this.setKey = function(code) {
  23. 		switch (code) {
  24. 		case 37:
  25. 			this.direct = 'left';
  26. 			break;
  27. 		case 38:
  28. 			this.direct = 'top';
  29. 			break;
  30. 		case 39:
  31. 			this.direct = 'right';
  32. 			break;
  33. 		case 40:
  34. 			this.direct = 'bottom';
  35. 			break;
  36. 		case 65:
  37. 			this.direct = 'left';
  38. 			break;
  39. 		case 87:
  40. 			this.direct = 'top';
  41. 			break;
  42. 		case 68:
  43. 			this.direct = 'right';
  44. 			break;
  45. 		case 83:
  46. 			this.direct = 'bottom';
  47. 		default:
  48. 			break;
  49. 		}
  50. 	}
  51. 	/*初始化蛇，长度为3，蛇身的最后一个方格是不属于蛇的，为后面的移动方法this.move=function(){}做铺垫的*/
  52. 	this.body = [ [ 3, 2, '#ffffff' ], [ 2, 2, '#ffffff' ],
  53. 			[ 1, 2, '#ffffff' ], [ 0, 2, '#000000' ] ];
  54. 	this.display = function() {
  55. 		for ( var i = 0; i < this.body.length; i++) {
  56. 			/*创建一个图层节点<div></div>此图层的大小为10x10，颜色就是二维数组中每个元素的第三个元素，对齐方式当然是任意*/
  57. 			/*其位置等于二维数组中每个元素的第一个元素乘以10，高度为二维数组中每个元素的第二个元素等于10*/
  58. 			/*之后把这个图层节点放到<div id="map"></div>中，创建完第一个，就创建第二个……以此类推，保护最后那个与背景色相同的蛇身方块*/
  59. 			var bodycell;
  60. 			bodycell = document.createElement("div");
  61. 			bodycell.style.width = 10 + "px";
  62. 			bodycell.style.height = 10 + "px";
  63. 			bodycell.style.backgroundColor = this.body[i][2];
  64. 			bodycell.style.position = "absolute";
  65. 			bodycell.style.left = this.body[i][0] * 10 + "px";
  66. 			bodycell.style.top = this.body[i][1] * 10 + "px";
  67. 			document.getElementById("map").appendChild(bodycell);
  68. 		}
  69. 	}
  70. }


5.蛇的移动，此乃最难的一步，最关键的一步，整个程序是否能够憋出来，就看程序猿是否能够弄清楚这一步是怎么实现的

整体思想是把前面一个方格元素的横纵坐标赋值给后面一个元素的横纵坐标，也就是说，使后面一个元素的横纵坐标的值等于前面一个方格元素的横纵坐标的值，

而蛇头的横纵坐标则根据此时的移动方向this.direct来对横纵坐标进行处理。

之后确定好新的横纵坐标之后，重绘这条蛇。

至于为什么最后一个蛇身元素要与背景色一样，那是因为，你需要把蛇尾那个方格抹去。

蛇，随着this.move()中被window.onload = function() {} 主函数是在不停地调用，也就是通过setInterval('snake.move()', 100);每隔100毫秒也就是0.1秒就调用一次snake.move()，this.display()也在不停地调用，换而言之就是蛇不地被重绘。

那么每一次重绘，之前的画出来的蛇依旧是存在的，你必须把上一次重绘出来的蛇抹掉，那么蛇才能不停的移动，当然，一会儿判断蛇是否撞到自己，最后那个方格也不判断之列了。

至于上一次重绘出来的蛇怎么地抹掉，你要么选择清屏，但这不是好办法，程序你没法写，于是就把蛇尾定义成与背景一样的颜色，蛇在不停地移动，自然而然地就把之前的作图痕迹抹得干干净净了！

在想不通就在初始化的时候，把最后一个方块的颜色换成其他，整个过程你会看得清清楚楚。

于是，我们的脚本程序就大致变成这个模样了：

  1. <script>
  2. var snake = new snake();
  3. window.onload = function() {
  4. 	snake.display();
  5. 	food.display();
  6. 	document.onkeydown = function(event) {
  7. 		var code;
  8. 		if (window.event) {
  9. 			code = window.event.keyCode;
  10. 		} else {
  11. 			code = event.keyCode;
  12. 		}
  13. 		if (code == 80)
  14. 			alert("pause");
  15. 		snake.setKey(code);
  16. 	}
  17. 	setInterval('snake.move()', 100);
  18. }
  19. function snake() {
  20. 	this.setKey = function(code) {
  21. 		switch (code) {
  22. 		case 37:
  23. 			this.direct = 'left';
  24. 			break;
  25. 		case 38:
  26. 			this.direct = 'top';
  27. 			break;
  28. 		case 39:
  29. 			this.direct = 'right';
  30. 			break;
  31. 		case 40:
  32. 			this.direct = 'bottom';
  33. 			break;
  34. 		case 65:
  35. 			this.direct = 'left';
  36. 			break;
  37. 		case 87:
  38. 			this.direct = 'top';
  39. 			break;
  40. 		case 68:
  41. 			this.direct = 'right';
  42. 			break;
  43. 		case 83:
  44. 			this.direct = 'bottom';
  45. 		default:
  46. 			break;
  47. 		}
  48. 	}
  49. 	this.body = [ [ 3, 2, '#ffffff' ], [ 2, 2, '#ffffff' ],
  50. 			[ 1, 2, '#ffffff' ], [ 0, 2, '#000000' ] ];
  51. 	this.display = function() {
  52. 		for ( var i = 0; i < this.body.length; i++) {
  53. 			var bodycell;
  54. 			bodycell = document.createElement("div");
  55. 			bodycell.style.width = 10 + "px";
  56. 			bodycell.style.height = 10 + "px";
  57. 			bodycell.style.backgroundColor = this.body[i][2];
  58. 			bodycell.style.position = "absolute";
  59. 			bodycell.style.left = this.body[i][0] * 10 + "px";
  60. 			bodycell.style.top = this.body[i][1] * 10 + "px";
  61. 			document.getElementById("map").appendChild(bodycell);
  62. 		}
  63. 	}
  64. 	this.direct = 'right';
  65. 	this.move = function() {
  66. 		/*因为是使后面一个元素的横纵坐标的值等于前面一个方格元素的横纵坐标的值，所以必须从后面开始处理，从前面开始处理会出现错误的*/
  67. 		for ( var i = this.body.length - 1; i > 0; i--) {
  68. 			this.body[i][0] = this.body[i - 1][0];
  69. 			this.body[i][1] = this.body[i - 1][1];
  70. 		}
  71. 		switch (this.direct) {
  72. 		case 'left':
  73. 			this.body[0][0] = this.body[0][0] - 1;
  74. 			break;
  75. 		case 'top':
  76. 			this.body[0][1] = this.body[0][1] - 1;
  77. 			break;
  78. 		case 'right':
  79. 			this.body[0][0] = this.body[0][0] + 1;
  80. 			break;
  81. 		case 'bottom':
  82. 			this.body[0][1] = this.body[0][1] + 1;
  83. 			break;
  84. 		}
  85. 		this.display();
  86. 	}
  87. }
  88. </script>


6.蛇是否撞到墙了？

相当简单，只要判断蛇头的纵横坐标是否等于边界的纵横坐标。

当然，游戏结束，就不能让这条蛇继续移动了，那么，我们就打断程序对snake.move()的不停调用即可。

同时弹窗，显示积分count与提示信息，此count一会儿在对食物的处理中计算，为一个全局变量，刷新一下页面，让游戏重新开始，让用户继续挑战，玩上瘾什么的就最好了。

要判断的地方一共有4个，因为有四面墙。

在snake.move()中加入判断，于是程序就变成这个样子：

  1. <script>
  2. /*用来积分的，处理在食物模块中*/
  3. var count = -1;
  4. var snake = new snake();
  5. /*用来打断循环调用snake.move()的*/
  6. var timer;
  7.  
  8. window.onload = function() {
  9. 	snake.display();
  10. 	food.display();
  11. 	document.onkeydown = function(event) {
  12. 		var code;
  13. 		if (window.event) {
  14. 			code = window.event.keyCode;
  15. 		} else {
  16. 			code = event.keyCode;
  17. 		}
  18. 		if (code == 80)
  19. 			alert("pause");
  20. 		snake.setKey(code);
  21. 	}
  22. 	timer = setInterval('snake.move()', 100);
  23. }
  24.  
  25.  
  26. function snake() {
  27. 	this.setKey = function(code) {
  28. 		switch (code) {
  29. 		case 37:
  30. 			this.direct = 'left';
  31. 			break;
  32. 		case 38:
  33. 			this.direct = 'top';
  34. 			break;
  35. 		case 39:
  36. 			this.direct = 'right';
  37. 			break;
  38. 		case 40:
  39. 			this.direct = 'bottom';
  40. 			break;
  41. 		case 65:
  42. 			this.direct = 'left';
  43. 			break;
  44. 		case 87:
  45. 			this.direct = 'top';
  46. 			break;
  47. 		case 68:
  48. 			this.direct = 'right';
  49. 			break;
  50. 		case 83:
  51. 			this.direct = 'bottom';
  52. 		default:
  53. 			break;
  54. 		}
  55. 	}
  56. 	this.body = [ [ 3, 2, '#ffffff' ], [ 2, 2, '#ffffff' ],
  57. 			[ 1, 2, '#ffffff' ], [ 0, 2, '#000000' ] ];
  58. 	this.display = function() {
  59. 		for ( var i = 0; i < this.body.length; i++) {
  60. 			var bodycell;
  61. 			bodycell = document.createElement("div");
  62. 			bodycell.style.width = 10 + "px";
  63. 			bodycell.style.height = 10 + "px";
  64. 			bodycell.style.backgroundColor = this.body[i][2];
  65. 			bodycell.style.position = "absolute";
  66. 			bodycell.style.left = this.body[i][0] * 10 + "px";
  67. 			bodycell.style.top = this.body[i][1] * 10 + "px";
  68. 			document.getElementById("map").appendChild(bodycell);
  69. 		}
  70. 	}
  71. 	this.direct = 'right';
  72. 	this.move = function() {
  73. 		for ( var i = this.body.length - 1; i > 0; i--) {
  74. 			this.body[i][0] = this.body[i - 1][0];
  75. 			this.body[i][1] = this.body[i - 1][1];
  76. 		}
  77. 		switch (this.direct) {
  78. 		case 'left':
  79. 			this.body[0][0] = this.body[0][0] - 1;
  80. 			break;
  81. 		case 'top':
  82. 			this.body[0][1] = this.body[0][1] - 1;
  83. 			break;
  84. 		case 'right':
  85. 			this.body[0][0] = this.body[0][0] + 1;
  86. 			break;
  87. 		case 'bottom':
  88. 			this.body[0][1] = this.body[0][1] + 1;
  89. 			break;
  90. 		}
  91. 		/*history.go(0)为刷新本页，clearTimeout(timer)用来打断timer所指向的循环调用*/
  92. 		if (this.body[0][0] == 40 || this.body[0][0] == -1
  93. 				|| this.body[0][1] == -1 || this.body[0][1] == 30) {
  94. 			alert("Game Over，" + "积分：" + count);
  95. 			history.go(0);
  96. 			clearTimeout(timer);
  97. 		}
  98. 		this.display();
  99. 	}
  100. }
  101. </script>


7.蛇是否撞到自己了？

继续在snake.move()中加入判断，

加入一个循环，判断蛇头的纵横坐标是否等于蛇身所有方块的纵横坐标，当然，最后一个蛇身方块就不要判断了，这是用来抹掉作图痕迹的方块来的，

如果等于，就是游戏结束了，就同上面的三部曲，弹窗，刷新，中断函数循环调用

 

 

8.最后一步，食物的生成，与蛇吃到食物之后怎么处理？

这一步的逻辑还是有点难度的，难就难在应该想透：

在snake.move()函数中加入遇到食物的判断，这个判断有点类似于数据结构中对单链表删除处理的步骤，具体见下图：

如果蛇吃到食物之后，

就应该压一个元素进蛇身this.body这一二维数组，就是this.body这一二维数组在最后添加一个元素。

加入元素的纵横坐标等于蛇此时倒数第二个元素的纵横坐标。

此元素的颜色任意，但是应该把此时蛇身的倒数第二个元素的颜色设置为背景色，倒数第三个元素颜色设置为蛇身颜色，因为蛇在下一步的重绘中，后一个元素的所有东西，就变成前一个元素的所有。

之后是不难题了，重绘食物就是绘出一个小方块，纵横坐标在400x300这个场景中产生，

Math.random()能够产生一个从0-1的随机小数，Math.floor();可以取上限，

同时全局计分变量count自增，更新一下，在html部分静态行内文本<span id="count"></span>的数据。

食物一开始就要显示，所以在window.onload = function() {}要放入food.display()，

于是乎，这个贪吃蛇游戏就大功告成，全代码如下：

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. 	<head>
  4. 		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  5. 		<title>贪吃蛇</title>
  6. 	</head>
  7.  
  8. 	<body>
  9. 		<p>
  10. 			<strong>贪吃蛇~</strong>
  11. 		</p>
  12. 		<p>
  13. 			按P暂停~wasd或↑↓←→可控制方向~
  14. 		</p>
  15. 		<p>
  16. 			积分：
  17. 			<span id="count"></span>
  18. 		</p>
  19. 		<div id="map"
  20. 			style="background-color: #000000; width: 400px; height: 300px; position: absolute;"></div>
  21. 		<div id="key"
  22. 			style="margin-top: 300px; margin-left: 150px; position: absolute;">
  23. 			<table>
  24. 				<tr align="center">
  25. 					<td colspan="3">
  26. 						<input type="button" value="↑" οnclick="snake.setKey(38);" />
  27. 					</td>
  28. 				</tr>
  29. 				<tr>
  30. 					<td>
  31. 						<input type="button" value="←" οnclick="snake.setKey(37);" />
  32. 					</td>
  33. 					<td>
  34. 						<input type="button" value="↓" οnclick="snake.setKey(40);" />
  35. 					</td>
  36. 					<td>
  37. 						<input type="button" value="→" οnclick="snake.setKey(39);" />
  38. 					</td>
  39. 				</tr>
  40. 			</table>
  41. 		</div>
  42. 	</body>
  43. </html>
  44.  
  45.  
  46. <script>
  47. var count = -1;
  48. var snake = new snake();
  49. var food = new food();
  50. var timer;
  51.  
  52. window.onload = function() {
  53. 	snake.display();
  54. 	food.display();
  55. 	document.onkeydown = function(event) {
  56. 		var code;
  57. 		if (window.event) {
  58. 			code = window.event.keyCode;
  59. 		} else {
  60. 			code = event.keyCode;
  61. 		}
  62. 		if (code == 80)
  63. 			alert("pause");
  64. 		snake.setKey(code);
  65. 	}
  66. 	timer = setInterval('snake.move()', 100);
  67. }
  68.  
  69. function food() {
  70. 	var foodcell;
  71. 	this.x = null;
  72. 	this.y = null;
  73. 	this.display = function() {
  74. 		count = count + 1;
  75. 		document.getElementById("count").innerHTML = count.toString();
  76. 		this.x = Math.floor(Math.random() * 39);
  77. 		this.y = Math.floor(Math.random() * 29);
  78. 		foodcell = document.createElement("div");
  79. 		foodcell.style.width = 10 + "px";
  80. 		foodcell.style.height = 10 + "px";
  81. 		foodcell.style.backgroundColor = "#ffff00";
  82. 		foodcell.style.position = "absolute";
  83. 		foodcell.style.left = this.x * 10 + "px";
  84. 		foodcell.style.top = this.y * 10 + "px";
  85. 		document.getElementById("map").appendChild(foodcell);
  86. 	}
  87. }
  88.  
  89. function snake() {
  90. 	this.setKey = function(code) {
  91. 		switch (code) {
  92. 		case 37:
  93. 			this.direct = 'left';
  94. 			break;
  95. 		case 38:
  96. 			this.direct = 'top';
  97. 			break;
  98. 		case 39:
  99. 			this.direct = 'right';
  100. 			break;
  101. 		case 40:
  102. 			this.direct = 'bottom';
  103. 			break;
  104. 		case 65:
  105. 			this.direct = 'left';
  106. 			break;
  107. 		case 87:
  108. 			this.direct = 'top';
  109. 			break;
  110. 		case 68:
  111. 			this.direct = 'right';
  112. 			break;
  113. 		case 83:
  114. 			this.direct = 'bottom';
  115. 		default:
  116. 			break;
  117. 		}
  118. 	}
  119. 	this.body = [ [ 3, 2, '#ffffff' ], [ 2, 2, '#ffffff' ],
  120. 			[ 1, 2, '#ffffff' ], [ 0, 2, '#000000' ] ];
  121. 	this.display = function() {
  122. 		for ( var i = 0; i < this.body.length; i++) {
  123. 			var bodycell;
  124. 			bodycell = document.createElement("div");
  125. 			bodycell.style.width = 10 + "px";
  126. 			bodycell.style.height = 10 + "px";
  127. 			bodycell.style.backgroundColor = this.body[i][2];
  128. 			bodycell.style.position = "absolute";
  129. 			bodycell.style.left = this.body[i][0] * 10 + "px";
  130. 			bodycell.style.top = this.body[i][1] * 10 + "px";
  131. 			document.getElementById("map").appendChild(bodycell);
  132. 		}
  133. 	}
  134. 	this.direct = 'right';
  135. 	this.move = function() {
  136. 		for ( var i = this.body.length - 1; i > 0; i--) {
  137. 			this.body[i][0] = this.body[i - 1][0];
  138. 			this.body[i][1] = this.body[i - 1][1];
  139. 		}
  140. 		switch (this.direct) {
  141. 		case 'left':
  142. 			this.body[0][0] = this.body[0][0] - 1;
  143. 			break;
  144. 		case 'top':
  145. 			this.body[0][1] = this.body[0][1] - 1;
  146. 			break;
  147. 		case 'right':
  148. 			this.body[0][0] = this.body[0][0] + 1;
  149. 			break;
  150. 		case 'bottom':
  151. 			this.body[0][1] = this.body[0][1] + 1;
  152. 			break;
  153. 		}
  154. 		if (this.body[0][0] == food.x && this.body[0][1] == food.y) {
  155. 			var x = this.body[this.body.length - 1][0];
  156. 			var y = this.body[this.body.length - 1][1];
  157. 			this.body.push( [ x, y, 'black' ]);
  158. 			this.body[this.body.length - 1][2] = "#000000";
  159. 			this.body[this.body.length - 2][2] = "#ffffff";
  160. 			food.display();
  161. 		}
  162. 		if (this.body[0][0] == 40 || this.body[0][0] == -1
  163. 				|| this.body[0][1] == -1 || this.body[0][1] == 30) {
  164. 			alert("Game Over，" + "积分：" + count);
  165. 			history.go(0);
  166. 			clearTimeout(timer);
  167. 		}
  168. 		for ( var i = 1; i < this.body.length - 1; i++) {
  169. 			if (this.body[0][0] == this.body[i][0]
  170. 					&& this.body[0][1] == this.body[i][1]) {
  171. 				alert("Game Over，" + "积分：" + count);
  172. 				history.go(0);
  173. 				clearTimeout(timer);
  174. 			}
  175. 		}
  176. 		this.display();
  177. 	}
  178. }
  179. </script>


完结撒花~一共179行代码，代码不长，有几个关键的逻辑比较难，克服了，就能够写出来了。没什么神秘的。

或许有时间，可以试试c,c#,java,java swing+awt,安卓,c++mfc……贪吃蛇？

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

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

  

闽ICP备14008679号