C++ 实现 2048 游戏核心逻辑解析

void processUserInput() {
    char userInput = getchar();
    switch (userInput) {
        case 'w':
            moveUp(gameBoard);
            break;
        case 's':
            moveDown(gameBoard);
            break;
        case 'a':
            moveLeft(gameBoard);
            break;
        case 'd':
            moveRight(gameBoard);
            break;
        default:
            break;
    }
}

4. 更新游戏界面

这是最核心的部分。当用户按下方向键时，需要将数字向指定方向移动，并填充空白格子。如果相邻的两个格子数字相同，则合并为一个，数值翻倍。

以向上移动为例，遍历每一列，从第二行开始检查。如果遇到非零元素，尝试将其向上'浮'直到遇到边界或其他数字。如果上方数字与当前相同，则合并。

bool moveUp(int board[SIZE][SIZE]) {
    bool moved = false;
    for (int j = 0; j < SIZE; j++) {
        for (int i = 1; i < SIZE; i++) {
            if (board[i][j] != 0) {
                int k = i;
                while (k > 0 && board[k-1][j] == 0) {
                    board[k-1][j] = board[k][j];
                    board[k][j] = 0;
                    k--;
                    moved = true;
                }
                if (k > 0 && board[k-1][j] == board[k][j]) {
                    board[k-1][j] *= 2;
                    board[k][j] = 0;
                    moved = true;
                }
            }
        }
    }
    return moved;
}

// 向下、向左、向右的逻辑类似，只需调整循环方向和比较索引
bool moveDown(int board[SIZE][SIZE]) {
    bool moved = false;
    for (int j = 0; j < SIZE; j++) {
        for (int i = SIZE - 2; i >= 0; i--) {
            if (board[i][j] != 0) {
                int k = i;
                while (k < SIZE - 1 && board[k+1][j] == 0) {
                    board[k+1][j] = board[k][j];
                    board[k][j] = 0;
                    k++;
                    moved = true;
                }
                if (k < SIZE - 1 && board[k+1][j] == board[k][j]) {
                    board[k+1][j] *= 2;
                    board[k][j] = 0;
                    moved = true;
                }
            }
        }
    }
    return moved;
}

bool moveLeft(int board[SIZE][SIZE]) {
    bool moved = false;
    for (int i = 0; i < SIZE; i++) {
        for (int j = 1; j < SIZE; j++) {
            if (board[i][j] != 0) {
                int k = j;
                while (k > 0 && board[i][k-1] == 0) {
                    board[i][k-1] = board[i][k];
                    board[i][k] = 0;
                    k--;
                    moved = true;
                }
                if (k > 0 && board[i][k-1] == board[i][k]) {
                    board[i][k-1] *= 2;
                    board[i][k] = 0;
                    moved = true;
                }
            }
        }
    }
    return moved;
}

bool moveRight(int board[SIZE][SIZE]) {
    bool moved = false;
    for (int i = 0; i < SIZE; i++) {
        for (int j = SIZE - 2; j >= 0; j--) {
            if (board[i][j] != 0) {
                int k = j;
                while (k < SIZE - 1 && board[i][k+1] == 0) {
                    board[i][k+1] = board[i][k];
                    board[i][k] = 0;
                    k++;
                    moved = true;
                }
                if (k < SIZE - 1 && board[i][k+1] == board[i][k]) {
                    board[i][k+1] *= 2;
                    board[i][k] = 0;
                    moved = true;
                }
            }
        }
    }
    return moved;
}

5. 判断游戏结束

游戏结束通常有两种情况：一是达到了胜利条件（出现 2048），二是失败条件（棋盘已满且无相邻可合并项）。

bool isGameWon() {
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            if (gameBoard[i][j] == 2048) {
                return true;
            }
        }
    }
    return false;
}

bool isGameOver() {
    bool canMove = false;
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            // 如果有空位，说明还能继续
            if (gameBoard[i][j] == 0) {
                canMove = true;
                break;
            }
            // 检查右侧是否有相同数字
            if (j < SIZE - 1 && gameBoard[i][j] == gameBoard[i][j + 1]) {
                canMove = true;
                break;
            }
            // 检查下方是否有相同数字
            if (i < SIZE - 1 && gameBoard[i][j] == gameBoard[i + 1][j]) {
                canMove = true;
                break;
            }
        }
        if (canMove) break;
    }
    return !canMove;
}

通过以上模块组合，即可完成基础版 2048 的核心逻辑。重点在于数组操作与状态判断的准确性。