Объектно-ориентированный дизайн для шашек и крестиков

Question

Я выложил сходство между двумя играми с целью, возможно, распространить его на шахматы, но поставил под сомнение мой дизайн.

Сходства

• Piece - расположение предмета (строка, кол) на доске
• Доска - nxn сетка фигур
• Игра - содержит доску и список игроков
• Player - имя игрока

Различия

• В шашках вы можете перемещаться в разных направлениях, поэтому я создал отдельный абстрактный класс, называемый Checker, который наследует от Piece и реализует интерфейс Moveable, который возвращает движения кусков. Таким образом, пешка и король должны реализовать этот метод и обеспечить его ходы.

Проблемы и проблемы

• Я подвергаю сомнению этот дизайн, потому что я мог бы также создать абстрактный метод по сравнению с интерфейсом, но его нельзя было бы распространить на шахматы.
• Я также не знал, как связать игрока с таким маркером, как х или о в крестики-нолики. Я использую хэш-карту, чтобы привязать игрока к его маркеру.
• У меня есть некоторое дублирование кода для шашек, в котором у меня есть цвет enum, но у меня также есть переменный маркер, что-то вроде того же самого. Не знаете, как это исправить.
• Можно ли типизировать объект? Поскольку доска не знает, какой тип фигуры у нее есть, я должен сделать это в классе шашек

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);
}

Вот Tic Tac Toe

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 в крестики-нолики. Я использую хэш-карту, чтобы привязать игрока к его маркеру.

Ничего плохого в том, как вы делаете это в данный момент, в том, что касается назначения предмета на фигуру. Возможно, вы захотите сделать его немного лучше, например 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 |ЧЕРНЫЙ будет применяться к фигуре, когда игрок получает контроль над ней. Например, если у вас есть игра, в которой игроки могут украсть токены других игроков, процесс добавления нового токена игроку автоматически обновит его цвет. Затем цвет применяется при вызове piece.draw(); или piece.draw(canvas) в зависимости от того, что вы делаете.

3) У меня есть некоторое дублирование кода для шашек, в котором у меня есть цвет enum, но у меня также есть переменнаямаркер, который вроде то же самое. Не знаете, как это исправить.

Если вы используете приведенные выше комментарии, вы можете сделать следующее:

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) Можно ли типизировать объект? Поскольку доска не знает, какой тип фигуры у нее есть, я должен сделать это в классе шашек

Если вы использовали интерфейс Movable при реализации фигуры, вам не нужно разыгрывать, так как обе игры/ Доски будут знать:

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

или

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

, что опять-таки гарантирует, что board.getPeice(x,y) вернет Checker, и кастинг не требуется. Это зависит от того, что может произойти позже в игре, и каковы правила.

5) Реализация крайних случаев на основе игры - шашки, где пешка становится королем.

В большинстве игр есть результаты, которыепроисходят после того, как движение имеет место. Например, как вы упомянули:

• Шашками вы удалите фигуру других игроков, если они были прыгнуты
• Шашками вы станете пешкой короля, если они достигнут другой стороны доски.
• Шахматы: вы удалите фигуру другого игрока, если они окажутся на

. В вашем примере игры в шашки вам нужно будет вызывать что-то после setNewPiecePosition, которое обрабатывает успешные ходы. Для шашек вам понадобится этот метод:

1. Проверить начальную и конечную позиции и определить, была ли фигура другого игрока в середине. Если это так, вы удаляете эту фигуру с доски (и / или список фигур других игроков).
2. Определите, может ли игрок снова двигаться, если он кого-то перепрыгнул, тот же игрок может снова выбрать из обновленногосписок доступных ходов.
3. Определите, находится ли новая позиция в конце доски, затем замените Пешку Королем в коллекции фигур игроков.