贪吃蛇

贪吃蛇

Cell 是数据格子，是数据结构
Worm 是核心数据和算法的封装，包括爬行，碰撞，吃食物等
TestCase 是核心业务数据的测试案例，必须严格实现通过
Wormstage  1 是蛇的绘制面板，还充当了软件流程控制器的
作用：控制定时任务处理，和键盘输入流程控制creepTo（）！
Jframe 只是窗口容器。将Wormstage 显示出来。

结构图

1、Cell.java

package com.feike.worm;
/** 一个单元格子 */
public class Cell {
private int x;
private int y;
public Cell() {
}
public Cell(int x, int y) {
super();
this.x = x;
this.y = y;
}
public String toString() {
return "["+x+","+y+"]";
}

public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}

}

2、Worm.java

package com.feike.worm;

import java.util.Arrays;

/** 贪吃蛇 */
public class Worm {
public static final int DEFAULL_LENGTH = 12;
private Cell[] cells;

public static final int UP = 1;
public static final int DOWN = -1;
public static final int LEFT = 2;
public static final int RIGHT = -2;
/** 蛇当前的运行方向 */
private int currentDirection;
public Worm() {
cells = new Cell[DEFAULL_LENGTH];
for(int i=0;i<cells.length;i++){
cells[i] = new Cell(i,0);//[0,0][1,0][2,0][3,0]...
}
/**给蛇一个默认的爬行方向 */
currentDirection = DOWN;
}
public boolean contains(int x,int y){
for(int i= 0;i<cells.length;i++){
Cell node = cells[i];
if(node.getX()==x && node.getY()==y){
return true;
}
}
return false;
}
/**
* 1)计算currentDirection与direction的和，
*   如果是0表示方向了，就结束方法返回，不进行任何动作
* 2）currentDirection = Direction 改变当前方向，
*   作为下次运行的方向
* 3）判断当前头节点的坐标和食物对象的坐标一致
*   如果一致说明吃到食物了
* 4）如果吃到食物，就将cells数组进行扩容
*   将cells数组内容的每个元素向后移动。
* 5）将新头节点插入的头位置cells[0] = newHead
* 6）返回是否吃到食物
*/
public boolean creep(int direction,Cell food){
if(currentDirection + direction ==0){
return false;//反向了，不进行任何动作
}
currentDirection = direction;
Cell head = createHead(direction);
/*
boolean eat = false;
if(head.getX()==food.getX() &&
head.getY()==food.getY()){
eat = true;
}*/
boolean eat = head.getX()==food.getX() &&
head.getY()==food.getY();
if(eat){
//如果吃了 就扩容
cells = Arrays.copyOf(cells, cells.length+1);
}
for(int i=cells.length-1;i>=1;i--){
cells[i] = cells[i-1];
}
cells[0] = head;
return eat;
}
/** 重载一下方便使用 看当前方向*/
public boolean creep(Cell food){
return creep(currentDirection,food);
}
/** 爬 */
public void creep(){
for(int i=cells.length-1;i>=1;i--){
cells[i] = cells[i-1];
}
cells[0] = createHead(currentDirection);
}
/** 看当前方向是否会碰撞*/
public boolean hit(){
return hit(currentDirection);
}
/** 检查是否撞墙或撞到自己*/
public boolean hit(int direction){
System.out.println("方向(2)： "+direction);//检查方向
Cell head = createHead(direction);
System.out.println(head);//检查头坐标位置
if(currentDirection + direction ==0){
return false;//反向了，不进行任何动作
}
if(head.getX()<0 || head.getX()>=WormStage.COLS ||
head.getY()<0 || head.getY()>WormStage.ROWS){
//if(true)这撞在墙上了，返回true
return true;
}
for(int i=0;i<cells.length-1;i++){
Cell node = cells[i];
if(node.getX()==head.getX() &&
node.getY()==head.getY()){
return true;
}
}
return false;
}
/** 头节点的移动*/
private Cell createHead(int direction){
int x = cells[0].getX();
int y = cells[0].getY();
switch (direction) {
case DOWN: y++; break;
case UP: y--; break;
case LEFT: x--; break;
case RIGHT: x++; break;
}
return new Cell(x,y);
}
/** Worm.java */
public Cell[] getCells(){
// return cells;
//下面这专业点
return Arrays.copyOf(cells, cells.length);
}
public String toString() {
return Arrays.toString(cells);
}
}

3、WormStage.java

package com.feike.worm;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.security.PublicKey;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.LineBorder;

public class WormStage extends JPanel{
/** 行数*/
public static final int ROWS = 35;
/** 列数*/
public static final int COLS = 35;
/** 格子大小 10个像素大小*/
public static final int CELL_SIZE = 10;
private Worm worm;
private Cell food;
public WormStage() {
worm = new Worm();
food = createFood();
}
/** 生成一个食物
* 1 生成随机数x,y
* 2 检查蛇是否包含x,y
*      2.1 如果包含  返回 1
* 3 创建食物节点。
*  */
private Cell createFood(){
int x;
int y;
Random r = new Random();
do{
x = r.nextInt(COLS);
y = r.nextInt(ROWS);
}while(worm.contains(x,y));
return new Cell(x,y);
}
public String toString(){
return "worm:"+worm+"\nfood:"+food;
}
/** 重写绘图方法*/
public void paint(Graphics g){
//填充背景色
g.setColor(Color.DARK_GRAY);
g.fillRect(0, 0, getWidth(), getHeight());
//绘制食物
g.setColor(Color.RED);
g.fill3DRect(CELL_SIZE*food.getX(),
CELL_SIZE*food.getY(), CELL_SIZE, CELL_SIZE, true);
//绘制蛇
g.setColor(Color.GREEN);
Cell[] cells = worm.getCells();
for(int i=0;i<cells.length;i++){
Cell node = cells[i];
g.fill3DRect(CELL_SIZE*node.getX(),
CELL_SIZE*node.getY(), CELL_SIZE, CELL_SIZE, true);
}
}

public static void main(String[] args) {
//启动软件  WormStage.java
JFrame frame = new JFrame("贪吃蛇");
WormStage pane = new WormStage();
frame.setLayout(null);// 取消窗口的默认布局，取消自动充满
frame.add(pane);// 窗口添加面板
pane.setSize(CELL_SIZE*COLS, CELL_SIZE*ROWS);//面板大小
pane.setLocation(50, 50);//面板位置
frame.setSize(450, 480);//设置窗口的大小
pane.setBorder(new LineBorder(Color.black));//添加边框
frame.setLocationRelativeTo(null);//frame居中
frame.setVisible(true);//显示窗口
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pane.action();//启动蛇的运行
}
/**行为 */
private void action(){
/* worm.creep(food);
swing JPanel 中声明的方法，会尽快的启动重绘功能，
尽快调用paint（g）方法绘制界面
repaint();*/
Timer timer = new Timer();
timer.schedule(new TimerTask(){
public void run(){
//爬行控制逻辑
if(worm.hit()){
worm = new Worm();
food = createFood();
}else{
boolean eat = worm.creep(food);
if(eat){
food = createFood();
}
}
worm.creep(food);
repaint();
}
}, 0,1000/7);
//this 就是当前舞台面板
this.requestFocus();//获得焦点
this.addKeyListener(new KeyAdapter(){
public void keyPressed(KeyEvent e){
//key 代表哪个按键被按下！
int key = e.getKeyCode();
switch (key) {
case KeyEvent.VK_UP: //上箭头按下
creepTo(Worm.UP);
break;
case KeyEvent.VK_DOWN: //下箭头按下
creepTo(Worm.DOWN);
break;
case KeyEvent.VK_LEFT: //左箭头按下
creepTo(Worm.LEFT);
break;
case KeyEvent.VK_RIGHT: //右箭头按下
creepTo(Worm.RIGHT);
break;
}
}
});//addKeyListener
}//action()
/** 爬行控制方法，在按键按下时调用*/
private void creepTo(int direction){
if(worm.hit(direction)){
worm = new Worm();
food = createFood();
}else {
boolean eat = worm.creep(direction,food);
if(eat){
food = createFood();
}
}
repaint();
}
}//wormStage

下面代码是用作测试用的

1、TestCase.java

package com.feike.test;
import org.junit.Test;

import com.feike.worm.*;

/**
* test 测试
* test 案例
*
*/
public class TestCase {
@Test //来自JUnit的注释标记，用于执行测试方法
public void testWormInit(){
System.out.println("测试Worm构造器");
Worm worm = new Worm();
System.out.println(worm);
}
@Test
public void testWormContains(){
System.out.println("测试Worm包含算法");
Worm worm = new Worm();
System.out.println(worm.contains(2, 0));//true
System.out.println(worm.contains(5, 6));//false
}
@Test
public void testWormStage(){
System.out.println("创建舞台实例");
WormStage stage = new WormStage();
System.out.println(stage);
}
@Test
public void testCreep(){
System.out.println("爬行测试");
Worm worm = new  Worm();
System.out.println(worm);
worm.creep();
System.out.println(worm);
}
@Test
public void testCreepForFood(){
System.out.println("检查食物的爬行");
Worm worm = new Worm();
Cell food = new Cell(1,2);
System.out.println(worm.creep(Worm.DOWN, food));
System.out.println(worm);
System.out.println(worm.creep(Worm.DOWN, food));
System.out.println(worm);
System.out.println(worm.creep(Worm.RIGHT, food));
System.out.println(worm);
}
@Test
public void testHit(){
System.out.println("碰撞测试");
Worm worm = new Worm();
Cell food = new Cell(10,10);
System.out.println(worm);
System.out.println(worm.creep(Worm.DOWN, food));
System.out.println(worm);
System.out.println(worm.creep(Worm.DOWN, food));
System.out.println(worm);
System.out.println(worm.hit(Worm.LEFT));//true
System.out.println(worm.hit(Worm.RIGHT));//false
System.out.println(worm.creep(Worm.RIGHT, food));
System.out.println(worm);
System.out.println(worm.creep(Worm.RIGHT, food));
System.out.println(worm);
System.out.println(worm.creep(Worm.UP, food));
System.out.println(worm);
System.out.println(worm.hit(Worm.UP));//true

}
}

2、Test.java

package com.feike.test;

import com.feike.worm.Worm;
/**
* 测试默认创建的贪吃蛇对象
*
*/
public class Test {
public static void main(String[] args) {
Worm worm = new Worm();
System.out.println(worm);
}
}

3、JFrameDemo.java

package com.feike.test;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;// Frame 相框，框架
import javax.swing.JPanel;// panel 面板
import javax.swing.border.LineBorder;

/** 显示窗口 与 绘图 */
public class JFrameDemo {
public static void main(String[] args) {

JFrame frame = new JFrame("窗口");
Stage pane = new Stage();
frame.setLayout(null);// 取消窗口的默认布局，取消自动充满
frame.add(pane);// 窗口添加面板
pane.setSize(10 * 35, 10 * 35);//面板大小
pane.setLocation(50, 50);//面板位置
frame.setSize(450, 480);//设置窗口的大小
pane.setBorder(new LineBorder(Color.black));//添加边框
frame.setLocationRelativeTo(null);//frame居中
frame.setVisible(true);//显示窗口
//在Swing中如下代码可以实现对键盘事件的监听，
//也就是获得到底那个键盘按键被按下了
pane.requestFocus();//使pane获取输入“焦点”,
//也就是使pane变成键盘输入的目标
//pane.addKeyListener(new KeyListener(){
//继承KeyAdapter比实现KeyListener 更加简洁。
//在pane上添加键盘事件的监听，获得到底哪个按键被按下
pane.addKeyListener(new KeyAdapter(){
//在按键按下的时候执行的方法
public void keyPressed(KeyEvent e) {
System.out.println("hi"+e.getKeyCode());
}
/*//在按键释放的时候执行
public void keyReleased(KeyEvent e) {
}
public void keyTyped(KeyEvent e) {
}*/
});
}
}
class Stage extends JPanel{
/** 重写了 默认的绘图方法*/
public void paint(Graphics g){//paint
g.setColor(Color.darkGray);//深灰色
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(Color.RED);
g.fill3DRect(50, 50, 30, 20, true);
}
}