java - 跳棋和井字棋的面向对象设计

Question

我列出了这两款游戏之间的相似之处，目的是可能将其扩展到国际象棋，但对我的设计提出了质疑。

相似之处

• 件 - 元素在船上的位置(行、列)
• 棋盘 - nxn 棋子网格
• 游戏 - 包含棋盘和玩家列表
• 玩家 - 玩家姓名

差异

• 在跳棋中，你可以向不同的方向移动，因此我创建了一个名为 Checker 的单独抽象类，它继承自 Piece 并实现了一个 Moveable 接口(interface)，该接口(interface)返回棋子的移动方式。所以 Pawn 和 King 必须实现这个方法并提供它的 Action 。

问题和疑虑

• 我对这种设计提出质疑，因为我也可以创建一个抽象方法而不是一个接口(interface)，但这不能扩展到国际象棋。
• 我也不知道如何将玩家与标记(例如井字棋中的 x 或 o)联系起来。我使用 HashMap 将玩家映射到其标记。
• 我有一些跳棋代码重复，其中我有一个枚举颜色，但我也有一个变量标记，这有点相同。不知道如何解决这个问题。
• 可以对对象进行类型转换吗？由于棋盘不知道它有什么类型的棋子，因此我必须在西洋跳棋类中执行此操作

List<List<Integer>> moves = ((Checker)piece).getPossibleMoves();

注释

我没有完成所有的实现，例如知道玩家何时获胜，或处理边缘情况或棋子何时变成国王。为了简单起见，我同时还对玩家进行了硬编码，只是希望得到反馈(如果这是一个好的方向)。

public class Piece {
    private String marker;
    protected int row;
    protected int col;

    public Piece(String marker, int row, int col) {
        this.marker = marker;
        this.col = col;
        this.row = row;
    }

    public String getMarker() {
        return marker;
    }

    public void setMarker(String marker) {
        this.marker = marker;
    }

    public int getRow() {
        return row;
    }

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

    public int getCol() {
        return col;
    }

    public void setCol(int col) {
        this.col = col;
    }
}

public class Player {
    private String name;

    public Player(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

public class Board {
    private Piece[][] grid;

    public Board(int rows, int cols) {
        grid = new Piece[rows][cols];
    }

    private boolean isSpotEmpty(int row, int col) {
        return grid[row][col] == null;
    }

    public void move(Piece piece) {
        if(isSpotEmpty(piece.getRow(), piece.getCol())) {
            grid[piece.getRow()][piece.getCol()] = piece;
        } else {
            throw new InvalidStateException("Invalid Move");
        }
    }

    public void showBoard() {
        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[0].length; j++) {
                Piece piece = grid[i][j];
                if(piece == null) {
                    System.out.print('*');
                } else {
                    System.out.print(piece.getMarker());
                }
            }
            System.out.println();
        }
    }

    public boolean isCellEmpty(int row, int col) {
        return grid[row][col] == null;
    }

    public String getMarker(int row, int col) {
        return grid[row][col].getMarker();
    }

    public Piece getPiece(int row, int col) {
        return grid[row][col];
    }

    public void removePiece(int row, int col) {
        grid[row][col] = null;
    }
}

public abstract class Game {
    protected List<Player> players;
    protected Board board;
    public abstract void startGame();
    public abstract Piece getPieceFromInput(Player player, String marker);
}

这是井字棋

public class TicTacToe extends Game {
    private static final int BOARD_SIZE = 3;
    private HashMap<Player, String> playerMap;

    public TicTacToe() {
        board = new Board(BOARD_SIZE, BOARD_SIZE);
        players = new ArrayList<>();
        players.add(new Player("player1"));
        players.add(new Player("player2"));
        playerMap.put(players.get(0), "o");
        playerMap.put(players.get(1), "x");
    }

    @Override
    public void startGame() {
        boolean playerOneTurn = true;
        Player currPlayer;
        Piece piece;
        while(1 < 2) {

            currPlayer = (playerOneTurn) ? players.get(0) : players.get(1);
            piece = getPieceFromInput(currPlayer, playerMap.get(currPlayer));
            try {
                board.move(piece);
                playerOneTurn = !playerOneTurn;
            } catch(InvalidStateException e) {
                System.out.println(currPlayer.getName() + e.getMessage());
            }
            board.showBoard();
        }
    }

    @Override
    public Piece getPieceFromInput(Player player, String marker) {
        System.out.println(player.getName() + " Please enter move by row col");
        Scanner sc = new Scanner(System.in);
        int row = sc.nextInt();
        int col = sc.nextInt();
        return new Piece(marker, row, col);
     }


}

这是跳棋

public abstract class Checker extends Piece implements Movable {
    protected Color color;

    public Checker(String marker, int row, int col, Color color) {
        super(marker, row, col);
        this.color = color;
    }

}

public enum Color {
    RED, BLACK
}

public class King extends Checker {

    public King(String marker, int row, int col, Color color) {
        super(marker, row, col, color);
    }

    @Override
    public List<List<Integer>> getPossibleMoves() {
        List<List<Integer>> list = new ArrayList<>();
        //go up/down
        for(int i = 0; i < 8; i++) {
            if(i == row) continue;
            list.add(Arrays.asList(i, col));
        }

        //go horizontal
        for(int i = 0; i < 8; i++) {
            if(i == col) continue;
            list.add(Arrays.asList(row, i));
        }

        //go left diag
        for(int i = 0; i < 8; i++) {
            for(int j = col - row; j < 8; j++) {
                if(i == row && j == col) continue;
                list.add(Arrays.asList(i, j));
            }
        }
        return list;
    }
}

public class Pawn extends Checker {

    public Pawn(String marker, int row, int col, Color color) {
        super(marker, row, col, color);
    }

    @Override
    public List<List<Integer>> getPossibleMoves() {
        List<List<Integer>> list = new ArrayList<>();
        if(color == Color.RED) {
            list.add(Arrays.asList(row - 1,col - 1));
            list.add(Arrays.asList(row - 1,row + 1));
        } else {
            list.add(Arrays.asList(row + 1,row + 1));
            list.add(Arrays.asList(row + 1,row - 1));
        }
        return list;
    }
}

public interface Movable {
    List<List<Integer>> getPossibleMoves();
}

public class Checkers extends Game {
    private static final int BOARD_SIZE = 8;
    private Board board;
    private List<Player> players;
    private HashMap<Player, String> playerMap;

    public Checkers() {
        board = new Board(BOARD_SIZE, BOARD_SIZE);
        players = new ArrayList<>();
        players.add(new Player("alice"));
        players.add(new Player("bob"));
        playerMap = new HashMap<>();
        playerMap.put(players.get(0), "o");
        playerMap.put(players.get(1), "x");
    }

    @Override
    public void startGame() {
        setBoard();
        boolean playerOneTurn  = true;
        Player currPlayer = null;
        String playerMarker = "";
        while(1 < 2) {
            board.showBoard();
            currPlayer = (playerOneTurn) ? players.get(0) : players.get(1);
            playerMarker = playerMap.get(currPlayer);

            try {
                Piece selectedPiece = getPieceFromInput(currPlayer, playerMarker);
                setNewPiecePosition(currPlayer, selectedPiece);
                playerOneTurn = !playerOneTurn;

            } catch(InvalidStateException e) {
                System.out.println(e.getMessage());
            }
        }
    }

    private void setBoard() {
        for(int i = 0; i < 3; i++) {
            for(int j = 0; j < BOARD_SIZE; j++) {
               if((j + i) % 2 == 0) {
                   board.move(new Pawn("o", i, j, Color.BLACK));
               }
            }
        }

        for(int i = BOARD_SIZE - 1; i > BOARD_SIZE - 4; i--) {
            for(int j = 0; j < BOARD_SIZE; j++) {
                if((j + i) % 2 == 0) {
                    board.move(new Pawn("x", i, j, Color.RED));
                }
            }
        }
    }

    @Override
    public Piece getPieceFromInput(Player player, String marker) {
        System.out.println(player.getName() + " please select your piece from row : col");
        Scanner sc = new Scanner(System.in);
        int row = sc.nextInt();
        int col = sc.nextInt();
        if(board.isCellEmpty(row, col) ) {
            throw new InvalidStateException("You selected a wrong piece");
        } else if(!board.getMarker(row, col).equals(marker)) {
            throw new InvalidStateException("You selected the other players piece");

        }
        return board.getPiece(row, col);
    }

    private void setNewPiecePosition(Player player, Piece piece) {
        List<List<Integer>> moves = ((Checker)piece).getPossibleMoves();
        Scanner sc = new Scanner(System.in);
        System.out.println(player.getName() + " Please put your new piece to row : col");
        int row = sc.nextInt();
        int col = sc.nextInt();
        boolean isMoveValid = false;
        for(int i = 0; i < moves.size(); i++) {
            if(row == moves.get(i).get(0) && col == moves.get(i).get(1)){
                isMoveValid = true;
                break;
            }
        }
        if(!isMoveValid) {
            throw new InvalidStateException("Wrong move for selected piece");
        }
        board.removePiece(piece.getRow(), piece.getCol());
        piece.setRow(row);
        piece.setCol(col);
        board.move(piece);
    }
}

来这里玩游戏

public class GameMain {

    public static void main(String[] args) {
        Game checkers = new Checkers();
        Game tictactoe = new TicTacToe();
        checkers.startGame();
        tictactoe.startGame();
    }
}

Answer 1

这可能是在 https://gamedev.stackexchange.com/ 中发布问题的更好论坛。但这里有一些我的意见，有些可能是错误的，但也许它们会有所帮助(看起来是一个有趣的项目)。

1)我质疑这种设计，因为我也可以创建一个抽象方法而不是接口(interface)，但这不能扩展到国际象棋。

您可能希望坚持使用接口(interface)，因为它们允许您通过较少的重构来扩展功能，因为您可以实现多个接口(interface)而不是扩展一个接口(interface)。使用默认方法，如果需要，您还可以包含任何常用代码。

2) 我也不知道如何将玩家与井字游戏中的 x 或 o 等标记关联起来。我使用 HashMap 将玩家映射到其标记。

就将项目分配给作品而言，您目前的做法没有任何问题。您可能想要研究使其变得更好一点，例如 Piece Implements Movable, Drawable (回到上面的界面注释)。关于棋子的存储位置，如果您想将棋子保留在游戏中并让游戏确定每个棋子的所有可用 Action 和有效性。或者，如果玩家或棋子本身负责确定棋盘上的可用性，则可以将它们移动到 Player.Collection 中。

例如:

public TicTacToe() {
    this.players.add(new Player("Player 1", Color.RED, initPieces());
    this.players.add(new Player("Player 2", Color.BLACK, initPieces());
}

当玩家控制该棋子时，Color.RED|BLACK 将应用于该棋子。例如，如果您有一款游戏，玩家可以窃取其他玩家的 token ，则向玩家添加新 token 的行为会自动更新其颜色。然后，根据您正在执行的操作调用 piece.draw(); 或 piece.draw(canvas) 时应用颜色。

3)我有一些跳棋代码重复，其中我有一个枚举颜色，但我也有一个变量标记，这有点相同。不知道如何解决这个问题。

如果使用上述注释，您可以执行以下操作:

Collection<Piece<String>> initPieces(String mark) {
    return Arrays.asList(new Piece<>(mark), ...);  // create 5
}

public Person(String name, Color color, Collection<Piece> initialPieces) {
    // for initialPieces set piece color to color
}

4) 可以对对象进行类型转换吗？由于棋盘不知道它有什么类型的棋子，因此我必须在西洋跳棋类中执行此操作

如果您在实现 Piece 时使用了 Movable 接口(interface)，那么您不需要进行转换，因为游戏/棋盘都会知道:

List<List<Integer>> moves = piece.getPossibleMoves();

或

this.board = new Board<Checker>();

这将再次确保 board.getPeice(x,y) 将返回一个 Checker 并且不需要强制转换。这取决于游戏后期可能发生的情况以及规则是什么。

5) 实现基于游戏 - 跳棋的边缘情况，其中 Pawn 成为国王。

在大多数游戏中，移动发生后就会出现结果。例如，正如您提到的:

• 如果其他玩家跳棋，您将删除他们的棋子
• 跳棋时，如果棋子到达棋盘的另一边，您将成为棋子的国王
• 在国际象棋中，如果其他玩家的棋子落在了棋子上，您将移除该棋子

在跳棋游戏示例中，您需要在处理成功移动的 setNewPiecePosition 之后调用某些内容。对于跳棋，您需要此方法来:

1. 检查开始和结束位置，并确定是否有其他玩家棋子位于中间。如果是这样，您可以从棋盘上删除该棋子(和/或其他玩家的棋子列表)。
2. 确定玩家是否可以再次移动，以便如果他们跳过某人，同一玩家可以从更新的可用移动列表中再次选择。
3. 确定新位置是​​否位于棋盘末端，然后将棋子替换为玩家棋子集合中的国王。