Java Swing斗兽棋

于 2023-08-30 08:03:05 发布
阅读量192 收藏
点赞数 1
分类专栏： 个人-程序作品集 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61799540/article/details/132574677
版权

Java Swing斗兽棋

设计思路

1.Cell 类：
这个类代表棋盘上的一个格子，也就是棋盘上的一个位置。每个格子可以包含一个棋子，用于表示在该位置上是否有棋子存在。

2.ChessboardPoint 类：
这个类代表棋盘上的一个点，使用行和列来标识棋盘上的位置。这在表示棋子的位置以及在棋盘上点击的位置时很有用。

3.ChessPiece 类：
这个类表示棋子，包含了棋子的所有属性。每个棋子有一个所有者（蓝色或红色玩家）、名称（象、鼠等）以及等级（表示棋子的力量）。这个类还包含了一个方法 canCapture，用于判断一个棋子是否可以吃掉另一个棋子。

4.PlayerColor 枚举类：
这个枚举类定义了玩家的颜色，即蓝色和红色。每个颜色都与一个Java的Color对象关联，用于在界面上显示不同玩家的棋子。

5.Constant 枚举类：
这个枚举类定义了一些常量，包括棋盘的行数和列数。这些常量可以在代码中被引用，使得代码更加可读和易于维护。

通过上述代码片段，可以看出这个斗兽棋游戏的实现是基于面向对象的设计。不同的类代表了游戏中的不同实体和概念，如棋盘、棋子、玩家颜色等。棋子之间的互动规则在 ChessPiece 类中被定义，包括了棋子的移动和吃掉其他棋子的规则。PlayerColor 枚举类用于表示玩家的颜色，这在界面上用不同的颜色显示不同玩家的棋子。

运行图片

在这里插入图片描述
请添加图片描述

请添加图片描述
请添加图片描述
请添加图片描述

相关代码

package boardForJunjun;

import java.awt.*;

/**
 * This class store the real chess information.
 * The Chessboard has 9*7 cells, and each cell has a position for chess
 */
public class Chessboard {
    private Cell[][] grid;

    public Chessboard() {
        this.grid = new Cell[Constant.CHESSBOARD_ROW_SIZE.getNum()][Constant.CHESSBOARD_COL_SIZE.getNum()];//19X19
        initGrid();
        initPieces();
    }

    private void initGrid() {
        for (int i = 0; i < Constant.CHESSBOARD_ROW_SIZE.getNum(); i++) {
            for (int j = 0; j < Constant.CHESSBOARD_COL_SIZE.getNum(); j++) {
                grid[i][j] = new Cell();
            }
        }
    }
    public void initPieces() {
        grid[2][6].setPiece(new ChessPiece(PlayerColor.BLUE, "Elephant", 8));
        grid[0][0].setPiece(new ChessPiece(PlayerColor.BLUE, "Lion", 7));
        grid[0][6].setPiece(new ChessPiece(PlayerColor.BLUE, "Tiger", 6));
        grid[2][2].setPiece(new ChessPiece(PlayerColor.BLUE, "Leopard", 5));
        grid[2][4].setPiece(new ChessPiece(PlayerColor.BLUE, "Wolf", 4));
        grid[1][1].setPiece(new ChessPiece(PlayerColor.BLUE, "Dog", 3));
        grid[1][5].setPiece(new ChessPiece(PlayerColor.BLUE, "Cat", 2));
        grid[2][0].setPiece(new ChessPiece(PlayerColor.BLUE, "Rat", 1));
        grid[6][0].setPiece(new ChessPiece(PlayerColor.RED, "Elephant", 8));
        grid[8][6].setPiece(new ChessPiece(PlayerColor.RED, "Lion", 7));
        grid[8][0].setPiece(new ChessPiece(PlayerColor.RED, "Tiger", 6));
        grid[6][4].setPiece(new ChessPiece(PlayerColor.RED, "Leopard", 5));
        grid[6][2].setPiece(new ChessPiece(PlayerColor.RED, "Wolf", 4));
        grid[7][5].setPiece(new ChessPiece(PlayerColor.RED, "Dog", 3));
        grid[7][1].setPiece(new ChessPiece(PlayerColor.RED, "Cat", 2));
        grid[6][6].setPiece(new ChessPiece(PlayerColor.RED, "Rat", 1));
    }

    private ChessPiece getChessPieceAt(ChessboardPoint point) {
        return getGridAt(point).getPiece();
    }
    public Cell getGridAt(ChessboardPoint point) {
        return grid[point.getRow()][point.getCol()];
    }

    //下面这个方法可以不看，是计算两点之间距离用的
    private int calculateDistance(ChessboardPoint src, ChessboardPoint dest) {
        return Math.abs(src.getRow() - dest.getRow()) + Math.abs(src.getCol() - dest.getCol());
    }

    private ChessPiece removeChessPiece(ChessboardPoint point) {
        ChessPiece chessPiece = getChessPieceAt(point);
        getGridAt(point).removePiece();//point包含了行和列//这个removePiece是cell里面的一个方法，是令这里的piece变成null
        return chessPiece;
    }

    private void setChessPiece(ChessboardPoint point, ChessPiece chessPiece) {
        getGridAt(point).setPiece(chessPiece);
    }

    public void moveChessPiece(ChessboardPoint point1, ChessboardPoint point2) {//我把这里的src改成了point1，方便理解这是一个point
        if (!isValidMove(point1, point2)) {//判断是不是有效的移动
            throw new IllegalArgumentException("Illegal chess move!");
        }
        setChessPiece(point2, removeChessPiece(point1));//如果是的，就把Point1移走，然后把原本的棋子放到Point2的位置
        //在setChessPiece这个方法里，point2的意思是放上的棋子的位置，
        // removeChessPiece后面的point1是指把该位置的棋子移走，但是它的返回值是一个chessPiece
    }
    public void captureChessPiece(ChessboardPoint point1, ChessboardPoint point2) {
        removeChessPiece(point2);
        setChessPiece(point2, removeChessPiece(point1));
//        if (isValidCapture(point1, point2)) {
//            throw new IllegalArgumentException("Illegal chess capture!");
//        } else {
//            removeChessPiece(point1);
//            removeChessPiece(point2);
//            setChessPiece(point2, getChessPieceAt(point1));
//        }
        // TODO: Finish the method.
    }
    //chessboard里面的类
    public void removeAllPieces () {
        for (int i = 0; i < Constant.CHESSBOARD_ROW_SIZE.getNum(); i++) {
            for (int j = 0; j < Constant.CHESSBOARD_COL_SIZE.getNum(); j++) {
                if (grid[i][j].getPiece() != null){
                    grid[i][j].setPiece(null);
                }
            }
        }
    }
    public Cell[][] getGrid() {
        return grid;
    }

    public PlayerColor getChessPieceOwner(ChessboardPoint point) {
        return getGridAt(point).getPiece().getOwner();
    }

    public boolean isValidMove(ChessboardPoint point1, ChessboardPoint point2) {
        if (getChessPieceAt(point1) == null || getChessPieceAt(point2) != null) {
            return false;
        }
        if ((getGridAt(point2)==grid[3][1]||getGridAt(point2)==grid[3][2]||getGridAt(point2)==grid[3][4]||getGridAt(point2)==grid[3][5]||getGridAt(point2)==grid[4][1]||getGridAt(point2)==grid[4][2]||getGridAt(point2)==grid[4][4]||getGridAt(point2)==grid[4][5]||getGridAt(point2)==grid[5][1]||getGridAt(point2)==grid[5][2]||getGridAt(point2)==grid[5][4]||getGridAt(point2)==grid[5][5])) {
            if (getChessPieceAt(point1).getName() != "Rat") {
                return false;
            } else {
                return calculateDistance(point1, point2) == 1;
            }
        }//鼠可以进河
        if (getGridAt(point2)==grid[8][3] && getChessPieceAt(point1).getOwner() ==PlayerColor.RED ) {
            return false;
        }
        if (getGridAt(point2)==grid[0][3] && getChessPieceAt(point1).getOwner() ==PlayerColor.BLUE) {
            return false;
        }
        if (calculateDistance(point1, point2) > 1
                && (getChessPieceAt(point1).getName() == "Lion" || getChessPieceAt(point1).getName() == "Tiger")) {
            if (point1.getCol() == 0 && point1.getRow() == 3 && point2.getRow() == 3 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(3, 1)) == null && getChessPieceAt(new ChessboardPoint(3, 2)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 0 && point1.getRow() == 4 && point2.getRow() == 4 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(4, 1)) == null && getChessPieceAt(new ChessboardPoint(4, 2)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 0 && point1.getRow() == 5 && point2.getRow() == 5 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(5, 1)) == null && getChessPieceAt(new ChessboardPoint(5, 2)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 3 && point1.getRow() == 3 && point2.getRow() == 3 && point2.getCol() == 0) {
                if (getChessPieceAt(new ChessboardPoint(3, 1)) == null && getChessPieceAt(new ChessboardPoint(3, 2)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 3 && point1.getRow() == 4 && point2.getRow() == 4 && point2.getCol() == 0) {
                if (getChessPieceAt(new ChessboardPoint(4, 1)) == null && getChessPieceAt(new ChessboardPoint(4, 2)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 3 && point1.getRow() == 5 && point2.getRow() == 5 && point2.getCol() == 0) {
                if (getChessPieceAt(new ChessboardPoint(5, 1)) == null && getChessPieceAt(new ChessboardPoint(5, 2)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 3 && point1.getCol() == 3 && point2.getRow() == 3 && point2.getCol() == 6) {
                if (getChessPieceAt(new ChessboardPoint(3, 4)) == null && getChessPieceAt(new ChessboardPoint(3, 5)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 4 && point1.getCol() == 3 && point2.getRow() == 4 && point2.getCol() == 6) {
                if (getChessPieceAt(new ChessboardPoint(4, 4)) == null && getChessPieceAt(new ChessboardPoint(4, 5)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 5 && point1.getCol() == 3 && point2.getRow() == 5 && point2.getCol() == 6) {
                if (getChessPieceAt(new ChessboardPoint(5, 4)) == null && getChessPieceAt(new ChessboardPoint(5, 5)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 3 && point1.getCol() == 6 && point2.getRow() == 3 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(3, 4)) == null && getChessPieceAt(new ChessboardPoint(3, 5)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 4 && point1.getCol() == 6 && point2.getRow() == 4 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(4, 4)) == null && getChessPieceAt(new ChessboardPoint(4, 5)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 5 && point1.getCol() == 6 && point2.getRow() == 5 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(5, 4)) == null && getChessPieceAt(new ChessboardPoint(5, 5)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 2 && point1.getCol() == 1 && point2.getRow() == 6 && point2.getCol() == 1) {
                if (getChessPieceAt(new ChessboardPoint(3, 1)) == null && getChessPieceAt(new ChessboardPoint(4, 1)) == null && getChessPieceAt(new ChessboardPoint(5, 1)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 6 && point1.getCol() == 1 && point2.getRow() == 2 && point2.getCol() == 1) {
                if (getChessPieceAt(new ChessboardPoint(3, 1)) == null && getChessPieceAt(new ChessboardPoint(4, 1)) == null && getChessPieceAt(new ChessboardPoint(5, 1)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 2 && point1.getCol() == 2 && point2.getRow() == 6 && point2.getCol() == 2) {
                if (getChessPieceAt(new ChessboardPoint(3, 2)) == null && getChessPieceAt(new ChessboardPoint(4, 2)) == null && getChessPieceAt(new ChessboardPoint(5, 2)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 6 && point1.getCol() == 2 && point2.getRow() == 2 && point2.getCol() == 2) {
                if (getChessPieceAt(new ChessboardPoint(3, 2)) == null && getChessPieceAt(new ChessboardPoint(4, 2)) == null && getChessPieceAt(new ChessboardPoint(5, 2)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 2 && point1.getCol() == 4 && point2.getRow() == 6 && point2.getCol() == 4) {
                if (getChessPieceAt(new ChessboardPoint(3, 4)) == null && getChessPieceAt(new ChessboardPoint(4, 4)) == null && getChessPieceAt(new ChessboardPoint(5, 4)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 6 && point1.getCol() == 4 && point2.getRow() == 2 && point2.getCol() == 4) {
                if (getChessPieceAt(new ChessboardPoint(3, 4)) == null && getChessPieceAt(new ChessboardPoint(4, 4)) == null && getChessPieceAt(new ChessboardPoint(5, 4)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 2 && point1.getCol() == 5 && point2.getRow() == 6 && point2.getCol() == 5) {
                if (getChessPieceAt(new ChessboardPoint(3, 5)) == null && getChessPieceAt(new ChessboardPoint(4, 5)) == null && getChessPieceAt(new ChessboardPoint(5, 5)) == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 6 && point1.getCol() == 5 && point2.getRow() == 2 && point2.getCol() == 5) {
                if (getChessPieceAt(new ChessboardPoint(3, 5)) == null && getChessPieceAt(new ChessboardPoint(4, 5)) == null && getChessPieceAt(new ChessboardPoint(5, 5)) == null) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }//狮虎可以跨河
        return calculateDistance(point1, point2) == 1;//在本class中的一个方法，用于计算两点之间的距离，如果距离为一就是true，否则为false
    }
    public boolean isValidCapture(ChessboardPoint point1, ChessboardPoint point2) {
        if (getChessPieceAt(point1) == null || getChessPieceAt(point2) == null) {
            return false;
        }//有一个为空
        if (getChessPieceAt(point1).getOwner() == getChessPieceOwner(point2)) {
            return false;
        }//两个都是同一方
        if((getGridAt(point1)==grid[0][2]||getGridAt(point1)==grid[0][4]||getGridAt(point1)==grid[1][3])&&getChessPieceAt(point2).getOwner() ==PlayerColor.BLUE&&getChessPieceAt(point1).getOwner() ==PlayerColor.RED){
            return  false;
        }
        if((getGridAt(point1)==grid[8][2]||getGridAt(point1)==grid[8][4]||getGridAt(point1)==grid[7][3])&&getChessPieceAt(point2).getOwner() ==PlayerColor.RED&&getChessPieceAt(point1).getOwner() ==PlayerColor.BLUE){
            return  false;
        }
        if ((getGridAt(point1)==grid[3][1]||getGridAt(point1)==grid[3][2]||getGridAt(point1)==grid[3][4]||getGridAt(point1)==grid[3][5]||getGridAt(point1)==grid[4][1]||getGridAt(point1)==grid[4][2]||getGridAt(point1)==grid[4][4]||getGridAt(point1)==grid[4][5]||getGridAt(point1)==grid[5][1]||getGridAt(point1)==grid[5][2]||getGridAt(point1)==grid[5][4]||getGridAt(point1)==grid[5][5])&&(getGridAt(point2)!=grid[3][1]&&getGridAt(point2)!=grid[3][2]&&getGridAt(point2)!=grid[3][4]&&getGridAt(point2)!=grid[3][5]&&getGridAt(point2)!=grid[4][1]&&getGridAt(point2)!=grid[4][2]&&getGridAt(point2)!=grid[4][4]&&getGridAt(point2)!=grid[4][5]&&getGridAt(point2)!=grid[5][1]&&getGridAt(point2)!=grid[5][2]&&getGridAt(point2)!=grid[5][4]&&getGridAt(point2)!=grid[5][5])) {
            return false;
        }
        if ((getGridAt(point2)==grid[3][1]||getGridAt(point2)==grid[3][2]||getGridAt(point2)==grid[3][4]||getGridAt(point2)==grid[3][5]||getGridAt(point2)==grid[4][1]||getGridAt(point2)==grid[4][2]||getGridAt(point2)==grid[4][4]||getGridAt(point2)==grid[4][5]||getGridAt(point2)==grid[5][1]||getGridAt(point2)==grid[5][2]||getGridAt(point2)==grid[5][4]||getGridAt(point2)==grid[5][5])&&(getGridAt(point1)!=grid[3][1]&&getGridAt(point1)!=grid[3][2]&&getGridAt(point1)!=grid[3][4]&&getGridAt(point1)!=grid[3][5]&&getGridAt(point1)!=grid[4][1]&&getGridAt(point1)!=grid[4][2]&&getGridAt(point1)!=grid[4][4]&&getGridAt(point1)!=grid[4][5]&&getGridAt(point1)!=grid[5][1]&&getGridAt(point1)!=grid[5][2]&&getGridAt(point1)!=grid[5][4]&&getGridAt(point1)!=grid[5][5])) {
            return false;
        }
        if((getGridAt(point2)==grid[0][2]||getGridAt(point2)==grid[0][4]||getGridAt(point2)==grid[1][3])&&getChessPieceAt(point1).getOwner() ==PlayerColor.BLUE&&getChessPieceAt(point2).getOwner() ==PlayerColor.RED){
            return  true;
        }
        if((getGridAt(point2)==grid[8][2]||getGridAt(point2)==grid[8][4]||getGridAt(point2)==grid[7][3])&&getChessPieceAt(point1).getOwner() ==PlayerColor.RED&&getChessPieceAt(point2).getOwner() ==PlayerColor.BLUE){
            return  true;
        }
        if (calculateDistance(point1, point2) > 1
                && (getChessPieceAt(point1).getName() == "Lion" || getChessPieceAt(point1).getName() == "Tiger")) {
            if (point1.getCol() == 0 && point1.getRow() == 3 && point2.getRow() == 3 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(3, 1)) == null && getChessPieceAt(new ChessboardPoint(3, 2)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 0 && point1.getRow() == 4 && point2.getRow() == 4 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(4, 1)) == null && getChessPieceAt(new ChessboardPoint(4, 2)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 0 && point1.getRow() == 5 && point2.getRow() == 5 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(5, 1)) == null && getChessPieceAt(new ChessboardPoint(5, 2)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 3 && point1.getRow() == 3 && point2.getRow() == 3 && point2.getCol() == 0) {
                if (getChessPieceAt(new ChessboardPoint(3, 1)) == null && getChessPieceAt(new ChessboardPoint(3, 2)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 3 && point1.getRow() == 4 && point2.getRow() == 4 && point2.getCol() == 0) {
                if (getChessPieceAt(new ChessboardPoint(4, 1)) == null && getChessPieceAt(new ChessboardPoint(4, 2)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getCol() == 3 && point1.getRow() == 5 && point2.getRow() == 5 && point2.getCol() == 0) {
                if (getChessPieceAt(new ChessboardPoint(5, 1)) == null && getChessPieceAt(new ChessboardPoint(5, 2)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 3 && point1.getCol() == 3 && point2.getRow() == 3 && point2.getCol() == 6) {
                if (getChessPieceAt(new ChessboardPoint(3, 4)) == null && getChessPieceAt(new ChessboardPoint(3, 5)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 4 && point1.getCol() == 3 && point2.getRow() == 4 && point2.getCol() == 6) {
                if (getChessPieceAt(new ChessboardPoint(4, 4)) == null && getChessPieceAt(new ChessboardPoint(4, 5)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 5 && point1.getCol() == 3 && point2.getRow() == 5 && point2.getCol() == 6) {
                if (getChessPieceAt(new ChessboardPoint(5, 4)) == null && getChessPieceAt(new ChessboardPoint(5, 5)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 3 && point1.getCol() == 6 && point2.getRow() == 3 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(3, 4)) == null && getChessPieceAt(new ChessboardPoint(3, 5)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 4 && point1.getCol() == 6 && point2.getRow() == 4 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(4, 4)) == null && getChessPieceAt(new ChessboardPoint(4, 5)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 5 && point1.getCol() == 6 && point2.getRow() == 5 && point2.getCol() == 3) {
                if (getChessPieceAt(new ChessboardPoint(5, 4)) == null && getChessPieceAt(new ChessboardPoint(5, 5)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 2 && point1.getCol() == 1 && point2.getRow() == 6 && point2.getCol() == 1) {
                if (getChessPieceAt(new ChessboardPoint(3, 1)) == null && getChessPieceAt(new ChessboardPoint(4, 1)) == null && getChessPieceAt(new ChessboardPoint(5, 1)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 6 && point1.getCol() == 1 && point2.getRow() == 2 && point2.getCol() == 1) {
                if (getChessPieceAt(new ChessboardPoint(3, 1)) == null && getChessPieceAt(new ChessboardPoint(4, 1)) == null && getChessPieceAt(new ChessboardPoint(5, 1)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 2 && point1.getCol() == 2 && point2.getRow() == 6 && point2.getCol() == 2) {
                if (getChessPieceAt(new ChessboardPoint(3, 2)) == null && getChessPieceAt(new ChessboardPoint(4, 2)) == null && getChessPieceAt(new ChessboardPoint(5, 2)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 6 && point1.getCol() == 2 && point2.getRow() == 2 && point2.getCol() == 2) {
                if (getChessPieceAt(new ChessboardPoint(3, 2)) == null && getChessPieceAt(new ChessboardPoint(4, 2)) == null && getChessPieceAt(new ChessboardPoint(5, 2)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 2 && point1.getCol() == 4 && point2.getRow() == 6 && point2.getCol() == 4) {
                if (getChessPieceAt(new ChessboardPoint(3, 4)) == null && getChessPieceAt(new ChessboardPoint(4, 4)) == null && getChessPieceAt(new ChessboardPoint(5, 4)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 6 && point1.getCol() == 4 && point2.getRow() == 2 && point2.getCol() == 4) {
                if (getChessPieceAt(new ChessboardPoint(3, 4)) == null && getChessPieceAt(new ChessboardPoint(4, 4)) == null && getChessPieceAt(new ChessboardPoint(5, 4)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 2 && point1.getCol() == 5 && point2.getRow() == 6 && point2.getCol() == 5) {
                if (getChessPieceAt(new ChessboardPoint(3, 5)) == null && getChessPieceAt(new ChessboardPoint(4, 5)) == null && getChessPieceAt(new ChessboardPoint(5, 5)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            }
            if (point1.getRow() == 6 && point1.getCol() == 5 && point2.getRow() == 2 && point2.getCol() == 5) {
                if (getChessPieceAt(new ChessboardPoint(3, 5)) == null && getChessPieceAt(new ChessboardPoint(4, 5)) == null && getChessPieceAt(new ChessboardPoint(5, 5)) == null) {
                    return getChessPieceAt(point1).canCapture(getChessPieceAt(point2));
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
        return calculateDistance(point1, point2) == 1&&getChessPieceAt(point1).canCapture(getChessPieceAt(point2));

    }
    public boolean  checknest(ChessboardPoint dest){
        if (getGridAt(dest)==grid[0][3]||getGridAt(dest)==grid[8][3]) {
            return true;
        }
        return false;
    }//进对方巢穴赢
    public boolean checkBlueNest(ChessboardPoint dest){
        if (getGridAt(dest)==grid[0][3]) {
            return true;
        }
        return false;
    }
    public boolean checkRedNest(ChessboardPoint dest){
        if (getGridAt(dest)==grid[8][3]) {
            return true;
        }
        return false;
    }



//    public boolean unablemove(PlayerColor currentPlayer){
//        int count=0;
//        for(int i=0;i<9;i++){
//            for(int j=0;j<7;j++){
//                if (getChessPieceAt(new ChessboardPoint(i, j)) == null || getChessPieceAt(new ChessboardPoint(i, j)).getOwner() != currentPlayer){
//                    count+=0;
//                }else {
//                    count++;
//                }
//            }
//        }if (count==0) {
//            return true;
//        }else {
//            return  false;
//        }
//    }

    public boolean UnableMove(PlayerColor currentPlayer){
        int count = 0;
        for(int i = 0; i < 9; i++){
            for(int j = 0; j < 7; j++){
                ChessPiece chessPiece = getChessPieceAt(new ChessboardPoint(i,j));
                if(chessPiece != null && currentPlayer.getColor().equals(chessPiece.getOwner().getColor())){
                    count++;
                }
            }
        }
        if(count == 0)return true;
        else return false;
    }
    public boolean BlueUnableMove(PlayerColor currentPlayer){
        int count=0;
        for(int i=0;i<9;i++){
            for(int j=0;j<7;j++){
                if (getChessPieceAt(new ChessboardPoint(i, j)) == null && currentPlayer.getColor().equals(Color.RED)){
                    count+=0;
                }else {
                    count++;
                }
            }
        }
        System.out.println(count);
        if (count==0) {
            return true;
        }else {
            return  false;
        }
    }
    public boolean RedUnableMove(PlayerColor currentPlayer){
        int count=0;
        for(int i=0;i<9;i++){
            for(int j=0;j<7;j++){
                if (getChessPieceAt(new ChessboardPoint(i, j)) == null && currentPlayer.getColor().equals(Color.BLUE)){
                    count+=0;
                }else {
                    count++;
                }
            }
        }if (count==0) {
            return true;
        }else {
            return  false;
        }
    }

    public void setGrid(Cell[][] grid) {
        this.grid = grid;
    }
}


package boardForJunjun;


public class ChessPiece {
    // the owner of the chess
    private PlayerColor owner;
    // Elephant? Cat? Dog? ...
    private String name;
    private int rank;

    public ChessPiece(PlayerColor owner, String name, int rank) {
        this.owner = owner;
        this.name = name;
        this.rank = rank;
    }

    /**
     * 在这里也有一个捕食需要我们写
     * @param target
     * @return
     */
    public boolean canCapture(ChessPiece target) {
        // TODO: Finish this method!
        if (target.getOwner() == this.owner){
            return false;
        }
        if (this.name.equals("Elephant") && target.name.equals("Rat")){
            return false;
        }
        if (this.name.equals("Rat") && target.name.equals("Elephant")){
            return true;
        }
        if (this.rank >= target.rank) {
            return true;
        }
        return false;
    }

    /**
     * 以下是getter和setter方法
     */
    public String getName() {
        return name;
    }

    public PlayerColor getOwner() {
        return owner;
    }

    public void setOwner(PlayerColor owner) {
        this.owner = owner;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }
}

运行视频

8月29日

厉掣
关注
专栏目录
java斗兽棋源码_Java 写的斗兽棋
weixin_39986435的博客
02-26 748
【实例简介】刚学Java 自己写的第一个小游戏 菜鸟【实例截图】【核心代码】AnimalGame└── AnimalGame├── bin│ ├── Animal.class│ ├── MainForm$1.class│ ├── MainForm$2.class│ ├── MainForm$3.class│ ├── MainForm$4.class│ ├── MainFor...
用java编写斗兽棋
Darvec的博客
07-18 3508
Hello 大家好！我们今天来尝试用java来编写一个斗兽棋的小游戏 可能有些人对斗兽棋比较陌生，这里简单的介绍一下。 https://baike.baidu.com/item/斗兽棋/896091?fr=aladdin 斗兽棋从写法上就比五子棋要复杂的多了 开始编程 第一步还是一样，import所需要的类库 import java.awt.Color; import java.awt.Conta...
kingofwild_斗兽棋代码_斗兽棋脚本_游戏_
10-01
HTML斗兽棋代码，包含JS脚本，图片资源，部分注释。游戏规则如下：双方有八只棋子，依大小顺序为象、狮、虎、豹、狼、犬、猫、鼠。较大的可吃较小的，同类可以互吃，而鼠则可吃象，象不能吃鼠。动物走一格，前后左右都可以。两者相同的相遇，执下一步棋的可吃对方而并不会与对方同归于尽。
Easyx-----c语言实现斗兽棋
weixin_60569662的博客
03-16 5781
原游戏链接：新斗兽棋_新斗兽棋html5游戏_4399h5游戏-h.4399.com #include<stdio.h> #include<easyx.h> #include<stdlib.h> #include<time.h> #define IMAGE_NUM_ANIMAL 8 //动物图片数量 /* 动物类型枚举 从弱到强*/ enum AnimalType { AT_None, //没有 AT_Mouse, //老鼠 AT_C....
c语言斗兽棋源代码,智能斗兽棋-智能斗兽棋下载-医源世界
weixin_39618730的博客
05-22 559
智能斗兽棋游戏是一款可以让你自己就可以在里面自己来到里面进行着战斗，并且还是可以让自己得到更多的一些收获的游戏。这个对于你来说，只要是经过了一段时间之后，肯定是会给你带来不一样的感受。但是在现在的话，整个的实力已经算得上是非常强大的了，那么在现在的话，你能够一个人战胜对手，那么就很简单了。智能斗兽棋游戏特色：1、其实这个对于你来说，这些角色也都是你自己所喜欢的，而且你自己也都是可以自己来进行操控，...
斗兽棋游戏源码下载.rar
02-21
斗兽棋游戏源码
Java 写的斗兽棋
02-15
在这个特定的案例中，"Java 写的斗兽棋" 是一个初学者用Java实现的小游戏，这表明你正在探索Java的基础和游戏开发的初步概念。 斗兽棋，又称兽棋，是一种两人对弈的策略棋类游戏，其规则相对简单，但包含了基础的...
用java编写斗兽棋2之规则与走法
Darvec的博客
07-19 2223
今天我们来写斗兽棋的规则和走法 首先介绍一下斗兽棋的一些规则： 动物的实力按照鼠、猫、狗、狼、豹、虎、狮、象从小到大排列，实力大的动物可以吃掉实力比自己小的以及和自己实力相当的动物。老鼠虽小，却能反杀大象，大象虽大，却不能奈何老鼠。 除了老鼠以外，任何动物都不能进入小河。在小河中的老鼠不能吃地上的大象，同样，地上的其他动物也不能吃小河里的老鼠，小河里的老鼠可以互相吃。 走棋时只能把棋子走到相邻的一...
简单的斗兽棋游戏（java下实现）
06-10
在Java中实现斗兽棋游戏，主要涉及以下几个关键点： 1. **用户界面**：使用Java Swing或JavaFX库创建图形用户界面（GUI），展示棋盘和棋子，允许玩家进行交互。这些库提供了丰富的组件，如按钮、面板等，用于构建...
java实现的斗兽棋游戏
07-24
【Java实现的斗兽棋游戏】是一个基于Java编程语言开发的简单桌面游戏，它展示了Java在游戏开发领域的应用。斗兽棋，又称“兽棋”，是一种策略性棋类游戏，通常由两人对弈，每方有八种不同的棋子，棋子之间存在相互...
斗兽棋游戏-微信小程序-项目源码
05-16
这是一个微信小程序项目源码，是经典怀旧的斗兽棋游戏，适合新手入门参考学习。 相关指导教程请看作者发表的文章https://blog.csdn.net/zs1028/article/details/124788721
斗兽棋(python).zip
08-31
JessicaFeng0926原作翻牌斗兽棋，在上面改动了一点，想优化成过河版或者军棋版，但ai比较难写。
C#斗兽棋demo
05-25
这是一个最简单的斗兽棋，没有局域网对战和AI，只是用来展示一个关于C#写斗兽棋的思路
斗兽棋游戏-uniapp-项目源码
05-16
这是一个uniapp项目小程序源码，是经典怀旧的斗兽棋游戏，适合新手入门参考学习。 相关指导教程请看作者发表的文章https://blog.csdn.net/zs1028/article/details/124788721
斗兽棋游戏
09-08
斗兽棋游戏：带动物叫声 C++ VS2005
斗兽棋
nameofcsdn的博客
05-29 8766
apk下载：点击打开链接斗兽棋的棋子斗兽棋棋子共十六个，分为红蓝双方，双方各有八只一样的棋子，按照战斗力强弱排列为：象&gt;狮&gt;虎&gt;豹&gt;狼&gt;狗&gt;猫&gt;鼠。斗兽棋的走法　　游戏开始时，红方先走，然后轮流走棋。每次可走动一只兽，每只兽每次走一方格，除己方兽穴和小河以外，前后左右均可。但是，狮、虎、鼠还有不同走法：　　狮虎跳河法：狮虎在小河边时，可以纵横对直跳过小河，...
联网对战游戏开源实例分享之《斗兽棋》
weixin_33826609的博客
09-26 840
本次，Matchvs为大家带来的是一款回合制休闲游戏的开源案例 。玩家双方在一个4X4的棋盘上，遵循食物链的规则玩法下进行翻牌与追逐，最终以场上存活的一方为获胜者。体验地址&gt;&gt;源码地址&gt;&gt;首先你需要下载Cocos Creator 和Matchvs JavaScript SDK。本次游戏设计的实现步骤主要拆分为用户登录、随机匹配和创建房间、以及同屏游戏三个部分完成。用户登录​...
python简单版斗兽棋
05-16 1793
纯粹练手哈，简单的实现了人机对战， 吃光为胜。电脑随机走棋= = jungle.py： #_*_coding:utf-8_*_ ''' Created on 2012-3-27 简单版斗兽棋 @author: myter7 ''' from animal import ...
斗兽棋 java_GitHub - java-a/project1: 基于命令行的斗兽棋
weixin_32943807的博客
02-21 974
Project 1: 斗兽棋项目目标本项目中，同学们需要使用 Java 编程语言，结合课堂知识、lab 内容，实现一个简单的、可以在命令行下玩的斗兽棋游戏，并按要求编写一份开发文档，介绍你的实现方式、开发思路等内容。项目参考游戏参考：斗兽棋是一款小众益智游戏，游戏规则在不同版本中各有差别。在本项目中，我们使用野兽争霸斗兽棋的游戏规则(链接：www.doushouqi.net )。对游戏不熟悉的同学...
Java Swing实现五子棋游戏开发详解
"Java Swing五子棋的实现方法" Java Swing五子棋的实现方法详细介绍了如何使用Java Swing开发图形界面程序五子棋，具有一定的参考价值。下面是对标题、描述、标签和部分内容的解释和分析。 标题“Java Swing五子棋...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

厉掣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值