这周我们写java项目，老师规定了要写养成类或者升级类小游戏

我写的题目是魔塔，但是内容已经偏离了魔塔（哭笑不得），不要在意这些小细节（尴尬），有什么问题欢迎评论（写的不完整所以请见谅啦）
第一步先理清思路，分析出需要哪些类，这些有哪些属性

人物类：昵称，等级，生命力，攻击力，防御力，获得的金币、经验

怪物类：名称，生命力，攻击力

装备类：名称，等级，攻击力，防御力

大概就这三个父类，至于子类就不一一概述了
第二步搭好框架，创建出你所需要的类



第三步就可以开始写代码了
代码有点多就语言描述了

游戏开始后输入昵称，角色封装成一个父类之后需要在主类中new出对象，分别给对象赋上初值。这是一个练级的游戏所以需要副本，需要刷怪，刷了怪之后有金币和经验，说到金币就得有商店，可以买可以卖。副本里怪物死亡时，除了有金币经验还得要掉装备。装备需要有装备父类，装备父类new出一个对象，一个对象代表一个装备，这个对象里要有装备的属性。。。。。。
public class Game {
	public static  HashMap<Integer, String> proplist =  new HashMap<Integer, String>();
	final int lvmax = 86;//等级上限
	static int lv = 1;
	static int blood ;//血量上限
	static int expmax = 100;
	static Scanner input = new Scanner(System.in);
	static int type;
	static Property weapon = new PropertyEqu();
	static Property armor = new Armorlist();
	public static Role role = new Role();
	public static Monster monsterPeo = new MonsterPeo();
	static Npc npc1 = new Sailiya();
	public void  menu() {
		System.out.println("***************");
		System.out.println("欢迎来到魔塔！！");
		System.out.println("***************");
		System.out.println("1、开始新游戏");
		System.out.println("2、游戏说明");
		System.out.println("3、读取存档");
		System.out.println("4、退出游戏");
		System.out.println("请输入编号：");
		 type = input.nextInt();
		 switch (type) {
			case 1:
				start();
				break;
			case 2:
				background();
				break;
			case 3:
				break;
			case 4:
				System.out.println("欢迎下次再来！");
				break;
			default:
				System.out.println("请输入正确的编号！！");
				ret();
				break;
			}
}

效果图：







有点多所以就不全部贴出来了。。。。

经过这次写java项目，让我对java更加熟悉了，对面向对象有了更深层次的了解。所以在学习的过程中，最好不是仅仅停留在java表层，不是抄书上的例子运行出结果就可以。要注意，即便对一个简单的例子也要有耐心去琢磨、调试、改动。


给大家分享本人收集整理的16款Java小游戏源码，大部分是applet小程序，下面把每个游戏做个截图，最下面会有下载地址：
目录结构：





下载地址：http://programmer.ischoolbar.com/index.php/article/article/id/78.html

猜生日 Java小游戏
最近看到一个很有趣的小游戏：
询问朋友5个问题，找到他出生在一个月的哪一天。每个问题都是询问他的生日是否是5个数字集合中的一个。
这5个集合分别是：
set1：1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31
set2：2 3 6 7 10 11 14 15 18 19 22 23  26 27 30 31
set3：4 5 6 7 12 13 14 15 20 21 22 23  28 29 30 31
set4：8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31
set5：16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
生日是出现这一天的每个集合的第一个数字之和，例如生日是19，那么它会出现在集合1、2和5中，三个集合的第一个数字分别是1、2和16，它们的和就是19。

用Java实现就是：
package 贪心;
/*
作者     :XiangLin
创建时间 :2020/9/21 10:53
文件     :GussBirthday.java
IDE      :IntelliJ IDEA
*/

import java.util.Scanner;

public class GussBirthday {
    public static void main(String[] args) {
        String set1 =
                "1 3 5 7\n" +
                "9 11 13 15\n" +
                "17 19 21 23\n" +
                "25 27 29 31";

        String set2 =
                "2 3 6 7\n" +
                "10 11 14 15\n" +
                "18 19 22 23\n" +
                "26 27 30 31";

        String set3 =
                " 4  5  6  7" +
                 "\n 12 13 14 15" +
                 "\n 20 21 22 23" +
                 "\n 28 29 30 31";

        String set4 =
                " 8  9 10 11" +
                "\n 12 13 14 15" +
                "\n 24 25 26 27" +
                 "\n 28 29 30 31";

        String set5 =
                " 16 17 18 19" +
                "\n 20 21 22 23" +
                "\n 24 25 26 27" +
                "\n 28 29 230 31";

        int  day = 0;

        // Create Scanner
        Scanner input = new Scanner(System.in);

        // Prompt the user to answer questions
        System.out.println("Is your birthday in Set1?\n");
        System.out.println(set1);
        System.out.println("\nEnter 0 for No and 1 for Yes: ");
        int answer = input.nextInt();

        if (answer == 1)
            day += 1;

        // Prompt the user to answer questions
        System.out.println("Is your birthday in Set2?\n");
        System.out.println(set2);
        System.out.println("\nEnter 0 for No and 1 for Yes: ");
        answer = input.nextInt();

        if (answer == 1)
             day += 2;

        // Prompt the user to answer questions
        System.out.println("Is your birthday in Set3?\n");
        System.out.println(set3);
        System.out.println("\nEnter 0 for No and 1 for Yes: ");
        answer = input.nextInt();

        if (answer == 1)
            day += 4;

        // Prompt the user to answer questions
        System.out.println("Is your birthday in Set4?\n");
        System.out.println(set4);
        System.out.println("\nEnter 0 for No and 1 for Yes: ");
        answer = input.nextInt();

        if (answer == 1)
             day += 8;

        // Prompt the user to answer questions
        System.out.println("Is your birthday in Set5?\n");
        System.out.println(set5);
        System.out.println("\nEnter 0 for No and 1 for Yes: ");
        answer = input.nextInt();

        if (answer == 1)
            day += 16;

        System.out.println("\nYour birthday is " + day + "!");

    }
}

输出：
Is your birthday in Set1?

1 3 5 7
9 11 13 15
17 19 21 23
25 27 29 31

Enter 0 for No and 1 for Yes: 
1
Is your birthday in Set2?

2 3 6 7
10 11 14 15
18 19 22 23
26 27 30 31

Enter 0 for No and 1 for Yes: 
1
Is your birthday in Set3?

 4  5  6  7
 12 13 14 15
 20 21 22 23
 28 29 30 31

Enter 0 for No and 1 for Yes: 
0
Is your birthday in Set4?

 8  9 10 11
 12 13 14 15
 24 25 26 27
 28 29 30 31

Enter 0 for No and 1 for Yes: 
0
Is your birthday in Set5?

 16 17 18 19
 20 21 22 23
 24 25 26 27
 28 29 230 31

Enter 0 for No and 1 for Yes: 
1

Your birthday is 19!

这个游戏是很容易编程的。你可能很好奇想知道如何创建这个游戏。实际上，这个游戏背后的数学
知识是非常简单的。这些数字不是随意组成一组的。它们放在五个集合中的方式是经过深思熟虑的。这五个集合的第一个数分别是1、2、4、8和16，它们分别对应二进制数的1、10、100、1000和10000。从1到31的十进制数最多用五个二进制数就可以表示，如图3-2a所示。假设它是b5b4b3b2b1，那么
b5b4b3b2b1=b50000 + b4000 + b300 + b20+b1，如图所示。如果某天的二进制数在b位为整数1，那么该数就该出现在Setk中。例如:数字19的二进制是10011，所以它就该出现在集合1、集合2和集合5中。它就是二进制数1+10+10000=10011或者十进制数1+2+16=19。数字31的二进制是11111，所以它就会出现在集合1,集合2、集合3、集合4和集合5中。它就是二进制数1+10+100+1000+10000=11111，或是十进制数1+2+4+8+16=31。

几百本常用电子书免费领取：https://github.com/XiangLinPro/IT_book

《Java小游戏实现》：贪吃蛇

在完成坦克大战之后，就想到了贪吃蛇这个小游戏，因为这两个游戏太像了，因此，就决定把这个游戏来尝试的写下。接下来的几篇博文就是来记录这个小游戏实现的全过程。

突然，想起，一年前(时间是2015年7月3日)，我刚学习Java的时候看过别人写的这个游戏源代码，还专门写了篇博文，连接如下：http://blog.csdn.net/u010412719/article/details/46746343

确实好巧，今天我自己就从零开始来完成这个小游戏，完成的方式也是一步一步的添加功能这样的方式来实现。



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

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

实现代码如下：

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方法，单元格就是横着画几条线竖着画几条线即可。

代码如下：

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

    g.setColor(c);
}


效果如下：





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

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

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、构造函数

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方法即可。

效果如下：



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

首先想到的是这样：在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);
        }

    }

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

小结

以上基本上实现了贪吃蛇的基本功能。剩下的一些功能不再介绍，例如：添加得分记录、通过键盘某按键来控制游戏的停止、重新开始、再来一局等。

以上的功能虽然没有介绍，但是在代码中，我有实现这些相应的功能。

完整代码可以在这里获取：https://github.com/wojiushimogui/Snake