JavaSE-十分钟写个五子棋

最新推荐文章于 2021-11-28 15:57:33 发布
最新推荐文章于 2021-11-28 15:57:33 发布
阅读量432 收藏 3
点赞数
分类专栏： JavaSE 文章标签： 游戏 java 五子棋 类与对象 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41573860/article/details/109426080
版权

 

1.设计说明

1.1 简介

其实很久之前就写过五子棋，当时拿AWT写的界面，后面通过socket通信实现了联机对战操作，当时写五子棋写的可费劲了，现在又要写一次五子棋，不过是简单版的哈哈，一会就写完了。

描述：基于Java类和对象以及数组开发的一个小型五子棋游戏程序。游戏开始时，选择黑棋、白棋开局，将一枚棋子落在棋盘一坐标上，然后轮番落子，如此轮流下子，直到某一方首先在棋盘的竖、横或两斜四方向上的五子连成线，则该方该局获胜。

1.2 游戏说明

功能列表如下：

（1）输出棋盘；

（2）提示用户下子；

（3）查看用户是否出界或者落子位置是否被占用；

（4）轮番黑棋白棋选择坐标位置进行下子；

（5）判断游戏是否输赢；

（6）判断是否进入下一局；

（7）退出游戏。

 

2. 实现思路

  1. 棋盘设计为10*10格,棋盘类型Chess[][] 二维数组，所含属性String chessType; 棋盘首先chessType值是”➕”。
  2. 初始化二维数组
  3. 玩家选择黑白圈后，开始下棋。输入要下棋子的行列坐标，黑白棋子轮流落子，当一方连成五子或下满棋盘时，游戏结束（连成五子的一方获胜，下满棋盘为和棋）。
  4. 每一次落子成功后，马上判断以该位置为中心的八个方向：上、下、左、右、左上、左下、右上、右下是否有相同颜色的棋子连成五子，如果连成五子，则游戏结束，输出相应的信息。
  5. 当游戏一方胜利后显示胜利信息。从程序表面看，这是一个二维平面图，所以数据用二维数组来表示，数组两个下标可以表示棋盘上的位置，数组元素的值代表棋格上的状态，共有三种情况，分别是，⭕代表白棋，●代表黑棋，➕代表格子。

 

3. 实现流程

由于时间原因，写的很仓促，说是十分钟写，其实思考加编写加调试前后花了差不多半个小时，老标题党了，hiahia。

3.1 棋子类

首先要写一个棋子类用于存放棋子信息，它的属性主要是chessType（这枚棋子的种类，黑棋还是白棋），flag（棋盘对应的这个位置是否有棋，有棋给true，没棋就给false），每次将棋子下到棋盘上之后，要把flag给置true，表示已经有棋子了，如果还往这个位置下棋就报错。另外两个属性row，colum是我顺手写习惯写上的，没有用到可以省略。

package com.fiveChess;

/**
 * Description :
 * Created by Resumebb
 * Date :2020/10/31
 */
public class ChessNode {
    private String chessType;
    private int row;
    private int colum;
    private boolean flag;

    public ChessNode(String chessType, int row, int colum, boolean flag) {
        this.chessType = chessType;
        this.row = row;
        this.colum = colum;
        this.flag = flag;
    }

    public String getChessType() {
        return chessType;
    }

    public void setChessType(String chessType) {
        this.chessType = chessType;
    }

    public int getRow() {
        return row;
    }

    public void setRow(int row) {
        this.row = row;
    }

    public int getColum() {
        return colum;
    }

    public void setColum(int colum) {
        this.colum = colum;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

3.2操作类

1.run函数

首先上一个run，用来控制操作流程，尽可能做高内聚低耦合，让每一个函数各司其职，专精一件事情。

这个run方法就是最开始进入的界面控制，先直接开始一次游戏，完成后判断用户输入，1重开一盘，0退出游戏。

    public void run(){
        int choice = 0;
        boolean flag = false;
        do {
            initChessBoard();
            show();
            playChess();
            System.out.println("继续扣1,退出扣0");
            Scanner in = new Scanner(System.in);
            choice = in.nextInt();
            if(choice == 1){
                flag = true;
            }
        }while (flag);
    }

2.initChessBoard函数

该函数用于初始化棋盘，所有的chessType给置＋，需求是给定10*10大小棋盘，也可以自己增加两个变量，生成自定义大小的棋盘

   private void initChessBoard(){
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                chessNodes[i][j] = new ChessNode("➕",i,j,false);
            }
        }
        System.out.println("初始化完成。");
    }

  3.show函数

用于打印棋盘信息

    private void show(){
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(chessNodes[i][j].getChessType()+" ");
            }
            System.out.println();
        }
        System.out.println();
    }

4.playChess函数

根据需求，要判断先手棋子，然后开始下棋。获取用户输入的xy坐标，先进行安全型检查，然后通过chessNode的flag属性可以判断该位置是否有棋，有棋重新输入坐标，没棋的话就将该位置的flag置true，并将chessType改为first，然后检查是否和棋，是否获胜，都不满足的话，交换棋子类型，继续循环，直至和棋或者一方胜出。

 private void playChess(){
        Scanner in = new Scanner(System.in);
        boolean flag = false;
        String first = "", second = "", temp = "";

        //先手判断
        do {
        System.out.println("请选择：黑棋● | 白棋⭕");
        String choice = in.next();
        if(choice.equals("黑棋")){
            first = "●";
            second = "⭕";
            flag = true;
        }
        else if(choice.equals("白棋")){
            first = "⭕";
            second = "●";
            flag = true;
        }
        else{
            System.out.println("输入有误,请重输：");
        }}while (!flag);

        //下棋操作
        int x = 0, y = 0;
        while(true) {
            System.out.println("请输入"+first+"x，y坐标：");
            x = in.nextInt()-1;
            y = in.nextInt()-1;

            //参数安全检查
            if(x<0 || x>9 || y<0 || y>9){
                System.out.println("输入有误，x：1-10，y：1-10，请重新输入：");
                continue;
            }
            //判断原位置是否有棋
            if (chessNodes[x][y].isFlag() == true) {
                System.out.println("原位置已有棋，请重新输入x，y坐标：");
            }
            else {
                chessNodes[x][y].setChessType(first);
                chessNodes[x][y].setFlag(true);
                size++;
                //判和
                if(peace()){
                    System.out.println("和棋！");
                    break;
                }
                if(judgeVectory(x,y,first)){
                    break;
                }
                //不满足胜利条件，交换顺序继续下
                temp = first;
                first = second;
                second = temp;
                show();
            }
        }
    }

4. judgeVectory函数

首先用四个变量来分别存储水平，垂直，左右俩斜线四个大方向上的棋子数量。然后每次调用函数，以当前给定的x，y坐标下的棋子位置为中心，分别计算八个小方向上的 棋子数量，最后判断只要四个大方向的棋子数量和大于等于4就胜利，因为自身有一个棋子了，所以加上就是大于等于5。整个项目唯一要注意的点就是计算八个小方向上的棋子数量，比如我计算90°方向的数量，首先不能改变x，y坐标的值，否则会影响其他7个小方向的判断，然后判断该棋子正右是否由棋子，应该是x不变，y向右移动，我开始想当然的判断右边，x+1，明显不对，而且每次+1也不行，最好就是利用循环的i去加，减少变量使用，同时还要注意检查x坐标+i后是否越界，越界也不行。

    private boolean judgeVectory(int x, int y, String chessType){
        int vertical = 0;	//垂直方向棋子数量
        int level = 0;	//水平方向棋子数量
        int bevelLeft = 0; //正北为0，-45°斜线上棋子数量
        int bevelRight = 0; //正北为0，45°斜线上棋子数量

        //计算90°方向棋子数量
        for (int i=1; i<5; i++) {
            if (y+i < 10 && chessNodes[x][y+i].getChessType().equals(chessType)) {
                level++;
            } else {
                break;
            }
        }

        //计算-90°方向棋子数量
        for (int i=1; i<5; i++) {
            if (y-i >= 0 && chessNodes[x][y-i].getChessType().equals(chessType)){
                level++;
            } else {
                break;
            }
        }

        //计算0°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x+i < 10 && chessNodes[x+i][y].getChessType().equals(chessType)){
                vertical++;
            } else {
                break;
            }
        }

        //计算180°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x-i >= 0 && chessNodes[x-i][y].getChessType().equals(chessType)){
                vertical++;
            } else {
                break;
            }
        }

        //计算45°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x+i >= 0 && y+i >= 0 && chessNodes[x+i][y+i].getChessType().equals(chessType)){
                bevelRight++;
            } else {
                break;
            }
        }

        //计算225°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x-i >= 0 && y-i >= 0 && chessNodes[x-i][y-i].getChessType().equals(chessType)){
                bevelRight++;
            } else {
                break;
            }
        }

        //计算-45°方向棋子数量
        for (int i=1; i<5; i++) {
            if (y-i >= 0 && x+i >= 0 && chessNodes[x+i][y-i].getChessType().equals(chessType)){
                bevelLeft++;
            } else {
                break;
            }
        }

        //计算135°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x-i >= 0 && y+i >= 0 && chessNodes[x-i][y+i].getChessType().equals(chessType)){
                bevelLeft++;
            } else {
                break;
            }
        }

        //获胜条件
        if(vertical >= 4 || level >=4 || bevelLeft >= 4 || bevelRight >= 4){
            System.out.println(chessType+"胜利！");
            return true;
        }
        return false;
    }

5.chess类完整代码

package com.fiveChess;

import java.util.Scanner;

/**
 * Description :
 * Created by Resumebb
 * Date :2020/10/31
 */
public class Chess {
    private ChessNode[][] chessNodes;
    private static int size;
    public Chess(){
        chessNodes = new ChessNode[10][10];
    }

    //棋盘初始化填值➕，10*10大小
    private void initChessBoard(){
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                chessNodes[i][j] = new ChessNode("➕",i,j,false);
            }
        }
        System.out.println("初始化完成。");
    }

    //显示棋盘
    private void show(){
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(chessNodes[i][j].getChessType()+" ");
            }
            System.out.println();
        }
        System.out.println();
    }


    //下棋操作
    private void playChess(){
        Scanner in = new Scanner(System.in);
        boolean flag = false;
        String first = "", second = "", temp = "";

        //先手判断
        do {
        System.out.println("请选择：黑棋● | 白棋⭕");
        String choice = in.next();
        if(choice.equals("黑棋")){
            first = "●";
            second = "⭕";
            flag = true;
        }
        else if(choice.equals("白棋")){
            first = "⭕";
            second = "●";
            flag = true;
        }
        else{
            System.out.println("输入有误,请重输：");
        }}while (!flag);

        //下棋操作
        int x = 0, y = 0;
        while(true) {
            System.out.println("请输入"+first+"x，y坐标：");
            x = in.nextInt()-1;
            y = in.nextInt()-1;

            //参数安全检查
            if(x<0 || x>9 || y<0 || y>9){
                System.out.println("输入有误，x：1-10，y：1-10，请重新输入：");
                continue;
            }
            //判断原位置是否有棋
            if (chessNodes[x][y].isFlag() == true) {
                System.out.println("原位置已有棋，请重新输入x，y坐标：");
            }
            else {
                chessNodes[x][y].setChessType(first);
                chessNodes[x][y].setFlag(true);
                size++;
                //判和
                if(peace()){
                    System.out.println("和棋！");
                    break;
                }
                if(judgeVectory(x,y,first)){
                    break;
                }
                //不满足胜利条件，交换顺序继续下
                temp = first;
                first = second;
                second = temp;
                show();
            }
        }
    }

    //判断胜利
    private boolean judgeVectory(int x, int y, String chessType){
        int vertical = 0;	//垂直方向棋子数量
        int level = 0;	//水平方向棋子数量
        int bevelLeft = 0; //正北为0，-45°斜线上棋子数量
        int bevelRight = 0; //正北为0，45°斜线上棋子数量

        //计算90°方向棋子数量
        for (int i=1; i<5; i++) {
            if (y+i < 10 && chessNodes[x][y+i].getChessType().equals(chessType)) {
                level++;
            } else {
                break;
            }
        }

        //计算-90°方向棋子数量
        for (int i=1; i<5; i++) {
            if (y-i >= 0 && chessNodes[x][y-i].getChessType().equals(chessType)){
                level++;
            } else {
                break;
            }
        }

        //计算0°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x+i < 10 && chessNodes[x+i][y].getChessType().equals(chessType)){
                vertical++;
            } else {
                break;
            }
        }

        //计算180°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x-i >= 0 && chessNodes[x-i][y].getChessType().equals(chessType)){
                vertical++;
            } else {
                break;
            }
        }

        //计算45°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x+i >= 0 && y+i >= 0 && chessNodes[x+i][y+i].getChessType().equals(chessType)){
                bevelRight++;
            } else {
                break;
            }
        }

        //计算225°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x-i >= 0 && y-i >= 0 && chessNodes[x-i][y-i].getChessType().equals(chessType)){
                bevelRight++;
            } else {
                break;
            }
        }

        //计算-45°方向棋子数量
        for (int i=1; i<5; i++) {
            if (y-i >= 0 && x+i >= 0 && chessNodes[x+i][y-i].getChessType().equals(chessType)){
                bevelLeft++;
            } else {
                break;
            }
        }

        //计算135°方向棋子数量
        for (int i=1; i<5; i++) {
            if (x-i >= 0 && y+i >= 0 && chessNodes[x-i][y+i].getChessType().equals(chessType)){
                bevelLeft++;
            } else {
                break;
            }
        }

        //获胜条件
        if(vertical >= 4 || level >=4 || bevelLeft >= 4 || bevelRight >= 4){
            System.out.println(chessType+"胜利！");
            return true;
        }
        return false;
    }

    //和棋判断
    private boolean peace(){
        if(size == 100){
            return true;
        }
        return false;
    }
    public void run(){
        int choice = 0;
        boolean flag = false;
        do {
            initChessBoard();
            show();
            playChess();
            System.out.println("继续扣1,退出扣0");
            Scanner in = new Scanner(System.in);
            choice = in.nextInt();
            if(choice == 1){
                flag = true;
            }
        }while (flag);
    }
}

 

4.测试

 4.1测试函数

public class Start {
	public static void main(String[] args) {
		Chess chess = new Chess();
		chess.run();
	}
}

测试截图

因为写的很仓促，就测试了几个例子，边界条件啥的都没测试，有可能会有bug，不过主要学习的是类与对象的思想，还有五子棋的判断流程，掌握了就可以了。 

Van-bo
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java SE 五子棋
12-31
设计一个围棋棋盘11*11的，由两明玩家进行对战，重置棋盘，刷新重新开始，最后判断某一方是否为五子连珠。分为人人对战，人机对战，人机对战暂时不实现具体判断功能
JavaSE实现五子棋小游戏
wuud__的博客
03-30 1060
适合Java练手用，及其简单，界面使用awt框架实现。 五子棋小游戏一共有四个类：background.java（画五子棋的背景）、constant.java（存储一些常量）、ruler.java（判赢规则）、Main.java（启动类）。 一步一步来，我们先定义好游戏内的常量（这里是我一点一点调出来的）： public class constant { final static ...
javase 编写五子棋
04-16
利用java编写一个游戏，实现了面向对象的思想，对初学者有很大的帮助
javase 五子棋单机版
09-04
用Java写的一个单机版五子棋对弈程序，加入了人机对弈。附带的文档给出了设计思想。
javase-2.2-API文档-中文版.zip
07-13
赠送jar包：javase-2.2.jar； 赠送原API文档：javase-2.2-javadoc.jar； 赠送源代码：javase-2.2-sources.jar； 赠送Maven依赖信息文件：javase-2.2.pom； 包含翻译后的API文档：javase-2.2-javadoc-API文档-中文...
javase-3.3.3-API文档-中英对照版.zip
06-12
赠送jar包：javase-3.3.3.jar； 赠送原API文档：javase-3.3.3-javadoc.jar； 赠送源代码：javase-3.3.3-sources.jar； 赠送Maven依赖信息文件：javase-3.3.3.pom； 包含翻译后的API文档：javase-3.3.3-javadoc-API...
javase-2.0.jar
04-21
使用java在服务端进行aes的加密解密，前端使用该js进行aes加密解密；
javase-3.3.0.zip
08-29
谷歌二维码生成工具包，MatrixToImageWriter.writeToPath()方法，2的版本木有
core-3.3.3 + javase-3.3.3+ zxing-1.7-core + zxing-j2se-1.7
06-18
该资源提供两个iReport 生成二维码必须的包core javase，其中包含JDK1.7 版本 及JDK1.8版本
Java实现的五子棋
04-16
JavaSE 实现的简单版五子棋 使用JPanel的画板画棋盘跟棋子 可以存盘和复盘（文件读写）
Java五子棋项目视频教程（附源码）
07-22
资源名称：Java五子棋项目视频教程（附源码）资源目录：【】五子棋10、完成几个简单按钮的功能【】五子棋11、完成开始游戏和认输按钮的功能【】五子棋12、完成游戏设置按钮功能并加入时间控制【】五子棋1、游戏说明及Swing知识准备【】五子棋2、Swing知识准备【】五子棋3、完成五子棋游戏界面编写【】五子棋4、完成下棋的功能【I 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
Java实现五子棋游戏（人机对战）
04-06
本程序适用于java初学者巩固类与对象、事件响应、awt包中各种工具的相关概念以及对逻辑能力的锻炼 需要注意的有： ①要加入java界面的重绘（基本原则） ②由于玩家需要通过鼠标点击，计算机响应出棋子的位置，但却不能保证每次点击都正中棋盘点位，所以要有一定的误差范围 ③要保存更新棋盘上的棋子信息，因为棋盘格数是固定的故本例中采取最简单的数组
chess 棋类小游戏——井字棋
12-29
Java棋类小游戏——井字棋，适合初学者的参考。
java 五子棋 项目_Java小项目——五子棋
weixin_39610956的博客
02-12 170
一、需求分析1、界面设计左：棋盘，单独写一个GamePanel类右：控制栏panel22、功能2.1 棋盘首先绘制一个棋盘。考虑重绘，将该绘制写在paint()重写中。2.2 下棋用户点击相应位置：计算出棋子的位置，绘制棋子，并存储棋子位置。同样将该绘制写在paint()重写中。2.3 胜利胜利判断：横向、竖直、斜向判断2.4 电脑下棋使用xxx实现二、实现0、Config 常数接口存在一些数为常...
简易版五子棋---JavaSE
qq_46127056的博客
06-08 231
要求 可以在控制台输出棋盘效果 可以从控制台读取用户输入的落子位置 当其中一方领先在同一直线上连续棋子达到4个时，可以判断胜负，并退出游戏 Method类 public class Method { //棋盘 public void Backgammon(String[][] checkerboard) { int count1 = 1; int count2 = 1; for (int i = 0; i < checkerboard.length; i++
JavaSE小游戏——五子棋
qq_43199083的博客
02-20 338
五子棋！！！！！！！！ 五子棋是一种两人对弈的纯策略型棋类游戏，通常双方分别使用黑白两色的棋子，轮流下在棋盘直线与横线的交叉点上，先在横线、直线或斜对角线上形成5子连线者获胜。　　　　 因为棋子在落子后不能移动或拿掉，所以也可以用纸和笔来进行游戏。 行棋：黑子先行，一人轮流一著下于棋盘空点处。 胜负：先把五枚或以上己棋相连成任何横纵斜方向为胜。（长连仍算胜利） 解题思路 ！！！！！！！ ...
Java五子棋
一光年
10-23 6287
Java基础与案例开发详解里面的案例，值得认真学习 下载地址：http://download.csdn.net/detail/hong0220/4676567      (第17章) 主程序： import javax.swing.*; import java.awt.event.*; import java.awt.*; /* 五子棋-主框架类, 程序启动类 */ public cl
Java项目（五子棋）
G_Y_Chen的博客
11-28 878
五子棋功能分析界面绘制下棋策略胜负判定棋局录制与回放悔棋功能实现界面绘制与更新胜负判定策略回放悔棋项目优化界面重构时棋盘闪烁问题解决方案整体展示界面展示代码 功能分析 界面绘制 界面分为棋盘区域和按键面板 整体界面为1500×1000 棋盘区域背景色为浅灰色，棋盘为21×21大小间隔45个像素点，放置在左侧 按键面板背景色为白色，大小为500×1000，共放置5个按键“开始游戏，悔棋，认输，回放，退出游戏” 下棋策略 棋子放置在棋盘线的交汇点上 黑白交替下棋 胜负判定 每下颗棋子后进行胜负判定 输
那javaSE -17可不可以用
最新发布
06-12
JavaSE-17是Java的最新版本，如果您使用JavaSE-17，则可以使用Java 14中引入的记录（Record）特性而无需担心保留字问题。JavaSE-17中包含了Java 14及更早版本中的所有功能，同时还引入了新的功能和改进。 因此，如果您想在Java中使用记录特性，建议您升级到最新的JavaSE-17版本。请注意，一些旧版的Java开发工具可能需要更新才能支持JavaSE-17。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值