【Java语言基础】控制台实现贪吃蛇小游戏

一、实现效果

二、题目要求

三、项目结构

四、节点信息 Node.java

package sakeGame;

//节点信息
public class Node {
    private int i;
    private int j;

    public Node(){}

    public Node(int i, int j) {
        this.i = i;
        this.j = j;
    }

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    public int getJ() {
        return j;
    }

    public void setJ(int j) {
        this.j = j;
    }


//    用到了HashSet，重新hashCode和equals方法
    public int hashCode()
    {
        return i*8+j*96;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Node node = (Node) o;
        return i == node.i &&
                j == node.j;
    }
}

五、贪吃蛇主体 WormPanel.java

package sakeGame;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Random;


//蛇游戏面板，游戏主体
class WormPanel {
    private Worm worm;  //  内部类定义一条蛇
    private int rows = 10;    //行
    private int cols = 32;   //列


    private HashSet<Node> foods = new HashSet<>();  //节点类型的食物


    public WormPanel()
    {
        //生成蛇
        worm = new Worm();
//        生成食物
        getFoods(40

        );
    }

    public Worm getWorm() {
        return worm;
    }

    //打印游戏面板
    public void showPanel()
    {
        for (int i=0; i<rows; i++)
        {
            for (int j=0; j<cols; j++)
            {

                //当坐标为第0行或者第rows-1时，打印“-”
                if (i == 0 || i == rows-1)
                {
                    System.out.print("-");
                }
                //当坐标为第0列或者第cols-1时，打印“|”
                else if(j == 0 || j == cols-1)
                {
                    System.out.print("|");
                }
                //打印蛇
                else if(worm.isContains(i, j))
                {
//                    如果位置<i,j>存在于蛇结点链表中，则应该打印出#
                    System.out.print("#");
                }
                //打印食物
//                boolean contains(Object o) 如果此集合包含指定的元素，则返回 true
                else if(foods.contains(new Node(i, j)))
                {
                    System.out.print("O");
                }
                //其他位置打印空白即可
                else
                    System.out.print(" ");
            }
            System.out.println();
        }
    }


    //随机生成食物,num表示生成食物的数量
    public void getFoods(int foodNum)
    {
        Random random = new Random();

        while (true)
        {
            //生成行坐标，第0行和第0列不能使用
            //最后一行和最后一列不能使用
            int i=random.nextInt(rows-2)+1;
            int j=random.nextInt(cols-2)+1;

//            每次将生成的<i,j>位置信息进行判断，若该位置在蛇结点中
//            则应当重新生成
            if(worm.isContains(i,j))
                   continue;
//            将食物添加进HashSet中，并且不会重复添加
            foods.add(new Node(i, j));

//            当食物数量添加到foodNum时添加食物完毕
            if(foods.size() == foodNum)
                break;
        }

    }


    //生成蛇
    public class Worm
    {

        //使用UP、DOWN、LEFT、RIGHT控制是向哪个方向移动
        public static final int UP = -10;
        public static final int DOWN = 10;
        public static final int LEFT = -1;
        public static final int RIGHT = 1;

//        使用链表存储蛇节点位置信息
        private LinkedList<Node> nodes = new LinkedList<>();
//        定义方向
        private int direction;

//        该方法用用于初始化蛇的结点信息和方向
        public Worm()
        {
            nodes.add(new Node(3,9));
            nodes.add(new Node(4,9));
            nodes.add(new Node(5,9));
            nodes.add(new Node(5,10));
            nodes.add(new Node(5,11));
            nodes.add(new Node(6,11));
//            初始化方向是往右走
            this.direction = RIGHT;
        }

//        该方法用于生成蛇头下一个前进的位置，遇到食物应当将食物移除
        public void step()
        {
            if(foods.size() == 0) {
                System.out.println("恭喜你赢了！");
                System.exit(0);
            }
//            得到第一个#号的坐标
            Node head = nodes.getFirst();
            int i = head.getI() + direction/10;
            int j = head.getJ() + direction%10;

            if (i<=0 || i>=rows-1 || j<=0 || j>= cols-1)
                throw new RuntimeException("哎呀，你这么这么不小心，你撞墙了！");

//            将计算得到的蛇头位置添加到节点
            head = new Node(i,j);

//            这个计算得到的新结点应该不能再蛇链表中
            for (Node node : nodes)
            {
                if (node.equals(head))
                    throw new RuntimeException("bang，你把自己吃了！");
            }


            nodes.addFirst(head);

//            每次向前走一步就要移除最后一个元素
            nodes.removeLast();

//            判断是否遇到了食物  boolean remove(Object o) 如果存在，则从该集合中删除指定的元素
//            并且蛇应该长度+1
            if(foods.remove(new Node(i, j)))
            {
                Node rail = new Node(i, j);
//                元素加到最后面
                nodes.addLast(rail);
            }
        }

        public void step(int direction)
        {
            if(this.direction + direction == 0)
            {
                throw  new RuntimeException("憨批，不能掉头！");
            }
            this.direction = direction;
            step();
        }

//        用于判断是否包含某个坐标
        public boolean isContains(int i, int j)
        {
//            判断位值<i,j>是否存在于节点中
            return nodes.contains(new Node(i,j));
        }
    }
}

六、贪吃蛇控制面板 WormDemo.java

package sakeGame;

import java.util.Scanner;

public class WormDemo {
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        WormPanel wormPanel = new WormPanel();
//        获取蛇对象
        WormPanel.Worm worm = wormPanel.getWorm();


        while (true)
        {
            wormPanel.showPanel();

            System.out.println("W:向上移动\tS:向下移动");
            System.out.println("A:向左移动\tD:向右移动");
            String dir = sc.nextLine();
            if("w".equalsIgnoreCase(dir))
                worm.step(WormPanel.Worm.UP);
            else if("s".equalsIgnoreCase(dir))
                worm.step(WormPanel.Worm.DOWN);
            else if("a".equalsIgnoreCase(dir))
                worm.step(WormPanel.Worm.LEFT);
            else if("d".equalsIgnoreCase(dir))
                worm.step(WormPanel.Worm.RIGHT);
            else if("q".equalsIgnoreCase(dir)) {
                System.out.println("Game over");
                break;
            }
            else
                worm.step();

        }
    }
}