JAVA 五子棋（人机）昨天买的棋子今天就用不上了

最新推荐文章于 2022-08-15 08:59:27 发布
最新推荐文章于 2022-08-15 08:59:27 发布
阅读量241 收藏 2
点赞数
分类专栏： java 五子棋
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fal_se/article/details/116379246
版权

五子棋 JAVA

首先我们应该思考五子棋是由哪些东西组成的

1、棋盘，假设我们要创建一个10*10的棋盘，应该使用数组且为二维数组

public class QP {
   static String[][]a=new String[10][10];
    public static void main(String[] args) {
      Qi();
      Pan();
      Zi();
    }

由于下面要创建方法，为了方便，将数组定义为成员变量

 public static void Qi(){
        for (int i = 0; i <a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                a[j][i]="+";
            }System.out.println();
        }
    }

创建一个方法使其循环

第一个循环代表的是打印的行数比数组长度少一行

第二个循环代表每一行打印多少个

定义a [j] [i]="+";然后让他们换行

出来的效果就是在数组中将"+"存进去

 public static void Pan(){
        for (int i = 0; i <a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                System.out.print(a[j][i]+"\t");
            }System.out.println();
        }
    }

接着在创建一个方法，让他能够调用数组里存的"+",并将他显示出来，至此棋盘创建成功

2、接下来就是要开始下子了

单独创建一个方法

我们来分析一下下子的逻辑

首先下子要分为两方对弈，所以会有前后两次的输入来在棋盘上确认一点然后完成下子

其次下的子肯定不能重复下在同一个坐标上

比如下了一个黑子坐标（1，,1），接着又下了一个白子坐标也是（1,1）

那么要判定（1,1）这个坐标到底是哪种颜色的子呢？所以不能下在同一个坐标，也不能下出棋盘

 public static void Zi(){
        Scanner s = new Scanner(System.in);
        boolean flag = true;
         int x = 0;
         int y = 0;
        while (true){
            if (flag){
                System.out.println("空心先下");
                 x = s.nextInt();
                 y = s.nextInt();
                if (x>10||x<1||y>10||y<1){
                    System.out.println("重新输入");
                    continue;
                }
                if (!a[y-1][x-1].equals("○")&&!a[y-1][x-1].equals("●")){
                    a[y-1][x-1] = "○";
                }else {

                    System.out.println("重新输入");
                    continue;
                }
            }else {
                System.out.println("实心后下");
                 x = s.nextInt();
                 y = s.nextInt();
                if (x>10||x<1||y>10||y<1){
                    System.out.println("重新输入");
                    continue;
                }
                if (!a[y-1][x-1].equals("○")&&!a[y-1][x-1].equals("●")){
                    a[y-1][x-1] = "●";
                }else {
                    System.out.println("重新输入");
                    continue;
                }
            }
            Pan();
            flag = !flag;

先创建一个布尔类型boolean flag = true;

再创建一个while死循环，一直为true

[y-1] [x-1]是因为我们按照习惯输入的数肯定是从1开始的，但是[y-1]是数组的下标，数字中的0，可以看作平常的1，所以要把输入的x,y坐标都减一，这样才能正确找到相应数组的下标

循环内有两种情况，一种是flag = true时，白子下

要先判断他能下坐标的范围，也就是横坐标大于1，小于10，纵坐标大于1，小于10的时候输出“重新输入”并且下边的代码都不执行，判断输入的坐标里不是黑子，也不是白子，也就是"+";那么下白子，如果棋盘上不是"+";要重新输入，并且下面的代码不执行

flag = false，黑子下

原理与判断白子相同

每次下子都重新打印棋盘

每次循环 flag = !flag，也就是每次进入循环的值都不一样，一次为true，下一次就是false，就会形成白子下一次，黑子下一次

接着就是判断输赢

要判断输赢，我们要明白赢的方式有哪些

一、五个相同的棋子连成一条线

二、横着连五个

三、竖着连五个

四、斜着连五个——1、左边在上右边在下的连五子 2、左边在下右边在上的连五子

也就是会有四种情况来判断赢

我们每一种情况都创建一个方法

横着连五个

public static boolean Ying(int x,int y,String s){
        int count = 1;
        int i = x;
        int j = y-1;
        for (; j >=0 ; j--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = y+1;
        for (; k <=9 ; k++) {
            if (a[k][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }

横着连五个又有两种判断

1、判断以一个子为原点向左找是否连成5个，但是不能小于0，判断成功，那么这个坐标的左边是和他相同的棋子，棋子连成的长度加一

在这里插入图片描述

2、判断以一个子为原点向右找是否连成5个，但是不能大于9，判断成功，那么这个坐标的左边是和他相同的棋子，棋子连成的长度加一
在这里插入图片描述

如果棋子连成的长度大于等于5，那么就是这种棋子赢，如果是，就停止这个程序

竖着连五个

public static boolean Ying1(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y;
        for (; i >=0 ; i--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        for (; k <=9 ; k++) {
            if (a[j][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }

竖着连五个又有两种判断

1、判断以一个子为原点向上找是否连成5个，但是不能小于0，判断成功，那么这个坐标的上边是和他相同的棋子，棋子连成的长度加一
在这里插入图片描述

2、判断以一个子为原点向下找是否连成5个，但是不能大于9，判断成功，那么这个坐标的下边是和他相同的棋子，棋子连成的长度加一
在这里插入图片描述

如果棋子连成的长度大于等于5，那么就是这种棋子赢，如果是，就停止这个程序

左边在上右边在下的连五子

 public static boolean Ying2(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y-1;
        for (; i >=0&& j>=0; i--,j--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        int z = y+1;
        for (; k <=9 &&z<=9; k++,z++) {
            if (a[z][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }

我们来看一下这种判断方式

也是以一个子为原点来判断他相邻的那个棋子是不和他一样

左上

就是x坐标，y坐标同时减一来判断相邻在这里插入图片描述

右下

就是x坐标，y坐标同时加一来判断相邻在这里插入图片描述

如果判断五个相同的连在一起，就判赢

左边在下右边在上的连五子

 public static boolean Ying3(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y+1;
        for (; i >=0&&j<=9 ; i--,j++) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        int z = y-1;
        for (; k <=9 && z>=0; k++, z--) {
            if (a[z][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }
}

左下

x坐标减一，y坐标加一在这里插入图片描述

右上

x坐标加一，y坐标减一在这里插入图片描述

至此有了四种判断方式，任意一种判断出为赢就可以结束程序了
完整程序如下

import jdk.nashorn.internal.ir.ContinueNode;

import java.util.Scanner;

public class QP {
   static String[][]a=new String[10][10];
    public static void main(String[] args) {
      Qi();
      Pan();
      Zi();
    }

    public static void Qi(){
        for (int i = 0; i <a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                a[j][i]="+";
            }System.out.println();
        }
    }

    public static void Pan(){
        for (int i = 0; i <a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                System.out.print(a[j][i]+"\t");
            }System.out.println();
        }
    }
    public static void Zi(){
        Scanner s = new Scanner(System.in);
        boolean flag = true;
         int x = 0;
         int y = 0;
        while (true){
            if (flag){
                System.out.println("空心先下");
                 x = s.nextInt();
                 y = s.nextInt();
                if (x>10||x<1||y>10||y<1){
                    System.out.println("重新输入");
                    continue;
                }
                if (!a[y-1][x-1].equals("○")&&!a[y-1][x-1].equals("●")){
                    a[y-1][x-1] = "○";
                }else {

                    System.out.println("重新输入");
                    continue;
                }
            }else {
                System.out.println("实心后下");
                 x = s.nextInt();
                 y = s.nextInt();
                if (x>10||x<1||y>10||y<1){
                    System.out.println("重新输入");
                    continue;
                }
                if (!a[y-1][x-1].equals("○")&&!a[y-1][x-1].equals("●")){
                    a[y-1][x-1] = "●";
                }else {
                    System.out.println("重新输入");
                    continue;
                }
            }
            Pan();
            flag = !flag;
            boolean res = Ying(x-1,y-1,a[y-1][x-1]);
            if (res){
                break;
            }
            boolean res1 = Ying1(x-1,y-1,a[y-1][x-1]);
            if (res1){
                break;
            }
            boolean res2 = Ying2(x-1,y-1,a[y-1][x-1]);
            if (res2){
                break;
            }
            boolean res3 = Ying3(x-1,y-1,a[y-1][x-1]);
            if (res3){
                break;
            }
        }
    }

    public static boolean Ying(int x,int y,String s){
        int count = 1;
        int i = x;
        int j = y-1;
        for (; j >=0 ; j--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = y+1;
        for (; k <=9 ; k++) {
            if (a[k][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }


    public static boolean Ying1(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y;
        for (; i >=0 ; i--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        for (; k <=9 ; k++) {
            if (a[j][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }

    public static boolean Ying2(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y-1;
        for (; i >=0&& j>=0; i--,j--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        int z = y+1;
        for (; k <=9 &&z<=9; k++,z++) {
            if (a[z][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }


    public static boolean Ying3(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y+1;
        for (; i >=0&&j<=9 ; i--,j++) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        int z = y-1;
        for (; k <=9 && z>=0; k++, z--) {
            if (a[z][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }
}
Fal_se
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用java实现五子棋
weixin_35752122的博客
12-20 492
好的，我来给你介绍一下如何使用 Java 来实现五子棋游戏。 首先，你需要准备一个二维数组来表示棋盘，其中 0 表示这个位置没有棋子，1 表示黑色棋子，2 表示白色棋子。 然后你需要编写一个函数来判断当前局面是否有一方胜利。可以按如下步骤来判断： 枚举棋盘上的每一个位置，如果这个位置有棋子，就向四个方向(上下左右)扩展，如果有五个连续的相同颜色的棋子，就表示这一方胜利。 如果棋盘已经满了，但是没...
Java五子棋（人机版），昨天买的棋子今天就用不上了
javadada1197的博客
07-22 1753
效果图 由于篇长的原因有需要LeetCode刷题笔记+视频中源码资料+Java全栈开发学习路线图私信回复“java笔记” 实现思路 1.创建运行窗口并添加背景色。 2.绘制棋盘。 3.用二维数组来控制起码落子位置、绘制指示器。 4.鼠标在落子位置处点击可落子。 5.落子后检查是否获得胜利。 6.机器判断下一步，并落子。 7.机器判断是否获得胜利。 代码实现 创建窗口 首先创建一个...
java五子棋
meiyijian的博客
08-11 8689
java五子棋总结 刚刚学习java不久，尝试自己做了一个五子棋先附上一个运行效果的图： 五子棋的主要目的： 1.练习java面向对象的编程思想 2.掌握监听器的使用（鼠标监听器） 制作五子棋为了代码的可扩充性，我们首先要定义一个五子棋的各个属性的接口： /** * 五子棋的相关属性 * @author Administrator * */ public int
Java五子棋
m0_58730471的博客
08-15 2810
java，小游戏，五子棋，大作业
JAVA五子棋
smdnzhan的博客
09-24 703
一个简单的JAVA小项目，主要实现的功能有： 一、下棋功能，在棋盘的交点处落子。 二、悔棋功能，取消最后一颗下的棋子。 三、简单人机对战功能。 1.窗体实现。主要使用了JFrame类 public class GameUI { public static void main(String[] args) { GameUI ui = new GameUI(); ui.showUI(); } //显示游戏界面 public vo
java五子棋人机对战项目
11-10
【Java五子棋人机对战项目】是一个利用JavaSwing图形用户界面库开发的桌面游戏应用程序，专注于提供一个互动的五子棋游戏环境。在这个项目中，玩家可以与计算机进行对弈，体验到一定程度的智能挑战。智能的实现主要...
java五子棋人机对战
03-13
在本项目中，"java五子棋人机对战"是一个使用Java编程语言实现的五子棋游戏。这个游戏不仅提供了人机对战模式，还支持玩家之间的对战，展现了Java在开发交互式游戏方面的应用。下面我们将深入探讨相关知识点。 1. *...
java五子棋人机人人
01-13
Java五子棋人机人人项目是一个利用Java编程语言实现的五子棋游戏，它支持人与人对战、人与计算机对战以及计算机与计算机之间的对战模式。在这个项目中，我们将探讨Java编程基础、图形用户界面（GUI）设计、算法实现...
wuziqi.rar_java 五子棋_wuziqi java_五子棋 java_五子棋 人机 java_五子棋 棋盘
09-19
五子棋是一种双人策略棋类游戏，目标是先在棋盘上形成连续的五个棋子（横向、纵向或对角线方向）来赢得比赛。这个特定的实现提供了多种棋盘尺寸供玩家选择，并且支持人机对战和双人对战模式。 首先，我们要理解Java...
用Java实现五子棋人机博弈.pdf
最新发布
01-01
"用Java实现五子棋人机博弈.pdf" 本文主要介绍了使用Java语言在NetBeans IDE 5.0环境中实现五子棋人机博弈的过程，该过程包括设计思路、具体设计和实现细节。 知识点1：设计思路 在设计五子棋人机博弈时，需要...
java游戏之五子棋
12-07
java游戏五子棋，更多开源游戏见博客http://blog.csdn.net/simon_world
基于Java实现的五子棋
08-31
基于JAVA语言，开发五子棋游戏，新增分数机制，不死机制等
Java实现五子棋
01-16
下载后是一个txt，txt内有百度云链接和直链 包含完整代码，是用eclipse写的，下载即可运行，新手可以参考下 如有问题，请联系邮箱：aliulf@foxmail.com
java实现五子棋
12-03
java实现的五子棋，加入智能落子功能 java实现的五子棋，加入智能落子功能
简单五子棋
Wen先森的博客
12-30 202
package demo; import java.util.Scanner; public class GoBang { //声明一个二维数组存储棋盘的行和列。 private static char[][] ChessBoard; //声明棋盘行和列的序号（即定义坐标） private static char[]number= { '1','2','3','4','5','6','7','8','9', 'A','B','C','D','E','F','G','H','I'.
【Java之五子棋】——java五子棋游戏
热门推荐
qq_50497708的博客
01-09 1万+
基本思路： 1.先有一个界面可以弹出窗口，在界面上重写paint方法，在这个方法里加入棋盘，使得棋盘可以不断重绘，不会因为刷新而消失； 2.创建鼠标监听器，为了让鼠标监听器界面可以下黑白棋子； 3.再创建一个判断输赢的类，可以用数组来存储棋子 接下来完成具体步骤： 1.创建一个Gobang的类，继承了JFrame的功能，因此以前会写jf.setTitle("五子棋")；这里就可以用this代替或者不写，下面这四个就是分别用了这两个方法 2.重写paint方法，绘制棋盘 可以先画两条直线
Java小游戏——五子棋
weixin_51937688的博客
04-29 2691
文章目录内容简介一、规则二、具体代码实现1.调试环境2.代码实现3.运行演示小结彩蛋 内容简介 本文介绍了一个修改自某位大佬的五子棋小游戏qwq 目前可以实现简单的双人对战~ 原文传送门 GitHub传送门 以下是本篇文章正文内容 一、规则 本程序作为基础的五子棋，连成五个即可获胜，没有设置禁手。 注：五子棋RIF规则中黑棋只能以“四、三”取胜 二、具体代码实现 1.调试环境 开发环境为Eclipse。 2.代码实现 大致结构 具体代码如下： 1.GoBangframe类 package GoBang
JAVA简单五子棋
weixin_47596965的博客
06-08 1370
JAVA简单五子棋，这几天刚做的，放在CSDN也是为了保存自己的成果吧。``因为只是一名大一生刚接触java所以有些专业词用的不到位。见谅见谅，也没有做悔棋和剩余时间，嘿嘿 package com.Swing; import java.awt.BasicStroke; import java.awt.Color; import java.awt.Font; import java.awt.Frame; import java.awt.Graphics; import java.awt.Graphics2D;
Java项目（五子棋）
G_Y_Chen的博客
11-28 930
五子棋功能分析界面绘制下棋策略胜负判定棋局录制与回放悔棋功能实现界面绘制与更新胜负判定策略回放悔棋项目优化界面重构时棋盘闪烁问题解决方案整体展示界面展示代码 功能分析 界面绘制 界面分为棋盘区域和按键面板 整体界面为1500×1000 棋盘区域背景色为浅灰色，棋盘为21×21大小间隔45个像素点，放置在左侧 按键面板背景色为白色，大小为500×1000，共放置5个按键“开始游戏，悔棋，认输，回放，退出游戏” 下棋策略 棋子放置在棋盘线的交汇点上 黑白交替下棋 胜负判定 每下颗棋子后进行胜负判定 输
java五子棋人机大战
12-15
Java五子棋人机大战是一款基于Java语言开发的五子棋游戏，它可以让玩家与计算机进行对战。在游戏中，玩家可以选择先手或后手，然后与计算机进行对弈。游戏中的计算机AI可以根据当前棋局的情况，选择最优的下棋位置，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值