c++实现消消乐小程序对应代码

消消乐小程序的实现方式有很多种，以下是一种简单的C++实现，仅供参考。这个实现方式使用了二维数组来存储游戏棋盘，使用递归方式实现了消除方块的逻辑。

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int ROWS = 8;
const int COLS = 8;
const char BLOCKS[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L'};
const int BLOCK_NUM = 12;

char board[ROWS][COLS];

void initBoard() {
    srand(time(NULL));
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            board[i][j] = BLOCKS[rand() % BLOCK_NUM];
        }
    }
}

bool canEliminate(int x1, int y1, int x2, int y2) {
    if (board[x1][y1] != board[x2][y2]) {
        return false;
    }
    if (x1 == x2 && y1 == y2) {
        return false;
    }
    if (x1 == x2) {
        int minY = min(y1, y2);
        int maxY = max(y1, y2);
        for (int i = minY + 1; i < maxY; i++) {
            if (board[x1][i] != '*') {
                return false;
            }
        }
        return true;
    }
    if (y1 == y2) {
        int minX = min(x1, x2);
        int maxX = max(x1, x2);
        for (int i = minX + 1; i < maxX; i++) {
            if (board[i][y1] != '*') {
                return false;
            }
        }
        return true;
    }
    return false;
}

bool canEliminate(int x1, int y1, int x2, int y2, int x3, int y3) {
    return canEliminate(x1, y1, x2, y2) && canEliminate(x2, y2, x3, y3) && canEliminate(x1, y1, x3, y3);
}

bool eliminate(int x1, int y1, int x2, int y2) {
    if (!canEliminate(x1, y1, x2, y2)) {
        return false;
    }
    board[x1][y1] = board[x2][y2] = '*';
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (board[i][j] == '*') {
                continue;
            }
            if (i > 0 && board[i - 1][j] == '*' && canEliminate(i, j, i - 1, j)) {
                eliminate(i, j, i - 1, j);
                return true;
            }
            if (i < ROWS - 1 && board[i + 1][j] == '*' && canEliminate(i, j, i + 1, j)) {
                eliminate(i, j, i + 1, j);
                return true;
            }
            if (j > 0 && board[i][j - 1] == '*' && canEliminate(i, j, i, j - 1)) {
                eliminate(i, j, i, j - 1);
                return true;
            }
            if (j < COLS - 1 && board[i][j + 1] == '*' && canEliminate(i, j, i, j + 1)) {
                eliminate(i, j, i, j + 1);
                return true;
            }
        }
    }
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (board[i][j] == '*') {
                int k = i;
                while (k > 0) {
                    swap(board[k][j], board[k - 1][j]);
                    k--;
                }
                board[k][j] = BLOCKS[rand() % BLOCK_NUM];
            }
        }
    }
    return true;
}

bool canEliminate() {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (board[i][j] == '*') {
                continue;
            }
            if (i > 0 && board[i - 1][j] == '*' && canEliminate(i, j, i - 1, j)) {
                return true;
            }
            if (i < ROWS - 1 && board[i + 1][j] == '*' && canEliminate(i, j, i + 1, j)) {
                return true;
            }
            if (j > 0 && board[i][j - 1] == '*' && canEliminate(i, j, i, j - 1)) {
                return true;
            }
            if (j < COLS - 1 && board[i][j + 1] == '*' && canEliminate(i, j, i, j + 1)) {
                return true;
            }
        }
    }
    return false;
}

void printBoard() {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            cout << board[i][j] << ' ';
        }
        cout << endl;
    }
    cout << endl;
}

int main() {
    initBoard();
    while (canEliminate()) {
        printBoard();
        int x1, y1, x2, y2;
        cout << "Please input the position of two blocks to eliminate: ";
        cin >> x1 >> y1 >> x2 >> y2;
        if (eliminate(x1, y1, x2, y2)) {
            cout << "Eliminated!" << endl;
        } else {
            cout << "Can't eliminate!" << endl;
        }
    }
    cout << "Game over!" << endl;
    return 0;
}

这个实现方式中使用了一个二维数组来存储游戏棋盘，使用随机数初始化了棋盘，并使用递归方式实现了消除方块的逻辑。可以通过调用initBoard()函数初始化棋盘，通过调用printBoard()函数打印棋盘，通过调用eliminate()函数消除两个方块，并通过调用canEliminate()函数判断是否还有可以消除的方块，从而实现整个消消乐小程序的功能。