Java实现“简单的”五子棋游戏（二维数组）

已于 2023-07-13 08:35:04 修改
阅读量190 收藏 1
点赞数 1
文章标签： java 游戏
于 2023-07-12 21:05:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77514110/article/details/131689871
版权
一.游戏分析
//五子棋游戏必备元素
static String white = "○";
static String black = "●";
static String[][] qp = new String[15][15];//棋盘
static String[] num = {"⒈", "⒉", "⒊", "⒋", "⒌", "⒍", "⒎", "⒏", "⒐", "⒑", "⒒", "⒓", "⒔", "⒕", "⒖"};
static String line = "十";

 1.将所有必要元素搞到棋盘中去

如图所示：

 代码实现：

//初始化棋盘
public static void init() {
    for (int i = 0; i < qp.length; i++) {
        for (int j = 0; j < qp[i].length; j++) {
            qp[i][j] = line; //将"十"放进去
            if (j == qp[i].length - 1) {
                qp[i][j] = num[i]; /*将{"⒈", "⒉", "⒊", "⒋", "⒌", "⒍",
                                         "⒎", "⒏","⒐", "⒑", "⒒", "⒓",
                                         "⒔", "⒕", "⒖"}，放进去*/
            }
            if (i == qp.length - 1) {
                qp[i][j] = num[j];/*将{"⒈", "⒉", "⒊", "⒋", "⒌", "⒍",
                                       "⒎", "⒏", "⒐", "⒑", "⒒", "⒓", 
                                       "⒔", "⒕", "⒖"}，放进去*/
            }
            System.out.print(qp[i][j] + " "); //遍历数组
        }
        System.out.println(); //换行
    }
}

2.打印棋盘

//打印棋盘
public static void print() {
    for (int i = 0; i < qp.length; i++) {
        for (int j = 0; j < qp[i].length; j++) {
            System.out.print(qp[i][j] + " ");
        }
        System.out.println();
    }
}

3.判断下的棋子是否越界

//判断是否越界，是否重复
public static boolean check(int x, int y) {
    if (x < 0 || y < 0 || y > 14 || x > 14) { // c超过棋盘边界及判定为越界
        return false;
    }
    if (!qp[x][y].equals(line)) { //如果输入的棋子坐标对应的地方不是"十"，即为重复
        return false;
    }
    return true;
}

4.判断输赢

        说明：从上，下，左，右，右斜向上，右斜向下，左斜向上，左斜向下这八个方向判断；

                   如果出现有五个连续的同一方的棋子（使用记数的方法，出现一个连续的就加一），                       即获胜。代码实现：

  private static boolean Iswin(int x, int y, String qizi) {

        /*
        水平查找
         */
        //水平向右查找
        int risum = 1;
        for (int righty = y - 1; righty >= 0; righty--) {
            if (qp[x][righty].equals(qizi)) {
                risum++;
            } else {
                break;
            }
        }
        if (risum >= 5) {
            return true;
        }
        //水平向左查找
        int lesum = 1;
        for (int lefty = y + 1; lefty <= 14; lefty++) {
            if (qp[x][lefty].equals(qizi)) {
                lesum++;
            } else {
                break;
            }
        }
        if (lesum >= 5) {
            return true;
        }

        /*
        竖直查找
         */
        //向上查找
        int upsum = 1;
        for (int upx = x + 1; upx <= 14; upx++) {
            if (qp[upx][y].equals(qizi)) {
                upsum++;
            } else {
                break;
            }
        }
        if (upsum >= 5) {
            return true;
        }
        //向下查找
        int dosum = 1;
        for (int dox = x - 1; dox >= 0; dox--) {
            if (qp[dox][y].equals(qizi)) {
                dosum++;
            } else {
                break;
            }
        }
        if (dosum >= 5) {
            return true;
        }
        /*
        对角线查找
         */
        //右斜向下查找
        int xridosum = 1;
        for (int xridox = x + 1, xridoy = y + 1; xridox <= 14 && xridoy <= 14; xridox++, xridoy++) {
            if (qp[xridox][xridoy].equals(qizi)) {
                xridosum++;
            } else {
                break;
            }
        }
        if (xridosum >= 5) {
            return true;
        }
        //右斜向上查找
        int xriupsum = 1;
        for (int xriupx = x + 1, xriupy = y - 1; xriupx <= 14 && xriupy >= 0; xriupx++, xriupy--) {
            if (qp[xriupx][xriupy].equals(qizi)) {
                xriupsum++;
            } else {
                break;
            }
        }
        if (xriupsum >= 5) {
            return true;
        }
        //左斜向下查找
        int xledosum = 1;
        for (int xledox = x - 1, xledoy = y + 1; xledox >= 0 && xledoy <= 14; xledox--, xledoy++) {
            if (qp[xledox][xledoy].equals(qizi)) {
                xledosum++;
            } else {
                break;
            }
        }
        if (xledosum >= 5) {
            return true;
        }
        //左斜向上查找
        int xleupsum = 1;
        for (int xleupx = x - 1, xleupy = y - 1; xleupx >= 0 && xleupy >= 0; xleupx--, xleupy--) {
            if (qp[xleupx][xleupy].equals(qizi)) {
                xleupsum++;
            } else {
                break;
            }
        }
        if (xriupsum >= 5) {
            return true;
        }
        return false;
    }

5.准备阶段结束，游戏开始

  //开始游戏
    public static void stratGame() {
        Scanner PD = new Scanner(System.in);
        boolean flag = true;
        while (true) {
            if (flag == true) {
                System.out.println("黑方下");
                int num1 = PD.nextInt() - 1;
                int num12 = PD.nextInt() - 1;
                boolean result = check(num1, num12);
                if (result) {
                    qp[num1][num12] = black;
                    print();
                    boolean win = Iswin(num1, num12, black);
                    if(win){
                        System.out.println("黑方胜利");
                        break;
                    }
                    flag = false;
                } else {
                    System.out.println("棋子越界或重复，请重新输入！");
                }
            }
            if (flag == false) {
                System.out.println("白方下");
                int num2 = PD.nextInt() - 1;
                int num21 = PD.nextInt() - 1;
                boolean result = check(num2, num21);
                if (result) {
                    qp[num2][num21] = white;
                    print();
                    boolean win = Iswin(num2, num21, white);
                    if(win){
                        System.out.println("白方胜利");
                        break;
                    }
                    flag = true;
                } else {
                    System.out.println("棋子越界或重复，请重新输入！");
                }
            }
        }
    }

总上述方法，总代码如下：

import java.util.Scanner;

public class WZQ {
    static String white = "○";
    static String black = "●";
    static String[][] qp = new String[15][15];//棋盘
    static String[] num = {"⒈", "⒉", "⒊", "⒋", "⒌", "⒍", "⒎", "⒏", "⒐", "⒑", "⒒", "⒓", "⒔", "⒕", "⒖"};
    static String line = "十";

    public static void main(String[] args) {
        /*
         1.
            初始化棋盘 抽取到一个方法中
            打印棋盘 抽取到一个方法中
         2.
            黑白双方交替下棋
            打印棋盘
         3.
            判断是否越界
            判断是否重复
            判断输赢
         */
        init();
        stratGame();
    }

    //初始化棋盘
    public static void init() {
        for (int i = 0; i < qp.length; i++) {
            for (int j = 0; j < qp[i].length; j++) {
                qp[i][j] = line;
                if (j == qp[i].length - 1) {
                    qp[i][j] = num[i];
                }
                if (i == qp.length - 1) {
                    qp[i][j] = num[j];
                }
                System.out.print(qp[i][j] + " ");
            }
            System.out.println();
        }
    }

    //打印棋盘
    public static void print() {
        for (int i = 0; i < qp.length; i++) {
            for (int j = 0; j < qp[i].length; j++) {
                System.out.print(qp[i][j] + " ");
            }
            System.out.println();
        }
    }

    //开始游戏
    public static void stratGame() {
        Scanner PD = new Scanner(System.in);
        boolean flag = true;
        while (true) {
            if (flag == true) {
                System.out.println("黑方下");
                int num1 = PD.nextInt() - 1;
                int num12 = PD.nextInt() - 1;
                boolean result = check(num1, num12);
                if (result) {
                    qp[num1][num12] = black;
                    print();
                    boolean win = Iswin(num1, num12, black);
                    if(win){
                        System.out.println("黑方胜利");
                        break;
                    }
                    flag = false;
                } else {
                    System.out.println("棋子越界或重复，请重新输入！");
                }
            }
            if (flag == false) {
                System.out.println("白方下");
                int num2 = PD.nextInt() - 1;
                int num21 = PD.nextInt() - 1;
                boolean result = check(num2, num21);
                if (result) {
                    qp[num2][num21] = white;
                    print();
                    boolean win = Iswin(num2, num21, white);
                    if(win){
                        System.out.println("白方胜利");
                        break;
                    }
                    flag = true;
                } else {
                    System.out.println("棋子越界或重复，请重新输入！");
                }
            }
        }
    }

    private static boolean Iswin(int x, int y, String qizi) {

        /*
        水平查找
         */
        //水平向右查找
        int risum = 1;
        for (int righty = y - 1; righty >= 0; righty--) {
            if (qp[x][righty].equals(qizi)) {
                risum++;
            } else {
                break;
            }
        }
        if (risum >= 5) {
            return true;
        }
        //水平向左查找
        int lesum = 1;
        for (int lefty = y + 1; lefty <= 14; lefty++) {
            if (qp[x][lefty].equals(qizi)) {
                lesum++;
            } else {
                break;
            }
        }
        if (lesum >= 5) {
            return true;
        }

        /*
        竖直查找
         */
        //向上查找
        int upsum = 1;
        for (int upx = x + 1; upx <= 14; upx++) {
            if (qp[upx][y].equals(qizi)) {
                upsum++;
            } else {
                break;
            }
        }
        if (upsum >= 5) {
            return true;
        }
        //向下查找
        int dosum = 1;
        for (int dox = x - 1; dox >= 0; dox--) {
            if (qp[dox][y].equals(qizi)) {
                dosum++;
            } else {
                break;
            }
        }
        if (dosum >= 5) {
            return true;
        }
        /*
        对角线查找
         */
        //右斜向下查找
        int xridosum = 1;
        for (int xridox = x + 1, xridoy = y + 1; xridox <= 14 && xridoy <= 14; xridox++, xridoy++) {
            if (qp[xridox][xridoy].equals(qizi)) {
                xridosum++;
            } else {
                break;
            }
        }
        if (xridosum >= 5) {
            return true;
        }
        //右斜向上查找
        int xriupsum = 1;
        for (int xriupx = x + 1, xriupy = y - 1; xriupx <= 14 && xriupy >= 0; xriupx++, xriupy--) {
            if (qp[xriupx][xriupy].equals(qizi)) {
                xriupsum++;
            } else {
                break;
            }
        }
        if (xriupsum >= 5) {
            return true;
        }
        //左斜向下查找
        int xledosum = 1;
        for (int xledox = x - 1, xledoy = y + 1; xledox >= 0 && xledoy <= 14; xledox--, xledoy++) {
            if (qp[xledox][xledoy].equals(qizi)) {
                xledosum++;
            } else {
                break;
            }
        }
        if (xledosum >= 5) {
            return true;
        }
        //左斜向上查找
        int xleupsum = 1;
        for (int xleupx = x - 1, xleupy = y - 1; xleupx >= 0 && xleupy >= 0; xleupx--, xleupy--) {
            if (qp[xleupx][xleupy].equals(qizi)) {
                xleupsum++;
            } else {
                break;
            }
        }
        if (xriupsum >= 5) {
            return true;
        }
        return false;
    }

    //判断是否越界，是否重复
    public static boolean check(int x, int y) {
        if (x < 0 || y < 0 || y > 14 || x > 14) {
            return false;
        }
        if (!qp[x][y].equals(line)) {
            return false;
        }
        return true;
    }
}

郭天宇 abfore
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
java五子棋人机对战项目
11-10
本项目使用了JavaSwing实现桌面五子棋应用，人机对战部分用a-B剪枝算法实现，有一定的智能。
java数组游戏_Java之迷宫小游戏（二维数组）
weixin_30303283的博客
02-16 212
importjava.util.Scanner;public classgame1 {static int score = 0; //分数static int blood = 3; //生命static int step = 0; //步数//& 玩家//@ 终点static String[][] arr ={//0 1 2 3 4 5 6 7 ...
【蓝桥杯3533】棋盘（二维数组&java）
归忆_AC的博客
11-20 206
其实就是建立一个二维数组，然后根据输入的左上角和右下角的点确定一个矩形区域，对里面的值进行取反（0和1）。注意题目的输出格式！
java二维数组实现五子棋功能
fxbsdl的博客
01-24 331
如下图:输入后重新输出棋盘如下图:白棋输入后如下图黑白棋依次重复输入下棋。
Java基础练习题3--(在交互输出界面实现一个简单的五子棋)
从零开始的异世界JAVA学习
04-13 335
使用二维数组实现一个简单的五子棋游戏;黑白棋轮流落子;判断输赢. import java.util.Scanner; public class Chess001 { static char[] num = {'⒈', '⒉', '⒊', '⒋', '⒌', '⒍', '⒎', '⒏', '⒐', '⒑', '⒒', '⒓', '⒔', '⒕', '⒖'}; //黑棋 static char black = '○'; //白棋 static char white =
Java基础学习——二维数组之打地鼠2.0
xdbbty的博客
10-15 217
这是一个由二维数组实现的简单练手项目——打地鼠2.0小游戏，可以很好的训练自己的逻辑思维能力，以及代码的编写能力，是入门数组基础很好的一个锻炼机会。
二维数组应用：井字棋
weixin_53048474的博客
11-08 483
使用二维数组实现井字棋小游戏
二维数组实现五子棋小游戏
08-08
用java的二维数组实现五子棋小游戏，适合初学者学习二维数组
基于Java的五子棋游戏的设计与实现.rar
04-12
数据结构：使用二维数组来表示棋盘状态，简化棋盘管理和游戏规则判定的实现。 可选功能： 网络对战：如果需要实现网络对战功能，可以考虑使用Socket编程实现客户端与服务器之间的通信，并同步玩家的落子情况。 游戏...
基于Java的五子棋游戏的设计的毕业设计，采用Java语言进行开发,使用图形用户界面(GUI)技术实现游戏界面
03-30
棋盘为19*19的二维数组,表示游戏区域。棋子为黑子和白子,分别由“B”和“W”表示,存储在棋盘数组中。 游戏开始时,系统随机选择一方为黑子,另一方为白子。双方轮流行棋,每次行棋需要选择一个空白位置并放置自己的...
java五子棋课设（含人机对战）.rar
07-28
③判断输赢：每次根据下棋位置更新二维数组后对齐进行行、列、斜的判断，当存在五子连珠时弹出窗口，根据一系列状态变量判断黑方/白方获胜。 ④认输：根据当前轮到某一方下棋判断另一方获胜。 ⑤合理性判断：对不...
五子棋(Java语言实现)
01-21
首先我们需要创建一个String的二维数组来表示棋盘，棋盘具体用”+”来进行表示，大小为15*15。考虑到后面能在棋盘的左边和上面用序号进行标注，为了方便起见，我们横坐标用数字1-15来进行表示，纵坐标用字母A-O来...
java 使用二维数组实现推箱子文字游戏版
qq_63805931的博客
08-15 1367
在java 中使用二维数组实现推箱子文字游戏版
【二维数组】java二维数组简易五子棋
m0_62876664的博客
04-29 3061
需求 编写一个简易五子棋游戏，棋盘在控制台上绘制，棋盘每一个点都有对应的坐标，下棋者输入两位数字表示落棋子的坐标 实现 public class Gobang { public static void main(String[] args) { System.out.println("- - - - - - - - - - -"); String first="*"; String next="o"; Scanner sc = new Scanner(System.i...
用java实现五子棋
2303_77522514的博客
07-12 404
1.使用二维数组存储五子棋棋盘如下图2.在控制台通过Scanner输入黑白棋坐标(例如:1,2 2,1格式 表示二维数组坐标),使用实心五角星和空心五角星表示黑白棋子.如下图:白棋输入后如下图黑白棋依次重复输入下棋3.判断棋子是否越界,棋子是否重复,判断输赢。
Java用二维数组实现五子棋
weixin_44576890的博客
02-20 1579
import java.util.Scanner; public class Text1{ //二维数组，棋盘 static String[][] chess = new String[15][15];//成员，全局唯一;static保存在方法区，在类对象加载前jvm static int times; //棋盘上棋子总数 static String who[] ={...
Java二维数组实现五子棋
qq_42903272的博客
11-17 1498
五子棋是我们生活中一个经常玩的小游戏，游戏分为黑棋、白棋，游戏开始时，黑棋先落子，白棋随后落子，若某种颜色的棋子在横向、竖向、上斜向（坐标轴中y=x）、下斜向（坐标轴中y=-x）的某个方向形成五个相同的棋子，则这个颜色获胜，游戏结束。那么如何判断某个棋子在某个方向形成五个相同的棋子呢？定义初始化棋盘为0，黑棋为1，白棋为2，假设某点上现在为黑棋，则这个点的数字从0变为1，那么分别比较四个方向的棋子...
用Java写一个d简单的五子棋游戏（含人机对决，双人对决）
罗铠威的博客
11-17 1021
Java语言设计五子棋游戏，二维数组的使用，黑白棋依次重复输入下棋每下一个棋子后需要判断该棋子是否出界,此位置是否已经有棋子,判断是否有5个棋子连在一起,有则表示胜利,否则继续下棋.
android高斯模糊填充imageview背景
最新发布
cf8833的博客
05-21 572
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
基于java的五子棋游戏设计与实现
10-22
首先，我们需要设计游戏的棋盘，可以使用二维数组来表示。每个元素表示一个棋格，可以为空，也可以是黑子或白子。 其次，我们需要设计游戏的规则。如下： 1. 黑方和白方逐轮下棋，可以通过鼠标点击来选择下子位置。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

郭天宇 abfore

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值