跳棋和井字游戏的面向对象设计

Question

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

相似之处

• 件 - 物品在船上的位置（行、列）
• Board - nxn 棋子网格
• 游戏 - 包含棋盘和玩家列表
• 玩家 - 玩家名称

区别

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

问题和担忧

• 我质疑这种设计，因为我也可以创建一个抽象方法而不是一个接口，但这不能扩展到国际象棋。
• 我也不知道如何将玩家与标记相关联，例如井字游戏中的 x 或 o。我使用 hashmap 将玩家映射到其标记。
• 我有一些检查器的代码重复，其中我有一个枚举颜色，但我也有一个变量标记，它有点相同。不知道如何补救。
• 可以对对象进行类型转换吗？由于棋盘不知道它有什么类型的棋子，我必须在 Checkers 类中这样做

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) 我质疑这种设计，因为我也可以创建一个抽象方法而不是一个接口，但这不能扩展到国际象棋。

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

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

关于将项目分配给作品，您目前的做法没有任何问题。您可能希望像Piece implements Movable, Drawable 那样考虑使它更好一点（从上面返回界面注释）。关于棋子的存储位置，如果您想将棋子保留在游戏中并让游戏确定所有可用的移动和每个棋子的有效性。或者，如果玩家或棋子本身将负责确定棋盘上的可用性，您可以将它们移动到 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 会应用到它。例如，如果您的游戏中玩家可以窃取其他玩家的代币，那么向玩家添加新代币的行为会自动更新其颜色。然后在调用piece.draw(); 或piece.draw(canvas) 时根据您正在执行的操作应用颜色。

3) 我有一些检查器的代码重复，其中我有一个枚举颜色，但我也有一个变量标记，这有点相同。不知道如何补救。

如果使用上面的 cmets，你可以这样做：

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) 可以对对象进行类型转换吗？由于板子不知道它有什么类型的棋子，我必须在 Checkers 类中这样做

如果您在实现 Piece 时使用了 Movable 接口，那么您就不需要投射，因为两个游戏/棋盘都知道：

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

或

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

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

5) 实现基于游戏的边缘案例 - 棋子成为国王的棋子。

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

• 跳棋，如果他们被跳，你将移除其他玩家棋子
• 如果棋子到达棋盘的另一边，您将成为棋子
• 国际象棋，如果其他玩家落下，您将移除他们的棋子

在您的 Checkers 游戏示例中，您需要在处理成功移动的 setNewPiecePosition 之后调用一些东西。对于跳棋，您需要此方法：

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