gameboard.cpp

#include "gameboard.h"
#include <QRandomGenerator>
#include <QMessageBox>
#include <algorithm>

GameBoard::GameBoard(QWidget *parent) 
    : QWidget(parent), remainingCells(BOARD_WIDTH * BOARD_HEIGHT - MINE_COUNT), gameOver(false) {
    gridLayout = new QGridLayout(this);
    gridLayout->setSpacing(1);
    setLayout(gridLayout);
    
    // Initialize cells vector
    cells.resize(BOARD_HEIGHT);
    for (int i = 0; i < BOARD_HEIGHT; ++i) {
        cells[i].resize(BOARD_WIDTH);
    }
    
    initializeBoard();
}

GameBoard::~GameBoard() {
    if (gridLayout) {
        delete gridLayout;
    }
    for (auto &row : cells) {
        for (auto cell : row) {
            if (cell) {
                delete cell;
            }
        }
    }
}

void GameBoard::initializeBoard() {
    // Create cells
    for (int row = 0; row < BOARD_HEIGHT; ++row) {
        for (int col = 0; col < BOARD_WIDTH; ++col) {
            MineCell *cell = new MineCell(this);
            cell->setPosition(row, col);
            cells[row][col] = cell;
            gridLayout->addWidget(cell, row, col);
            
            connect(cell, &MineCell::cellClicked, 
                    this, &GameBoard::handleCellClick);
            connect(cell, &MineCell::cellRightClicked, 
                    this, &GameBoard::handleCellRightClick);
        }
    }
    
    placeMines();
    calculateAdjacentMines();
}

void GameBoard::placeMines() {
    int minesPlaced = 0;
    while (minesPlaced < MINE_COUNT) {
        int row = QRandomGenerator::global()->bounded(BOARD_HEIGHT);
        int col = QRandomGenerator::global()->bounded(BOARD_WIDTH);
        
        if (!cells[row][col]->hasMine()) {
            cells[row][col]->setMine(true);
            minesPlaced++;
        }
    }
}

void GameBoard::calculateAdjacentMines() {
    for (int row = 0; row < BOARD_HEIGHT; ++row) {
        for (int col = 0; col < BOARD_WIDTH; ++col) {
            if (!cells[row][col]->hasMine()) {
                cells[row][col]->setAdjacentMines(countAdjacentMines(row, col));
            }
        }
    }
}

int GameBoard::countAdjacentMines(int row, int col) const {
    int count = 0;
    for (int i = -1; i <= 1; ++i) {
        for (int j = -1; j <= 1; ++j) {
            if (i == 0 && j == 0) continue;
            
            int newRow = row + i;
            int newCol = col + j;
            
            if (isValidCell(newRow, newCol) && cells[newRow][newCol]->hasMine()) {
                count++;
            }
        }
    }
    return count;
}

void GameBoard::handleCellClick(int row, int col) {
    if (gameOver || cells[row][col]->isRevealed()) {
        return;
    }

    if (cells[row][col]->hasMine()) {
        revealAllMines();
        handleGameOver(false);
        return;
    }

    revealCell(row, col);
    
    if (remainingCells == 0) {
        handleGameOver(true);
    }
}

void GameBoard::revealCell(int row, int col) {
    MineCell *cell = cells[row][col];
    if (cell->isRevealed() || !cell->icon().isNull()) {
        return;
    }

    cell->setRevealed(true);
    cell->setEnabled(true);  // Keep enabled but with different style
    cell->setFlat(true);    // Make it look flat/revealed
    remainingCells--;

    if (cell->getAdjacentMines() > 0) {
        cell->setText(QString::number(cell->getAdjacentMines()));
        // Different colors for different numbers
        QString color;
        switch(cell->getAdjacentMines()) {
            case 1: color = "blue"; break;
            case 2: color = "green"; break;
            case 3: color = "red"; break;
            case 4: color = "darkblue"; break;
            default: color = "darkred"; break;
        }
        cell->setStyleSheet(QString("QPushButton { background-color: #E0E0E0; color: %1; font-weight: bold; }").arg(color));
    } else {
        cell->setStyleSheet("QPushButton { background-color: #E0E0E0; }");
        revealAdjacentCells(row, col);
    }
}

void GameBoard::revealAdjacentCells(int row, int col) {
    for (int i = -1; i <= 1; ++i) {
        for (int j = -1; j <= 1; ++j) {
            if (i == 0 && j == 0) continue;
            
            int newRow = row + i;
            int newCol = col + j;
            
            if (isValidCell(newRow, newCol) && !cells[newRow][newCol]->isRevealed()) {
                revealCell(newRow, newCol);
            }
        }
    }
}

void GameBoard::handleCellRightClick(int row, int col) {
    if (!gameOver && !cells[row][col]->isRevealed()) {
        cells[row][col]->toggleFlag();
    }
}

void GameBoard::revealAllMines() {
    for (int row = 0; row < BOARD_HEIGHT; ++row) {
        for (int col = 0; col < BOARD_WIDTH; ++col) {
            if (cells[row][col]->hasMine()) {
                cells[row][col]->setMineIcon();
                cells[row][col]->setStyleSheet("QPushButton { background-color: red; }");
            }
        }
    }
}

void GameBoard::handleGameOver(bool won) {
    gameOver = true;
    if (won) {
        emit gameWon();
    } else {
        emit gameLost();
    }
}

bool GameBoard::isValidCell(int row, int col) const {
    return row >= 0 && row < BOARD_HEIGHT && col >= 0 && col < BOARD_WIDTH;
}

void GameBoard::resetGame() {
    gameOver = false;
    remainingCells = BOARD_WIDTH * BOARD_HEIGHT - MINE_COUNT;
    
    for (int row = 0; row < BOARD_HEIGHT; ++row) {
        for (int col = 0; col < BOARD_WIDTH; ++col) {
            cells[row][col]->reset();
        }
    }
    
    placeMines();
    calculateAdjacentMines();
}