Java弱智电脑五子棋大战

直接主题，下面是两个电脑的五子棋Java代码

import java.util.Random;

public class WuZiQi03 {
    // 让人脑溢血的电脑五子棋世纪大战
    // 绘制棋盘
    // 第一步 设置二维数组
    static String[][] zi = new String[10][10];

    public static void main(String[] args) {
        // 创建棋盘，调用方法
        jia(); // 给这个数组里所有的一维数组改为加号。
        qi();  // 将棋盘绘制出来
        xia(); // 下棋字 绘制出下完棋子的棋盘
    }
    // 给这个数组里所有的一维数组改为加号的方法
    public static void jia(){
        for (int i = 0; i < zi.length; i++) {
            for (int j = 0; j < zi[i].length; j++) {
                zi[i][j] = "+";
            }
        }
    }
    // 将棋盘绘制出来的方法
    public static void qi(){
        System.out.print(" ");
        for (int i = 0; i < 11; i++) {  //写出x轴的位置（1、2、3...），方便看到棋子下到哪里
            System.out.print(i + "  "); //在棋盘上面打印出坐标 1 2 3 4 ....
        }
        System.out.println();
        int u = 0;
        for (int i = 0; i < zi.length; i++) {
            u++;                        //在棋盘左面打印出坐标 1 2 3 4 ....
            System.out.print(u + "\t"); //写出y轴的位置（1、2、3...），方便看到棋子下到哪里
            for (int j = 0; j < zi[i].length; j++) {
                System.out.print(zi[i][j] + "  "); // 棋盘每到10行换行，使用System.out.print是不换行的意思。
            }
            System.out.println(); // 不需要输出任何东西时，它也可以提供换行的作用，
        }                         // 上面代码的意思，每当一维数组里的数值变为＋号后，换行。新的一维数值重新赋值＋号，之道棋盘绘制完成。
    }
    // 下棋字 绘制出下完棋子的棋盘的方法
    public static void xia(){
        boolean tuo = true; //既然是下棋，必须要有两个玩家，声明一个布尔型的值为true，用它来交换选手。
        while (true){       //因为要五个棋子相连，所有使用死循环，之道五子相连，退出循环。
            if (tuo){       //当布尔值为true时，A选手下棋。
                Util.yin("A选手下棋");
                //用两个弱智电脑下棋，不再需要自己手动输入，可以更好的发现代码中忽略问题，想和朋友下棋，下面改为输入即可。
                Random r = new Random();    // 使用随机数来充当一个弱智电脑。
                int x = r.nextInt(10)+1; // 这里随机数加1是因为除了这里改为随机数以外的所有代码，都是之前自己输入2个坐标下棋子
                int y = r.nextInt(10)+1; // 下面的代码都是为了方便用户输入一个数值，同时对应上数值里的数值，因为数组的坐标是从
                                                // 0开始的。用户输入1要对应的是数组的坐标0，因此下面的坐标x、y的坐标都减1
                if (pan(x,y)){ // if () 里面调用了判断下棋棋子是否超出范围的方法
                    Util.yin("请输入棋盘范围内的数字！"); // 使用的是人机的话 ，忽略这行代码。玩家自己输入棋子坐标时，这是用来判断
                    continue;                             // 玩家输入的范围是否在五子棋的范围里面，若不是重新循环。
                }
                if (pan1(x,y)){ // if () 里面调用了判断下棋是否位置上有棋子的方法
                    Util.yin("这个位置上已经有一个棋子了");// 这里有一个白棋或黑棋，就不能在下了。判断下的棋子位置上是否有棋子，位置上
                    continue;                             // 位置上有棋子 ，结束当前循环，重新输入一个坐标。
                }else {
                    zi[x-1][y-1] = "⚪";     //反之没有，就可以下棋子了
                    qi();  // 下完棋子后，当然要调用新的下完棋子的棋盘。
                    // 五子棋的赢法有 竖着5个 横着5个 左上右下5个 左下右上5个方法。只要满足一个条件，就赢了。下面就是调用4种胜利的方法
                    boolean g = shangxia(x,y,zi[x-1][y-1]+"");//竖着5个赢
                    boolean g1 = zuoyou(x,y,zi[x-1][y-1]+"");//横着5个赢
                    boolean g2 = zuoshang(x,y,zi[x-1][y-1]+"");//左上右下5个赢
                    boolean g3 = zuoxia(x,y,zi[x-1][y-1]+"");//左下右上5个赢
                    if (g || g1 || g2 || g3){
                        System.out.println("A选手胜利");
                        break; //一个玩家赢了自然结束循环。
                    }
                }
                // B选手下棋自然与上面白棋是一样的。
            }else {
                Util.yin("B选手下棋");
                Random r = new Random();
                int x = r.nextInt(10)+1;
                int y = r.nextInt(10)+1;
                if (pan(x,y)){
                    Util.yin("请输入棋盘范围内的数字！");
                    continue;
                }
                if (pan1(x,y)){
                    Util.yin("这个位置上已经有一个棋子了");
                    continue;
                }else {
                    zi[x-1][y-1] = "●";
                    qi();
                    boolean g = shangxia(x,y,zi[x-1][y-1]+"");
                    boolean g1 = zuoyou(x,y,zi[x-1][y-1]+"");
                    boolean g2 = zuoshang(x,y,zi[x-1][y-1]+"");
                    boolean g3 = zuoxia(x,y,zi[x-1][y-1]+"");
                    if (g || g1 || g2 || g3){
                        System.out.println("B选手胜利");
                        break;
                    }
                }
            }
            tuo = !tuo;// !是取反的意思，每当一个玩家下完棋后这里的值会从true变为false,再从false变为true，反复循环，之道一方玩家胜利。
        }
    }
    // 这个方法是用来判断棋子是否超出范围 ，一但输入的数值超出范围，返回true，实行重新输入。
    public static boolean pan(int x, int y){
        if ( x > 10 || y >10 || x < 1 || y <1){
            return true;
        }
        return false;
    }
    // 这个方法是用来判断位置上是否有棋子 ，一但有棋子，返回true，实行重新输入。
    public static boolean pan1(int x,int y){
        if (zi[x-1][y-1].equals("⚪") || zi[x-1][y-1].equals("●")){
            return true;
        }
        return false;
    }
    //这个方法是用来判断左右五子是否相连。
    public static boolean zuoyou(int x,int y,String s){
        int n = 0;   // 声明一个变量，当判断到5个子相连就返回true。
        for (int i = 1; i < 5; i++) {  // 这个判断五子棋左边是否有4个棋子。
            if (y-i>0){
                if (zi[x-1][(y-1)-i].equals(s)){ // 判断左边相连 y 每次循环自然要减1。
                    n++;               // 如果有棋子，n就会加1，反之n就不会加1
                }else {
                    break;// 当判断到左边只有1个或2个棋子相连的棋子，再往左碰见不一样的棋子或没有棋子时，结束循环。因为后面不用在判断了
                }         // 只需要判断相连的棋子，没有相连的棋子不需要判断。所有判断方向上的棋子相连，都是这个逻辑。
            }
        }
        for (int i = 1; i < 5; i++) { // 这个判断五子棋右边是否有4个棋子。
            if ((y-1)+i<10){
                if (zi[x-1][(y-1)+i].equals(s)){// 判断右边相连 y 每次循环自然要加1。
                    n++;
                }else {
                    break;
                }
            }
        }
        if (n >= 4){ // 当左边有4个或右边有4个或左右合起来有4个的时候，返回true，玩家胜利
            return true;
        }
        return false; // 反之当没有4个的时候 返回false 判断其他方法是否胜利。
    }
    //这个方法是用来判断上下是否相连
    public static boolean shangxia(int x,int y,String s){
        int n = 0;
        for (int i = 1; i < 5; i++) { // 这个判断五子棋上方是否有4个棋子。
            if (x-i>0){
                if (zi[(x-1)-i][(y-1)].equals(s)){// 判断上边相连 x 每次循环自然要减1。
                    n++;
                }else {
                    break;
                }
            }
        }
        for (int i = 1; i < 5; i++) { // 这个判断五子棋下方是否有4个棋子。
            if ((x-1)+i<10){
                if (zi[(x-1)+i][(y-1)].equals(s)){// 判断下边相连 x 每次循环自然要加1。
                    n++;
                }else {
                    break;
                }
            }
        }
        if (n >= 4){
            return true;
        }
        return false;
    }
    //这个方法是用来判断上左下右是否相连
    public static boolean zuoshang(int x,int y,String s){
        // 道理与横竖一样，每次判断变为x+1、y+1或x-1、y-1。
        int n = 0;
        for (int i = 1; i < 5; i++) {
            if (x-i>0 && y-i>0){
                if (zi[(x-1)-i][(y-1)-i].equals(s)){ 
                    n++;
//                    System.out.println(n);
                }else {
                    break;
                }
            }
        }
        for (int i = 1; i < 5; i++) {
            if ((x-1)+i<10 && (y-1)+i<10){
                if (zi[(x-1)+i][(y-1)+i].equals(s)){
                    n++;
//                    System.out.println(n);
                }else {
                    break;
                }
            }
        }
        if (n >= 4){
            return true;
        }
        return false;
    }
    //这个方法是用来判断上右下左是否相连
    public static boolean zuoxia(int x,int y,String s){
        // 道理与横竖一样，每次判断变为x+1、y-1或x-1、y+1。
        int n = 0;
        for (int i = 1; i < 5; i++) {
            if (y-i>0 && (x-1)+i<10){
                if (zi[(x-1)+i][(y-1)-i].equals(s)){
                    n++;
//                                System.out.println(n);
                }else {
                    break;
                }
            }
        }
        for (int i = 1; i < 5; i++) {
            if (x-i>0 && (y-1)+i<10){
                if (zi[(x-1)-i][(y-1)+i].equals(s)){
                    n++;
//                                System.out.println(n);
                }else {
                    break;
                }
            }
        }
        if (n >= 4){
            return true;
        }
        return false;
    }

}

结果

 0  1  2  3  4  5  6  7  8  9  10  
1	+  +  +  +  +  +  +  +  +  +  
2	+  +  +  +  +  +  +  +  +  +  
3	+  +  +  +  +  +  +  +  +  +  
4	+  +  +  +  +  +  +  +  +  +  
5	+  +  +  +  +  +  +  +  +  +  
6	+  +  +  +  +  +  +  +  +  +  
7	+  +  +  +  +  +  +  +  +  +  
8	+  +  +  +  +  +  +  +  +  +  
9	+  +  +  +  +  +  +  +  +  +  
10	+  +  +  +  +  +  +  +  +  + 
........
B选手下棋
 0  1  2  3  4  5  6  7  8  9  10  
1	⚪  +  ●  ⚪  ●  ⚪  ●  ⚪  ⚪  +  
2	+  +  ⚪  ⚪  ⚪  +  ⚪  +  +  ⚪  
3	+  +  ●  ●  +  ⚪  ⚪  ●  ●  ⚪  
4	⚪  ●  +  +  +  ⚪  +  +  ●  ●  
5	●  +  ●  +  +  +  ●  +  +  +  
6	⚪  ●  +  +  ⚪  ●  +  ⚪  ●  +  
7	⚪  +  ●  ●  ●  ⚪  ●  ●  ●  ⚪  
8	+  ⚪  +  ●  ⚪  ⚪  +  +  +  +  
9	⚪  +  ⚪  +  ●  +  ⚪  ⚪  ●  ●  
10	●  ●  ●  ⚪  +  +  +  +  +  +  
B选手胜利

好吧，其实只是加了一个随机数而已，但每次看结果都竟然大战了两百回合也是让人意想不到，这个五子棋方法重点只是为了测试写出的五子棋是否有各式各样的bug，方便我们发现问题，解决问题，当测试没有问题的时候，就找个小伙伴一起玩耍吧。