终于懂了java贪吃蛇小游戏设计过程

用JAVA设计游戏:贪吃蛇游戏用MVC方式实现的贪吃蛇游戏，共有4个类。运行运行即可。主要是观察者模式的使用，我已经添加了很多注释了。
1、

package mvcTest;

public class {
public static void main(String[] args) {
model = new (20,30);
control = new (model);
SnakeView view = new SnakeView(model,control);
//添加一个观察者，让view成为model的观察者
model.(view);

(new Thread(model)).start();
}
}
-------------------------------------------------------------
2、
package mvcTest;
//.java
import .KeyEvent;
import .;

public class {
model;
public ( model){
= model;
}
public void (KeyEvent e) {
int keyCode = e.();
if (){ // 运行状态下，处理的按键
switch (keyCode) {
case :
model.(.UP);
break;
case :
model.(.DOWN);
break;
case :
model.(.LEFT);
break;
case :
model.(.RIGHT);
break;
case :
case :
();
break;
case :
case :
();
break;
case :
case :
model.();
break;
default:
}
}
// 任何情况下处理的按键，按键导致重新启动游戏
if (keyCode == ||
keyCode == ||
keyCode == ) {
();
}
}
public void (KeyEvent e) {
}
public void keyTyped(KeyEvent e) {
}
}
-------------------------------------------------------------
3、

package mvcTest;

//.java
import .*;
import ;
import .;
import .;
import ;

class extends Runnable {
boolean[][] matrix; // 指示位置上有没蛇体或食物
nodeArray = new (); // 蛇体
Node food;
int maxX;
int maxY;
int direction = 2; // 蛇运行的方向
boolean running = false; // 运行状态
int = 200; // 时间间隔，毫秒
double = ; // 每次得速度变化率
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 ( int maxX, int maxY) {
= maxX;
= maxY;
reset();
}
public void reset(){
direction = .UP; // 蛇运行的方向
= 200; // 时间间隔，毫秒
paused = false; // 暂停标志
score = 0; // 得分
countMove = 0; // 吃到食物前移动的次数
// initial matirx, 全部清0
matrix = new boolean[maxX][];
for (int i = 0; i matrix[i] = new boolean[maxY];
(matrix[i], false);
}
// initial the snake
// 初始化蛇体，如果横向位置超过20个，长度为10，否则为横向位置的一半
int = maxX > 20 ? 10 : maxX / 2;
();
for (int i = 0; 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]
(new Node(x, y));
matrix[x][y] = true;
}
// 创建食物
food = ();
matrix[][] = true;
}
public void (int ) {
// 改变的方向不能与原来方向同向或反向
if (direction % 2 != % 2) {
direction = ;
}
}

public boolean moveOn() {
Node n = (Node) ();
int x = ;
int y = ;
// 根据方向增减坐标值
switch (direction) {
case UP:
y--;
break;
case DOWN:
y++;
break;
case LEFT:
x--;
break;
case RIGHT:
x++;
break;
}
// 如果新坐标落在有效范围内，则进行处理
if ((0
if (matrix[x][y]) { // 如果新坐标的点上有东西（蛇体或者食物）
if (x == && y == ) { // 吃到食物，成功
(food); // 从蛇头赠长
// 分数规则，与移动改变方向的次数和速度两个元素有关
int scoreGet = (10000 - 200 * countMove) / ;
score += scoreGet > 0 ? scoreGet : 10;
countMove = 0;
food = (); // 创建新的食物
matrix[][] = true; // 设置食物所在位置
return true;
} else // 吃到蛇体自身，失败
return false;

} else { // 如果新坐标的点上没有东西（蛇体），移动蛇体
(new Node(x, y));
matrix[x][y] = true;
n = (Node) nodeArray.();
matrix[][] = false;
countMove++;
return true;
}
}
return false; // 触到边线，失败
}
public void run() {
running = true;
while (running) {
try {
();
} catch (Exception e) {
break;
}
if (!paused) {
if (moveOn()) {
(); // Model通知View数据已经更新
();
} else {
.(null,
"you failed",
"Game Over",
._MESSAGE);
break;
}
}
}
running = false;
}
private Node () {
int x = 0;
int y = 0;
// 随机获取一个有效区域内的与蛇体和食物不重叠的位置
do {
Random r = new Random();
x = (maxX);
y = (maxY);
} while (matrix[x][y]);
return new Node(x, y);
}
public void speedUp() {
*= ;
}
public void speedDown() {
/= ;
}
public void () {
paused = !paused;
}
public String toString() {
String result = "";
for (int i = 0; i Node n = (Node) (i);
result += "[" + + "," + + "]";
}
return result;
}
}
class Node {
int x;
int y;
Node(int x, int y) {
= x;
= y;
}
}
------------------------------------------------------------
4、
package mvcTest;
//
import .*;
import .*;
import ;
import .;
import .;
import ;

public class SnakeView Observer {
control = null;
model = null;
Jframe mainframe;
Canvas ;
JLabel ;
public static final int = 200;
public static final int = 300;
public static final int nodeWidth = 10;
public static final int = 10;
public SnakeView( model, control) {
= model;
= control;
mainframe = new Jframe("");
Container cp = mainframe.();
// 创建顶部的分数显示
= new JLabel("Score:");
(, .NORTH);
// 创建中间的游戏显示区域
= new Canvas();
.setSize( + 1, + 1);
.(control);
(, .CENTER);
// 创建底下的帮助栏
JPanel = new JPanel();
.setLayout(new ());
JLabel labelHelp;
labelHelp = new JLabel("PageUp, PageDown for speed;", );
.add(labelHelp, .NORTH);
labelHelp = new JLabel("ENTER or R or S for start;", );
.add(labelHelp, .CENTER);
labelHelp = new JLabel("SPACE or P for pause", );
.add(labelHelp, .SOUTH);
(, .SOUTH);
mainframe.(control);
();
mainframe.(false);
mainframe.();
mainframe.(true);
}
void repaint() {
Graphics g = .();
//draw
();
(0, 0, , );
// draw the snake
();
na = ;
Iterator it = ();
while (()) {
Node n = (Node) ();
drawNode(g, n);
}
// draw the food
();
Node n = ;
drawNode(g, n);
();
}
private void drawNode(Graphics g, Node n) {
( * nodeWidth,
* ,
nodeWidth - 1,
- 1);
}
public void () {
String s = "Score: " + ;
.setText(s);
}
public void update( o, Object arg) {
repaint();
}
}
-------------------------------------------------------------Java 编写 贪吃蛇游戏的 大体思路是什么？要代码和jar包我这有，思路我就大概讲一下:首先是要在画布上画上一个块，这就是蛇头，但是蛇是会变长的，所以需要用一个东西来存蛇，那就可以用数组、ArrayList、、等等（我比较喜欢用），这里虽然说的是蛇，其实是一个块的x、y坐标，蛇是画好了，但蛇是会动的，这就要用一个线程和一个move()方法了，让它不停的动，蛇是动了，但是没有方向，这时需要一个方法让它有方向，但要注意的是相反的方向不能改变方向（也就是按了上，按下就不能用了），蛇有方向又能动，但到边上了就不行了，这时就要让它出界结束游戏，接下来就是要出现食物了，食物这个好办，用一个随机数搞定它，注意食物不能在界外，食物有了，蛇就要去吃它了，这时就要用一个方法去吃食物了，吃到了让蛇长一个块，食物重新出现，蛇是长大了，但是它可以碰到自己的身体，那么你就要做了方法让它碰到后结束游戏，就这样最初步的思路搞定了。接下来的就是一些细节了，这就不说了。java贪吃蛇是怎么做出来的
class SnakeView Observer {
control = null; //实例话一个对象是control ..在jdk中不存在可能是第3方的或者是自己编写的一个类吧
model = null;//如上
Jframe mainframe; //创建一个面板类jframe
Canvas ;

JLabel ;//....不说了吧..
public static final int = 200; //常量宽度200
public static final int = 300;//常量高300
public static final int nodeWidth = 10;//常量宽度10
public static final int = 10;//常量高度10
public SnakeView( model, control) {
= model;
= control;
mainframe = new Jframe("");//创建jframe 标题是
Container cp = mainframe.(); //得到jfram的容器
= new JLabel("Score:"); //创建jlabel 标签内容是"Score:"
(, .NORTH);/将jlabel添加到jfram的容器中去
= new Canvas(); //创建新绘图区
.setSize( + 1, + 1); //设置绘图区大小
.(control);//添加键盘监听器control
(, .CENTER);//将绘图区添加到jfram容器中去.布局是的CENTER位置.就是东西南北中的中间
JPanel = new JPanel();//创建一个panel
.setLayout(new ());//设置布局是
JLabel labelHelp;//标签的创建和添加开始了.......new了3遍就是实例化了3个都加到了panle的中间 ,标签的内容都是""中间的
labelHelp = new JLabel("PageUp, PageDown for speed;", );
.add(labelHelp, .NORTH);
labelHelp = new JLabel("ENTER or R or S for start;", );
.add(labelHelp, .CENTER);
labelHelp = new JLabel("SPACE or P for pause", );
.add(labelHelp, .SOUTH);
(, .SOUTH);//把这个panel添加到jframe的容器里面去
mainframe.(control);//为jframe添加键盘监听器
();//调整此窗口的大小，以适合其子组件的*大小和布局。如果该窗口和/或其所有者仍不可显示，则两者在计算*大小之前变得可显示。在计算*大小之后，将会验证该 Window。
mainframe.(false);//设置此 frame 是否可由用户调整大小。false就是不能
mainframe.();//点击又上角的就是关闭
mainframe.(true);//设置jfram为能看到
}
void repaint() {
Graphics g = .();//Graphics详细看jdk文档..我就知道是一个所有图形上下文的抽象基类..这里应该是那个画图面板
();//设置这个颜色
(0, 0, , );//画一个矩形在x,y处画一个宽是200,高是300的矩形,
();//颜色是黑的
na = ;// 类 List 接口的链接列表实现就是一个集合对象了,因为不知道具体是一个什么类这里就当作这个类能得到一个集合
Iterator it = ();//得到迭代器去迭代这个集合
while (()) {//开始用while迭代
Node n = (Node) ();//得到一个集合中元素.是一个Node....这里的Node不知道是什么对象..有待于研究
drawNode(g, n);//调用另外方法
}
();//设置颜色是红的
Node n = ;//得到一个新node..看来Node这里应该是一个坐标..这里的坐标就是蛇吃的那个东西
drawNode(g, n);//画这个东西..
();//调用..
}
private void drawNode(Graphics g, Node n) {//这是一个画方的方法..动态改变方型的位置
( * nodeWidth,
* ,
nodeWidth - 1,
- 1);
}
public void () {//这是更新标签的一个方法
String s = "Score: " + ;
.setText(s);
}
public void update( o, Object arg) {//这个就是Observer监听类必须实现的方法..这里是去调用repaint()方法..repaint方法就是不断去改变画图版里面的内容的
repaint();
}
}
参考资料:以下是贪吃蛇java程序一部分，我需要下面程序代码的详细注解...求java贪吃蛇的编程，并有注释J2ME贪吃蛇源代码——200行左右，包含详细注释 package snake;import javax..midlet.*;
import javax..lcdui.*;public class extends MIDlet {
= new ();
public () {
Display.(this).();
}public void startApp() {}public void pauseApp() {}public void (boolean ) {}}//文件名:. snake;import .*;
import javax..lcdui.*;
public class extends Canvas Runnable{

int[][] snake = new int[200][2];

int snakeNum;

int direction;


private final int DIRECTION_UP = 0;

private final int DIRECTION_DOWN = 1;

private final int DIRECTION_LEFT = 2;

private final int DIRECTION_RIGHT = 3;
int width;

int height;
private final byte = 4;
boolean isPaused = false;

boolean isRun = true;
private final int SLEEP_TIME = 300;

int foodX;

int foodY;

boolean b = true;

Random random = new Random();
public () {
//初始化
init();
width = ();
height = ();
//启动线程
new Thread(this).start();
}
private void init(){
//初始化节点数量
snakeNum = 7;
//初始化节点数据
for(int i = 0;i snake[i][0] = 100 - * i;
snake[i][1] = 40;
}
//初始化移动方向
direction = DIRECTION_RIGHT;
//初始化食物坐标
foodX = 100;
foodY = 100;
}protected void paint(Graphics g) {
//清屏
(0xffffff);
(0,0,width,height);
(0);//绘制蛇身
for(int i = 0;i (snake[i][0],snake[i][1],,);
}
//绘制食物
if(b){
(foodX,foodY,,);
}
}private void move(int direction){
//蛇身移动
for(int i = snakeNum - 1;i > 0;i--){
snake[i][0] = snake[i - 1][0];
snake[i][1] = snake[i - 1][1];
}/
private void eatFood(){
//判别蛇头是否和食物重叠
if(snake[0][0] == foodX && snake[0][1] == foodY){
snakeNum++;
();
}
}

private void (){
while(true){
foodX = (() % (width - + 1))
/ * ;
foodY = (() % (height - + 1))
/ * ;
boolean b = true;
for(int i = 0;i if(foodX == snake[i][0] && snake[i][1] == foodY){
b = false;
break;
}
}
if(b){
break;
}
}
}

private boolean (){
//边界判别
if(snake[0][0] (width - ) ||
snake[0][1] (height - )){
return true;
}
//碰到自身
for(int i = 4;i if(snake[0][0] == snake[i][0]
&& snake[0][1] == snake[i][1]){
return true;
}
}
return false;
}
public void (int keyCode){
int action = this.(keyCode);
//改变方向
switch(action){
case UP:
if(direction != DIRECTION_DOWN){
direction = DIRECTION_UP;
}
break;
case DOWN:
if(direction != DIRECTION_UP){
direction = DIRECTION_DOWN;
}
break;
case LEFT:
if(direction != DIRECTION_RIGHT){
direction = DIRECTION_LEFT;
}
break;
case RIGHT:
if(direction != DIRECTION_LEFT){
direction = DIRECTION_RIGHT;
}
break;
case FIRE:
//暂停和继续
isPaused = !isPaused;
break;
}
}
public void run(){
try{
while (isRun) {
//开始时间
long start = System.();
if(!isPaused){
//吃食物
eatFood();
//移动
move(direction);
//结束游戏
if(()){
break;
}
//控制闪烁
b = !b;
}
//重新绘制
repaint();
long end = System.();
//延时
if(end - start (SLEEP_TIME - (end - start));
}
}
}catch(Exception e){}
}
}java贪吃蛇技术选型怎么写的？

Java贪吃蛇技术选型一般需要考虑以下几点:

开发平台:需要选择适用于Java语言的开发平台，如Eclipse、IntelliJ IDEA等。

编程语言:需要选择Java语言来开发贪吃蛇游戏。

框架和库:可以使用Java中的Swing框架和AWT库来开发图形界面，并使用Java多线程编程技术来实现游戏的实时动态效果。

算法和数据结构:可以使用队列或链表等数据结构来存储贪吃蛇的身体，并使用类似贪心算法的思想来决定贪吃蛇的下一步移动方向。

编码风格和规范:需要遵循Java的编码风格和规范，确保代码的可读性和可维护性。

java 双人贪吃蛇package game;

import .*;
import .*;
import .*;
public class HsGame extends Jframe {
HsGame(String str) {
// 设置主面版
(str);
(910, 630);
this.(50, 50);
MyPanel mp = new MyPanel();
(mp);
this.(mp);
new Thread(mp).start();
}
// 主线程
public static void main(String[] args) {
HsGame m = new HsGame("贪吃蛇竞技版");
m.(true);
}
}
class MyPanel extends JPanel Runnable, {
int[][] s1 = new int[180][120];
int[][] s2 = new int[180][120];
int x1 = 40;
int y1 = 60;
int x2 = 140;
int y2 = 60;
// 设置线程休眠时间
int sleep = 50;
// 设置初始方向
int = 2;
int = 0;
// 构造函数
MyPanel() {
// 初始化界面
for (int ix = 0; ix for (int iy = 0; iy s1[ix][iy] = 0;
s2[ix][iy] = 0;
}
}
// 设置边界
// 上下边界
for (int ix = 0; ix s1[ix][0] = 1;
s1[ix][119] = 1;
s2[ix][0] = 1;
s2[ix][119] = 1;
}
// 左右边界
for (int iy = 0; iy s1[0][iy] = 1;
s1[179][iy] = 1;
s2[0][iy] = 1;
s2[179][iy] = 1;
}
}
// 画板
public void paint(Graphics g) {
// 显示玩家一
();
for (int ix = 0; ix for (int iy = 0; iy if (s1[ix][iy] == 1) {
(ix * 5, iy * 5, 5, 5);
}
}
}
// 显示玩家二
();
for (int ix = 0; ix for (int iy = 0; iy if (s2[ix][iy] == 1) {
(ix * 5, iy * 5, 5, 5);
}
}
}
// 画出边界
();
for (int i = 0; i (i * 5, 0, 5, 5);
(i * 5, 119 * 5, 5, 5);
}
for (int i = 0; i (0, i * 5, 5, 5);
(179 * 5, i * 5, 5, 5);
}
}
public void run() {
while (true) {
switch () {
case 0:
x1--;
break;
case 1:
y1--;
break;
case 2:
x1++;
break;
case 3:
y1++;
}
switch () {
case 0:
x2--;
break;
case 1:
y2--;
break;
case 2:
x2++;
break;
case 3:
y2++;
}
// 判断死活
if (s1[x1][y1] == 1 || s2[x1][y1] == 1) {
// 弹出player2胜利对话框
.(null,
"player 2 win!",
"Game Over !", .ERROR_MESSAGE);
// 结束游戏
(0);
} else {
s1[x1][y1] = 1;
}
if (s2[x2][y2] == 1 || s1[x2][y2] == 1) {
// 弹出player1胜利对话框
.(null,
"player 1 win!",
"Game Over !", .ERROR_MESSAGE);
// 结束游戏
(0);
} else {
s2[x2][y2] = 1;
}
try {
(sleep);
} catch (Exception e) {
e.();
}
// 重画
();
}
}
public void keyTyped(KeyEvent e) {
}
public void (KeyEvent e) {
// 玩家一控制
if (e.() == 65) {
if ( != 2) {
= 0;
("player 1 left");
}
}
if (e.() == 87) {
if ( != 3) {
= 1;
("player 1 up");
}
}
if (e.() == 68) {
if ( != 0) {
= 2;
("player 1 right");
}
}
if (e.() == 83) {
if ( != 1) {
= 3;
("player 1 down");
}
}
// 玩家二控制
if (e.() == 37) {
if ( != 2) {
= 0;
("player 2 left");
}
}
if (e.() == 38) {
if ( != 3) {
= 1;
("player 2 up");
}
}
if (e.() == 39) {
if ( != 0) {
= 2;
("player 2 right");
}
}
if (e.() == 40) {
if ( != 1) {
= 3;
("player 2 down");
}
}
}
public void (KeyEvent e) {
}
}谁会用java编写“贪吃蛇”小游戏汗 要程序怎么这么点分啊 哭了
呵呵 不过你还是挺幸运 给你吧
连连看的代码（基本算法）加了部分注释
import .*;
import .*;
public class
{
static String s="no"; //用来纪录点击按钮的信息
int x0=0,y0=0,x=0,y=0,n1=0,n2=0; //用来纪录按钮的位置信息
frame f,f1;
Button b1,b2,b3,b4,b5,b6,b7,b8,b9,b10; //用比较笨的方法添加了
Button b11,b12,b13,b14,b15,b16,b17,b18; //30个按钮来实现游戏界面
Button b19,b20,b21,b22,b23,b24,b25; //可以用数组实现，这是本人
Button b26,b27,b28,b29,b30,bc; //学java时，入门的联系，所以
Button b,ba,br,bt1,bt2; //有些东西很业余！！嘻嘻
Panel p1,p2,p3;
TextField t; //用来显示一些随机信息，方法是下面的guli().
Label l;
int d[][]={ //用来和界面的按钮建立映射关系
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0}
};
public static void main(String[] args)
{
t=new ();
();
();
}
public void ( e) //再来一次按钮的响应事件。
{
int d[][]={
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0}
};
=d;
suiji();
f.(false);
f1.(false);
s="no";
go();
}
public void go()//初始化界面
{
l=new Label("亲爱的玩家，");
f=new frame("连连看");
t=new TextField();
p2=new Panel();
p1=new Panel();
p3=new Panel();
bc=new Button("退出");
br=new Button("重列");
b=new Button();
b1=new Button((d[1][1]));
b2=new Button((d[1][2]));
b3=new Button((d[1][3]));
b4=new Button((d[1][4]));
b5=new Button((d[1][5]));
b6=new Button((d[2][1]));
b7=new Button((d[2][2]));
b8=new Button((d[2][3]));
b9=new Button((d[2][4]));
b10=new Button((d[2][5]));
b11=new Button((d[3][1]));
b12=new Button((d[3][2]));
b13=new Button((d[3][3]));
b14=new Button((d[3][4]));
b15=new Button((d[3][5]));
b16=new Button((d[4][1]));
b17=new Button((d[4][2]));
b18=new Button((d[4][3]));
b19=new Button((d[4][4]));
b20=new Button((d[4][5]));
b21=new Button((d[5][1]));
b22=new Button((d[5][2]));
b23=new Button((d[5][3]));
b24=new Button((d[5][4]));
b25=new Button((d[5][5]));
b26=new Button((d[6][1]));
b27=new Button((d[6][2]));
b28=new Button((d[6][3]));
b29=new Button((d[6][4]));
b30=new Button((d[6][5]));
(null);
(250,300);
(100,40);
(300,30);
(60,30);
(70,30);
(new (6,5));
p1.();
p1.(100,100);
p2.(0,400);
p3.(50,50);
t.(230,2);
l.(150,2);
bc.(0,40);
br.(0,100);
(p1);
(p2);
(p3);
(l);
(t);
(bc);
(br);
(b1);
(b2);
(b3);
(b4);
(b5);
(b6);
(b7);
(b8);
(b9);
(b10);
(b11);
(b12);
(b13);
(b14);
(b15);
(b16);
(b17);
(b18);
(b19);
(b20);
(b21);
(b22);
(b23);
(b24);
(b25);
(b26);
(b27);
(b28);
(b29);
(b30);
();
(280,100,500,450);
f.(false);
f.(true);
bc.(new (){
public void ( e)
{
ex();
}
});
br.(new (){
public void ( e)
{
chonglie();
}
});
b1.(new (){
public void ( e)
{
wei(1,1,b1);
}
});
b2.(new (){
public void ( e)
{
wei(1,2,b2);
}
});
b3.(new (){
public void ( e)
{
wei(1,3,b3);
}
});
b4.(new (){
public void ( e)
{
wei(1,4,b4);
}
});
b5.(new (){
public void ( e)
{
wei(1,5,b5);
}
});
b6.(new (){
public void ( e)
{
wei(2,1,b6);
}
});
b7.(new (){
public void ( e)
{
wei(2,2,b7);
}
});
b8.(new (){
public void ( e)
{
wei(2,3,b8);
}
});
b9.(new (){
public void ( e)
{
wei(2,4,b9);
}
});
b10.(new (){
public void ( e)
{
wei(2,5,b10);
}
});
b11.(new (){
public void ( e)
{
wei(3,1,b11);
}
});
b12.(new (){
public void ( e)
{
wei(3,2,b12);
}
});
b13.(new (){
public void ( e)
{
wei(3,3,b13);
}
});
b14.(new (){
public void ( e)
{
wei(3,4,b14);
}
});
b15.(new (){
public void ( e)
{
wei(3,5,b15);
}
});
b16.(new (){
public void ( e)
{
wei(4,1,b16);
}
});
b17.(new (){
public void ( e)
{
wei(4,2,b17);
}
});
b18.(new (){
public void ( e)
{
wei(4,3,b18);
}
});
b19.(new (){
public void ( e)
{
wei(4,4,b19);
}
});
b20.(new (){
public void ( e)
{
wei(4,5,b20);
}
});
b21.(new (){
public void ( e)
{
wei(5,1,b21);
}
});
b22.(new (){
public void ( e)
{
wei(5,2,b22);
}
});
b23.(new (){
public void ( e)
{
wei(5,3,b23);
}
});
b24.(new (){
public void ( e)
{
wei(5,4,b24);
}
});
b25.(new (){
public void ( e)
{
wei(5,5,b25);
}
});
b26.(new (){
public void ( e)
{
wei(6,1,b26);
}
});
b27.(new (){
public void ( e)
{
wei(6,2,b27);
}
});
b28.(new (){
public void ( e)
{
wei(6,3,b28);
}
});
b29.(new (){
public void ( e)
{
wei(6,4,b29);
}
});
b30.(new (){
public void ( e)
{
wei(6,5,b30);
}
});
}
public void ex() //退出界面，可用diolog来实现有模式的类型，更加符合
{
f1=new frame("游戏作业");
(new (1,1));
bt1=new Button("确定退出");
bt2=new Button("再来一局");
(bt1);
(bt2);
();
(400,250,90,60);
f1.(false);
();
f1.(true);
bt1.(new (){
public void ( e)
{
(0);
}
});
bt2.(this);
}
public void suiji() //产生随机数，来填充游戏界面对应的数组的各个位置
{
int m,n,k=0,k1,k2,k3;
for(m=1;m{
k1=(int)(()*25+1);
for(n=1;n{
k2=(int)(()*6+1);
k3=(int)(()*5+1);
while(d[k2][k3]!=0 && k!=30)
{
k2=(int)(()*6+1);
k3=(int)(()*5+1);
}
[k2][k3]=k1;
k++;
}
}
}
public void guli() //随机信息
{
int l=0;
("");
l=(int)(()*10);
(l);
switch(l)
{
case 1:
("好！加油！");
break;
case 3:
("你真棒！");
break;
case 5:
("加快速度！");
break;
case 6:
("不错啊！");
break;
case 8:
("加油吧！");
break;
case 9:
("够聪明!");
break;
default:
break;
}
}
public void chonglie() //重列方法
{
int save[],i,j,n=0,k2,k3,k;
int d[][]={
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0}
};
save=new int[30];
for(n=0;nsave[n]=0; //定义一个数组来保存当前的每个按钮位置上的信息
n=0;
for(i=0;ifor(j=0;j{
if([i][j]!=0)
{
save[n]=[i][j];
n++;
}
}
n=n-1;
=d;
while(n>=0) //产生随机位置，放置按钮
{
k2=(int)(()*6+1);
k3=(int)(()*5+1);
while(d[k2][k3]!=0)
{
k2=(int)(()*6+1);
k3=(int)(()*5+1);
}
[k2][k3]=save[n];
n--;
}
f.(false);
s="no"; //这里一定要将按钮点击信息归为初始
go();
ling();
}
public void ling() //将数组中为零的成员对应的按钮消去
{ //用按钮类型的数组实现会简化得多，
if(d[1][1]==0)
b1.(false);
if(d[1][2]==0)
b2.(false);
if(d[1][3]==0)
b3.(false);
if(d[1][4]==0)
b4.(false);
if(d[1][5]==0)
b5.(false);
if(d[2][1]==0)
b6.(false);
if(d[2][2]==0)
b7.(false);
if(d[2][3]==0)
b8.(false);
if(d[2][4]==0)
b9.(false);
if(d[2][5]==0)
b10.(false);
if(d[3][1]==0)
b11.(false);
if(d[3][2]==0)
b12.(false);
if(d[3][3]==0)
b13.(false);
if(d[3][4]==0)
b14.(false);
if(d[3][5]==0)
b15.(false);
if(d[4][1]==0)
b16.(false);
if(d[4][2]==0)
b17.(false);
if(d[4][3]==0)
b18.(false);
if(d[4][4]==0)
b19.(false);
if(d[4][5]==0)
b20.(false);
if(d[5][1]==0)
b21.(false);
if(d[5][2]==0)
b22.(false);
if(d[5][3]==0)
b23.(false);
if(d[5][4]==0)
b24.(false);
if(d[5][5]==0)
b25.(false);
if(d[6][1]==0)
b26.(false);
if(d[6][2]==0)
b27.(false);
if(d[6][3]==0)
b28.(false);
if(d[6][4]==0)
b29.(false);
if(d[6][5]==0)
b30.(false);
}
public void wei(int w1,int w2,Button bz) //判断并纪录每次点击按钮的信息
{ //当两次的按钮相同才能消去
if((()).equals("no"))
{
s=();
x0=w1;
y0=w2;
n1=d[x0][y0];
b=bz;
x=w1;
y=w2;
n2=d[x][y];
ba=bz;
}
else
{
x0=x;
y0=y;
n1=d[x0][y0];
b=ba;
x=w1;
y=w2;
n2=d[x][y];
ba=bz;
if(n1==n2 && ba!=b)
{
xiao();
}
}
}
public void xiao() //这里是整个游戏最重要的部分，就是判断两个按钮在信息
{ //相同的情况下能不能消去。仔细分析，不一条条注释
int i=0, j=0,n=0,k=0;
if((x0==x &&(y0==y+1||y0==y-1)) || ((x0==x+1||x0==x-1)&&(y0==y))) //相邻的情况
{
ba.(false);
b.(false);
guli();
s="no";
d[x0][y0]=0;
d[x][y]=0;
}
else
{
for (j=0;j{
if (d[x0][j]==0)
{
if (y>j)
{
for (i=y-1;i>=j;i-- )
{
if (d[x][i]!=0)
{
k=0;
break;
}
else
{
k=1;
}
}
if (k==1)
{
if (y0>j)
{
for (i=y0-1;i>=j ;i-- )
{
if (d[x0][i]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
if (y0{
for (i=y0+1;i{
if (d[x0][i]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
}
}
if (y{
for (i=y+1;i{
if (d[x][i]!=0)
{
k=0;
break;
}
else
{
k=1;
}
}
if (k==1)
{
if (y0>j)
{
for (i=y0-1;i>=j ;i-- )
{
if (d[x0][i]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
if (y0{
for (i=y0+1;i{
if (d[x0][i]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
}
}
if (y==j )
{
if (y0>j)
{
for (i=y0-1;i>=j ;i-- )
{
if (d[x0][i]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
if (y0{
for (i=y0+1;i{
if (d[x0][i]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
}
}
if (k==2)
{ if (x0==x)
{
b.(false);
ba.(false);
guli();
s="no";
k=0;
d[x0][y0]=0;
d[x][y]=0;
}
if (x0{
for (n=x0;n{
if (d[n][j]!=0)
{
k=0;
break;
}
if(d[n][j]==0 && n==x-1)
{
b.(false);
ba.(false);
guli();
s="no";
k=0;
d[x0][y0]=0;
d[x][y]=0;
}
}
}
if (x0>x)
{
for (n=x0;n>=x+1 ;n-- )
{
if (d[n][j]!=0)
{
k=0;
break;
}
if(d[n][j]==0 && n==x+1)
{
b.(false);
ba.(false);
guli();
s="no";
k=0;
d[x0][y0]=0;
d[x][y]=0;
}
}
}
}
}
for (i=0;i{
if (d[i][y0]==0)
{
if (x>i)
{
for (j=x-1;j>=i ;j-- )
{
if (d[j][y]!=0)
{
k=0;
break;
}
else
{
k=1;
}
}
if (k==1)
{
if (x0>i)
{
for (j=x0-1;j>=i ;j-- )
{
if (d[j][y0]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
if (x0{
for (j=x0+1;j{
if (d[j][y0]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
}
}
if (x{
for (j=x+1;j{
if (d[j][y]!=0)
{
k=0;
break;
}
else
{
k=1;
}
}
if (k==1)
{
if (x0>i)
{
for (j=x0-1;j>=i ;j-- )
{
if (d[j][y0]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
if (x0{
for (j=x0+1;j{
if (d[j][y0]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
}
}
if (x==i)
{
if (x0>i)
{
for (j=x0-1;j>=i ;j-- )
{
if (d[j][y0]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
if (x0{
for (j=x0+1;j{
if (d[j][y0]!=0)
{
k=0;
break;
}
else
{
k=2;
}
}
}
}
}
if (k==2)
{
if (y0==y)
{
b.(false);
ba.(false);
guli();
s="no";
k=0;
d[x0][y0]=0;
d[x][y]=0;
}
if (y0{
for (n=y0;n{
if (d[i][n]!=0)
{
k=0;
break;
}
if(d[i][n]==0 && n==y-1)
{
b.(false);
ba.(false);
guli();
s="no";
k=0;
d[x0][y0]=0;
d[x][y]=0;
}
}
}
if (y0>y)
{
for (n=y0;n>=y+1 ;n--)
{
if (d[i][n]!=0)
{
k=0;
break;
}
if(d[i][n]==0 && n==y+1)
{
b.(false);
ba.(false);
guli();
s="no";
k=0;
d[x0][y0]=0;
d[x][y]=0;
}
}
}
}
}
}
}
}Java 编写贪吃蛇游戏的大体思路是什么？楼主没有看到蛇移动的本质，蛇虽然是分成很多块，但他们还是一个整体，每一块的移动都和上一块有关，所以不需要对每一块都进行判断。x0dx0a原理:x0dx0a把蛇身体的每一块看成一个对象（对象存储该块的坐标和相关信息），作为节点存储在线性链表中，再设置一个变量标志蛇的方向（通过按键可以改变）。一般人都是让每一个节点等于他指向的下一个节点，并让头节点改变位置来实现转弯和移动，这个算法复杂度太高（O(n))，实际上只要做两步操作，插入一个头节点，删除一个尾节点就可以了，新插入的头节点位置根据蛇当前的方向决定 用一个数组将蛇头的行径记录下来，然后第二段的下一个方格设置为蛇头走过的方格，这样子蛇走过的路径都是前一段走过的，*将跟着蛇头走了，比如x0dx0a蛇身的路径x0dx0a for(int i=-1;i>0;i--){x0dx0arows[i]=rows[i-1];//依次将蛇前面一段走过行的路段赋值给蛇的下一段x0dx0acols[i]=cols[i-1];//依次将蛇前面一段走过列的路段赋值给蛇的下一段x0dx0a}x0dx0afor(int i=1;i