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

问题描述

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

相似之处

Piece - 物品在船上的位置（行，列）
板 - nxn 网格块
游戏 - 包含棋盘和玩家列表
玩家——玩家的名字

差异

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

问题和担忧

我质疑这种设计，因为我也可以创建一个抽象方法与一个接口，但这不能扩展到国际象棋。
我也不知道如何将玩家与 tic tac toe 中的 x 或 o 等标记联系起来。我使用哈希图将玩家映射到其标记。
我有一些检查器的代码重复，其中我有一个枚举颜色，但我也有一个变量标记，它有点相同。不知道如何解决这个问题。
可以对对象进行类型转换吗？由于棋盘不知道它有什么类型的棋子，我必须在 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();
    }
}

标签： javaoopobject-oriented-analysis

解决方案

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

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

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

2) 我也不知道如何将玩家与标记（例如井字游戏中的 x 或 o）联系起来。我使用哈希图将玩家映射到其标记。

关于将项目分配给作品，您目前的做法没有任何问题。您可能想考虑让它更好一点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）我有一些检查器的代码重复，其中我有一个枚举颜色，但我也有一个变量标记，这有点相同。不知道如何解决这个问题。

如果使用上述评论，您可以执行以下操作：

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 之后调用某些内容。对于跳棋，您需要此方法：

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

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

问题描述

解决方案

推荐阅读