java小游戏如何制作?五子棋游戏实例开发

阳光 2021-10-18 16:47:29 java常见问答 8796

Java是目前最受欢迎的开发语言,学会java就可以利用java开发网页、应用软件、小程序或者游戏等,那java小游戏如何制作?下面来我们就来给大家讲解一下java开发五子棋的方法。

一、功能分析

五子棋的实现还是较为简单的,通过下期的流程我们可以知道大概要实现一下功能:

1、格界面

2、点击下棋

3、悔棋

4、判断输赢

二、功能实现

根据之前的功能分析,要有网格先要有窗体,我们先重新写一个类,来继承JFrame类,以便在窗口变动的情况下,对窗口进行重绘(防止在窗口大小发生改变的时候,之前的绘画会消失),这里我们重写paint方法,画出网格线

public class MyFrame extends JFrame
{
    public void paint(Graphics g)
    {
        super.paint(g);
        //重画格子
        for (int i = 0; i < 700; i = i + 50)
        {
            g.drawLine(100, 100 + i, 750, 100 + i);
            g.drawLine(100 + i, 100, 100 + i, 750);
        }
    }

然后通过简单的设置窗口信息来把窗口实现,同时,在窗体内加好开始按钮和悔棋按钮,为窗体添加鼠标监听器和鼠标移动监听器,为按钮添加事件监听器,为下一步实现下棋晦气功能做准备。

public class Chess
{
    public static void main(String[] args)
    {
        Chess chess = new Chess();
        chess.ChessUI();
    }
    public void ChessUI()
    {
        MyFrame jf = new MyFrame();
        jf.setTitle("Chess");
        jf.setSize(900, 900);
        jf.setLocationRelativeTo(null);
        jf.setBackground(Color.WHITE);
        jf.setDefaultCloseOperation(3);
        FlowLayout border = new FlowLayout();
        jf.setLayout(border);
        Dimension dmb = new Dimension(80, 30);
        JButton startGame = new JButton("Start");
        startGame.setSize(dmb);
        jf.add(startGame);
        JButton retract = new JButton("Retract");
        retract.setSize(dmb);
        jf.add(retract);
        Buttonlistener bl = new Buttonlistener();
        jf.addMouseListener(bl);
        jf.addMouseMotionListener(bl);
        startGame.addActionListener(bl);
        retract.addActionListener(bl);
        jf.getContentPane()
            .setBackground(Color.WHITE);
        jf.setVisible(true);
        Graphics g = jf.getGraphics();
        bl.jf = jf;
        bl.g = g;
        // jf.count=bl.count;
        jf.counts = bl.counts;
        //传值与传址的区别
        jf.board = bl.board;
    }
}

接下来就是实现监听器,监听器里要做到下棋、悔棋、判断输赢。

下棋的实现是通过点击下棋按钮,开始新建一个与网格一样大小的数组,来存储棋局。在点击棋盘的时候获得鼠标位置,然后通过计算,算出离鼠标最近的网格交点坐标,通过记录之前的棋局来判断这个位置能否下棋,通过一个计数器将黑棋or白棋绘在交点上,计算是否有连续的5个同色棋子,弹出输赢框。

而悔棋则是在点击悔棋之后,获得当前计数器的状态,在记录棋局的矩阵中,找到上一次子的位置,然后对这个区域进行重绘(先用棋盘色覆盖棋子,再根据位置重画该区域的棋盘)

为了给用户更好的交互体验,我在这里加入了一个位置指示器。这个指示器的作用在于,在点击开始之后,随着鼠标的移动,可以在棋盘上显示如果在当前位置点击鼠标进行落字,将会落子的位置。这个功能可以通过鼠标移动监听器来实现,原理同对棋子的绘制,但是要注意的是,在鼠标移动到下一个落字区域的时候,要将之前的指示器用棋盘颜色覆盖掉。

public class Buttonlistener implements ActionListener, MouseListener, MouseMotionListener
{
    public Graphics g;
    public int[][] board = new int[14][14];
    public int count = 0;
    public int[] counts = new int[1];
    public String s = null;
    public JFrame jf;
    public void actionPerformed(ActionEvent e)
    {
        s = e.getActionCommand();
        if (s == "Start")
        {
            for (int i = 0; i < board.length; i++) p = ""
            {
                <= "" >
                for (int j = 0; j < board[i].length; j++) p = ""
                {
                    <= "" >
                    board[i][j] = -1;
                }
            }
        }
        if (s == "Retract")
        {
            System.out.print("haha");
            for (int m = 0; m < 14; m++)
            {
                for (int n = 0; n < 14; n++)
                    if (board[m][n] == count)
                    {
                        board[m][n] = -1;
                        count--;
                        counts[0] = count;
                        g.setColor(Color.white);
                        g.fillRect(m * 50 + 100 - 20, n * 50 + 100 - 20, 40, 40);
                        g.setColor(Color.black);
                        g.drawLine(m * 50 + 100 - 20, n * 50 + 100, m * 50 + 100 + 20, n * 50 + 100);
                        g.drawLine(m * 50 + 100, n * 50 + 100 - 20, m * 50 + 100, n * 50 + 100 + 20);
                        s = "Start";
                        break;
                    }
            }
        }
    }
    public void mouseClicked(MouseEvent e)
    {
        if (s == "Start")
        {
            int m = Math.round((e.getX() - 75) / 50);
            int n = Math.round((e.getY() - 75) / 50);
            if (board[m][n] == -1)
            {
                count++;
                counts[0] = count;
                board[m][n] = count;
                if (count % 2 == 1)
                {
                    g.setColor(Color.black);
                    g.fillOval(m * 50 + 85, n * 50 + 85, 30, 30);
                }
                if (count % 2 == 0)
                {
                    g.setColor(Color.black);
                    g.drawOval(m * 50 + 85, n * 50 + 85, 30, 30);
                    g.setColor(Color.white);
                    g.fillOval(m * 50 + 85, n * 50 + 85, 30, 30);
                }
                //判断输赢
                int chesscount = 1;
                for (int i = m; i < 13 && board[i + 1][n] % 2 == count % 2; i++)
                {
                    chesscount++;
                }
                for (int i = m; i > 0 && board[i - 1][n] % 2 == count % 2; i--)
                {
                    chesscount++;
                }
                if (chesscount == 5)
                {
                    //结束
                    win();
                }
                else
                {
                    chesscount = 1;
                    for (int i = n; i < 13 && board[m][i + 1] % 2 == count % 2; i++)
                    {
                        chesscount++;
                    }
                    for (int i = n; i > 0 && board[m][i - 1] % 2 == count % 2; i--)
                    {
                        chesscount++;
                    }
                    if (chesscount == 5)
                    {
                        win();
                    }
                    else
                    {
                        chesscount = 1;
                        for (int i = m, j = n; i < 13 && j < 13 && board[i + 1][j + 1] % 2 == count % 2; i++, j++)
                        {
                            chesscount++;
                        }
                        for (int i = m, j = n; i > 0 && j > 0 && board[i - 1][j - 1] % 2 == count % 2; i--, j--)
                        {
                            chesscount++;
                        }
                        if (chesscount == 5)
                        {
                            win();
                        }
                        else
                        {
                            chesscount = 1;
                            for (int i = m, j = n; i < 13 && j > 0 && board[i + 1][j - 1] % 2 == count % 2; i++, j--)
                            {
                                chesscount++;
                            }
                            for (int i = m, j = n; i > 0 && j < 13 && board[i - 1][j + 1] % 2 == count % 2; i--, j++)
                            {
                                chesscount++;
                            }
                            if (chesscount == 5)
                            {
                                win();
                            }
                        }
                    }
                }
            }
        }
    }
    public void win()
    {
        JFrame jf = new JFrame("游戏结束");
        jf.setSize(300, 100);
        jf.setLocationRelativeTo(null);
        jf.setDefaultCloseOperation(1);
        //流式布局管理器
        FlowLayout flow = new FlowLayout();
        jf.setLayout(flow);
        //字样提示
        JTextField jtf = new JTextField();
        if (count % 2 == 1)
        {
            jtf.setText("黑棋胜出");
        }
        else
        {
            jtf.setText("白棋胜出");
        }
        Dimension dm = new Dimension(60, 30);
        jtf.setSize(dm);
        jtf.setEditable(false);
        jf.add(jtf);
        jf.setVisible(true);
    }
    public void mousePressed(MouseEvent e)
    {}
    public void mouseReleased(MouseEvent e)
    {}
    public void mouseEntered(MouseEvent e)
    {}
    public void mouseExited(MouseEvent e)
    {}
    public void mouseDragged(MouseEvent e)
    {}
    public int m1, n1;
    public int m2 = 0, n2 = 0;
    public void mouseMoved(MouseEvent e)
    {
        m1 = Math.round((e.getX() - 75) / 50);
        n1 = Math.round((e.getY() - 75) / 50);
        if (s == null)
        {}
        if (s == "Start")
        {
            if ((m1 < 14 && m1 >= 0) && (n1 < 14 && n1 >= 0) && (board[m1][n1] == -1) && (m1 != m2 || n1 != n2))
            {
                g.setColor(Color.WHITE);
                g.drawLine(m2 * 50 + 100 - 10, n2 * 50 + 100 - 20, m2 * 50 + 100 - 20, n2 * 50 + 100 - 10);
                g.drawLine(m2 * 50 + 100 + 10, n2 * 50 + 100 + 20, m2 * 50 + 100 + 20, n2 * 50 + 100 + 10);
                g.drawLine(m2 * 50 + 100 + 20, n2 * 50 + 100 - 10, m2 * 50 + 100 + 10, n2 * 50 + 100 - 20);
                g.drawLine(m2 * 50 + 100 - 20, n2 * 50 + 100 + 10, m2 * 50 + 100 - 10, n2 * 50 + 100 + 20);
                m2 = m1;
                n2 = n1;
            }
            if ((m1 < 14 && m1 >= 0) && (n1 < 14 && n1 >= 0) && (board[m1][n1] == -1))
            {
                g.setColor(Color.red);
                g.drawLine(m1 * 50 + 100 - 10, n1 * 50 + 100 - 20, m1 * 50 + 100 - 20, n1 * 50 + 100 - 10);
                g.drawLine(m1 * 50 + 100 + 10, n1 * 50 + 100 + 20, m1 * 50 + 100 + 20, n1 * 50 + 100 + 10);
                g.drawLine(m1 * 50 + 100 + 20, n1 * 50 + 100 - 10, m1 * 50 + 100 + 10, n1 * 50 + 100 - 20);
                g.drawLine(m1 * 50 + 100 - 20, n1 * 50 + 100 + 10, m1 * 50 + 100 - 10, n1 * 50 + 100 + 20);
            }
        }
    }
}
}

在完成了这些之后,就可以和朋友下一盘五子棋了,但是如果朋友不小心拖动了窗口,棋局就不复存在了,所以我们要优化一下MyFrame类,通过将存储棋局的矩阵以及当前的计数器传入MyFrame类,可以在窗口变化的情况下依旧可以复现棋局。这里需要注意的是,传值与传址的区别。如果简单的将count传入MyFrame类,是不能实现将当前计数器传入的,因为count是一个int类型的数据,这种数据类型是基本数据类型是传值,而自定义类以及数组等,都是传址,所以再一次赋值之后,自定义数据类型会实时更新,而基本数据类型则不会再变。为了解决这个问题,我们将计数器放到一个数组内,通过地址传递传入MyFrame类的对象内,然后再从数组内取出技术去进行使用。

public class MyFrame extends JFrame
{
    public int[][] board = new int[14][14];
    public int count;
    public int[] counts = new int[1];
    public void paint(Graphics g)
    {
        count = counts[0];
        super.paint(g);
        //重画格子
        for (int i = 0; i < 700; i = i + 50)
        {
            g.drawLine(100, 100 + i, 750, 100 + i);
            g.drawLine(100 + i, 100, 100 + i, 750);
        }
        for (; count > 0; count--)
        {
            System.out.println("" + count);
            for (int m = 0; m < 14; m++)
            {
                for (int n = 0; n < 14; n++)
                    if (board[m][n] == count)
                    {
                        if (count % 2 == 1)
                        {
                            g.setColor(Color.black);
                            g.fillOval(m * 50 + 85, n * 50 + 85, 30, 30);
                        }
                        if (count % 2 == 0)
                        {
                            g.drawOval(m * 50 + 85, n * 50 + 85, 30, 30);
                            g.setColor(Color.white);
                            g.fillOval(m * 50 + 85, n * 50 + 85, 30, 30);
                        }
                    }
            }
        }
    }
}

按照这些步骤,一个好玩有趣的五子棋小游戏就制作完成了,这就是java的神奇之处,学会java,我们还可以制作其他一些小游戏哦!最后大家如果想要了解更多java实战知识,敬请关注奇Q工具网。

推荐阅读:

java怎么做图形界面画图?Java简易画图板实现

java用什么开发?Java常用的开发工具

java安装程序打不开怎么办?Java安装要注意哪些?