#include <iostream>
#include <vector>
#include <conio.h>      // 用于 _getch()
#include <algorithm>    // 用于 std::find_if
#include <cstdlib>      // 用于 system()、rand()
#include <ctime>        // 用于 time()
#include <cmath>        // 用于 abs()、sin()、cos()、M_PI
#include <string>

// --------------------
// 前置声明
// --------------------
struct Entity;
struct Pickup;
struct Weapon;
struct DestructibleObstacle;

// 以下两个函数在 main() 中调用，所以提前声明
void playCampaign(int campaign);  // 处理战役1-4（地图模式）
void playCampaign5();             // 处理战役5（坦克驾驶模式）

// --------------------
// 数据结构（公共部分）
// --------------------
struct Entity {
    int x, y;       // 坐标
    int health;     // 生命值
    char symbol;    // 显示字符
};

struct Pickup {
    int x, y;
    char symbol;
    int value;      // 例如：生命值回复
};

struct Weapon {
    std::string name;
    int range;      // 有效射程（以网格为单位）
    int ammo;       // 当前弹夹中的子弹数量
    int clipSize;   // 弹夹容量
};

struct DestructibleObstacle {
    int x, y;
    int health;     // 障碍物生命值
    char symbol;    // 显示字符（通常为 '#'）
};

int score = 0;  // 分数

// --------------------
// 工具函数
// --------------------
float degToRad(float deg) {
    return deg * M_PI / 180.0f;
}

// 计算两个角度之间的最小差值（单位：度）
float angleDiff(float a, float b) {
    float diff = fabs(a - b);
    return diff > 180 ? 360 - diff : diff;
}

// 打印生命条
void displayHealthBar(const std::string &name, int health, int maxHealth) {
    int barWidth = 20;
    int pos = (health * barWidth) / maxHealth;
    std::cout << name << " 生命: [";
    for (int i = 0; i < barWidth; i++) {
        std::cout << (i < pos ? "#" : "-");
    }
    std::cout << "] " << health << "/" << maxHealth << std::endl;
}

// --------------------
// 战斗遭遇系统（用于战役1-3）
// --------------------
bool battleEncounter(const std::string &battleName, int &playerHealth, int maxPlayerHealth, int enemyHealth) {
    std::cout << "\n=== 战斗: " << battleName << " ===\n";
    while (playerHealth > 0 && enemyHealth > 0) {
        displayHealthBar("玩家", playerHealth, maxPlayerHealth);
        std::cout << "敌人生命值: " << enemyHealth << std::endl;
        std::cout << "按 's' 射击: ";
        char action = _getch();
        if (action == 's' || action == 'S') {
            // 步枪现在伤害为10-60
            int damage = 10 + rand() % 51;
            std::cout << "\n你射击敌人，造成 " << damage << " 点伤害！\n";
            enemyHealth -= damage;
            if (enemyHealth <= 0) {
                std::cout << "敌人被击败！\n";
                break;
            }
        } else {
            std::cout << "\n输入错误，失去射击机会！\n";
        }
        int enemyDamage = 10 + rand() % 6;  // 10-15伤害
        std::cout << "敌人反击，造成 " << enemyDamage << " 点伤害！\n";
        playerHealth -= enemyDamage;
        if (playerHealth <= 0) {
            std::cout << "在战斗 " << battleName << " 中你被击败了！\n";
            return false;
        }
    }
    return true;
}

bool battleBunker(Entity &bunker, int &playerHealth) {
    int bunkerMaxHealth = bunker.health;
    std::cout << "\n开始进攻掩体（坐标: " << bunker.x << "," << bunker.y << "），掩体生命值: " << bunker.health << "\n";
    while (bunker.health > 0 && playerHealth > 0) {
        displayHealthBar("玩家", playerHealth, 100);
        displayHealthBar("掩体", bunker.health, bunkerMaxHealth);
        std::cout << "按 's' 射击掩体: ";
        char action = _getch();
        if (action == 's' || action == 'S') {
            int damage = 10 + rand() % 51;  // 10-60伤害
            std::cout << "\n你射击掩体，造成 " << damage << " 点伤害！\n";
            bunker.health -= damage;
            if (bunker.health <= 0) {
                std::cout << "掩体被摧毁并占领！\n";
                return true;
            }
        } else {
            std::cout << "\n输入错误，失去射击机会！\n";
        }
        int turretDamage = 5 + rand() % 6;  // 5-10伤害
        std::cout << "掩体炮塔开火，造成 " << turretDamage << " 点伤害！\n";
        playerHealth -= turretDamage;
        if (playerHealth <= 0) {
            std::cout << "你被掩体防御击杀了！\n";
            return false;
        }
    }
    return true;
}

// --------------------
// 地图模式（战役1-4）
// --------------------
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;
    if (player.health < 30)
        std::cout << "  [警告: 生命值过低]";
    std::cout << "\n得分: " << score;
    std::cout << "\n武器: " << weapon.name << " | 子弹: " << weapon.ammo << "/" << weapon.clipSize << std::endl;
    std::cout << "\n操作提示:\n  移动: w/a/s/d 以及对角 (q, e, z, c)\n  射击: i/j/k/l 分别代表 上/左/下/右\n  手雷: g   装弹: 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++;
        }
    }
}

// 战役1-4的主函数
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;
    // 步枪伤害使用公式：10 + rand() % 51（10-60）
    Weapon weapon = {"步枪", 6, 6, 6};  
    std::vector<Entity> bunkers;
    
    if (campaign == 1) {
        std::cout << "任务简报: 诺曼底登陆 - 占领海岸的敌人掩体。\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 << "任务简报: 亚丁攻势 - 顽抗敌军！\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 << "任务简报: 柏林进攻 - 深入敌后，占领旗帜！\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) {
        // 德国诺曼底：机枪防御任务
        std::cout << "德国诺曼底任务：在战壕中使用机枪防御10波盟军进攻，与你的NPC战友协同作战。\n";
        player.health = 100;
        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 << " 波 ---\n";
            std::vector<Entity> waveEnemies = {
                {rand() % MAP_WIDTH, 0, 40, 'A'},
                {rand() % MAP_WIDTH, 0, 40, 'A'},
                {rand() % MAP_WIDTH, 0, 40, 'A'}
            };
            while (!waveEnemies.empty()) {
                system("cls");
                std::cout << "德国诺曼底 - 第 " << wave << " 波 / 共 " << totalWaves << " 波\n";
                displayHealthBar("玩家", player.health, 100);
                for (size_t i = 0; i < teammates.size(); i++)
                    std::cout << "战友" << i+1 << " 生命值: " << teammates[i].health << "\n";
                std::cout << "剩余攻击者: " << waveEnemies.size() << "\n";
                std::cout << "按 's' 发射机枪（方向: 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 << "\n输入错误，本回合跳过。\n"; }
                int shotX = player.x + mdx, shotY = player.y + mdy;
                bool hit = false;
                // 机枪伤害：25-50
                for (int r = 0; r < 6 && !hit; r++) {
                    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 = 25 + rand() % 26;
                        it->health -= damage;
                        std::cout << "\n你使用机枪射击攻击者（" << shotX << "," << shotY << "），造成 " << damage << " 点伤害。\n";
                        if (it->health <= 0) { waveEnemies.erase(it); score += 100; std::cout << "攻击者被消灭！（+100分）\n"; }
                        hit = true;
                        break;
                    }
                    shotX += mdx; shotY += mdy;
                }
                // 战友自动射击
                for (auto &tm : teammates) {
                    if (!waveEnemies.empty()) {
                        int targetIndex = rand() % waveEnemies.size();
                        int damage = 25 + rand() % 26;
                        waveEnemies[targetIndex].health -= damage;
                        std::cout << "战友射击，造成 " << damage << " 点伤害。\n";
                        if (waveEnemies[targetIndex].health <= 0) {
                            waveEnemies.erase(waveEnemies.begin() + targetIndex);
                            score += 100;
                            std::cout << "攻击者被战友击毙！（+100分）\n";
                        }
                    }
                }
                // 敌人反击
                for (auto &ae : waveEnemies) {
                    int dmg = 10 + rand() % 6;  // 10-15伤害
                    if (!teammates.empty() && (rand() % 2 == 0)) {
                        int tIndex = rand() % teammates.size();
                        teammates[tIndex].health -= dmg;
                        std::cout << "攻击者射击战友" << tIndex+1 << "，造成 " << dmg << " 点伤害。\n";
                        if (teammates[tIndex].health <= 0) {
                            std::cout << "战友" << tIndex+1 << "阵亡！\n";
                            teammates.erase(teammates.begin() + tIndex);
                        }
                    } else {
                        player.health -= dmg;
                        std::cout << "攻击者射击你，造成 " << dmg << " 点伤害。\n";
                    }
                }
                std::cout << "\n按任意键进入本波下回合...";
                _getch();
                if (player.health <= 0) break;
            }
            if (player.health <= 0) break;
            std::cout << "\n第 " << wave << " 波清除！按任意键继续下一波...";
            _getch();
        }
        if (player.health > 0)
            std::cout << "\n所有波次已击退！德国诺曼底任务完成。\n";
        else
            std::cout << "\n你在战壕中被淹没。任务失败。\n";
        return;
    }
    
    // 战役1-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 << "游戏结束！被掩体防御击杀。\n"; return; }
                    }
                }
                if (campaign == 3 && baseMap[newY][newX]=='F') { baseMap[newY][newX] = '.'; score += 100; std::cout << "旗帜被占领！（+100分）\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 << "捡到急救包（回复 " << it->value << " 点生命）\n"; 
                    score += 50; 
                    it = pickups.erase(it); 
                } else ++it;
            }
        }
        else if (isShoot) {
            if (weapon.ammo <= 0) { std::cout << "弹药不足！按 '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() % 51;  // 步枪伤害：10-60
                        it->health -= damage;
                        std::cout << "击中敌人（" << shotX << "," << shotY << "），造成 " << damage << " 点伤害。\n";
                        if (it->health <= 0) { enemies.erase(it); score += 100; std::cout << "敌人被消灭！（+100分）\n"; }
                        break;
                    }
                    shotX += dx; shotY += dy;
                }
            }
        }
        else if (isGrenade) {
            std::cout << "BOOM! 手雷爆炸。\n请输入手雷投掷方向 (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 << "手雷击中敌人（" << it->x << "," << it->y << "），造成 20 点伤害。\n";
                    if (it->health <= 0) { it = enemies.erase(it); score += 100; std::cout << "敌人被手雷消灭！（+100分）\n"; continue; }
                }
                ++it;
            }
        }
        else if (isReload) { 
            weapon.ammo = weapon.clipSize; 
            std::cout << "装弹中...\n"; 
        }
        
        // 敌人行为：
        for (auto &enemy : enemies) {
            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 << "敌人射击你，造成 " << dmg << " 点伤害！\n";
                        break;
                    }
                    shotX += shotDx; shotY += shotDy;
                }
            }
            else {
                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 << "游戏结束！你在任务中阵亡。\n"; return;
        }
        if (campaign == 1 && bunkers.empty()) {
            render(baseMap, player, enemies, pickups, bunkers, weapon);
            std::cout << "\n所有掩体已占领。进入最终战斗...\n";
            bool result = battleEncounter("最终进攻", player.health, 100, 80);
            std::cout << (result ? "胜利！任务完成。\n" : "失败！最终战斗中失败。\n");
            return;
        }
        else if (campaign == 2 && enemies.empty()) {
            render(baseMap, player, enemies, pickups, bunkers, weapon);
            std::cout << "\n所有敌人已消灭。进入最终战斗...\n";
            bool result = battleEncounter("最终防御", player.health, 100, 90);
            std::cout << (result ? "胜利！任务完成。\n" : "失败！最终战斗中失败。\n");
            return;
        }
        else if (campaign == 3 && baseMap[0][5] != 'F') {
            render(baseMap, player, enemies, pickups, bunkers, weapon);
            std::cout << "\n旗帜已占领。进入最终战斗...\n";
            bool result = battleEncounter("旗帜防御", player.health, 100, 80);
            std::cout << (result ? "胜利！任务完成。\n" : "失败！最终战斗中失败。\n");
            return;
        }
    }
}

// --------------------
// 战役5：德国亚丁攻势（Panther 坦克突击）
// --------------------
struct Tank {
    float x, y;
    float angle;  // 角度（0表示向右，逆时针增加）
    float speed;
    int health;
};

void addObstaclesDestructible(std::vector<std::vector<char>> &grid, std::vector<DestructibleObstacle> &obs, int count) {
    int height = grid.size(), width = grid[0].size();
    int placed = 0;
    while (placed < count) {
        int x = rand() % width, y = rand() % height;
        if (grid[y][x] == '.') {
            grid[y][x] = '#';
            // 每个障碍物初始生命值为100
            obs.push_back({x, y, 100, '#'});
            placed++;
        }
    }
}

void renderCampaign5Grid(const int MAP_WIDTH, const int MAP_HEIGHT,
                         const Tank &playerTank, const std::vector<DestructibleObstacle> &obs,
                         const std::vector<Entity> &enemies, const std::vector<Entity> &crew) {
    std::vector<std::vector<char>> grid(MAP_HEIGHT, std::vector<char>(MAP_WIDTH, '.'));
    for (const auto &o : obs)
        grid[o.y][o.x] = o.symbol;
    for (const auto &e : enemies)
        grid[e.y][e.x] = e.symbol;
    for (const auto &c : crew)
        grid[c.y][c.x] = c.symbol;
    int tx = (int)round(playerTank.x), ty = (int)round(playerTank.y);
    grid[ty][tx] = 'P';
    // 渲染网格
    system("cls");
    for (const auto &row : grid) {
        for (char c : row)
            std::cout << c << ' ';
        std::cout << std::endl;
    }
}

void playCampaign5() {
    const int MAP_WIDTH = 20, MAP_HEIGHT = 10;
    std::vector<std::vector<char>> grid(MAP_HEIGHT, std::vector<char>(MAP_WIDTH, '.'));
    std::vector<DestructibleObstacle> obstacles;
    addObstaclesDestructible(grid, obstacles, 5); // 放置5个可破坏障碍物
    
    Tank playerTank = { MAP_WIDTH/2.0f, MAP_HEIGHT - 2.0f, 90.0f, 0.0f, 150 };  // 坦克初始状态，朝上
    // 武器：主炮和机枪分别有独立弹药
    int cannonAmmo = 4;      // 主炮弹药
    int machineGunAmmo = 20; // 机枪弹药
    // 机组成员，用 'C' 表示
    std::vector<Entity> crew = { { (int)round(playerTank.x) - 1, (int)round(playerTank.y), 100, 'C' },
                                 { (int)round(playerTank.x) + 1, (int)round(playerTank.y), 100, 'C' } };
    
    int totalWaves = 8;
    for (int wave = 1; wave <= totalWaves; wave++) {
        std::cout << "\n--- 第 " << wave << " 波 ---\n";
        // 生成敌人步兵（'I'）和敌坦克（'T'）
        std::vector<Entity> enemies;
        int numInfantry = 3 + rand() % 3;  // 3-5个步兵
        int numEnemyTanks = 1 + rand() % 2;  // 1-2个坦克
        for (int i = 0; i < numInfantry; i++) {
            enemies.push_back({ rand() % MAP_WIDTH, 0, 40, 'I' });
        }
        for (int i = 0; i < numEnemyTanks; i++) {
            enemies.push_back({ rand() % MAP_WIDTH, 0, 80, 'T' });
        }
        
        // 波次模拟循环
        while (!enemies.empty()) {
            // 更新当前网格（障碍物、敌人、机组成员、坦克）
            std::vector<std::vector<char>> currentGrid(MAP_HEIGHT, std::vector<char>(MAP_WIDTH, '.'));
            for (const auto &o : obstacles)
                currentGrid[o.y][o.x] = o.symbol;
            for (const auto &e : enemies)
                currentGrid[e.y][e.x] = e.symbol;
            for (const auto &c : crew)
                currentGrid[c.y][c.x] = c.symbol;
            int tx = (int)round(playerTank.x), ty = (int)round(playerTank.y);
            currentGrid[ty][tx] = 'P';
            renderCampaign5Grid(MAP_WIDTH, MAP_HEIGHT, playerTank, obstacles, enemies, crew);
            
            std::cout << "德国亚丁攻势（Panther 坦克突击） - 第 " << wave << " 波 / " << totalWaves << "\n";
            std::cout << "坦克生命值: " << playerTank.health << "\n";
            std::cout << "机组成员: ";
            for (size_t i = 0; i < crew.size(); i++)
                std::cout << "机组" << i+1 << "(" << crew[i].health << ") ";
            std::cout << "\n主炮弹药: " << cannonAmmo << "   机枪弹药: " << machineGunAmmo << "\n";
            std::cout << "剩余敌人: " << enemies.size() << "\n";
            std::cout << "控制: w（加速）、s（刹车）、a/d（转向）、[空格] 发射主炮、m 发射机枪、r 装弹\n";
            std::cout << "请输入指令: ";
            char cmd = _getch();
            
            // 处理驾驶控制
            if (cmd == 'w') {
                playerTank.speed += 0.5f;
                if (playerTank.speed > 3.0f) playerTank.speed = 3.0f;
            } else if (cmd == 's') {
                playerTank.speed -= 0.5f;
                if (playerTank.speed < 0) playerTank.speed = 0;
            } else if (cmd == 'a') {
                playerTank.angle += 10.0f;
                if (playerTank.angle >= 360.0f) playerTank.angle -= 360.0f;
            } else if (cmd == 'd') {
                playerTank.angle -= 10.0f;
                if (playerTank.angle < 0) playerTank.angle += 360.0f;
            }
            // 处理武器射击
            else if (cmd == ' ') {  // 发射主炮
                if (cannonAmmo <= 0) {
                    std::cout << "\n主炮弹药不足！按 r 装弹。\n";
                } else {
                    cannonAmmo--;
                    std::cout << "\n发射主炮！\n";
                    float rad = degToRad(playerTank.angle);
                    int shotRange = 8;
                    int hitIndex = -1;
                    int bx = (int)round(playerTank.x), by = (int)round(playerTank.y);
                    for (int r = 0; r < shotRange; r++) {
                        bx += (int)round(cos(rad));
                        by -= (int)round(sin(rad));
                        // 检查障碍物
                        bool obstacleHit = false;
                        for (size_t i = 0; i < obstacles.size(); i++) {
                            if (obstacles[i].x == bx && obstacles[i].y == by) {
                                int damage = 200;  // 主炮基础伤害
                                float dx = obstacles[i].x - playerTank.x;
                                float dy = playerTank.y - obstacles[i].y;
                                float targetAngle = atan2(dy, dx) * 180.0f / M_PI;
                                if (targetAngle < 0) targetAngle += 360;
                                float diff = angleDiff(playerTank.angle, targetAngle);
                                float multiplier = (diff < 45 ? 0.5f : (diff > 135 ? 1.5f : 1.0f));
                                int finalDamage = (int)(damage * multiplier);
                                obstacles[i].health -= finalDamage;
                                std::cout << "主炮击中障碍物（" << obstacles[i].x << "," << obstacles[i].y << "），造成 " << finalDamage << " 点伤害。\n";
                                if (obstacles[i].health <= 0) {
                                    std::cout << "障碍物被摧毁！\n";
                                    obstacles.erase(obstacles.begin() + i);
                                }
                                obstacleHit = true;
                                break;
                            }
                        }
                        if (obstacleHit) break;
                        // 检查敌人
                        for (size_t i = 0; i < enemies.size(); i++) {
                            if (enemies[i].x == bx && enemies[i].y == by) {
                                hitIndex = i;
                                break;
                            }
                        }
                        if (hitIndex != -1) break;
                    }
                    if (hitIndex != -1) {
                        int baseDamage = 200;  // 主炮基础伤害
                        float dx = enemies[hitIndex].x - playerTank.x;
                        float dy = playerTank.y - enemies[hitIndex].y;
                        float targetAngle = atan2(dy, dx) * 180.0f / M_PI;
                        if (targetAngle < 0) targetAngle += 360;
                        float diff = angleDiff(playerTank.angle, targetAngle);
                        float multiplier = (diff < 45 ? 0.5f : (diff > 135 ? 1.5f : 1.0f));
                        int damage = (int)(baseDamage * multiplier);
                        enemies[hitIndex].health -= damage;
                        std::cout << "主炮击中敌人（" << enemies[hitIndex].x << "," << enemies[hitIndex].y << "），造成 " << damage << " 点伤害。\n";
                        if (enemies[hitIndex].health <= 0) {
                            std::cout << "敌人被摧毁！\n";
                            enemies.erase(enemies.begin() + hitIndex);
                            score += 150;
                        }
                    } else {
                        std::cout << "主炮未命中。\n";
                    }
                }
            }
            else if (cmd == 'm') {  // 发射机枪
                if (machineGunAmmo <= 0) {
                    std::cout << "\n机枪弹药不足！按 r 装弹。\n";
                } else {
                    machineGunAmmo--;
                    std::cout << "\n发射机枪！\n";
                    float rad = degToRad(playerTank.angle);
                    int shotRange = 6;
                    int hitIndex = -1;
                    int bx = (int)round(playerTank.x), by = (int)round(playerTank.y);
                    for (int r = 0; r < shotRange; r++) {
                        bx += (int)round(cos(rad));
                        by -= (int)round(sin(rad));
                        // 检查障碍物
                        bool obstacleHit = false;
                        for (size_t i = 0; i < obstacles.size(); i++) {
                            if (obstacles[i].x == bx && obstacles[i].y == by) {
                                int damage = 30 + rand() % 11;  // 30-40伤害
                                obstacles[i].health -= damage;
                                std::cout << "机枪击中障碍物（" << obstacles[i].x << "," << obstacles[i].y << "），造成 " << damage << " 点伤害。\n";
                                if (obstacles[i].health <= 0) {
                                    std::cout << "障碍物被摧毁！\n";
                                    obstacles.erase(obstacles.begin() + i);
                                }
                                obstacleHit = true;
                                break;
                            }
                        }
                        if (obstacleHit) break;
                        for (size_t i = 0; i < enemies.size(); i++) {
                            if (enemies[i].x == bx && enemies[i].y == by) { hitIndex = i; break; }
                        }
                        if (hitIndex != -1) break;
                    }
                    if (hitIndex != -1) {
                        int damage = 30 + rand() % 11;  // 30-40伤害
                        enemies[hitIndex].health -= damage;
                        std::cout << "机枪击中敌人（" << enemies[hitIndex].x << "," << enemies[hitIndex].y << "），造成 " << damage << " 点伤害。\n";
                        if (enemies[hitIndex].health <= 0) {
                            std::cout << "敌人被摧毁！\n";
                            enemies.erase(enemies.begin() + hitIndex);
                            score += 100;
                        }
                    } else {
                        std::cout << "机枪未命中。\n";
                    }
                }
            }
            else if (cmd == 'r') {
                cannonAmmo = 4;
                machineGunAmmo = 20;
                std::cout << "\n正在装弹...\n";
            }
            
            // 更新坦克物理：根据速度和角度更新位置
            float rad = degToRad(playerTank.angle);
            playerTank.x += playerTank.speed * cos(rad);
            playerTank.y -= playerTank.speed * sin(rad);
            if (playerTank.x < 0) playerTank.x = 0;
            if (playerTank.x >= MAP_WIDTH) playerTank.x = MAP_WIDTH - 1;
            if (playerTank.y < 0) playerTank.y = 0;
            if (playerTank.y >= MAP_HEIGHT) playerTank.y = MAP_HEIGHT - 1;
            
            // 敌人行动：每个敌人向坦克移动一格
            for (auto &enemy : enemies) {
                if (enemy.x < (int)round(playerTank.x)) enemy.x++;
                else if (enemy.x > (int)round(playerTank.x)) enemy.x--;
                if (enemy.y < (int)round(playerTank.y)) enemy.y++;
                else if (enemy.y > (int)round(playerTank.y)) enemy.y--;
                // 敌人有30%的几率射击
                if (rand() % 100 < 30) {
                    int baseDmg = 15 + rand() % 6; // 15-20伤害
                    float dx = enemy.x - playerTank.x;
                    float dy = playerTank.y - enemy.y;
                    float enemyAngle = atan2(dy, dx) * 180.0f / M_PI;
                    if (enemyAngle < 0) enemyAngle += 360;
                    float diff = angleDiff(playerTank.angle, enemyAngle);
                    float multiplier = (diff < 45 ? 0.5f : (diff > 135 ? 1.5f : 1.0f));
                    int dmg = (int)(baseDmg * multiplier);
                    playerTank.health -= dmg;
                    std::cout << "敌人射击你，造成 " << dmg << " 点伤害。\n";
                }
            }
            
            std::cout << "\n按任意键进入本波下回合...";
            _getch();
            if (playerTank.health <= 0) break;
        }
        if (playerTank.health <= 0) break;
        std::cout << "\n本波清除！按任意键进入下一波...";
        _getch();
    }
    if (playerTank.health > 0)
        std::cout << "\n所有敌防被摧毁！德国亚丁攻势任务完成。\n";
    else
        std::cout << "\n你的 Panzer 坦克和机组被摧毁。任务失败。\n";
}

// --------------------
// Main 函数
// --------------------
int main() {
    srand(static_cast<unsigned int>(time(0)));
    std::cout << "战场1 - 增强版-由BC20270371制作\n";
    std::cout << "【操作说明】\n";
    std::cout << "（战役1-4）移动: w/a/s/d 及对角 (q, e, z, c)  射击: i/j/k/l（上/左/下/右）  手雷: g  装弹: r\n";
    std::cout << "\n请选择战役：\n";
    std::cout << "1. 诺曼底登陆\n2. 阿登攻势\n3. 柏林进攻\n4. 德国诺曼底（机枪防御）\n5. 德国阿登攻势（Panzer坦克突击）\n请输入战役编号 (1-5): ";
    int choice;
    std::cin >> choice;
    if (choice >= 1 && choice <= 5) {
        if (choice == 5) {
            playCampaign5();
        } else {
            playCampaign(choice);
        }
    } else {
        std::cout << "输入无效！\n";
    }
    std::cout << "\n按任意键退出...";
    _getch();
    return 0;
}