#include <iostream>
#include <vector>
#include <conio.h>      // For _getch()
#include <algorithm>    // For std::find_if
#include <cstdlib>      // For system(), rand()
#include <ctime>        // For time()
#include <cmath>        // For abs()
#include <string>

// --------------------
// Data Structures
// --------------------
struct Entity {
    int x, y;
    int health;
    char symbol;
};

struct Pickup {
    int x, y;
    char symbol;
    int value; // e.g., health restore
};

struct Weapon {
    std::string name;
    int range;     // effective shooting range
    int ammo;      // current ammo in clip
    int clipSize;  // max ammo in a clip
};

// Global score variable
int score = 0;

// --------------------
// Battle Encounter System (Existing Modes)
// --------------------
void displayHealthBar(const std::string &name, int health, int maxHealth) {
    int barWidth = 20;
    int pos = (health * barWidth) / maxHealth;
    std::cout << name << " Health: [";
    for (int i = 0; i < barWidth; i++) {
        if (i < pos)
            std::cout << "#";
        else
            std::cout << "-";
    }
    std::cout << "] " << health << "/" << maxHealth << std::endl;
}

bool battleEncounter(const std::string &battleName, int &playerHealth, int maxPlayerHealth, int enemyHealth) {
    std::cout << "\n=== Battle: " << battleName << " ===\n";
    while (playerHealth > 0 && enemyHealth > 0) {
        displayHealthBar("Player", playerHealth, maxPlayerHealth);
        std::cout << "Enemy Health: " << enemyHealth << std::endl;
        
        std::cout << "Press 's' to shoot: ";
        char action = _getch();
        if (action == 's' || action == 'S') {
            int damage = 10 + rand() % 11;  // 10-20 damage
            std::cout << "\nYou shoot the enemy and deal " << damage << " damage!\n";
            enemyHealth -= damage;
            if (enemyHealth <= 0) {
                std::cout << "Enemy defeated!\n";
                break;
            }
        } else {
            std::cout << "\nInvalid input, you lose your chance to shoot!\n";
        }
        
        int enemyDamage = 10 + rand() % 6;  // 10-15 damage
        std::cout << "Enemy shoots back and deals " << enemyDamage << " damage!\n";
        playerHealth -= enemyDamage;
        if (playerHealth <= 0) {
            std::cout << "You have been defeated in battle: " << battleName << "\n";
            return false;
        }
    }
    return true;
}

bool battleBunker(Entity &bunker, int &playerHealth) {
    int bunkerMaxHealth = bunker.health;
    std::cout << "\nInitiating Bunker Assault at (" << bunker.x << "," << bunker.y << "). Bunker Health: " << bunker.health << "\n";
    while (bunker.health > 0 && playerHealth > 0) {
        displayHealthBar("Player", playerHealth, 100);
        displayHealthBar("Bunker", bunker.health, bunkerMaxHealth);
        std::cout << "Press 's' to shoot the bunker: ";
        char action = _getch();
        if (action == 's' || action == 'S') {
            int damage = 10 + rand() % 11;  // 10-20 damage
            std::cout << "\nYou hit the bunker for " << damage << " damage!\n";
            bunker.health -= damage;
            if (bunker.health <= 0) {
                std::cout << "Bunker destroyed and captured!\n";
                return true;
            }
        } else {
            std::cout << "\nInvalid input, you missed your chance!\n";
        }
        int turretDamage = 5 + rand() % 6;  // 5-10 damage
        std::cout << "Bunker turret fires and deals " << turretDamage << " damage to you!\n";
        playerHealth -= turretDamage;
        if (playerHealth <= 0) {
            std::cout << "You have been killed by the bunker defenses!\n";
            return false;
        }
    }
    return true;
}

// --------------------
// Map-Based Gameplay (Campaigns 1-3)
// --------------------
void render(const std::vector<std::vector<char>>& baseMap, 
            const Entity &player, 
            const std::vector<Entity> &enemies,
            const std::vector<Pickup> &pickups,
            const std::vector<Entity> &bunkers,
            const Weapon &weapon) {
    system("cls");
    std::vector<std::vector<char>> displayMap = baseMap;
    for (const auto &p : pickups) {
        displayMap[p.y][p.x] = p.symbol;
    }
    for (const auto &b : bunkers) {
        displayMap[b.y][b.x] = b.symbol;
    }
    for (const auto &e : enemies) {
        displayMap[e.y][e.x] = e.symbol;
    }
    displayMap[player.y][player.x] = player.symbol;
    for (const auto &row : displayMap) {
        for (char c : row)
            std::cout << c << ' ';
        std::cout << std::endl;
    }
    std::cout << "Player Health: " << player.health;
    if (player.health < 30)
        std::cout << "  [WARNING: LOW HEALTH]";
    std::cout << "\nScore: " << score;
    std::cout << "\nWeapon: " << weapon.name << " | Ammo: " << weapon.ammo << "/" << weapon.clipSize << std::endl;
    std::cout << "\nControls:\n  Movement: w/a/s/d and diagonals (q, e, z, c)\n  Shooting: i/j/k/l for up/left/down/right\n  Grenade: g   Reload: r" << std::endl;
}

void addObstacles(std::vector<std::vector<char>> &baseMap, int count) {
    int height = baseMap.size(), width = baseMap[0].size();
    int placed = 0;
    while (placed < count) {
        int x = rand() % width, y = rand() % height;
        if (baseMap[y][x] == '.') {
            baseMap[y][x] = '#';
            placed++;
        }
    }
}

void playCampaign(int campaign) {
    const int MAP_WIDTH = 10, MAP_HEIGHT = 10;
    std::vector<std::vector<char>> baseMap(MAP_HEIGHT, std::vector<char>(MAP_WIDTH, '.'));
    addObstacles(baseMap, 10);
    
    Entity player = {5, 9, 100, 'P'};
    std::vector<Entity> enemies;
    std::vector<Pickup> pickups;
    Weapon weapon = {"Rifle", 6, 6, 6};  // (range, ammo, clip size)
    std::vector<Entity> bunkers;
    
    if (campaign == 1) {
        std::cout << "Mission Briefing: D-Day - Capture enemy bunkers along the coast.\n";
        bunkers.push_back({3, 0, 50, 'B'});
        bunkers.push_back({7, 0, 50, 'B'});
        baseMap[0][3] = 'B'; baseMap[0][7] = 'B';
        enemies = { {3,3,50,'E'}, {7,3,50,'E'}, {5,5,50,'E'} };
        pickups.push_back({2,6,'M',20});
    }
    else if (campaign == 2) {
        std::cout << "Mission Briefing: Aden Offensive - Hold off enemy forces!\n";
        enemies = { {2,2,50,'E'}, {4,3,50,'E'}, {6,2,50,'E'}, {3,4,50,'E'}, {7,4,50,'E'} };
        pickups.push_back({1,8,'M',20});
    }
    else if (campaign == 3) {
        std::cout << "Mission Briefing: Berlin Attack - Capture the flag deep in enemy territory!\n";
        baseMap[0][5] = 'F';
        enemies = { {4,2,50,'E'}, {6,2,50,'E'}, {5,4,50,'E'}, {3,3,50,'E'} };
        pickups.push_back({8,7,'M',20});
    }
    else if (campaign == 4 || campaign == 5) {
        // German side missions are handled separately below.
    }
    
    // For campaigns 1-3:
    if (campaign >= 1 && campaign <= 3) {
        while (true) {
            render(baseMap, player, enemies, pickups, bunkers, weapon);
            char input = _getch();
            int dx = 0, dy = 0;
            bool isMove = false, isShoot = false, isGrenade = false, isReload = false;
            if      (input=='w') { dy = -1; isMove = true; }
            else if (input=='s') { dy = 1;  isMove = true; }
            else if (input=='a') { dx = -1; isMove = true; }
            else if (input=='d') { dx = 1;  isMove = true; }
            else if (input=='q') { dx = -1; dy = -1; isMove = true; }
            else if (input=='e') { dx = 1;  dy = -1; isMove = true; }
            else if (input=='z') { dx = -1; dy = 1;  isMove = true; }
            else if (input=='c') { dx = 1;  dy = 1;  isMove = true; }
            else if (input=='i') { dy = -1; isShoot = true; }
            else if (input=='k') { dy = 1;  isShoot = true; }
            else if (input=='j') { dx = -1; isShoot = true; }
            else if (input=='l') { dx = 1;  isShoot = true; }
            else if (input=='g') { isGrenade = true; }
            else if (input=='r') { isReload = true; }
            
            if (isMove) {
                int newX = player.x + dx, newY = player.y + dy;
                if (newX >= 0 && newX < MAP_WIDTH && newY >= 0 && newY < MAP_HEIGHT &&
                   (baseMap[newY][newX]=='.' || baseMap[newY][newX]=='B' || baseMap[newY][newX]=='F')) {
                    player.x = newX; player.y = newY;
                    if (campaign==1 && baseMap[newY][newX]=='B') {
                        auto it = std::find_if(bunkers.begin(), bunkers.end(), [newX,newY](const Entity &b){ return b.x==newX && b.y==newY; });
                        if (it!=bunkers.end()) {
                            bool survived = battleBunker(*it, player.health);
                            if (survived) { score += 100; baseMap[newY][newX] = '.'; bunkers.erase(it); }
                            else { render(baseMap, player, enemies, pickups, bunkers, weapon); std::cout << "Game Over! Killed by bunker defenses.\n"; return; }
                        }
                    }
                    if (campaign==3 && baseMap[newY][newX]=='F') { baseMap[newY][newX] = '.'; score += 100; std::cout << "Flag captured! (+100 points)\n"; }
                }
                for (auto it = pickups.begin(); it != pickups.end(); ) {
                    if (it->x==player.x && it->y==player.y) { player.health += it->value; if (player.health>100) player.health=100; std::cout << "Picked up medkit (" << it->value << ")\n"; score += 50; it = pickups.erase(it); }
                    else ++it;
                }
            }
            else if (isShoot) {
                if (weapon.ammo <= 0) { std::cout << "Out of ammo! Reload (press 'r')!\n"; }
                else {
                    weapon.ammo--;
                    std::cout << "BANG!\n";
                    int shotX = player.x + dx, shotY = player.y + dy;
                    for (int r = 0; r < weapon.range; r++) {
                        if (shotX < 0 || shotX >= MAP_WIDTH || shotY < 0 || shotY >= MAP_HEIGHT) break;
                        if (baseMap[shotY][shotX]=='#') break;
                        auto it = std::find_if(enemies.begin(), enemies.end(), [shotX,shotY](const Entity &e){ return e.x==shotX && e.y==shotY; });
                        if (it != enemies.end()) {
                            int damage = 10 + rand() % 11;
                            it->health -= damage;
                            std::cout << "Hit enemy at (" << shotX << "," << shotY << ") for " << damage << " damage.\n";
                            if (it->health <= 0) { enemies.erase(it); score += 100; std::cout << "Enemy eliminated! (+100 points)\n"; }
                            break;
                        }
                        shotX += dx; shotY += dy;
                    }
                }
            }
            else if (isGrenade) {
                std::cout << "BOOM! Grenade exploded.\nEnter grenade direction (i/j/k/l): ";
                char gDir = _getch();
                int centerX = player.x, centerY = player.y;
                if (gDir=='i') centerY = player.y - 1;
                else if (gDir=='k') centerY = player.y + 1;
                else if (gDir=='j') centerX = player.x - 1;
                else if (gDir=='l') centerX = player.x + 1;
                for (auto it = enemies.begin(); it != enemies.end(); ) {
                    if (abs(it->x - centerX) <= 1 && abs(it->y - centerY) <= 1) {
                        it->health -= 20;
                        std::cout << "Grenade hit enemy at (" << it->x << "," << it->y << ") for 20 damage.\n";
                        if (it->health <= 0) { it = enemies.erase(it); score += 100; std::cout << "Enemy eliminated by grenade! (+100 points)\n"; continue; }
                    }
                    ++it;
                }
            }
            else if (isReload) { weapon.ammo = weapon.clipSize; std::cout << "Reloading...\n"; }
            
            // Enemy actions:
            for (auto &enemy : enemies) {
                // If aligned with player, enemy shoots.
                if (enemy.x == player.x || enemy.y == player.y) {
                    int shotDx = (enemy.x == player.x) ? 0 : (enemy.x < player.x ? 1 : -1);
                    int shotDy = (enemy.y == player.y) ? 0 : (enemy.y < player.y ? 1 : -1);
                    int shotX = enemy.x + shotDx, shotY = enemy.y + shotDy;
                    while (shotX >= 0 && shotX < MAP_WIDTH && shotY >= 0 && shotY < MAP_HEIGHT) {
                        if (baseMap[shotY][shotX]=='#') break;
                        if (shotX==player.x && shotY==player.y) {
                            int dmg = 10 + rand() % 6;
                            player.health -= dmg;
                            std::cout << "Enemy shot you for " << dmg << " damage!\n";
                            break;
                        }
                        shotX += shotDx; shotY += shotDy;
                    }
                }
                else { // Otherwise, enemy moves toward player if destination is empty.
                    int moveDx = (enemy.x < player.x) ? 1 : (enemy.x > player.x ? -1 : 0);
                    int moveDy = (enemy.y < player.y) ? 1 : (enemy.y > player.y ? -1 : 0);
                    int newX = enemy.x + moveDx, newY = enemy.y + moveDy;
                    if (newX >= 0 && newX < MAP_WIDTH && newY >= 0 && newY < MAP_HEIGHT && baseMap[newY][newX]=='.') {
                        enemy.x = newX; enemy.y = newY;
                    }
                }
            }
            
            if (player.health <= 0) {
                render(baseMap, player, enemies, pickups, bunkers, weapon);
                std::cout << "Game Over! You died during the mission.\n";
                return;
            }
            if (campaign == 1 && bunkers.empty()) {
                render(baseMap, player, enemies, pickups, bunkers, weapon);
                std::cout << "\nAll bunkers captured. Initiating final battle...\n";
                bool result = battleEncounter("Bunker Final Assault", player.health, 100, 80);
                std::cout << (result ? "Victory! Mission accomplished.\n" : "Defeat! Mission failed in final battle.\n");
                return;
            }
            else if (campaign == 2 && enemies.empty()) {
                render(baseMap, player, enemies, pickups, bunkers, weapon);
                std::cout << "\nAll enemies eliminated. Initiating final battle...\n";
                bool result = battleEncounter("Final Defense", player.health, 100, 90);
                std::cout << (result ? "Victory! Mission accomplished.\n" : "Defeat! Mission failed in final battle.\n");
                return;
            }
            else if (campaign == 3 && baseMap[0][5] != 'F') {
                render(baseMap, player, enemies, pickups, bunkers, weapon);
                std::cout << "\nFlag captured. Initiating final battle...\n";
                bool result = battleEncounter("Flag Defense", player.health, 100, 80);
                std::cout << (result ? "Victory! Mission accomplished.\n" : "Defeat! Mission failed in final battle.\n");
                return;
            }
        } // end while
    } // end playCampaign for campaigns 1-3

    // --------------------
    // German Side Missions: Campaign 4 (German D-Day) & Campaign 5 (German Aden Offensive)
    if (campaign == 4) {
        // German D-Day: Machine gun defense in the trenches against 10 waves of Allied attack.
        std::cout << "German D-Day Mission: Use your machine gun to fend off 10 waves of Allied attackers in the trenches.\n";
        // Initialize player and teammates.
        player.health = 100; // player health
        // Create NPC teammates (symbol 'T') – we use a vector.
        std::vector<Entity> teammates = {
            {4, 9, 80, 'T'},
            {6, 9, 80, 'T'}
        };
        int totalWaves = 10;
        for (int wave = 1; wave <= totalWaves; wave++) {
            std::cout << "\n--- Wave " << wave << " ---\n";
            // Each wave spawns 3 allied enemy attackers (symbol 'A').
            std::vector<Entity> waveEnemies = {
                {rand() % MAP_WIDTH, 0, 40, 'A'},
                {rand() % MAP_WIDTH, 0, 40, 'A'},
                {rand() % MAP_WIDTH, 0, 40, 'A'}
            };
            // Wave battle loop.
            while (!waveEnemies.empty()) {
                // Display status.
                system("cls");
                std::cout << "German D-Day - Wave " << wave << " / " << totalWaves << "\n";
                displayHealthBar("Player", player.health, 100);
                for (size_t i = 0; i < teammates.size(); i++) {
                    std::cout << "Teammate " << i+1 << " Health: " << teammates[i].health << "\n";
                }
                std::cout << "Remaining enemy attackers: " << waveEnemies.size() << "\n";
                std::cout << "Press 's' to machine gun shoot (direction: i/j/k/l): ";
                char action = _getch();
                int mdx = 0, mdy = 0;
                if (action=='i') { mdy = -1; }
                else if (action=='k') { mdy = 1; }
                else if (action=='j') { mdx = -1; }
                else if (action=='l') { mdx = 1; }
                else { std::cout << "\nInvalid input, turn skipped.\n"; }
                // Player shoots: trace bullet starting from player's position.
                int shotX = player.x + mdx, shotY = player.y + mdy;
                bool hit = false;
                for (int r = 0; r < 6 && !hit; r++) { // machine gun range fixed at 6
                    if (shotX < 0 || shotX >= MAP_WIDTH || shotY < 0 || shotY >= MAP_HEIGHT)
                        break;
                    // Check if an enemy is at this cell.
                    auto it = std::find_if(waveEnemies.begin(), waveEnemies.end(), [shotX, shotY](const Entity &e) {
                        return e.x == shotX && e.y == shotY;
                    });
                    if (it != waveEnemies.end()) {
                        int damage = 10 + rand() % 11;  // 10-20 damage as before.
                        it->health -= damage;
                        std::cout << "\nYou machine gun an attacker at (" << shotX << "," << shotY << ") for " << damage << " damage.\n";
                        if (it->health <= 0) {
                            waveEnemies.erase(it);
                            score += 100;
                            std::cout << "Attacker eliminated! (+100 points)\n";
                        }
                        hit = true;
                        break;
                    }
                    shotX += mdx; shotY += mdy;
                }
                // NPC teammates automatically shoot: each teammate randomly targets one enemy if any.
                for (auto &tm : teammates) {
                    if (!waveEnemies.empty()) {
                        int targetIndex = rand() % waveEnemies.size();
                        int damage = 10 + rand() % 11;
                        waveEnemies[targetIndex].health -= damage;
                        std::cout << "Teammate at (" << tm.x << "," << tm.y << ") fires and deals " << damage << " damage to an attacker.\n";
                        if (waveEnemies[targetIndex].health <= 0) {
                            waveEnemies.erase(waveEnemies.begin() + targetIndex);
                            score += 100;
                            std::cout << "Attacker eliminated by teammate! (+100 points)\n";
                        }
                    }
                }
                // Enemies shoot back: each enemy deals random damage to player and a random teammate (if any exist).
                for (auto &ae : waveEnemies) {
                    int dmg = 10 + rand() % 6; // 10-15 damage
                    // Randomly choose to hit player (50% chance) or one teammate.
                    if (!teammates.empty() && (rand() % 2 == 0)) {
                        int tIndex = rand() % teammates.size();
                        teammates[tIndex].health -= dmg;
                        std::cout << "An enemy attacker shoots teammate " << tIndex+1 << " for " << dmg << " damage.\n";
                        if (teammates[tIndex].health <= 0) {
                            std::cout << "Teammate " << tIndex+1 << " is down!\n";
                            teammates.erase(teammates.begin() + tIndex);
                        }
                    } else {
                        player.health -= dmg;
                        std::cout << "An enemy attacker shoots you for " << dmg << " damage.\n";
                    }
                }
                std::cout << "\nPress any key for next turn in this wave...";
                _getch();
                if (player.health <= 0) break;
                // End of turn.
            } // end wave loop
            if (player.health <= 0) break;
            std::cout << "\nWave " << wave << " cleared! Press any key to continue to the next wave...";
            _getch();
        } // end waves
        if (player.health > 0) {
            std::cout << "\nAll waves repelled! German D-Day mission accomplished.\n";
        } else {
            std::cout << "\nYou have been overwhelmed in the trenches. Mission failed.\n";
        }
        return;
    }
    else if (campaign == 5) {
        // German Aden Offensive: Driving a Panther tank with NPC teammates protecting you.
        std::cout << "German Aden Offensive Mission: Drive your Panther tank to attack Allied defenses. Protect your vehicle as waves of enemy defenses approach.\n";
        // In this mission the player is in a vehicle with higher health.
        player.health = 150;
        // Create two NPC teammates (e.g. tank crew) with symbol 'C'
        std::vector<Entity> teammates = {
            {player.x - 1, player.y, 100, 'C'},
            {player.x + 1, player.y, 100, 'C'}
        };
        int totalWaves = 8;
        for (int wave = 1; wave <= totalWaves; wave++) {
            std::cout << "\n--- Wave " << wave << " ---\n";
            // Each wave spawns 4 enemy defenses (symbol 'D') at random positions near the top.
            std::vector<Entity> waveEnemies = {
                {rand() % MAP_WIDTH, 0, 50, 'D'},
                {rand() % MAP_WIDTH, 0, 50, 'D'},
                {rand() % MAP_WIDTH, 0, 50, 'D'},
                {rand() % MAP_WIDTH, 0, 50, 'D'}
            };
            while (!waveEnemies.empty()) {
                system("cls");
                std::cout << "German Aden Offensive - Wave " << wave << " / " << totalWaves << "\n";
                std::cout << "Tank (You) Health: " << player.health << "\n";
                for (size_t i = 0; i < teammates.size(); i++) {
                    std::cout << "Crew " << i+1 << " Health: " << teammates[i].health << "\n";
                }
                std::cout << "Remaining enemy defenses: " << waveEnemies.size() << "\n";
                std::cout << "Press 's' to fire your tank gun (direction: i/j/k/l): ";
                char action = _getch();
                int mdx = 0, mdy = 0;
                if (action=='i') { mdy = -1; }
                else if (action=='k') { mdy = 1; }
                else if (action=='j') { mdx = -1; }
                else if (action=='l') { mdx = 1; }
                else { std::cout << "\nInvalid input, turn skipped.\n"; }
                // Player (tank) shoots:
                int shotX = player.x + mdx, shotY = player.y + mdy;
                bool hit = false;
                for (int r = 0; r < 8 && !hit; r++) { // tank gun range is 8
                    if (shotX < 0 || shotX >= MAP_WIDTH || shotY < 0 || shotY >= MAP_HEIGHT)
                        break;
                    auto it = std::find_if(waveEnemies.begin(), waveEnemies.end(), [shotX,shotY](const Entity &e) {
                        return e.x==shotX && e.y==shotY;
                    });
                    if (it != waveEnemies.end()) {
                        int damage = 10 + rand() % 11; // 10-20 damage
                        it->health -= damage;
                        std::cout << "\nYour tank fires at (" << shotX << "," << shotY << ") for " << damage << " damage.\n";
                        if (it->health <= 0) {
                            waveEnemies.erase(it);
                            score += 100;
                            std::cout << "Enemy defense destroyed! (+100 points)\n";
                        }
                        hit = true;
                        break;
                    }
                    shotX += mdx; shotY += mdy;
                }
                // NPC teammates fire automatically.
                for (auto &tm : teammates) {
                    if (!waveEnemies.empty()) {
                        int targetIndex = rand() % waveEnemies.size();
                        int damage = 10 + rand() % 11;
                        waveEnemies[targetIndex].health -= damage;
                        std::cout << "Crew member fires and deals " << damage << " damage to an enemy defense.\n";
                        if (waveEnemies[targetIndex].health <= 0) {
                            waveEnemies.erase(waveEnemies.begin() + targetIndex);
                            score += 100;
                            std::cout << "Enemy defense destroyed by crew! (+100 points)\n";
                        }
                    }
                }
                // Enemy defenses fire back:
                for (auto &ed : waveEnemies) {
                    int dmg = 10 + rand() % 6; // 10-15 damage
                    if (!teammates.empty() && (rand() % 2 == 0)) {
                        int tIndex = rand() % teammates.size();
                        teammates[tIndex].health -= dmg;
                        std::cout << "An enemy defense fires at crew member " << tIndex+1 << " for " << dmg << " damage.\n";
                        if (teammates[tIndex].health <= 0) {
                            std::cout << "Crew member " << tIndex+1 << " is down!\n";
                            teammates.erase(teammates.begin() + tIndex);
                        }
                    } else {
                        player.health -= dmg;
                        std::cout << "An enemy defense fires at your tank for " << dmg << " damage.\n";
                    }
                }
                std::cout << "\nPress any key for next turn in this wave...";
                _getch();
                if (player.health <= 0) break;
            } // end wave loop
            if (player.health <= 0) break;
            std::cout << "\nWave " << wave << " cleared! Press any key to continue to the next wave...";
            _getch();
        } // end waves
        if (player.health > 0) {
            std::cout << "\nAll enemy defenses destroyed! German Aden Offensive mission accomplished.\n";
        } else {
            std::cout << "\nYour Panther tank and crew were destroyed. Mission failed.\n";
        }
        return;
    }
} // end playCampaign

// --------------------
// Main
// --------------------
int main() {
    srand(static_cast<unsigned int>(time(0)));
    std::cout << "Battleground 1 - Enhanced Edition\n";
    std::cout << "Controls:\n  Movement: w/a/s/d and diagonals (q, e, z, c)\n  Shooting: i/j/k/l for up/left/down/right\n  Grenade: g   Reload: r\n";
    std::cout << "\nSelect Campaign:\n1. D-Day\n2. Aden Offensive\n3. Berlin Attack\n4. German D-Day (Machine Gun Defense)\n5. German Aden Offensive (Panther Assault)\nEnter choice (1-5): ";
    int choice;
    std::cin >> choice;
    if (choice >= 1 && choice <= 5) {
        playCampaign(choice);
    } else {
        std::cout << "Invalid choice." << std::endl;
    }
    std::cout << "\nPress any key to exit.";
    _getch();
    return 0;
}