include <iostream></iostream>

include

include <ctime></ctime>

include <cstdlib></cstdlib>

include <iomanip></iomanip>

using namespace std;

// Cấu hình kích thước bàn cờ và số mìn const int BOARDSIZE = 9; const int TOTALMINES = 10;

// Các ký tự hiển thị const char CELLHIDDEN = '#'; const char CELLMINE = '*'; const char CELL_FLAG = 'F';

// Cấu trúc một ô trên bàn cờ struct Cell { bool isMine = false; bool isRevealed = false; bool isFlagged = false; int neighborMines = 0; };

Cell board[BOARDSIZE][BOARDSIZE]; bool gameOver = false; bool gameWon = false;

// Hàm kiểm tra tọa độ có hợp lệ không bool isValid(int r, int c) { return (r >= 0 && r < BOARDSIZE && c >= 0 && c < BOARDSIZE); }

// Khởi tạo bàn cờ và rải mìn ngẫu nhiên void Setup() { srand(time(0)); gameOver = false; gameWon = false;

// 1. Rải mìn ngẫu nhiên
int minesPlaced = 0;
while (minesPlaced < TOTAL_MINES) {
    int r = rand() % BOARD_SIZE;
    int c = rand() % BOARD_SIZE;
    if (!board[r][c].isMine) {
        board[r][c].isMine = true;
        minesPlaced++;
    }
}

// 2. Tính số mìn xung quanh mỗi ô
for (int r = 0; r < BOARD_SIZE; r++) {
    for (int c = 0; c < BOARD_SIZE; c++) {
        if (board[r][c].isMine) continue;

        int count = 0;
        // Duyệt 8 ô xung quanh
        for (int dr = -1; dr <= 1; dr++) {
            for (int dc = -1; dc <= 1; dc++) {
                if (isValid(r + dr, c + dc) && board[r + dr][c + dc].isMine) {
                    count++;
                }
            }
        }
        board[r][c].neighborMines = count;
    }
}

}

// Vẽ bàn cờ ra màn hình void Draw() { system("cls"); // Xóa màn hình cũ để cập nhật giao diện mới cout << " GAME DO MIN (MINESWEEPER)\n\n";

// In chỉ số cột
cout << "    ";
for (int c = 0; c < BOARD_SIZE; c++) cout << c << " ";
cout << "\n   ";
for (int c = 0; c < BOARD_SIZE; c++) cout << "--";
cout << "\n";

// In từng hàng của bàn cờ
for (int r = 0; r < BOARD_SIZE; r++) {
    cout << r << " | "; // In chỉ số hàng
    for (int c = 0; c < BOARD_SIZE; c++) {
        if (board[r][c].isRevealed) {
            if (board[r][c].isMine) {
                cout << CELL_MINE << " ";
            } else if (board[r][c].neighborMines == 0) {
                cout << ". " ; // Ô trống không có mìn xung quanh
            } else {
                cout << board[r][c].neighborMines << " ";
            }
        } else if (board[r][c].isFlagged) {
            cout << CELL_FLAG << " ";
        } else {
            // Nếu thua game, hiển thị toàn bộ mìn ẩn cho người chơi xem
            if (gameOver && board[r][c].isMine) {
                cout << CELL_MINE << " ";
            } else {
                cout << CELL_HIDDEN << " ";
            }
        }
    }
    cout << "\n";
}
cout << "\nSo min can tim: " << TOTAL_MINES << "\n";

}

// Thuật toán Đệ quy Loang (Flood Fill) để mở các ô trống lân cận void RevealCell(int r, int c) { if (!isValid(r, c) || board[r][c].isRevealed || board[r][c].isFlagged) return;

board[r][c].isRevealed = true;

// Nếu ô đó không có mìn xung quanh, tự động loang ra 8 ô bên cạnh
if (board[r][c].neighborMines == 0 && !board[r][c].isMine) {
    for (int dr = -1; dr <= 1; dr++) {
        for (int dc = -1; dc <= 1; dc++) {
            if (dr != 0 || dc != 0) {
                RevealCell(r + dr, c + dc);
            }
        }
    }
}

}

// Kiểm tra xem người chơi đã mở hết các ô an toàn chưa bool CheckWin() { for (int r = 0; r < BOARDSIZE; r++) { for (int c = 0; c < BOARDSIZE; c++) { // Nếu vẫn còn ô không phải mìn mà chưa được mở -> Chưa thắng if (!board[r][c].isMine && !board[r][c].isRevealed) { return false; } } } return true; }

// Xử lý lượt chơi của người dùng void Input() { int r, c; char action; cout << "Nhap hanh dong (M: Mo o, C: Cam co) va Toa do (Hang Cot).\n"; cout << "Vi du: M 3 4 (de mo o hang 3 cot 4): "; cin >> action >> r >> c;

if (!isValid(r, c)) {
    cout << "Toa do khong hop le! Nhan phim bat ky de thu lai...";
    cin.ignore(); cin.get();
    return;
}

if (action == 'M' || action == 'm') {
    if (board[r][c].isFlagged) return; // Không cho mở ô đang cắm cờ

    if (board[r][c].isMine) {
        board[r][c].isRevealed = true;
        gameOver = true; // Dẫm phải mìn -> Thua cuộc
    } else {
        RevealCell(r, c);
        if (CheckWin()) gameWon = true;
    }
} 
else if (action == 'C' || action == 'c') {
    if (!board[r][c].isRevealed) {
        board[r][c].isFlagged = !board[r][c].isFlagged; // Đảo trạng thái cắm cờ
    }
}

}

int main() { Setup();

while (!gameOver && !gameWon) {
    Draw();
    Input();
}

// Vẽ lại bàn cờ cuối cùng để cập nhật kết quả
Draw();

if (gameWon) {
    cout << "\nCHUC MUNG! Ban da xuat sac pha dao game Do Min!\n";
} else {
    cout << "\nBUMMMM!!! Ban da dam phai min. GAME OVER!\n";
}

return 0;

}

include <iostream></iostream>

include <windows.h></windows.h>

include <conio.h></conio.h>

include

include <ctime></ctime>

using namespace std;

const int WIDTH = 40; const int HEIGHT = 20;

struct Point { int x, y; };

class Bullet { public: Point pos; bool isDead;

Bullet(int startX, int startY) {
    pos.x = startX;
    pos.y = startY;
    isDead = false;
}

void update() {
    pos.y--;
    if (pos.y <= 0) isDead = true;
}

}; class Enemy { public: Point pos; bool isDead;

Enemy(int startX, int startY) {
    pos.x = startX;
    pos.y = startY;
    isDead = false;
}

void update() {
    pos.y++;
    if (pos.y >= HEIGHT - 1) isDead = true;
}

};

class Player { public: Point pos; int hp;

Player() {
    pos.x = WIDTH / 2;
    pos.y = HEIGHT - 2;
    hp = 10;
}

void move(int dx) {
    pos.x += dx;
    if (pos.x <= 0) pos.x = 1;
    if (pos.x >= WIDTH - 1) pos.x = WIDTH - 2;
}

};

class GameEngine { private: Player player; vector<bullet> bullets; vector<enemy> enemies; int score; bool gameOver; int spawnTimer; void gotoXY(int x, int y) { COORD coord; coord.X = x; coord.Y = y; SetConsoleCursorPosition(GetStdHandle(STDOUTPUTHANDLE), coord); }</enemy></bullet>

public: GameEngine() { score = 0; gameOver = false; spawnTimer = 0; srand(time(0)); }

void input() {
    if (_kbhit()) {
        switch (_getch()) {
            case 'a': case 'A': player.move(-2); break;
            case 'd': case 'D': player.move(2); break;
            case ' ':
                bullets.push_back(Bullet(player.pos.x, player.pos.y - 1));
                break;
            case 'x': case 'X': gameOver = true; break;
        }
    }
}

void logic() {
spawnTimer++;
if (spawnTimer >= 50) { 
    int rx = rand() % (WIDTH - 2) + 1;
    enemies.push_back(Enemy(rx, 1));
    spawnTimer = 0;
}
for (size_t i = 0; i < bullets.size(); i++) {
    bullets[i].update();
    if (bullets[i].isDead) {
        bullets.erase(bullets.begin() + i);
        i--;
    }
}
static int enemyMoveTimer = 0;
enemyMoveTimer++;

if (enemyMoveTimer >= 3) {
    for (size_t i = 0; i < enemies.size(); i++) {
        enemies[i].update();

        if (enemies[i].pos.y >= HEIGHT - 1) {
            player.hp--;
            enemies.erase(enemies.begin() + i);
            i--;
            if (player.hp <= 0) gameOver = true;
        }
    }
    enemyMoveTimer = 0;
}
    for (size_t b = 0; b < bullets.size(); b++) {
        for (size_t e = 0; e < enemies.size(); e++) {
            if (bullets[b].pos.x == enemies[e].pos.x && bullets[b].pos.y == enemies[e].pos.y) {
                score += 10;
                bullets.erase(bullets.begin() + b);
                enemies.erase(enemies.begin() + e);
                b--;
                break;
            }
        }
    }
    for (size_t e = 0; e < enemies.size(); e++) {
        if (enemies[e].pos.x == player.pos.x && enemies[e].pos.y == player.pos.y) {
            player.hp--;
            enemies.erase(enemies.begin() + e);
            e--;
            if (player.hp <= 0) gameOver = true;
        }
    }
}

void draw() {
    gotoXY(0, 0);

    for (int i = 0; i < HEIGHT; i++) {
        for (int j = 0; j < WIDTH; j++) {
            if (i == 0 || i == HEIGHT - 1 || j == 0 || j == WIDTH - 1) {
                cout << "#";
            }
            else if (j == player.pos.x && i == player.pos.y) {
                cout << "^";
            }
            else {
                bool isPrinted = false;
                for (const auto& b : bullets) {
                    if (b.pos.x == j && b.pos.y == i) {
                        cout << "|";
                        isPrinted = true;
                        break;
                    }
                }
                if (!isPrinted) {
                    for (const auto& e : enemies) {
                        if (e.pos.x == j && e.pos.y == i) {
                            cout << "V";
                            isPrinted = true;
                            break;
                        }
                    }
                }

                if (!isPrinted) cout << " ";
            }
        }
        cout << "\n";
    }
    cout << "DIEM SO: " << score << "  |  MANG: " << player.hp << "       \n";
}

void run() {
    HANDLE consoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO info;
    info.dwSize = 100;
    info.bVisible = FALSE;
    SetConsoleCursorInfo(consoleHandle, &info);
    while (!gameOver) {
        draw();
        input();
        logic();
        Sleep(40);
    }
    system("cls");
    cout << "=================================\n";
    cout << "           GAME OVER             \n";
    cout << "       Diem so cua ban: " << score << "     \n";
    cout << "=================================\n";
    system("pause");
}

};

int main() { GameEngine game; game.run(); return 0; }