java贪吃蛇游戏如何设计?java贪吃蛇游戏设计报告

贪吃蛇游戏绝对是很多朋友的童年记忆,几乎每个人都玩过这个游戏,现在我要告诉大家的是,学会java我们也可以设计出一个贪吃蛇游戏出来,那java贪吃蛇游戏如何设计?下面来我们就来给大家讲解一下。

第一步完成的功能:写一个界面

大家见到的贪吃蛇小游戏,界面肯定是少不了的。因此,第一步就是写一个小界面。

实现代码如下:

public class SnakeFrame extends Frame
{
    //方格的宽度和长度
    public static final int BLOCK_WIDTH = 15;
    public static final int BLOCK_HEIGHT = 15;
    //界面的方格的行数和列数
    public static final int ROW = 40;
    public static final int COL = 40;
    public static void main(String[] args)
    {
        new SnakeFrame()
            .launch();
    }
    public void launch()
    {
        this.setTitle("Snake");
        this.setSize(ROW * BLOCK_HEIGHT, COL * BLOCK_WIDTH);
        this.setLocation(300, 400);
        this.addWindowListener(new WindowAdapter()
        {
            @Override
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);
            }
        });
        this.setResizable(false);
        this.setVisible(true);
    }
}

第二步完成的功能:在界面上画成一格一格的

我们见过的贪吃蛇游戏,是有一个格子一个格子构成,然后蛇在这个里面运动。

重写paint方法,单元格就是横着画几条线竖着画几条线即可。

代码如下:

@Overridepublic void paint(Graphics g)
{
    Color c = g.getColor();
    g.setColor(Color.GRAY);
    /*
    * 将界面画成由ROW*COL的方格构成,两个for循环即可解决
    * */
    for (int i = 0; i < row; i++)
    {
        < p = "" >
            g.drawLine(0, i * BLOCK_HEIGHT, COL * BLOCK_WIDTH, i * BLOCK_HEIGHT);
    }
    for (int i = 0; i < col; i++)
    {
        < p = "" >
            g.drawLine(i * BLOCK_WIDTH, 0, i * BLOCK_WIDTH, ROW * BLOCK_HEIGHT);
    }
    g.setColor(c);
}

效果如下:

java贪吃蛇游戏如何设计?java贪吃蛇游戏设计报告.jpg

第三步完成的功能:建立另外的线程来控制重画

由于,蛇的运动就是改变蛇所在的位置,然后进行重画,就是我们所看到的运动。因此,在这里,我们单独用一个线程来控制重画。

1、新建一个MyPaintThread类,实现了Runnable接口

private class MyPaintThread implements Runnable
{
    @Override
    public void run()
    {
        //每隔50ms重画一次
        while (true)
        {
            repaint(); //会自动调用paint方法
            try
            {
                Thread.sleep(50);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
}

2、在SnakeFrame的launchFrame方法中添加代码:new Thread(new MyPaintThread()).start();即可。

完成功能:利用双缓冲来解决闪烁的问题

private Image offScreenImage = null;
/*
* 重写update方法
* */
@Override
public void update(Graphics g)
{
    if (offScreenImage == null)
    {
        offScreenImage = this.createImage(ROW * BLOCK_HEIGHT, COL * BLOCK_WIDTH);
    }
    Graphics offg = offScreenImage.getGraphics();
    //先将内容画在虚拟画布上
    paint(offg);
    //然后将虚拟画布上的内容一起画在画布上
    g.drawImage(offScreenImage, 0, 0, null);
}

第四步完成的功能:在界面上画一个蛇出来

贪吃蛇游戏中的蛇就是用一系列的点来表示,这里我们来模拟一个链表。链表上的每个元素代表一个节点。

首先,我们先新建一个Node类来表示构成蛇的节点,用面向对象的思想,发现,这个类应该有如下的属性和方法:

1、位置

2、大小,即长度、宽度

3、方向

4、构造方法

5、draw方法

Node类的代码如下:

public class Node
{
    private static final int BLOCK_WIDTH = SnakeFrame.BLOCK_WIDTH;
    private static final int BLOCK_HEIGHT = SnakeFrame.BLOCK_HEIGHT;
    /*
    * 每个节点的位置
    * */
    private int row;
    private int col;
    //方向
    private Direction dir;
    private Node pre;
    private Node next;
    public Node(int row, int col, Direction dir)
    {
        this.row = row;
        this.col = col;
        this.dir = dir;
    }
    public void draw(Graphics g)
    {
        Color c = g.getColor();
        g.setColor(Color.BLACK);
        g.fillRect(col * BLOCK_WIDTH, row * BLOCK_HEIGHT, BLOCK_WIDTH, BLOCK_HEIGHT);
        g.setColor(c);
    }
}

Direction是一个enum,具体如下:

public enum Direction
{
    L
    , U
    , R
    , D
}

而在Snake类中,用面向对象的思维,可以发现,Snake类中应该有如下的属性和方法

1、头结点

2、尾结点

3、构造函数

draw方法

具体代码如下:

public class Snake
{
    private Node head = null;
    private Node tail = null;
    private SnakeFrame sf;
    //初始化是蛇的位置
    private Node node = new Node(3, 4, Direction.D);
    private int size = 0;
    public Snake(SnakeFrame sf)
    {
        head = node;
        tail = node;
        size++;
        this.sf = sf;
    }
    public void draw(Graphics g)
    {
        if (head == null)
        {
            return;
        }
        for (Node node = head; node != null; node = node.next)
        {
            node.draw(g);
        }
    }
}

在SnakeFrame类中new一个Snake对象,然后调用Snake对象的draw方法即可。

效果如下:

1.jpg

第五步完成的功能:通过键盘控制蛇的上下左右移动

首先想到的是这样:在Snake类中添加一个keyPressed方法,然后在SnakeFrame的键盘事件中调用Snake对象的keyPressed方法。

注意:蛇的移动是通过在头部添加一个单元格,在尾部删除一个单元格这样的思想来实现。

具体如下:

Snake类中添加一个keyPressed方法,主要是根据键盘的上下左右键来确定蛇的头结点的方向,然后move方法再根据头结点的方向来在头部添加一个单元格。

public void keyPressed(KeyEvent e)
{
    int key = e.getKeyCode();
    switch (key)
    {
    case KeyEvent.VK_LEFT:
        if (head.dir != Direction.R)
        {
            head.dir = Direction.L;
        }
        break;
    case KeyEvent.VK_UP:
        if (head.dir != Direction.D)
        {
            head.dir = Direction.U;
        }
        break;
    case KeyEvent.VK_RIGHT:
        if (head.dir != Direction.L)
        {
            head.dir = Direction.R;
        }
        break;
    case KeyEvent.VK_DOWN:
        if (head.dir != Direction.U)
        {
            head.dir = Direction.D;
        }
        break;
    }
}
public void move()
{
    addNodeInHead();
    deleteNodeInTail();
}
private void deleteNodeInTail()
{
    Node node = tail.pre;
    tail = null;
    node.next = null;
    tail = node;
}
private void addNodeInHead()
{
    Node node = null;
    switch (head.dir)
    {
    case L:
        node = new Node(head.row, head.col - 1, head.dir);
        break;
    case U:
        node = new Node(head.row - 1, head.col, head.dir);
        break;
    case R:
        node = new Node(head.row, head.col + 1, head.dir);
        break;
    case D:
        node = new Node(head.row + 1, head.col, head.dir);
        break;
    }
    node.next = head;
    head.pre = node;
    head = node;
}
//最后,在draw中调用move方法即可
public void draw(Graphics g)
{
    if (head == null)
    {
        return;
    }
    move();
    for (Node node = head; node != null; node = node.next)
    {
        node.draw(g);
    }
}

这样就实现了通过键盘来实现蛇的移动。

完成的功能:蛇吃蛋

首先我们新建一个蛋Egg的类。

类的属性和方法有:

1、位置、大小

2、构造方法

3、draw方法

4、getRect方法:用于碰撞检测

5、reAppear方法:用于重新产生蛋的方法

代码如下:

public class Egg
{
    //所在的位置
    private int row;
    private int col;
    //大小
    private static final int BLOCK_WIDTH = SnakeFrame.BLOCK_WIDTH;
    private static final int BLOCK_HEIGHT = SnakeFrame.BLOCK_HEIGHT;
    private static final Random r = new Random();
    private Color color = Color.RED;
    public Egg(int row, int col)
    {
        this.row = row;
        this.col = col;
    }
    public Egg()
    {
        this((r.nextInt(SnakeFrame.ROW - 2)) + 2, (r.nextInt(SnakeFrame.COL - 2)) + 2);
    }
    /*
    * 改变当前对象的位置,即完成蛋的重现
    * */
    public void reAppear()
    {
        this.row = (r.nextInt(SnakeFrame.ROW - 2)) + 2;
        this.col = (r.nextInt(SnakeFrame.COL - 2)) + 2;
    }
    public void draw(Graphics g)
    {
        Color c = g.getColor();
        g.setColor(color);
        g.fillOval(col * BLOCK_WIDTH, row * BLOCK_HEIGHT, BLOCK_WIDTH, BLOCK_HEIGHT);
        g.setColor(c);
        //改变下一次的颜色
        if (color == Color.RED)
        {
            color = Color.BLUE;
        }
        else
        {
            color = Color.RED;
        }
    }
    //用于碰撞检测
    public Rectangle getRect()
    {
        return new Rectangle(col * BLOCK_WIDTH, row * BLOCK_HEIGHT, BLOCK_WIDTH, BLOCK_HEIGHT);
    }
}

蛇吃蛋,怎么样才能判断蛇吃到蛋了呢,这就需要用到碰撞检测了。

这里我们在Snake类中添加一个eatEgg方法。当蛇吃到蛋之后,就需要将蛇的长度+1,这里处理的是在蛇的头部添加一个节点,当蛋被吃掉之后,就需要再重新随机产生一个蛋。

代码如下:

public Rectangle getRect()
{
    return new Rectangle(head.col * BLOCK_WIDTH, head.row * BLOCK_HEIGHT, BLOCK_WIDTH, BLOCK_HEIGHT);
}
public boolean eatEgg(Egg egg)
{
    if (this.getRect()
        .intersects(egg.getRect()))
    {
        addNodeInHead();
        egg.reAppear();
        return true;
    }
    else
    {
        return false;
    }
}

以上就完成了蛇吃蛋的功能。

完成的功能:添加边界处理

在我们熟悉的贪吃蛇游戏中,我们一般都知道,当蛇撞到墙或者是撞到自己身体的某一部分,则游戏就结束。下面我们就来实现这一功能。

在Snake类中,添加checkDead方法

private void checkDead()
{
    //头结点的边界检查
    if (head.row < 2 || head.row > SnakeFrame.ROW || head.col < 0 || head.col > SnakeFrame.COL)
    {
        this.sf.gameOver();
    }
    //头结点与其它结点相撞也是死忙
    for (Node node = head.next; node != null; node = node.next)
    {
        if (head.row == node.row && head.col == node.col)
        {
            this.sf.gameOver();
        }
    }
}

如果蛇撞墙或是撞到自己本身的某一个部分。则调用SnakeFrame类中的gameOver()方法来进行一定的处理。

本游戏的处理方法为:通过设置一个boolean 变量,来停止游戏并提示相关信息。

具体代码如下:

private boolean b_gameOver = false;
public void gameOver()
{
    b_gameOver = true;
}
@Override
public void update(Graphics g)
{
    //其它代码省略
    if (b_gameOver)
    {
        g.drawString("游戏结束!!!", ROW / 2 * BLOCK_HEIGHT, COL / 2 * BLOCK_WIDTH);
    }
}

以上就完成了蛇是否撞墙或是撞到自身一部分的功能。

按照以上的方法去做基本实现了贪吃蛇的基本功能,如果你想做贪吃蛇游戏的话,也可以自己照着本文去设计哦!最后大家如果想要了解更多java实战知识,敬请关注奇Q工具网。

推荐阅读:

java程序员工资一般多少钱?java程序员如何做好职业规划?

有java为什么打不开jar文件?Java闪退怎么办?

java中继承的关键字是什么?java继承关键字讲解

推荐内容