java象棋实现悔棋思路

Java象棋实现悔棋的思路如下：

1. 在每次棋子移动时，记录下每个棋子在移动前的位置和移动后的位置；
2. 将每次移动的记录保存到一个栈中；
3. 当需要悔棋时，从栈中取出最近一次移动的记录，然后将棋子移回移动前的位置；
4. 删除该记录，防止悔棋后还可以悔棋；
5. 同时，记录下当前的回合数和悔棋次数，以便进行撤销悔棋操作。

这样，实现悔棋的过程就可以控制在游戏的流程之中，不仅保证了游戏的公平性，也提供了一个良好的操作体验。同时，还可以增加锻炼思维的乐趣，让玩家在游戏中更加沉浸和享受。

相关问题

在备忘录模式中用java实现象棋悔棋代码

在备忘录模式中，我们需要定义三个角色：Originator（发起人）、Memento（备忘录）和Caretaker（管理者）。在这个例子中，ChessBoard类是发起人，ChessBoardMemento类是备忘录，ChessBoardCaretaker类是管理者。

ChessBoard类定义：

public class ChessBoard {
    private String[][] board;
    private int size;

    public ChessBoard(int size) {
        this.size = size;
        board = new String[size][size];
        // 初始化棋盘
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                board[i][j] = "-";
            }
        }
    }

    public void setPiece(int x, int y, String piece) {
        board[x][y] = piece;
    }

    public void printBoard() {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
    }

    public ChessBoardMemento save() {
        return new ChessBoardMemento(board);
    }

    public void restore(ChessBoardMemento memento) {
        board = memento.getBoard();
    }
}

ChessBoardMemento类定义：

public class ChessBoardMemento {
    private String[][] board;

    public ChessBoardMemento(String[][] board) {
        this.board = new String[board.length][];
        for (int i = 0; i < board.length; i++) {
            this.board[i] = Arrays.copyOf(board[i], board[i].length);
        }
    }

    public String[][] getBoard() {
        return board;
    }
}

ChessBoardCaretaker类定义：

import java.util.Stack;

public class ChessBoardCaretaker {
    private Stack<ChessBoardMemento> mementos = new Stack<>();

    public void saveMemento(ChessBoardMemento memento) {
        mementos.push(memento);
    }

    public ChessBoardMemento getMemento() {
        if (mementos.empty()) {
            return null;
        }
        return mementos.pop();
    }
}

现在我们可以使用这些类来实现象棋悔棋代码了：

public class Main {
    public static void main(String[] args) {
        ChessBoard board = new ChessBoard(8);
        board.setPiece(2, 3, "車");
        board.setPiece(4, 5, "馬");
        board.printBoard();

        ChessBoardCaretaker caretaker = new ChessBoardCaretaker();
        caretaker.saveMemento(board.save());

        board.setPiece(3, 4, "炮");
        board.printBoard();

        caretaker.saveMemento(board.save());

        board.setPiece(2, 3, "-");
        board.setPiece(3, 4, "-");
        board.printBoard();

        board.restore(caretaker.getMemento());
        board.printBoard();

        board.restore(caretaker.getMemento());
        board.printBoard();
    }
}

输出结果：

- - - - - - - -
- - - - - - - -
- - - - - 車 - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - 炮 - - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - 車 - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - 炮 - - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - 車 - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -

- - - - - - - -
- - - - - - - -
- - - - - 車 - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - 炮 - - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - 車 - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -

- - - - - - - -
- - - - - - - -
- - - - - 車 - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - 炮 - - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - 車 - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -

- - - - - - - -
- - - - - - - -
- - - - - 車 - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - 炮 - - -
- - - - - - - -
- - - - - - 馬 -
- - - - - - - -
- - - - - - 車 -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -
- - - - - - - -

备忘库模式，用java实现象棋悔棋代码

下面是一个简单的Java代码实现，可以用于象棋中的悔棋功能：

import java.util.Stack;

public class ChessBoard {
    private int[][] board; // 棋盘矩阵，0表示空，1表示红棋，2表示黑棋
    private Stack<Move> moveStack; // 棋谱栈，用于记录每一步的操作

    public ChessBoard() {
        board = new int[10][9];
        moveStack = new Stack<>();
        initialize();
    }

    // 初始化棋盘
    private void initialize() {
        // 红方
        board[0][0] = board[0][8] = 1;
        board[0][1] = board[0][7] = 2;
        board[0][2] = board[0][6] = 3;
        board[0][3] = board[0][5] = 4;
        board[0][4] = 5;
        board[2][1] = board[2][7] = 6;
        board[3][0] = board[3][2] = board[3][4] = board[3][6] = 7;
        board[3][8] = board[3][6] = board[3][4] = board[3][2] = 7;
        board[9][0] = board[9][8] = -1;
        board[9][1] = board[9][7] = -2;
        board[9][2] = board[9][6] = -3;
        board[9][3] = board[9][5] = -4;
        board[9][4] = -5;
        board[7][1] = board[7][7] = -6;
        board[6][0] = board[6][2] = board[6][4] = board[6][6] = -7;
        board[6][8] = board[6][6] = board[6][4] = board[6][2] = -7;
    }

    // 走棋
    public boolean move(int fromX, int fromY, int toX, int toY) {
        int chess = board[fromX][fromY];
        if (chess == 0) {
            return false;
        }
        if (chess > 0 && (toX < 0 || toX > 9 || toY < 0 || toY > 8)) {
            return false; // 红方不能移出九宫格
        }
        if (chess < 0 && (toX < 7 || toX > 16 || toY < 0 || toY > 8)) {
            return false; // 黑方不能移出九宫格
        }
        if (chess == 1 && (toX < 7 || toY < 3 || toY > 5)) {
            return false; // 红方兵只能前进，不能后退或横着走
        }
        if (chess == -1 && (toX > 2 || toY < 3 || toY > 5)) {
            return false; // 黑方卒只能前进，不能后退或横着走
        }
        if (chess == 2 || chess == -2 || chess == 5 || chess == -5) {
            // 车或将，需要判断是否有障碍
            if (fromX == toX) {
                for (int i = Math.min(fromY, toY) + 1; i < Math.max(fromY, toY); i++) {
                    if (board[fromX][i] != 0) {
                        return false;
                    }
                }
            } else if (fromY == toY) {
                for (int i = Math.min(fromX, toX) + 1; i < Math.max(fromX, toX); i++) {
                    if (board[i][fromY] != 0) {
                        return false;
                    }
                }
            } else {
                return false; // 车和将只能横着或竖着走
            }
        }
        if (chess == 3 || chess == -3 || chess == 4 || chess == -4) {
            // 象或士，需要判断是否走斜线
            if (Math.abs(toX - fromX) != 2 || Math.abs(toY - fromY) != 2) {
                return false;
            }
            int middleX = (fromX + toX) / 2;
            int middleY = (fromY + toY) / 2;
            if (board[middleX][middleY] != 0) {
                return false; // 象或士不能跨越棋子
            }
            if (chess == 3 && (toX < 0 || toX > 4 || toY < 3 || toY > 5)) {
                return false; // 红方象不能过河
            }
            if (chess == -3 && (toX < 5 || toX > 9 || toY < 3 || toY > 5)) {
                return false; // 黑方象不能过河
            }
        }
        if (chess == 6 || chess == -6) {
            // 马，需要判断是否走日字
            int dx = toX - fromX;
            int dy = toY - fromY;
            if (Math.abs(dx) == 2 && Math.abs(dy) == 1) {
                int middleX = fromX + dx / 2;
                int middleY = fromY;
                if (board[middleX][middleY] != 0) {
                    return false; // 马脚被挡住
                }
            } else if (Math.abs(dx) == 1 && Math.abs(dy) == 2) {
                int middleX = fromX;
                int middleY = fromY + dy / 2;
                if (board[middleX][middleY] != 0) {
                    return false; // 马脚被挡住
                }
            } else {
                return false; // 马走日字
            }
        }
        if (board[toX][toY] * chess > 0) {
            return false; // 不能吃自己的棋子
        }
        // 能走到这里说明合法，进行移动
        board[toX][toY] = chess;
        board[fromX][fromY] = 0;
        moveStack.push(new Move(fromX, fromY, toX, toY, chess));
        return true;
    }

    // 悔棋
    public boolean undo() {
        if (moveStack.empty()) {
            return false;
        }
        Move lastMove = moveStack.pop();
        board[lastMove.fromX][lastMove.fromY] = lastMove.chess;
        board[lastMove.toX][lastMove.toY] = 0;
        return true;
    }

    // 打印棋盘
    public void print() {
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 9; j++) {
                System.out.print(getChessName(board[i][j]) + "\t");
            }
            System.out.println();
        }
    }

    // 将棋子编号转换成字符串
    private String getChessName(int chess) {
        switch (chess) {
            case 0:
                return "　";
            case 1:
                return "车";
            case 2:
                return "马";
            case 3:
                return "相";
            case 4:
                return "士";
            case 5:
                return "帅";
            case 6:
                return "炮";
            case -1:
                return "車";
            case -2:
                return "馬";
            case -3:
                return "象";
            case -4:
                return "士";
            case -5:
                return "將";
            case -6:
                return "砲";
            default:
                return "";
        }
    }

    // 移动信息类
    private static class Move {
        int fromX, fromY, toX, toY, chess;

        public Move(int fromX, int fromY, int toX, int toY, int chess) {
            this.fromX = fromX;
            this.fromY = fromY;
            this.toX = toX;
            this.toY = toY;
            this.chess = chess;
        }
    }
}

在这个实现中，我们使用了一个二维数组来表示棋盘矩阵，使用一个栈来记录每一步的操作，其中`Move`类表示一次移动的信息。`initialize()`方法用于初始化棋盘，`move()`方法用于走棋，`undo()`方法用于悔棋，`print()`方法用于打印棋盘，`getChessName()`方法用于将棋子编号转换成字符串。实际应用中，我们可能需要对这个代码进行一些修改，以适应不同的需求。