用C++编写一个2048的小游戏

以下是一个简单的2048游戏的实现。这个实现使用了控制台输入和输出，适合在终端或命令行环境中运行。

2048游戏的实现

1.游戏逻辑
2048游戏的核心逻辑包括：

• 初始化一个4x4的网格。

• 随机生成2或4。

• 处理玩家的移动操作（上、下、左、右）。

• 合并相同的数字。

• 检查游戏是否结束（胜利或失败）。

2.代码实现

```cpp
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <algorithm>

using namespace std;

const int GRID_SIZE = 4;
const int WINNING_SCORE = 2048;

void initializeGrid(vector<vector<int>>& grid) {
    for (int i = 0; i < GRID_SIZE; ++i) {
        grid.push_back(vector<int>(GRID_SIZE, 0));
    }
}

void printGrid(const vector<vector<int>>& grid) {
    for (const auto& row : grid) {
        for (int val : row) {
            cout << val << "\t";
        }
        cout << endl;
    }
    cout << endl;
}

void addRandomTile(vector<vector<int>>& grid) {
    vector<pair<int, int>> emptyCells;
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            if (grid[i][j] == 0) {
                emptyCells.push_back({i, j});
            }
        }
    }
    if (!emptyCells.empty()) {
        pair<int, int> cell = emptyCells[rand() % emptyCells.size()];
        grid[cell.first][cell.second] = (rand() % 2) ? 2 : 4;
    }
}

bool canMove(const vector<vector<int>>& grid) {
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            if (grid[i][j] == 0) return true;
            if (i > 0 && grid[i][j] == grid[i - 1][j]) return true;
            if (j > 0 && grid[i][j] == grid[i][j - 1]) return true;
            if (i < GRID_SIZE - 1 && grid[i][j] == grid[i + 1][j]) return true;
            if (j < GRID_SIZE - 1 && grid[i][j] == grid[i][j + 1]) return true;
        }
    }
    return false;
}

void compress(vector<int>& row) {
    vector<int> temp(GRID_SIZE, 0);
    int k = 0;
    for (int i = 0; i < GRID_SIZE; ++i) {
        if (row[i] != 0) {
            temp[k++] = row[i];
        }
    }
    for (int i = 0; i < GRID_SIZE; ++i) {
        row[i] = temp[i];
    }
}

void merge(vector<int>& row) {
    for (int i = 0; i < GRID_SIZE - 1; ++i) {
        if (row[i] == row[i + 1] && row[i] != 0) {
            row[i] *= 2;
            row[i + 1] = 0;
        }
    }
}

void moveLeft(vector<vector<int>>& grid) {
    for (auto& row : grid) {
        compress(row);
        merge(row);
        compress(row);
    }
}

void moveRight(vector<vector<int>>& grid) {
    for (auto& row : grid) {
        reverse(row.begin(), row.end());
        compress(row);
        merge(row);
        compress(row);
        reverse(row.begin(), row.end());
    }
}

void moveUp(vector<vector<int>>& grid) {
    for (int col = 0; col < GRID_SIZE; ++col) {
        vector<int> temp(GRID_SIZE, 0);
        for (int row = 0; row < GRID_SIZE; ++row) {
            temp[row] = grid[row][col];
        }
        compress(temp);
        merge(temp);
        compress(temp);
        for (int row = 0; row < GRID_SIZE; ++row) {
            grid[row][col] = temp[row];
        }
    }
}

void moveDown(vector<vector<int>>& grid) {
    for (int col = 0; col < GRID_SIZE; ++col) {
        vector<int> temp(GRID_SIZE, 0);
        for (int row = 0; row < GRID_SIZE; ++row) {
            temp[row] = grid[row][col];
        }
        reverse(temp.begin(), temp.end());
        compress(temp);
        merge(temp);
        compress(temp);
        reverse(temp.begin(), temp.end());
        for (int row = 0; row < GRID_SIZE; ++row) {
            grid[row][col] = temp[row];
        }
    }
}

bool isGameOver(const vector<vector<int>>& grid) {
    for (const auto& row : grid) {
        for (int val : row) {
            if (val == WINNING_SCORE) return true;
        }
    }
    return !canMove(grid);
}

int main() {
    srand(static_cast<unsigned int>(time(0)));
    vector<vector<int>> grid;
    initializeGrid(grid);
    addRandomTile(grid);
    addRandomTile(grid);

    while (true) {
        printGrid(grid);
        char move;
        cout << "Enter move (W/A/S/D): ";
        cin >> move;

        switch (move) {
            case 'W':
            case 'w':
                moveUp(grid);
                break;
            case 'A':
            case 'a':
                moveLeft(grid);
                break;
            case 'S':
            case 's':
                moveDown(grid);
                break;
            case 'D':
            case 'd':
                moveRight(grid);
                break;
            default:
                cout << "Invalid move. Try again." << endl;
                continue;
        }

        addRandomTile(grid);

        if (isGameOver(grid)) {
            printGrid(grid);
            cout << "Game Over! " << (grid[0][0] == WINNING_SCORE ? "You Win!" : "You Lose!") << endl;
            break;
        }
    }

    return 0;
}
```

3.代码说明

• 初始化网格：`initializeGrid`函数初始化一个4x4的网格，所有值初始化为0。

• 打印网格：`printGrid`函数打印当前网格的状态。

• 添加随机瓷砖：`addRandomTile`函数在网格的空位置随机添加一个2或4。

• 移动操作：`moveLeft`、`moveRight`、`moveUp`、`moveDown`函数分别处理左、右、上、下移动操作。

• 压缩和合并：`compress`和`merge`函数分别处理行或列的压缩和合并操作。

• 检查游戏结束：`isGameOver`函数检查游戏是否结束（胜利或失败）。

4.运行游戏
将上述代码保存为一个C++文件（例如`2048.cpp`），然后使用C++编译器编译并运行它。例如，使用g++编译器：

```sh
g++ -o 2048 2048.cpp
./2048
```

5.游戏玩法

• 使用W/A/S/D键控制方向（上/左/下/右）。

• 游戏目标是合并数字，直到出现2048。

• 如果没有可移动的空位且无法合并，则游戏结束。

希望这个实现对你有帮助！