贪吃蛇游戏设计的目的及内容
主要内容就是设计蛇的形状和方向，以及食物的产生与位置，先创建一个Point对象point，由多个point 组合成蛇身，当蛇吃到食物时，则增加一个point在蛇身上，使蛇身不断加长，同时利用随机函数在游戏面板上产生一个新的Food对象代替原来被“吃掉”的food，其次，玩家使用方向键来控制蛇的行进，当蛇吃到 food 就给玩家加分作为奖励，最后就可以得出用户的分数。
设计的目的在于学习Java程序设计基本技术，学习用MyEclipse开发Java程序的相关技术，以及熟悉项目开发的完整过程。学会怎样进行一个项目的需求分析、概要设计、详细设计等软件开发过程，熟练地掌握Java程序设计的基本技术和方法，以及熟练地掌握MyEclipse开发环境的使用方法，培养初步的项目分析能力和程序设计能力。
游戏实现的具体任务如下：
1) 游戏的开始，停止，暂停，继续。 根据用户单击的按钮（开始，停止，暂停，继续），游戏实现具体相应的功能。
2) 游戏难度的调整。 用户可以通过选择相应难度地形来设置游戏的难度级别，级别越高，游戏难度也越大。
3) 游戏帮助。单击游戏帮助按钮弹出一个消息框提供相应的游戏介绍。另外在游戏中提供了网格对每一块小方块进行包裹，玩家可以选择是否显示网格，可以帮助刚入门的玩家比对蛇头与食物的位置。
4) 蛇身和背景颜色的设置。可以通过单击相应的设置按钮让蛇身或背景的颜色以用户喜欢的颜色输出。另外如果玩家选择显示网格，也可以单击相应按钮设置网格线的颜色。
5) 游戏奖励。当蛇吃到一颗食物时则得到10分作为奖励，同时如果吃到
特殊的食物则会得到普通食物三倍的奖励。但特殊的食物会在一定时间内自动消失。
2.1程序功能介绍
贪吃蛇游戏是一个经典小游戏，一条蛇在封闭围墙里，围墙里随机出现一个食物，通过按键盘四个光标键控制蛇向上下左右四个方向移动，蛇头撞倒食物，则食物被吃掉，蛇身体长一节，同时记10分，接着又出现食物，等待蛇来吃，如果蛇在移动中撞到墙或身体交叉蛇头撞倒自己身体游戏结束。
2.2程序整体设计说明
一个游戏要有开始部分，运行部分，结束部分（实际上开始部分与运行部分是一体的）。
2.2.1设计思路
这个程序的关键是表示蛇的图形以及蛇的移动。用一个小矩形表示蛇的一节身体，身体每长一节，增加一个矩形块，蛇头用两节表示。移动时必须从蛇头开始，所以蛇不能向相反方向移动，也就是蛇尾不能改作蛇头。如果不按任何键，蛇自行在当前方向上前移，当游戏者按了有效的方向键后，蛇头朝着指定的方向移动，一步移动一节身体，所以当按了有效的方向键后，先确定蛇头的位置，然后蛇身体随着蛇头移动，图形的实现是从蛇头的新位置开始画出蛇，这时由于没有庆平的原因，原来蛇的位置和新蛇的位置差一个单位，所以看起来社会多一节身体，所以将蛇的最后一节用背景色覆盖。食物的出现和消失也是画矩形块和覆盖矩形块
2.2.2数据结构设计及用法说明
开始部分：
游戏是运行在图形模式下的，所以第一步一定是初始化图形模式，接着要有开始的界面，就像书有封面一样，我设置了一个游戏的标题画面，除了游戏标题画面我还设置了一个欢迎画面。标题画面以后，还要为游戏的运行部分作初始化，包括绘制游戏运行时的背景，对游戏某些重 要变量的初始化。
运行部分：
作为游戏的核心部分，这里包括的函数比较多，也就是模块比较多，首先让我模拟一下贪吃蛇的游戏模式：某个世界上突然出现一条蛇，它很短，它的运动神经异常，它没法停止自己的多动症在它的世界里就只有食物，它很饿，也很贪吃；同样在不明原因的情况下，食物从天而降，可惜的是没有落到嘴边；饥饿的主人公，不管它有没有毒，也不问食物的来历，径直向食物爬去；它吃到食物啦，它超出想象的同化能力让食物很快的成为自己身体的一部分，它的身子变长啦。当它吃到第一颗食物时，上帝有给它第二颗，于是它吃了第二颗，于是又变长了，于是又有第三颗……它的身子是一直的加长，它不管自己过长身体的麻烦——转身不便，继续吃下去，现在它是直接把巴张大，好让食物有个绿色通道。但是在某天的下午，它咬到了自己，它才想起自己是一条毒蛇，于是晕死过去（不是毒死）；又或者它往食物冲锋的时候，它失去控制，撞到了墙上。
第一轮循环：第一步，出现食物；第二步，蛇不停运动；第三步，检查蛇是撞到自己或墙壁；由第四步起游戏有两条支线（A、B）：
A ：第四步，蛇没有碰到自己或墙壁，蛇继续前进，绘制蛇的动作；第五步，判断蛇是否吃到食物，如果蛇吃到食物，身子变长，原来的食物消失；第六步，让玩家输入控制指令，让蛇在下一轮循环的第二步改变运动方向；第七步，第二轮循环的第一步，重复第一轮的步骤；
B：第四步，蛇碰到自己或墙壁，终止游戏。
结束部分：
游戏结束时，显示“GAME OVER”，已经是约定俗成的规律了，我的游戏也不例外。除了游戏结束画面外，我还设置了一个游戏退出画面，“善始善终”嘛。
有了上述的大致划分，我把整个程序划分成（13+2）个模块（其实就是函数）
2.2.3程序结构（流程图）
图2.1流程图
依据所需要处理的任务要求，规划输入数据和输出结果，决定存放数据的数据结构。
C语言中数据结构集中体现在数据类型上，因此在进行C语言程序设计时，应统筹规划程序中所使用的变量，数组，指针等，以及它们的类型等。这点是很重要的，如果在此期间选择不合适的变量或者数组，将来修改就十分困难。
现在分析一下贪吃蛇游戏中的元素，继而得出与它们对应的在程序中的描述：
蛇：
基本描述：长度，颜色，位置。
对应数据与数据类型：长度—虽然可以用坐标表示，但是这样的话，运算量将很大，所以换算成较大的单位—节数，以固定长度的每节描述；坐标--整型；颜色--整型； 位置--X，Y坐标。
增加的描述：蛇运动的方向，蛇的生命。
对应数据与数据类型：这些描述是为了与程序的按键的输入部分与判断游戏结束部分相联系而设的。方向只有四个方向：上下左右。可以设置与之对应的四个整型数：3、4、2、1。生命就只有两种情况：死或生，对应0或1。
食物：
基本描述：颜色，位置。
对应数据与数据类型：由于颜色设成固定的，所以不再讨论。位置—X、Y坐标。
增加的描述：食物的存在。
对应数据与数据类型：这是为了避免重复出现食物而设置的，与绘制食物的函数有联系。只有两个值：0或1（没有食物或有食物）
其他的元素：墙，由于它在显示上是作为背景而存在的，所以并没有什么说明实际的墙壁就是四条直线组成的边框，由坐标描述。
还需要的变量：键盘键入的键值（作为全局变量，整型）；经常要使用的循环变量；自定义的填充图案；说明文字的字符数组；游戏的记分；游戏的速度（蛇的速度）。
图2.2蛇的不停运动的关键算法的流程图
2.2.4各模块的功能及程序说明
主要模块的实现思路和算法的流程图说明：
关键所在——蛇不停移动的Snakemove()：
蛇的不停移动，就是蛇的下一节取代前一节的位置，在计算机中就是蛇下一节的位置坐标变成前一节的位置坐标。在上文中，已定义蛇的位置坐标为数组类型，一组坐标对应一节的位置，假设有i+1节，由0到i节，第i节的坐标取第i-1节的坐标，第i-1节的坐标取第i-2节的坐标……直到第1节取第0节的坐标。而第0节的坐标，即蛇头的坐标要往某个方向变化，变化量为蛇每节的长度。蛇的这种坐标轮换需要循环语句使其继续下去。
2.2.5程序结果
运行程序得到如下初始界面图：
图2.3程序结果图
用一个小矩形表示蛇的一节身体，身体每长一节，增加一个矩形块，蛇头用两节表示：
图2.4程序结果图
蛇没有碰到自己或墙壁，蛇继续前进：
图2.5程序结果图
游戏结束时，显示“GAME OVER”
图2.6程序结果图
2.3程序源代码及注释
#define N 200
#include <graphics.h>
#include <stdlib.h>
#include <dos.h>
#define LEFT 0x4b00
#define RIGHT 0x4d00
#define DOWN 0x5000
#define UP 0x4800
#define ESC 0x011b
int i,key
int score=0
int gamespeed=50000
struct Food{
int x
int y
int yes
}food
struct Snake{
int x[N]
int y[N]
int node
int direction
int life
}snake
void Init(void)
void Close(void)
void DrawK(void)
void GameOver(void)
void GamePlay(void)
void PrScore(void)
void main(void){
Init()
DrawK()
GamePlay()
Close()}
void Init(void){
int gd=DETECT,gm
registerbgidriver(EGAVGA_driver)
initgraph(&gd,&gm,"c:\\program files\\winyes\\tc20h\\bgi")
cleardevice()}
void DrawK(void){
setcolor(11)
setlinestyle(SOLID_LINE,0,THICK_WIDTH)
for(i=50i<=600i+=10) {
rectangle(i,40,i+10,49)
rectangle(i,451,i+10,460) }
for(i=40i<=450i+=10) {
rectangle(50,i,59,i+10)
rectangle(601,i,610,i+10) }}
void GamePlay(void){
randomize()
food.yes=1
snake.life=0
snake.direction=1
snake.x[0]=100snake.y[0]=100
snake.x[1]=110snake.y[1]=100
snake.node=2
PrScore()
while(1) {
while(!kbhit()) {
if(food.yes==1) {
food.x=rand()%400+60
food.y=rand()%350+60
while(food.x%10!=0)
food.x++
while(food.y%10!=0)
food.y++
food.yes=0 }
if(food.yes==0) {
setcolor(GREEN)
rectangle(food.x,food.y,food.x+10,food.y-10) }
for(i=snake.node-1i>0i--) {
snake.x[i]=snake.x[i-1]
snake.y[i]=snake.y[i-1] }
switch(snake.direction) {
case 1:snake.x[0]+=10break
case 2: snake.x[0]-=10break
case 3: snake.y[0]-=10break
case 4: snake.y[0]+=10break }
for(i=3i<snake.nodei++) {
if(snake.x[i]==snake.x[0]&&snake.y[i]==snake.y[0]) {
GameOver()
snake.life=1
break } }
if(snake.x[0]<55||snake.x[0]>595||snake.y[0]<55||
snake.y[0]>455) {
GameOver()
snake.life=1 }
if(snake.life==1)
break
if(snake.x[0]==food.x&&snake.y[0]==food.y) {
setcolor(0)
rectangle(food.x,food.y,food.x+10,food.y-10)
snake.x[snake.node]=-20snake.y[snake.node]=-20
snake.node++
food.yes=1
score+=10
PrScore() }
setcolor(4)
for(i=0i<snake.nodei++)
rectangle(snake.x[i],snake.y[i],snake.x[i]+10,
snake.y[i]-10)
delay(gamespeed)
setcolor(0)
rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
snake.x[snake.node-1]+10,snake.y[snake.node-1]-10) }
if(snake.life==1)
break
key=bioskey(0)
if(key==ESC)
break
else
if(key==UP&&snake.direction!=4)
snake.direction=3
else
if(key==RIGHT&&snake.direction!=2)
snake.direction=1
else
if(key==LEFT&&snake.direction!=1)
snake.direction=2
else
if(key==DOWN&&snake.direction!=3)
snake.direction=4
}}
void GameOver(void){
cleardevice()
PrScore()
setcolor(RED)
settextstyle(0,0,4)
outtextxy(200,200,"GAME OVER")
getch()}
void PrScore(void){
char str[10]
setfillstyle(SOLID_FILL,YELLOW)
bar(50,15,220,35)
setcolor(6)
settextstyle(0,0,2)
sprintf(str,"score:%d",score)
outtextxy(55,20,str)}
void Close(void){
getch()
closegraph()
}
1、
package mvcTest
public class GreedSnake {
public static void main(String[] args) {
SnakeModel model = new SnakeModel(20,30)
SnakeControl control = new SnakeControl(model)
SnakeView view = new SnakeView(model,control)
//添加一个观察者，让view成为model的观察者
model.addObserver(view)
(new Thread(model)).start()
}
}
-------------------------------------------------------------
2、
package mvcTest
//SnakeControl.java
import java.awt.event.KeyEvent
import java.awt.event.KeyListener
public class SnakeControl implements KeyListener{
SnakeModel model
public SnakeControl(SnakeModel model){
this.model = model
}
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode()
if (model.running){// 运行状态下，处理的按键
switch (keyCode) {
case KeyEvent.VK_UP:
model.changeDirection(SnakeModel.UP)
break
case KeyEvent.VK_DOWN:
model.changeDirection(SnakeModel.DOWN)
break
case KeyEvent.VK_LEFT:
model.changeDirection(SnakeModel.LEFT)
break
case KeyEvent.VK_RIGHT:
model.changeDirection(SnakeModel.RIGHT)
break
case KeyEvent.VK_ADD:
case KeyEvent.VK_PAGE_UP:
model.speedUp()
break
case KeyEvent.VK_SUBTRACT:
case KeyEvent.VK_PAGE_DOWN:
model.speedDown()
break
case KeyEvent.VK_SPACE:
case KeyEvent.VK_P:
model.changePauseState()
break
default:
}
}
// 任何情况下处理的按键，按键导致重新启动游戏
if (keyCode == KeyEvent.VK_R ||
keyCode == KeyEvent.VK_S ||
keyCode == KeyEvent.VK_ENTER) {
model.reset()
}
}
public void keyReleased(KeyEvent e) {
}
public void keyTyped(KeyEvent e) {
}
}
-------------------------------------------------------------
3、
package mvcTest
//SnakeModel.java
import javax.swing.*
import java.util.Arrays
import java.util.LinkedList
import java.util.Observable
import java.util.Random
class SnakeModel extends Observable implements Runnable {
boolean[][] matrix// 指示位置上有没蛇体或食物
LinkedList nodeArray = new LinkedList() // 蛇体
Node food
int maxX
int maxY
int direction = 2 // 蛇运行的方向
boolean running = false // 运行状态
int timeInterval = 200// 时间间隔，毫秒
double speedChangeRate = 0.75 // 每次得速度变化率
boolean paused = false// 暂停标志
int score = 0 // 得分
int countMove = 0 // 吃到食物前移动的次数
// UP and DOWN should be even
// RIGHT and LEFT should be odd
public static final int UP = 2
public static final int DOWN = 4
public static final int LEFT = 1
public static final int RIGHT = 3
public SnakeModel( int maxX, int maxY) {
this.maxX = maxX
this.maxY = maxY
reset()
}
public void reset(){
direction = SnakeModel.UP // 蛇运行的方向
timeInterval = 200// 时间间隔，毫秒
paused = false// 暂停标志
score = 0 // 得分
countMove = 0 // 吃到食物前移动的次数
// initial matirx, 全部清0
matrix = new boolean[maxX][]
for (int i = 0i <maxX++i) {
matrix[i] = new boolean[maxY]
Arrays.fill(matrix[i], false)
}
// initial the snake
// 初始化蛇体，如果横向位置超过20个，长度为10，否则为横向位置的一半
int initArrayLength = maxX >20 ? 10 : maxX / 2
nodeArray.clear()
for (int i = 0i <initArrayLength++i) {
int x = maxX / 2 + i//maxX被初始化为20
int y = maxY / 2 //maxY被初始化为30
//nodeArray[x,y]: [10,15]-[11,15]-[12，15]~~[20,15]
//默认的运行方向向上，所以游戏一开始nodeArray就变为：
// [10，14]-[10，15]-[11，15]-[12，15]~~[19，15]
nodeArray.addLast(new Node(x, y))
matrix[x][y] = true
}
// 创建食物
food = createFood()
matrix[food.x][food.y] = true
}
public void changeDirection(int newDirection) {
// 改变的方向不能与原来方向同向或反向
if (direction % 2 != newDirection % 2) {
direction = newDirection
}
}
public boolean moveOn() {
Node n = (Node) nodeArray.getFirst()
int x = n.x
int y = n.y
// 根据方向增减坐标值
switch (direction) {
case UP:
y--
break
case DOWN:
y++
break
case LEFT:
x--
break
case RIGHT:
x++
break
}
// 如果新坐标落在有效范围内，则进行处理
if ((0 <= x &&x <maxX) &&(0 <= y &&y <maxY)) {
if (matrix[x][y]) {// 如果新坐标的点上有东西（蛇体或者食物）
if (x == food.x &&y == food.y) { // 吃到食物，成功
nodeArray.addFirst(food) // 从蛇头赠长
// 分数规则，与移动改变方向的次数和速度两个元素有关
int scoreGet = (10000 - 200 * countMove) / timeInterval
score += scoreGet >0 ? scoreGet : 10
countMove = 0
food = createFood() // 创建新的食物
matrix[food.x][food.y] = true // 设置食物所在位置
return true
} else // 吃到蛇体自身，失败
return false
} else { // 如果新坐标的点上没有东西（蛇体），移动蛇体
nodeArray.addFirst(new Node(x, y))
matrix[x][y] = true
n = (Node) nodeArray.removeLast()
matrix[n.x][n.y] = false
countMove++
return true
}
}
return false // 触到边线，失败
}
public void run() {
running = true
while (running) {
try {
Thread.sleep(timeInterval)
} catch (Exception e) {
break
}
if (!paused) {
if (moveOn()) {
setChanged() // Model通知View数据已经更新
notifyObservers()
} else {
JOptionPane.showMessageDialog(null,
"you failed",
"Game Over",
JOptionPane.INFORMATION_MESSAGE)
break
}
}
}
running = false
}
private Node createFood() {
int x = 0
int y = 0
// 随机获取一个有效区域内的与蛇体和食物不重叠的位置
do {
Random r = new Random()
x = r.nextInt(maxX)
y = r.nextInt(maxY)
} while (matrix[x][y])
return new Node(x, y)
}
public void speedUp() {
timeInterval *= speedChangeRate
}
public void speedDown() {
timeInterval /= speedChangeRate
}
public void changePauseState() {
paused = !paused
}
public String toString() {
String result = ""
for (int i = 0i <nodeArray.size()++i) {
Node n = (Node) nodeArray.get(i)
result += "[" + n.x + "," + n.y + "]"
}
return result
}
}
class Node {
int x
int y
Node(int x, int y) {
this.x = x
this.y = y
}
}
------------------------------------------------------------
4、
package mvcTest
//SnakeView.java
import javax.swing.*
import java.awt.*
import java.util.Iterator
import java.util.LinkedList
import java.util.Observable
import java.util.Observer
public class SnakeView implements Observer {
SnakeControl control = null
SnakeModel model = null
JFrame mainFrame
Canvas paintCanvas
JLabel labelScore
public static final int canvasWidth = 200
public static final int canvasHeight = 300
public static final int nodeWidth = 10
public static final int nodeHeight = 10
public SnakeView(SnakeModel model, SnakeControl control) {
this.model = model
this.control = control
mainFrame = new JFrame("GreedSnake")
Container cp = mainFrame.getContentPane()
// 创建顶部的分数显示
labelScore = new JLabel("Score:")
cp.add(labelScore, BorderLayout.NORTH)
// 创建中间的游戏显示区域
paintCanvas = new Canvas()
paintCanvas.setSize(canvasWidth + 1, canvasHeight + 1)
paintCanvas.addKeyListener(control)
cp.add(paintCanvas, BorderLayout.CENTER)
// 创建底下的帮助栏
JPanel panelButtom = new JPanel()
panelButtom.setLayout(new BorderLayout())
JLabel labelHelp
labelHelp = new JLabel("PageUp, PageDown for speed", JLabel.CENTER)
panelButtom.add(labelHelp, BorderLayout.NORTH)
labelHelp = new JLabel("ENTER or R or S for start", JLabel.CENTER)
panelButtom.add(labelHelp, BorderLayout.CENTER)
labelHelp = new JLabel("SPACE or P for pause", JLabel.CENTER)
panelButtom.add(labelHelp, BorderLayout.SOUTH)
cp.add(panelButtom, BorderLayout.SOUTH)
mainFrame.addKeyListener(control)
mainFrame.pack()
mainFrame.setResizable(false)
mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
mainFrame.setVisible(true)
}
void repaint() {
Graphics g = paintCanvas.getGraphics()
//draw background
g.setColor(Color.WHITE)
g.fillRect(0, 0, canvasWidth, canvasHeight)
// draw the snake
g.setColor(Color.BLACK)
LinkedList na = model.nodeArray
Iterator it = na.iterator()
while (it.hasNext()) {
Node n = (Node) it.next()
drawNode(g, n)
}
// draw the food
g.setColor(Color.RED)
Node n = model.food
drawNode(g, n)
updateScore()
}
private void drawNode(Graphics g, Node n) {
g.fillRect(n.x * nodeWidth,
n.y * nodeHeight,
nodeWidth - 1,
nodeHeight - 1)
}
public void updateScore() {
String s = "Score: " + model.score
labelScore.setText(s)
}
public void update(Observable o, Object arg) {
repaint()
}
}
-------------------------------------------------------------
<head>
<title>贪吃蛇 Snake v2.4</title>
<style>
body{
font-size:9pt
}
table{
border-collapse: collapse
border:solid #333 1px
}
td{
height: 10px
width: 10px
font-size: 0px
}
.filled{
background-color:blue
}
</style>
</head>
<script>
function $(id){return document.getElementById(id)}
//贪吃蛇类
var Snake = {
tbl: null,
body: [],
//当前移动的方向,取值0,1,2,3, 分别表示向上,右,下,左, 按键盘方向键可以改变它
direction: 0,
//定时器
timer: null,
//速度
speed: 250,
//是否已经暂停
paused: true,
//行数
rowCount: 30,
//列数
colCount: 30,
//初始化
init: function(){
var colors = ['red','orange','yellow','green','blue','purple','#ccc']
this.tbl = $("main")
var x = 0
var y = 0
var colorIndex = 0
//产生初始移动方向
this.direction = Math.floor(Math.random()*4)
//构造table
for(var row=0row<this.rowCountrow++){
var tr=this.tbl.insertRow(-1)
for(var col=0col<this.colCountcol++) {
var td=tr.insertCell(-1)
}
}
//产生20个松散节点
for(var i=0i<10i++){
x = Math.floor(Math.random()*this.colCount)
y = Math.floor(Math.random()*this.rowCount)
colorIndex = Math.floor(Math.random()*7)
if(!this.isCellFilled(x,y)){
this.tbl.rows[y].cells[x].style.backgroundColor = colors[colorIndex]
}
}
//产生蛇头
while(true){
x = Math.floor(Math.random()*this.colCount)
y = Math.floor(Math.random()*this.rowCount)
if(!this.isCellFilled(x,y)){
this.tbl.rows[y].cells[x].style.backgroundColor = "black"
this.body.push({x:x,y:y,color:'black'})
break
}
}
this.paused = true
//添加键盘事件
document.onkeydown= function(e){
if (!e)e=window.event
switch(e.keyCode | e.which | e.charCode){
case 13: {
if(Snake.paused){
Snake.move()
Snake.paused = false
}
else{
//如果没有暂停，则停止移动
Snake.pause()
Snake.paused = true
}
break
}
case 37:{//left
//阻止蛇倒退走
if(Snake.direction==1){
break
}
Snake.direction = 3
break
}
case 38:{//up
//快捷键在这里起作用
if(event.ctrlKey){
Snake.speedUp(-20)
break
}
if(Snake.direction==2){//阻止蛇倒退走
break
}
Snake.direction = 0
break
}
case 39:{//right
if(Snake.direction==3){//阻止蛇倒退走
break
}
Snake.direction = 1
break
}
case 40:{//down
if(event.ctrlKey){
Snake.speedUp(20)
break
}
if(Snake.direction==0){//阻止蛇倒退走
break
}
Snake.direction = 2
break
}
}
}
},
//移动
move: function(){
this.timer = setInterval(function(){
Snake.erase()
Snake.moveOneStep()
Snake.paint()
}, this.speed)
},
//移动一节身体
moveOneStep: function(){
if(this.checkNextStep()==-1){
clearInterval(this.timer)
alert("Game over!\nPress Restart to continue.")
return
}
if(this.checkNextStep()==1){
var _point = this.getNextPos()
var _x = _point.x
var _y = _point.y
var _color = this.getColor(_x,_y)
this.body.unshift({x:_x,y:_y,color:_color})
//因为吃了一个食物，所以再产生一个食物
this.generateDood()
return
}
//window.status = this.toString()
var point = this.getNextPos()
//保留第一节的颜色
var color = this.body[0].color
//颜色向前移动
for(var i=0i<this.body.length-1i++){
this.body[i].color = this.body[i+1].color
}
//蛇尾减一节， 蛇尾加一节，呈现蛇前进的效果
this.body.pop()
this.body.unshift({x:point.x,y:point.y,color:color})
//window.status = this.toString()
},
//探寻下一步将走到什么地方
pause: function(){
clearInterval(Snake.timer)
this.paint()
},
getNextPos: function(){
var x = this.body[0].x
var y = this.body[0].y
var color = this.body[0].color
//向上
if(this.direction==0){
y--
}
//向右
else if(this.direction==1){
x++
}
//向下
else if(this.direction==2){
y++
}
//向左
else{
x--
}
//返回一个坐标
return {x:x,y:y}
},
//检查将要移动到的下一步是什么
checkNextStep: function(){
var point = this.getNextPos()
var x = point.x
var y = point.y
if(x<0||x>=this.colCount||y<0||y>=this.rowCount){
return -1//触边界，游戏结束
}
for(var i=0i<this.body.lengthi++){
if(this.body[i].x==x&&this.body[i].y==y){
return -1//碰到自己的身体,游戏结束
}
}
if(this.isCellFilled(x,y)){
return 1//有东西
}
return 0//空地
},
//擦除蛇身
erase: function(){
for(var i=0i<this.body.lengthi++){
this.eraseDot(this.body[i].x, this.body[i].y)
}
},
//绘制蛇身
paint: function(){
for(var i=0i<this.body.lengthi++){
this.paintDot(this.body[i].x, this.body[i].y,this.body[i].color)
}
},
//擦除一节
eraseDot: function(x,y){
this.tbl.rows[y].cells[x].style.backgroundColor = ""
},
paintDot: function(x,y,color){
this.tbl.rows[y].cells[x].style.backgroundColor = color
},
//得到一个坐标上的颜色
getColor: function(x,y){
return this.tbl.rows[y].cells[x].style.backgroundColor
},
//用于调试
toString: function(){
var str = ""
for(var i=0i<this.body.lengthi++){
str += "x:" + this.body[i].x + " y:" + this.body[i].y + " color:" + this.body[i].color + " - "
}
return str
},
//检查一个坐标点有没有被填充
isCellFilled: function(x,y){
if(this.tbl.rows[y].cells[x].style.backgroundColor == ""){
return false
}
return true
},
//重新开始
restart: function(){
if(this.timer){
clearInterval(this.timer)
}
for(var i=0i<this.rowCounti++){
this.tbl.deleteRow(0)
}
this.body = []
this.init()
this.speed = 250
},
//加速
speedUp: function(time){
if(!this.paused){
if(this.speed+time<10||this.speed+time>2000){
return
}
this.speed +=time
this.pause()
this.move()
}
},
//产生食物。
generateDood: function(){
var colors = ['red','orange','yellow','green','blue','purple','#ccc']
var x = Math.floor(Math.random()*this.colCount)
var y = Math.floor(Math.random()*this.rowCount)
var colorIndex = Math.floor(Math.random()*7)
if(!this.isCellFilled(x,y)){
this.tbl.rows[y].cells[x].style.backgroundColor = colors[colorIndex]
}
}
}
</script>
<body onload="Snake.init()">
<br />
<table id="main" border="1" cellspacing="0" cellpadding="0"></table>
<input type="button" id="btn" value="开始/暂停" />点左边按钮或按Enter开始/暂停游戏<br />
<input type="button" id="reset" value="重新开始" /><br />
<input type="button" id="upSpeed" value="加速" />点左边按钮或按Ctrl + ↑加速<br />
<input type="button" id="downSpeed" value="减速" />点左边按钮或按Ctrl + ↓减速
<script>
$('btn').onclick = function(){
if(Snake.paused){
Snake.move()
Snake.paused = false
}
else{
Snake.pause()
Snake.paused = true
}
}
$("reset").onclick = function(){
Snake.restart()
this.blur()
}
$("upSpeed").onclick = function(){
Snake.speedUp(-20)
}
$("downSpeed").onclick = function(){
Snake.speedUp(20)
}
</script>
</body>
</html>
基本思路：
蛇每吃一个食物蛇身子就增加一格，用UP, DOWN, LEFT, RIGHT控制蛇头的运动，而蛇身子跟着蛇头走，每后一格蛇身子下一步走到上一格蛇身子的位置，以此类推。
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#define BEG_X 2
#define BEG_Y 1
#define WID 20
#define HEI 20
HANDLE hout
typedef enum {UP, DOWN, LEFT, RIGHT} DIR
typedef struct Snake_body
{
COORD pos//蛇身的位置
struct Snake_body *next//下一个蛇身
struct Snake_body *prev//前一个蛇身
}SNAKE, *PSNAKE
PSNAKE head = NULL//蛇头
PSNAKE tail = NULL//蛇尾
//画游戏边框的函数
void DrawBorder()
{
int i, j
COORD pos = {BEG_X, BEG_Y}
for(i = 0i <HEI++i)
{
SetConsoleCursorPosition(hout, pos)
for(j = 0j <WID++j)
{
if(i == 0)//第一行
{
if(j == 0)
printf("┏")
else if(j == WID - 1)
printf("┓")
else
printf("━")
}
else if(i == HEI - 1)//最后一行
{
if(j == 0)
printf("┗")
else if(j == WID - 1)
printf("┛")
else
printf("━")
}
else if(j == 0 || j == WID - 1)//第一列或最后一列
printf("┃")
else
printf(" ")
}
++pos.Y
}
}
//添加蛇身的函数
void AddBody(COORD pos)
{
PSNAKE pnew = (PSNAKE)calloc(1, sizeof(SNAKE))
pnew->pos = pos
if(!head)
{
head = tail = pnew
}
else
{
pnew->next = head//新创建蛇身的next指向原先的蛇头
head->prev = pnew//原先的蛇头的prev指向新创建的蛇身
head = pnew//把新创建的蛇身作为新的蛇头
}
SetConsoleCursorPosition(hout, head->pos)
printf("◎")
}
//蛇身移动的函数
void MoveBody(DIR dir)
{
PSNAKE ptmp
COORD pos = head->pos
switch(dir)
{
case UP:
if(head->pos.Y >BEG_Y + 1)
--pos.Y
else
return
break
case DOWN:
if(head->pos.Y <BEG_Y + HEI - 2)
++pos.Y
else
return
break
case LEFT:
if(head->pos.X >BEG_X + 2)
pos.X -= 2
else
return
break
case RIGHT:
if(head->pos.X <BEG_X + (WID - 2) * 2)
pos.X += 2
else
return
break
}
AddBody(pos)//添加了一个新的蛇头
ptmp = tail//保存当前的蛇尾
tail = tail->prev
if(tail)
tail->next = NULL
SetConsoleCursorPosition(hout, ptmp->pos)
printf(" ")
free(ptmp)
}
int main()
{
int ctrl
DIR dir = RIGHT//初始蛇的方向是向右的
COORD pos = {BEG_X + 2, BEG_Y + HEI / 2}
system("color 0E")
system("mode con cols=90 lines=30")
hout = GetStdHandle(STD_OUTPUT_HANDLE)
printf(" ------------贪吃蛇的移动------------")
DrawBorder()
//自定义几个蛇的身体
AddBody(pos)
pos.X += 2
AddBody(pos)
pos.X += 2
AddBody(pos)
pos.X += 2
AddBody(pos)
pos.X += 2
AddBody(pos)
pos.X += 2
AddBody(pos)
pos.X += 2
AddBody(pos)
//控制蛇的移动
while(ctrl = getch())
{
switch(ctrl)
{
case 'w':
if(dir == DOWN)
continue
dir = UP
break
case 's':
if(dir == UP)
continue
dir = DOWN
break
case 'a':
if(dir == RIGHT)
continue
dir = LEFT
break
case 'd':
if(dir == LEFT)
continue
dir = RIGHT
break
case 'q':
return 0
}
MoveBody(dir)
}
return 0
}
扩展资料：
实现逻辑
1，可以设置光标，就能实现制定位置打印制定符号。
2，涉及一个结构体，包含两个元素坐标元素和一个结构体指针。
3，结构体串联形成链表，遍历获取成员坐标，打印符号得到蛇身。
4，不断的加头，去尾，重新遍历坐标，再打印形成蛇的移动。
5，食物产生的位置判定，不能越界，也不能与蛇身体重合。
6，蛇的转向判定，一条规则，不允许倒退。
7，转向的实现，跟行进方向决定新的关节坐标（当前头的上下左右）
8，死亡检测，是否头节点坐标是否与墙壁重合，是否与身体其他关节重合。
9，加速减速，设置刷新休眠时间实现。
参考资料来源：百度百科-C语言
贪吃蛇是一款非常经典的游戏，还记得以前拿着爸爸妈妈的按键手机上面就有内置这一款游戏。一开始的贪吃蛇是黑白像素的，我记得我以前有一个五块钱买的那种像素游戏机，里面就有内置坦克大战，俄罗斯方块，贪吃蛇等一些小游戏。
后来父母的手机变成彩色屏了，上面的贪吃蛇也得到了提升，变成了彩色的方块，随后诺基亚手机上的贪吃蛇就变成了类似于2.5d的游戏，当时吃的东西不再是单纯的像素块，而是苹果香蕉之类的，看起来更加的有趣，可以说是诺基亚把贪吃蛇这个游戏给带火了。
贪吃蛇会随着你的长度，速度越来越快到后面基本上就控制不了了，很容易碰到自己的尾巴或者是墙壁。但是在如今来看这款游戏已经是过时了，如果将它重新设计的话，应该多创造一些趣味的关卡，比如说可以增加一些道具，比如说无敌道具，在吃到它以后，即使是墙壁和自己的身体都可以穿过去。
吃任务道具的时候也可以加上连击的效果，这样玩起来就比较刺激。其次我认为它可以做成3d的模式，就是以第一人称和第三人称之间可以相互切换，自己控制着像赛车游戏那样会比较刺激好玩。随后就是添加如今各个游戏都有的排行榜功能，谁闯的关数越多就会排在前面，这样的话其他玩家就会产生竞争心理。这样才能吸引更多游戏爱好者前来游玩。
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <time.h>
const int H = 8 //地图的高
const int L = 16 //地图的长
char GameMap[H][L] //游戏地图
int key //按键保存
int sum = 1, over = 0 //蛇的长度, 游戏结束(自吃或碰墙)
int dx[4] = {0, 0, -1, 1} //左、右、上、下的方向
int dy[4] = {-1, 1, 0, 0}
struct Snake //蛇的每个节点的数据类型
{
int x, y //左边位置
int now //保存当前节点的方向, 0,1,2,3分别为左右上下
}Snake[H*L]
const char Shead = '@' //蛇头
const char Sbody = '#' //蛇身
const char Sfood = '*' //食物
const char Snode = '.' //'.'在地图上标示为空
void Initial() //地图的初始化
void Create_Food()//在地图上随机产生食物
void Show() //刷新显示地图
void Button() //取出按键,并判断方向
void Move() //蛇的移动
void Check_Border() //检查蛇头是否越界
void Check_Head(int x, int y) //检查蛇头移动后的位置情况
int main()
{
Initial()
Show()
return 0
}
void Initial() //地图的初始化
{
int i, j
int hx, hy
system("title 贪吃蛇") //控制台的标题
memset(GameMap, '.', sizeof(GameMap)) //初始化地图全部为空'.'
system("cls")
srand(time(0)) //随机种子
hx = rand()%H //产生蛇头
hy = rand()%L
GameMap[hx][hy] = Shead
Snake[0].x = hx Snake[0].y = hy
Snake[0].now = -1
Create_Food() //随机产生食物
for(i = 0i <Hi++) //地图显示
{
for(j = 0j <Lj++)
printf("%c", GameMap[i][j])
printf("\n")
}
printf("\n小小C语言贪吃蛇\n")
printf("按任意方向键开始游戏\n")
getch() //先接受一个按键,使蛇开始往该方向走
Button() //取出按键,并判断方向
}
void Create_Food() //在地图上随机产生食物
{
int fx, fy
while(1)
{
fx = rand()%H
fy = rand()%L
if(GameMap[fx][fy] == '.') //不能出现在蛇所占有的位置
{
GameMap[fx][fy] = Sfood
break
}
}
}
void Show() //刷新显示地图
{
int i, j
while(1)
{
_sleep(500)//延迟半秒(1000为1s),即每半秒刷新一次地图
Button() //先判断按键在移动
Move()
if(over) //自吃或碰墙即游戏结束
{
printf("\n**游戏结束**\n")
printf(" >_<\n")
getchar()
break
}
system("cls") //清空地图再显示刷新吼的地图
for(i = 0i <Hi++)
{
for(j = 0j <Lj++)
printf("%c", GameMap[i][j])
printf("\n")
}
printf("\n小小C语言贪吃蛇\n")
printf("按任意方向键开始游戏\n")
}
}
void Button() //取出按键,并判断方向
{
if(kbhit() != 0) //检查当前是否有键盘输入，若有则返回一个非0值，否则返回0
{
while(kbhit() != 0) //可能存在多个按键,要全部取完,以最后一个为主
key = getch()//将按键从控制台中取出并保存到key中
switch(key)
{ //左
case 75: Snake[0].now = 0
break
//右
case 77: Snake[0].now = 1
break
//上
case 72: Snake[0].now = 2
break
//下
case 80: Snake[0].now = 3
break
}
}
}
void Move() //蛇的移动
{
int i, x, y
int t = sum //保存当前蛇的长度
//记录当前蛇头的位置,并设置为空,蛇头先移动
x = Snake[0].x y = Snake[0].y GameMap[x][y] = '.'
Snake[0].x = Snake[0].x + dx[ Snake[0].now ]
Snake[0].y = Snake[0].y + dy[ Snake[0].now ]
Check_Border() //蛇头是否越界
Check_Head(x, y) //蛇头移动后的位置情况,参数为: 蛇头的开始位置
if(sum == t) //未吃到食物即蛇身移动哦
for(i = 1i <sumi++) //要从蛇尾节点向前移动哦,前一个节点作为参照
{
if(i == 1) //尾节点设置为空再移动
GameMap[ Snake[i].x ][ Snake[i].y ] = '.'
if(i == sum-1) //为蛇头后面的蛇身节点,特殊处理
{
Snake[i].x = x
Snake[i].y = y
Snake[i].now = Snake[0].now
}
else //其他蛇身即走到前一个蛇身位置
{
Snake[i].x = Snake[i+1].x
Snake[i].y = Snake[i+1].y
Snake[i].now = Snake[i+1].now
}
GameMap[ Snake[i].x ][ Snake[i].y ] = '#'//移动后要置为'#'蛇身
}
}
void Check_Border() //检查蛇头是否越界
{
if(Snake[0].x <0 || Snake[0].x >= H
|| Snake[0].y <0 || Snake[0].y >= L)
over = 1
}
void Check_Head(int x, int y) //检查蛇头移动后的位置情况
{
if(GameMap[ Snake[0].x ][ Snake[0].y ] == '.') //为空
GameMap[ Snake[0].x ][ Snake[0].y ] = '@'
else
if(GameMap[ Snake[0].x ][ Snake[0].y ] == '*') //为食物
{
GameMap[ Snake[0].x ][ Snake[0].y ] = '@'
Snake[sum].x = x //新增加的蛇身为蛇头后面的那个
Snake[sum].y = y
Snake[sum].now = Snake[0].now
GameMap[ Snake[sum].x ][ Snake[sum].y ] = '#'
sum++
Create_Food() //食物吃完了马上再产生一个食物
}
else
over = 1
}
Python版本： 3.6.4
相关模块：
pygame模块；
以及一些Python自带的模块。
安装Python并添加到环境变量，pip安装需要的相关模块即可。
贪吃蛇的 游戏 规则应该不需要我多做介绍了吧T_T。写个贪吃蛇 游戏 其实还是很简单的。首先，我们进行一下 游戏 初始化：
然后定义一个贪吃蛇类：
其中head_coord用来记录蛇头所在位置，而tail_coords是一个二维数组，用来记录所有蛇身的位置。一开始，贪吃蛇长为3，并且位置是随机生成的。用户通过 键来控制贪吃蛇的行动：
需要注意的是，贪吃蛇不能180 大拐弯，只能90 地拐弯。例如正在向左行动的贪吃蛇不能瞬间变成向右行动。具体而言，代码实现如下：
然后，我们需要随机生成一个食物，且需要保证该食物的位置不与贪吃蛇的位置相同：
在更新贪吃蛇的时候，如果它吃到了食物，则蛇身长加一，否则只是简单的按照给定的方向行动而不改变蛇身长度：
同时，当贪吃蛇吃到食物时，需要重新生成一个新的食物：
最后，当贪吃蛇碰到墙壁或者蛇头碰到蛇身时， 游戏 结束：
并显示一下 游戏 结束界面：
玩家通过 键控制 游戏 的主角吃豆人吃掉藏在迷宫内的所有豆子，并且不能被鬼魂抓到。
若能顺利吃完迷宫内的所有豆子并且不被鬼魂抓到，则 游戏 胜利，否则 游戏 失败。
逐步实现：
Step1：定义 游戏 精灵类
首先，让我们先来明确一下该 游戏 需要哪些 游戏 精灵类。
① 墙类
② 食物类(即豆豆)
③ 角色类
角色类包括吃豆人和鬼魂，鬼魂由电脑控制其运动轨迹，吃豆人由玩家控制其运动轨迹。
显然，其均需具备更新角色位置和改变角色运动方向的能力，其源代码如下：
Step2：设计 游戏 地图
利用Step1中定义的 游戏 精灵类，我们就可以开始设计 游戏 地图了。由于时间有限，我只写了一个关卡的 游戏 地图，有兴趣的小伙伴可以在此基础上进行扩展(在我的源代码基础上进行扩展是很方便滴~)。 游戏 地图的设计包括以下四方面内容：
① 创建墙
② 创建门(一开始关幽灵用的)
image.gif
③ 创建角色
④ 创建食物
因为食物不能和墙、门以及角色的位置重叠，所以为了方便设计 游戏 地图，要先创建完墙、门以及角色后再创建食物：
Step3：设计 游戏 主循环
接下来开始设计 游戏 主循环。首先是初始化：
然后定义主函数：
其中startLevelGame函数用于开始某一关 游戏 ，其源代码如下：
showText函数用于在 游戏 结束或关卡切换时在 游戏 界面中显示提示性文字，其源代码如下：
1.首先，用一个结构体数组来标记蛇的X位置和Y位置，还有每一节的方向。用一变量标识蛇的长度。
2.在蛇非转弯的移动时用定时器来自动移动，不管蛇是哪种形状，都只需在每次移动时先将各节向后移动（蛇尾舍弃，新的蛇尾由蛇尾的上一节代替）：如蛇本身为snake[0]到snake[3]，就是将snake[0]到snake[2]一起移动到snake[1]到snake[3]： 将 snake[2]的XY坐标赋值snake[3]的XY坐标 ，snake[1]的XY坐标 赋值给snake[2]的XY坐标 ，snake[0]的XY坐标 赋值给snake[1]的XY坐标 。再判断蛇头的方向，然后将蛇头顺着这个方向向前移动一格就是蛇头snake[0]的XY坐标 。而蛇除蛇头外各节的方向由函数SetDirection()来确定（明显此种情况，蛇头的方向不变），SetDirection()的思想是根据蛇的每一节的前一节的相对位置来确定本节的方向。(其实这个函数是多余的，真正用到的只有蛇头的方向)。
3.蛇在转弯时，也是各节一次向后移，蛇头的位置顺着转弯的方向移动，方向由转弯方向确定。
4.蛇在吃到食物时，长度加一，蛇头的位置变成食物的位置，方向不变。蛇的本身每节的XY位置都向后移。如蛇本身为snake[0]到snake[3]， 就是将snake[0]到snake[3]一起移动到snake[1]到snake[4]。
5.基于对话框的应用程序，响应按键消息需在PreTranslateMessage里，而不是像文档视图模式那样在OnKeyDown里响应。
6.每次蛇在转弯时只能有一种方向按键能响应，即要么左右转，要么上下转。蛇头方向向左或向右时，只能上下转；蛇头方向向上或向下时，只能左右转。
7.食物的位置由rand函数随机产生。
2.添加如下函数和变量
1 void HuaFangGe(int bianChang, int gridShumu) //如在400*400的方格里绘制20*20个格子，则bianChang = 400；gridShumu = 20
2 void InitSnackSite() //初始化蛇的位置
3
4 int snakeLength //表示蛇的长度
5 int foodX //食物的X位置
6 int foodY //食物的Y位置
7 bool start //标志是否开始
8 bool reStart //标志是否重新开始
9
10 struct SNAKE
11 {
12 int x
13 int y
14 char direction //某位置的方向为前一个位置相对于该位置的方向，由SetDirection()确定
15 }snake[200]
16
17 void DrawRed(int x, int y) //指定点0*0到20*20，画相应颜色，下同（红头绿身蓝尾）
18 void DrawGreen(int x, int y)
19 void DrawBlue(int x, int y)
20 void DrawBlack(int x, int y) //根据SetFoodXY()所确定的foodX和foodY来画食物。
21
22 void DrawSnakeFood() //根据数组snakeSite数组的标识信息类绘制蛇的形状位置颜色。
23 void SetFoodXY() //随机绘制食物的XY位置
24
25 bool leftRight //确定是否能上下走（蛇本身在上下走，再按上下就无用了）
26 bool upDown //确定是否能左右走（蛇本身在左右走，再按左右就无用了）
27
28 void MoveSite() //蛇移动过程中，设置“除蛇头”外各节的x和y的位置，顺序前移。
29 void SetDirection() //蛇移动过程中，设置“除蛇头”外各节的方向
30
31 void TurnLeft() //当蛇左转时
32 void TurnRight() //当蛇右转时
33 void GoUp() //当蛇向上时
34 void GoDown() //当蛇向下时
可以参考这里：http://www.cnblogs.com/jncpp/archive/2012/07/24/2606908.html
【原创】基于MFC的 贪吃蛇 小游戏的实现，附源码下载
