问题标题: 小游戏

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <fstream>
#include <algorithm>
#include <thread>    // 跨平台延时所需头文件
#include <chrono>    // 时间单位所需头文件

using namespace std;

// ===================== 全局常量定义 =====================
const int MAX_NAME_LEN = 20;
const int MAX_SKILL = 6;
const int MAX_ITEM = 30;
const int MAX_MONSTER = 15;
const int MAX_TASK = 8;
const int MAP_SIZE = 10;
const int SAVE_OK = 1;
const int SAVE_FAIL = 0;

// ===================== 结构体定义 =====================
// 技能结构体
struct Skill
{
    char skillName[MAX_NAME_LEN];
    int damage;        // 技能伤害
    int mpCost;        // 蓝量消耗
    int type;          // 0普攻 1火系 2冰系 3毒系 4治疗
    int unlockLevel;   // 解锁等级
    bool isUnlock;     // 是否解锁
};

// 物品结构体
struct Item
{
    char itemName[MAX_NAME_LEN];
    int type;          // 1回血 2回蓝 3攻击buff 4防御buff 5材料 6装备
    int value;         // 效果数值
    int price;         // 购买价格
    int count;         // 拥有数量
    bool isEquip;      // 是否可装备
};

// 怪物结构体
struct Monster
{
    char monName[MAX_NAME_LEN];
    int hp;
    int maxHp;
    int attack;
    int defense;
    int exp;
    int gold;
    int level;
    bool isBoss;
    int dropItem;      // 掉落物品下标
};

// 任务结构体
struct Task
{
    char taskName[MAX_NAME_LEN];
    char taskDesc[100];
    int needKill;      // 需要击杀怪物数量
    int nowKill;       // 当前击杀数量
    int targetMon;     // 目标怪物下标
    int rewardExp;
    int rewardGold;
    bool isFinish;
    bool isAccept;
};

// 玩家结构体
struct Player
{
    char name[MAX_NAME_LEN];
    int level;
    int hp;
    int maxHp;
    int mp;
    int maxMp;
    int attack;
    int defense;
    int exp;
    int needExp;
    int gold;
    int positionX;
    int positionY;
    int buffAtk;
    int buffDef;
    int buffRound;
    Skill skill[MAX_SKILL];
    Item bag[MAX_ITEM];
    Task task[MAX_TASK];
};

// 地图格子类型
enum GridType
{
    GRID_EMPTY,
    GRID_MONSTER,
    GRID_TREASURE,
    GRID_SHOP,
    GRID_SAVE,
    GRID_BOSS,
    GRID_TRAP
};

// 地图结构体
struct GameMap
{
    GridType grid[MAP_SIZE][MAP_SIZE];
    int monIndex[MAP_SIZE][MAP_SIZE];
    bool isExplore[MAP_SIZE][MAP_SIZE];
};

// ===================== 全局变量 =====================
Player hero;
Monster monsterList[MAX_MONSTER];
GameMap worldMap;
bool gameRun = true;
int gameDay = 1;

// ===================== 函数声明 =====================
// 初始化函数
void InitGame();
void InitPlayer();
void InitSkill();
void InitItem();
void InitMonster();
void InitTask();
void InitMap();

// 界面函数
void ShowStartMenu();
void ShowMainMenu();
void ShowPlayerInfo();
void ShowBag();
void ShowSkillList();
void ShowTaskList();
void ShowShop();
void ShowMap();
void ClearScreen();
void SleepTime(int ms);

// 战斗函数
void Battle(int monID);
void PlayerAttack(int monID);
void PlayerUseSkill(int monID);
void PlayerUseItem();
void MonsterAttack(int monID);
void CalculateDamage(int atk, int def, int& hurt);
void BossBattle();

// 养成函数
void LevelUp();
void RecoverHPMP();
void AddBuff(int atk, int def, int round);
void ClearBuff();

// 地图探索
void MovePlayer(int dir);
void RandomEvent();
void OpenTreasure();
void StepTrap();

// 任务**
void AcceptTask(int tid);
void SubmitTask(int tid);
void UpdateTaskKill(int monID);

// 物品操作
void UseItem(int id);
void BuyItem(int id);
void DropItem(int id);

// 存档读档
int SaveGame();
int LoadGame();

// 随机工具
int RandomInt(int min, int max);
bool RandomBool(int rate);

// ===================== 函数实现开始 =====================
void ClearScreen()
{
    system("cls");
}

// 跨平台延时函数（修复核心）
void SleepTime(int ms)
{
    // 替换Windows专属Sleep，支持Linux/macOS/Windows全平台
    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
}

int RandomInt(int min, int max)
{
    return rand() % (max - min + 1) + min;
}

bool RandomBool(int rate)
{
    int r = RandomInt(1, 100);
    return r <= rate;
}

void InitSkill()
{
    // 初始技能1 普通攻击
    strcpy(hero.skill[0].skillName, "普通打击");
    hero.skill[0].damage = 10;
    hero.skill[0].mpCost = 0;
    hero.skill[0].type = 0;
    hero.skill[0].unlockLevel = 1;
    hero.skill[0].isUnlock = true;

    // 技能2 烈火斩
    strcpy(hero.skill[1].skillName, "烈火斩");
    hero.skill[1].damage = 25;
    hero.skill[1].mpCost = 15;
    hero.skill[1].type = 1;
    hero.skill[1].unlockLevel = 3;
    hero.skill[1].isUnlock = false;

    // 技能3 冰霜护盾
    strcpy(hero.skill[2].skillName, "冰霜护盾");
    hero.skill[2].damage = 18;
    hero.skill[2].mpCost = 12;
    hero.skill[2].type = 2;
    hero.skill[2].unlockLevel = 5;
    hero.skill[2].isUnlock = false;

    // 技能4 剧毒突袭
    strcpy(hero.skill[3].skillName, "剧毒突袭");
    hero.skill[3].damage = 35;
    hero.skill[3].mpCost = 22;
    hero.skill[3].type = 3;
    hero.skill[3].unlockLevel = 8;
    hero.skill[3].isUnlock = false;

    // 技能5 清心治愈
    strcpy(hero.skill[4].skillName, "清心治愈");
    hero.skill[4].damage = 40;
    hero.skill[4].mpCost = 30;
    hero.skill[4].type = 4;
    hero.skill[4].unlockLevel = 10;
    hero.skill[4].isUnlock = false;

    // 技能6 万剑归宗
    strcpy(hero.skill[5].skillName, "万剑归宗");
    hero.skill[5].damage = 80;
    hero.skill[5].mpCost = 50;
    hero.skill[5].type = 1;
    hero.skill[5].unlockLevel = 15;
    hero.skill[5].isUnlock = false;
}

void InitItem()
{
    // 清空背包
    for (int i = 0; i < MAX_ITEM; i++)
    {
        hero.bag[i].count = 0;
        hero.bag[i].isEquip = false;
    }

    // 物品1 小红药
    strcpy(hero.bag[0].itemName, "低级回血丹");
    hero.bag[0].type = 1;
    hero.bag[0].value = 30;
    hero.bag[0].price = 15;
    hero.bag[0].count = 5;

    // 物品2 小蓝药
    strcpy(hero.bag[1].itemName, "低级回蓝丹");
    hero.bag[1].type = 2;
    hero.bag[1].value = 20;
    hero.bag[1].price = 12;
    hero.bag[1].count = 5;

    // 物品3 力量药剂
    strcpy(hero.bag[2].itemName, "力量增幅药剂");
    hero.bag[2].type = 3;
    hero.bag[2].value = 8;
    hero.bag[2].price = 35;
    hero.bag[2].count = 2;

    // 物品4 防御药剂
    strcpy(hero.bag[3].itemName, "铁皮防御药剂");
    hero.bag[3].type = 4;
    hero.bag[3].value = 6;
    hero.bag[3].price = 32;
    hero.bag[3].count = 2;

    // 物品5 中级血药
    strcpy(hero.bag[4].itemName, "中级回血丹");
    hero.bag[4].type = 1;
    hero.bag[4].value = 80;
    hero.bag[4].price = 45;
    hero.bag[4].count = 0;

    // 物品6 高级血药
    strcpy(hero.bag[5].itemName, "高级回血丹");
    hero.bag[5].type = 1;
    hero.bag[5].value = 150;
    hero.bag[5].price = 88;
    hero.bag[5].count = 0;

    // 物品7 玄铁矿石
    strcpy(hero.bag[6].itemName, "玄铁矿石");
    hero.bag[6].type = 5;
    hero.bag[6].value = 0;
    hero.bag[6].price = 25;
    hero.bag[6].count = 0;

    // 物品8 精钢甲
    strcpy(hero.bag[7].itemName, "精钢护甲");
    hero.bag[7].type = 6;
    hero.bag[7].value = 12;
    hero.bag[7].price = 120;
    hero.bag[7].count = 0;
    hero.bag[7].isEquip = true;
}

void InitMonster()
{
    // 1级小怪 野狼
    strcpy(monsterList[0].monName, "荒野野狼");
    monsterList[0].hp = 45;
    monsterList[0].maxHp = 45;
    monsterList[0].attack = 8;
    monsterList[0].defense = 3;
    monsterList[0].exp = 12;
    monsterList[0].gold = 8;
    monsterList[0].level = 1;
    monsterList[0].isBoss = false;
    monsterList[0].dropItem = 0;

    // 2级 毒蜘蛛
    strcpy(monsterList[1].monName, "剧毒蜘蛛");
    monsterList[1].hp = 55;
    monsterList[1].maxHp = 55;
    monsterList[1].attack = 12;
    monsterList[1].defense = 4;
    monsterList[1].exp = 18;
    monsterList[1].gold = 12;
    monsterList[1].level = 2;
    monsterList[1].isBoss = false;
    monsterList[1].dropItem = 1;

    // 3级 山贼
    strcpy(monsterList[2].monName, "拦路山贼");
    monsterList[2].hp = 70;
    monsterList[2].maxHp = 70;
    monsterList[2].attack = 15;
    monsterList[2].defense = 6;
    monsterList[2].exp = 25;
    monsterList[2].gold = 18;
    monsterList[2].level = 3;
    monsterList[2].isBoss = false;
    monsterList[2].dropItem = 2;

    // 4级 丛林猛虎
    strcpy(monsterList[3].monName, "丛林猛虎");
    monsterList[3].hp = 90;
    monsterList[3].maxHp = 90;
    monsterList[3].attack = 20;
    monsterList[3].defense = 7;
    monsterList[3].exp = 35;
    monsterList[3].gold = 25;
    monsterList[3].level = 4;
    monsterList[3].isBoss = false;
    monsterList[3].dropItem = 3;

    // 5级 沼泽巨蟒
    strcpy(monsterList[4].monName, "沼泽巨蟒");
    monsterList[4].hp = 110;
    monsterList[4].maxHp = 110;
    monsterList[4].attack = 24;
    monsterList[4].defense = 9;
    monsterList[4].exp = 45;
    monsterList[4].gold = 32;
    monsterList[4].level = 5;
    monsterList[4].isBoss = false;
    monsterList[4].dropItem = 4;

    // 6级 亡灵武士
    strcpy(monsterList[5].monName, "亡灵武士");
    monsterList[5].hp = 130;
    monsterList[5].maxHp = 130;
    monsterList[5].attack = 28;
    monsterList[5].defense = 11;
    monsterList[5].exp = 55;
    monsterList[5].gold = 40;
    monsterList[5].level = 6;
    monsterList[5].isBoss = false;
    monsterList[5].dropItem = 5;

    // 7级 熔岩蜥蜴
    strcpy(monsterList[6].monName, "熔岩蜥蜴");
    monsterList[6].hp = 155;
    monsterList[6].maxHp = 155;
    monsterList[6].attack = 33;
    monsterList[6].defense = 13;
    monsterList[6].exp = 68;
    monsterList[6].gold = 48;
    monsterList[6].level = 7;
    monsterList[6].isBoss = false;
    monsterList[6].dropItem = 6;

    // 8级 暗夜刺客
    strcpy(monsterList[7].monName, "暗夜刺客");
    monsterList[7].hp = 180;
    monsterList[7].maxHp = 180;
    monsterList[7].attack = 38;
    monsterList[7].defense = 15;
    monsterList[7].exp = 80;
    monsterList[7].gold = 58;
    monsterList[7].level = 8;
    monsterList[7].isBoss = false;
    monsterList[7].dropItem = 7;

    // 9级 寒冰雪熊
    strcpy(monsterList[8].monName, "寒冰雪熊");
    monsterList[8].hp = 220;
    monsterList[8].maxHp = 220;
    monsterList[8].attack = 42;
    monsterList[8].defense = 18;
    monsterList[8].exp = 95;
    monsterList[8].gold = 68;
    monsterList[8].level = 9;
    monsterList[8].isBoss = false;
    monsterList[8].dropItem = 0;

    // 10级 千年树妖
    strcpy(monsterList[9].monName, "千年树妖");
    monsterList[9].hp = 260;
    monsterList[9].maxHp = 260;
    monsterList[9].attack = 48;
    monsterList[9].defense = 20;
    monsterList[9].exp = 110;
    monsterList[9].gold = 80;
    monsterList[9].level = 10;
    monsterList[9].isBoss = false;
    monsterList[9].dropItem = 1;

    // Boss1 山贼头领
    strcpy(monsterList[10].monName, "山贼头领·黑风");
    monsterList[10].hp = 400;
    monsterList[10].maxHp = 400;
    monsterList[10].attack = 55;
    monsterList[10].defense = 22;
    monsterList[10].exp = 200;
    monsterList[10].gold = 150;
    monsterList[10].level = 10;
    monsterList[10].isBoss = true;
    monsterList[10].dropItem = 7;

    // Boss2 毒沼之王
    strcpy(monsterList[11].monName, "毒沼之王·腐鳞");
    monsterList[11].hp = 600;
    monsterList[11].maxHp = 600;
    monsterList[11].attack = 68;
    monsterList[11].defense = 28;
    monsterList[11].exp = 350;
    monsterList[11].gold = 260;
    monsterList[11].level = 12;
    monsterList[11].isBoss = true;
    monsterList[11].dropItem = 5;

    // Boss3 亡灵领主
    strcpy(monsterList[12].monName, "亡灵领主·噬魂");
    monsterList[12].hp = 850;
    monsterList[12].maxHp = 850;
    monsterList[12].attack = 82;
    monsterList[12].defense = 35;
    monsterList[12].exp = 520;
    monsterList[12].gold = 400;
    monsterList[12].level = 14;
    monsterList[12].isBoss = true;
    monsterList[12].dropItem = 6;

    // Boss4 熔岩巨龙
    strcpy(monsterList[13].monName, "熔岩巨龙·炎狱");
    monsterList[13].hp = 1200;
    monsterList[13].maxHp = 1200;
    monsterList[13].attack = 105;
    monsterList[13].defense = 45;
    monsterList[13].exp = 800;
    monsterList[13].gold = 666;
    monsterList[13].level = 18;
    monsterList[13].isBoss = true;
    monsterList[13].dropItem = 7;

    // 终极Boss 武林魔尊
    strcpy(monsterList[14].monName, "武林魔尊·天煞");
    monsterList[14].hp = 2000;
    monsterList[14].maxHp = 2000;
    monsterList[14].attack = 150;
    monsterList[14].defense = 60;
    monsterList[14].exp = 1500;
    monsterList[14].gold = 1200;
    monsterList[14].level = 25;
    monsterList[14].isBoss = true;
    monsterList[14].dropItem = 7;
}

void InitTask()
{
    // 任务1 猎杀野狼
    strcpy(hero.task[0].taskName, "猎杀荒野野狼");
    strcpy(hero.task[0].taskDesc, "击杀10只荒野野狼，维护村庄安全");
    hero.task[0].needKill = 10;
    hero.task[0].nowKill = 0;
    hero.task[0].targetMon = 0;
    hero.task[0].rewardExp = 100;
    hero.task[0].rewardGold = 50;
    hero.task[0].isAccept = false;
    hero.task[0].isFinish = false;

    // 任务2 清除毒蛛
    strcpy(hero.task[1].taskName, "清除剧毒蜘蛛");
    strcpy(hero.task[1].taskDesc, "森林深处毒蛛泛滥，消灭12只");
    hero.task[1].needKill = 12;
    hero.task[1].nowKill = 0;
    hero.task[1].targetMon = 1;
    hero.task[1].rewardExp = 150;
    hero.task[1].rewardGold = 80;
    hero.task[1].isAccept = false;
    hero.task[1].isFinish = false;

    // 任务3 剿灭山贼
    strcpy(hero.task[2].taskName, "剿灭拦路山贼");
    strcpy(hero.task[2].taskDesc, "剿灭沿路山贼8名，保护商旅");
    hero.task[2].needKill = 8;
    hero.task[2].nowKill = 0;
    hero.task[2].targetMon = 2;
    hero.task[2].rewardExp = 220;
    hero.task[2].rewardGold = 120;
    hero.task[2].isAccept = false;
    hero.task[2].isFinish = false;

    // 任务4 猎杀猛虎
    strcpy(hero.task[3].taskName, "猎杀丛林猛虎");
    strcpy(hero.task[3].taskDesc, "猎杀凶猛猛虎5只，获取虎皮");
    hero.task[3].needKill = 5;
    hero.task[3].nowKill = 0;
    hero.task[3].targetMon = 3;
    hero.task[3].rewardExp = 300;
    hero.task[3].rewardGold = 180;
    hero.task[3].isAccept = false;
    hero.task[3].isFinish = false;

    // 任务5 **黑风头领
    strcpy(hero.task[4].taskName, "**山贼Boss");
    strcpy(hero.task[4].taskDesc, "击败山贼头领黑风，根除山贼隐患");
    hero.task[4].needKill = 1;
    hero.task[4].nowKill = 0;
    hero.task[4].targetMon = 10;
    hero.task[4].rewardExp = 500;
    hero.task[4].rewardGold = 350;
    hero.task[4].isAccept = false;
    hero.task[4].isFinish = false;

    // 任务6 清理亡灵
    strcpy(hero.task[5].taskName, "清理亡灵武士");
    strcpy(hero.task[5].taskDesc, "古墓亡灵作乱，斩杀10名亡灵武士");
    hero.task[5].needKill = 10;
    hero.task[5].nowKill = 0;
    hero.task[5].targetMon = 5;
    hero.task[5].rewardExp = 420;
    hero.task[5].rewardGold = 260;
    hero.task[5].isAccept = false;
    hero.task[5].isFinish = false;

    // 任务7 斩杀熔岩蜥蜴
    strcpy(hero.task[6].taskName, "斩杀熔岩异兽");
    strcpy(hero.task[6].taskDesc, "火山地带蜥蜴肆虐，斩杀7只");
    hero.task[6].needKill = 7;
    hero.task[6].nowKill = 0;
    hero.task[6].targetMon = 6;
    hero.task[6].rewardExp = 480;
    hero.task[6].rewardGold = 320;
    hero.task[6].isAccept = false;
    hero.task[6].isFinish = false;

    // 任务8 **武林魔尊
    strcpy(hero.task[7].taskName, "终极宿命之战");
    strcpy(hero.task[7].taskDesc, "击败最终Boss武林魔尊，拯救江湖");
    hero.task[7].needKill = 1;
    hero.task[7].nowKill = 0;
    hero.task[7].targetMon = 14;
    hero.task[7].rewardExp = 3000;
    hero.task[7].rewardGold = 2000;
    hero.task[7].isAccept = false;
    hero.task[7].isFinish = false;
}

void InitPlayer()
{
    strcpy(hero.name, "江湖少侠");
    hero.level = 1;
    hero.hp = 100;
    hero.maxHp = 100;
    hero.mp = 50;
    hero.maxMp = 50;
    hero.attack = 15;
    hero.defense = 8;
    hero.exp = 0;
    hero.needExp = 50;
    hero.gold = 100;
    hero.positionX = 5;
    hero.positionY = 5;
    hero.buffAtk = 0;
    hero.buffDef = 0;
    hero.buffRound = 0;

    InitSkill();
    InitItem();
    InitTask();
}

void InitMap()
{
    // 全部初始化为空地
    for (int i = 0; i < MAP_SIZE; i++)
    {
        for (int j = 0; j < MAP_SIZE; j++)
        {
            worldMap.grid[i][j] = GRID_EMPTY;
            worldMap.isExplore[i][j] = false;
            worldMap.monIndex[i][j] = -1;
        }
    }

    // 固定特殊格子
    worldMap.grid[5][5] = GRID_SAVE;
    worldMap.isExplore[5][5] = true;

    worldMap.grid[2][3] = GRID_SHOP;
    worldMap.grid[7][8] = GRID_TREASURE;
    worldMap.grid[1][1] = GRID_BOSS;
    worldMap.grid[8][2] = GRID_TRAP;

    // 随机生成怪物点
    for (int i = 0; i < 15; i++)
    {
        int x = RandomInt(0, MAP_SIZE - 1);
        int y = RandomInt(0, MAP_SIZE - 1);
        if (worldMap.grid[x][y] == GRID_EMPTY)
        {
            worldMap.grid[x][y] = GRID_MONSTER;
            worldMap.monIndex[x][y] = RandomInt(0, 9);
        }
    }
}

void InitGame()
{
    srand((unsigned int)time(NULL));
    InitPlayer();
    InitMonster();
    InitMap();
    gameDay = 1;
}

void ShowStartMenu()
{
    ClearScreen();
    cout << "========================================" << endl;
    cout << "        武侠江湖冒险游戏 V1.0           " << endl;
    cout << "========================================" << endl;
    cout << "  1. 开始新游戏" << endl;
    cout << "  2. 读取存档" << endl;
    cout << "  3. 游戏说明" << endl;
    cout << "  4. 退出游戏" << endl;
    cout << "========================================" << endl;
    cout << "请输入选择：";
    int op;
    cin >> op;
    switch (op)
    {
        case 1:
            InitGame();
            ShowMainMenu();
            break;
        case 2:
            if (LoadGame() == SAVE_OK)
            {
                cout << "存档读取成功！" << endl;
                SleepTime(1000);
                ShowMainMenu();
            }
            else
            {
                cout << "暂无存档文件！" << endl;
                SleepTime(1500);
                ShowStartMenu();
            }
            break;
        case 3:
            ClearScreen();
            cout << "【游戏说明】" << endl;
            cout << "1. 方向键WASD移动探索地图" << endl;
            cout << "2. 击杀怪物获得经验、金币、材料" << endl;
            cout << "3. 升级解锁更强技能，提升属**" << endl;
            cout << "4. 商店购买药品道具，提升生存能力" << endl;
            cout << "5. 接取任务完成可获得大量奖励" << endl;
            cout << "6. 地图存档点可手动保存游戏进度" << endl;
            cout << "7. **Boss获取极品装备与大量资源" << endl;
            cout << "----------------------------------------" << endl;
            cout << "按回车键返回主菜单...";
            getchar();
            getchar();
            ShowStartMenu();
            break;
        case 4:
            gameRun = false;
            cout << "感谢游玩，江湖再会！" << endl;
            break;
        default:
            cout << "输入错误，请重新选择！" << endl;
            SleepTime(1000);
            ShowStartMenu();
            break;
    }
}

void ShowMainMenu()
{
    while (gameRun)
    {
        ClearScreen();
        cout << "========== 武侠江湖 | 第" << gameDay << "天 ==========" << endl;
        cout << "1.角色信息  2.背包物品  3.技能列表  4.任务面板" << endl;
        cout << "5.地图探索  6.商店交易  7.原地休息  8.手动存档" << endl;
        cout << "9.返回标题栏" << endl;
        cout << "========================================" << endl;
        cout << "请输入操作序号：";
        int op;
        cin >> op;
        switch (op)
        {
            case 1:
                ShowPlayerInfo();
                break;
            case 2:
                ShowBag();
                break;
            case 3:
                ShowSkillList();
                break;
            case 4:
                ShowTaskList();
                break;
            case 5:
                ShowMap();
                break;
            case 6:
                ShowShop();
                break;
            case 7:
                RecoverHPMP();
                gameDay++;
                cout << "你原地打坐休息，体力内力完全恢复！" << endl;
                cout << "天数流逝，当前：第" << gameDay << "天" << endl;
                cout << "按回车继续...";
                getchar();getchar();
                break;
            case 8:
                if (SaveGame() == SAVE_OK)
                {
                    cout << "游戏存档成功！" << endl;
                }
                else
                {
                    cout << "存档失败！" << endl;
                }
                SleepTime(1200);
                break;
            case 9:
                ShowStartMenu();
                return;
            default:
                cout << "输入无效，请重新选择！" << endl;
                SleepTime(800);
                break;
        }
    }
}

void ShowPlayerInfo()
{
    ClearScreen();
    cout << "========== 角色属**面板 ==========" << endl;
    cout << "角色名称：" << hero.name << endl;
    cout << "当前等级：Lv." << hero.level << endl;
    cout << "经验值：" << hero.exp << " / " << hero.needExp << endl;
    cout << "生命值：" << hero.hp << " / " << hero.maxHp << endl;
    cout << "内力值：" << hero.mp << " / " << hero.maxMp << endl;
    cout << "攻击力：" << hero.attack + hero.buffAtk << endl;
    cout << "防御力：" << hero.defense + hero.buffDef << endl;
    cout << "持有金币：" << hero.gold << " 枚" << endl;
    cout << "增益回合：" << hero.buffRound << " 回合" << endl;
    cout << "==================================" << endl;
    cout << "按回车键返回...";
    getchar();getchar();
}

void ShowSkillList()
{
    ClearScreen();
    cout << "========== 武学技能列表 ==========" << endl;
    for (int i = 0; i < MAX_SKILL; i++)
    {
        cout << i + 1 << "." << hero.skill[i].skillName;
        if (hero.skill[i].isUnlock)
        {
            cout << "【已解锁】";
        }
        else
        {
            cout << "【未解锁-等级" << hero.skill[i].unlockLevel << "解锁】";
        }
        cout << endl;
        cout << "   伤害：" << hero.skill[i].damage
             << "  耗蓝：" << hero.skill[i].mpCost << endl;
    }
    cout << "==================================" << endl;
    cout << "按回车键返回...";
    getchar();getchar();
}

void ShowBag()
{
    ClearScreen();
    cout << "========== 背包物品栏 ==========" << endl;
    int num = 0;
    for (int i = 0; i < MAX_ITEM; i++)
    {
        if (hero.bag[i].count > 0)
        {
            num++;
            cout << num << "." << hero.bag[i].itemName
                 << "  x" << hero.bag[i].count << endl;
        }
    }
    if (num == 0)
    {
        cout << "背包空空如也，快去探索收集物资吧！" << endl;
    }
    cout << "------------------------------" << endl;
    cout << "1.使用物品  2.返回上一级" << endl;
    cout << "请选择：";
    int op;
    cin >> op;
    if (op == 1)
    {
        PlayerUseItem();
    }
}

void ShowTaskList()
{
    ClearScreen();
    cout << "========== 江湖任务列表 ==========" << endl;
    for (int i = 0; i < MAX_TASK; i++)
    {
        cout << i + 1 << "." << hero.task[i].taskName;
        if (hero.task[i].isFinish)
        {
            cout << "【已完成】";
        }
        else if (hero.task[i].isAccept)
        {
            cout << "【进行中】" << hero.task[i].nowKill
                 << "/" << hero.task[i].needKill;
        }
        else
        {
            cout << "【可接取】";
        }
        cout << endl;
    }
    cout << "--------------------------------" << endl;
    cout << "请输入任务序号操作(0返回)：";
    int tid;
    cin >> tid;
    if (tid >= 1 && tid <= MAX_TASK)
    {
        tid--;
        if (!hero.task[tid].isAccept && !hero.task[tid].isFinish)
        {
            AcceptTask(tid);
        }
        else if (hero.task[tid].isAccept && hero.task[tid].nowKill >= hero.task[tid].needKill)
        {
            SubmitTask(tid);
        }
        else
        {
            cout << "当前无法操作该任务！" << endl;
            SleepTime(1000);
        }
    }
}

void AcceptTask(int tid)
{
    hero.task[tid].isAccept = true;
    cout << "成功接取任务：" << hero.task[tid].taskName << endl;
    cout << "任务描述：" << hero.task[tid].taskDesc << endl;
    SleepTime(1500);
}

void SubmitTask(int tid)
{
    hero.exp += hero.task[tid].rewardExp;
    hero.gold += hero.task[tid].rewardGold;
    hero.task[tid].isFinish = true;
    hero.task[tid].isAccept = false;
    cout << "任务完成！奖励**成功！" << endl;
    cout << "获得经验：" << hero.task[tid].rewardExp << endl;
    cout << "获得金币：" << hero.task[tid].rewardGold << endl;
    LevelUp();
    SleepTime(1500);
}

void UpdateTaskKill(int monID)
{
    for (int i = 0; i < MAX_TASK; i++)
    {
        if (hero.task[i].isAccept && hero.task[i].targetMon == monID && !hero.task[i].isFinish)
        {
            hero.task[i].nowKill++;
        }
    }
}

void ShowShop()
{
    ClearScreen();
    cout << "========== 江湖杂货铺 ==========" << endl;
    cout << "当前金币：" << hero.gold << endl;
    cout << "1.低级回血丹  15金币" << endl;
    cout << "2.低级回蓝丹  12金币" << endl;
    cout << "3.力量增幅药剂 35金币" << endl;
    cout << "4.铁皮防御药剂 32金币" << endl;
    cout << "5.中级回血丹  45金币" << endl;
    cout << "6.高级回血丹  88金币" << endl;
    cout << "7.精钢护甲    120金币" << endl;
    cout << "0.离开商店" << endl;
    cout << "--------------------------------" << endl;
    cout << "请输入购买编号：";
    int id;
    cin >> id;
    if (id >= 1 && id <= 7)
    {
        BuyItem(id - 1);
    }
}

void BuyItem(int id)
{
    if (hero.gold >= hero.bag[id].price)
    {
        hero.gold -= hero.bag[id].price;
        hero.bag[id].count++;
        cout << "购买成功！获得：" << hero.bag[id].itemName << endl;
    }
    else
    {
        cout << "金币不足，无法购买！" << endl;
    }
    SleepTime(1000);
}

void PlayerUseItem()
{
    ClearScreen();
    cout << "选择要使用的物品序号(0返回)：";
    int id;
    cin >> id;
    if (id > 0 && id <= MAX_ITEM)
    {
        UseItem(id - 1);
    }
}

void UseItem(int id)
{
    if (hero.bag[id].count <= 0)
    {
        cout << "该物品数量不足！" << endl;
        SleepTime(800);
        return;
    }
    switch (hero.bag[id].type)
    {
        case 1:
            hero.hp += hero.bag[id].value;
            if (hero.hp > hero.maxHp) hero.hp = hero.maxHp;
            cout << "使用" << hero.bag[id].itemName
                 << "，恢复生命" << hero.bag[id].value << "点！" << endl;
            break;
        case 2:
            hero.mp += hero.bag[id].value;
            if (hero.mp > hero.maxMp) hero.mp = hero.maxMp;
            cout << "使用" << hero.bag[id].itemName
                 << "，恢复内力" << hero.bag[id].value << "点！" << endl;
            break;
        case 3:
            AddBuff(hero.bag[id].value, 0, 5);
            cout << "力量提升！5回合内攻击+" << hero.bag[id].value << endl;
            break;
        case 4:
            AddBuff(0, hero.bag[id].value, 5);
            cout << "防御提升！5回合内防御+" << hero.bag[id].value << endl;
            break;
        default:
            cout << "该物品无法直接使用！" << endl;
            return;
    }
    hero.bag[id].count--;
    SleepTime(1200);
}

void AddBuff(int atk, int def, int round)
{
    hero.buffAtk += atk;
    hero.buffDef += def;
    hero.buffRound = round;
}

void ClearBuff()
{
    if (hero.buffRound > 0)
    {
        hero.buffRound--;
        if (hero.buffRound <= 0)
        {
            hero.buffAtk = 0;
            hero.buffDef = 0;
        }
    }
}

void ShowMap()
{
    ClearScreen();
    cout << "===== 江湖大地图 | W上 S下 A左 D右 =====" << endl;
    for (int i = 0; i < MAP_SIZE; i++)
    {
        for (int j = 0; j < MAP_SIZE; j++)
        {
            if (i == hero.positionX && j == hero.positionY)
            {
                cout << "【人】";
                worldMap.isExplore[i][j] = true;
            }
            else if (!worldMap.isExplore[i][j])
            {
                cout << "【？】";
            }
            else
            {
                switch (worldMap.grid[i][j])
                {
                    case GRID_EMPTY: cout << "【·】"; break;
                    case GRID_MONSTER: cout << "【怪】"; break;
                    case GRID_TREASURE: cout << "【宝】"; break;
                    case GRID_SHOP: cout << "【店】"; break;
                    case GRID_SAVE: cout << "【存】"; break;
                    case GRID_BOSS: cout << "【王】"; break;
                    case GRID_TRAP: cout << "【陷】"; break;
                }
            }
        }
        cout << endl;
    }
    cout << "========================================" << endl;
    cout << "请输入移动方向(W/A/S/D)，Q退出探索：";
    char dir;
    cin >> dir;
    MovePlayer(dir);
}

void MovePlayer(int dir)
{
    int x = hero.positionX;
    int y = hero.positionY;
    switch (dir)
    {
        case 'W':case 'w': x--; break;
        case 'S':case 's': x++; break;
        case 'A':case 'a': y--; break;
        case 'D':case 'd': y++; break;
        case 'Q':case 'q': return;
        default:
            cout << "输入错误！" << endl;
            SleepTime(800);
            return;
    }
    // 边界判断
    if (x < 0 || x >= MAP_SIZE || y < 0 || y >= MAP_SIZE)
    {
        cout << "前方已是地图边界，无法通行！" << endl;
        SleepTime(800);
        return;
    }
    hero.positionX = x;
    hero.positionY = y;
    worldMap.isExplore[x][y] = true;
    // 判断格子事件
    switch (worldMap.grid[x][y])
    {
        case GRID_MONSTER:
            Battle(worldMap.monIndex[x][y]);
            break;
        case GRID_TREASURE:
            OpenTreasure();
            break;
        case GRID_SHOP:
            ShowShop();
            break;
        case GRID_SAVE:
            cout << "你到达存档点，是否存档？(1是 0否)：";
            int s;
            cin >> s;
            if (s == 1) SaveGame();
            break;
        case GRID_BOSS:
            BossBattle();
            break;
        case GRID_TRAP:
            StepTrap();
            break;
        default:
            RandomEvent();
            break;
    }
}

void OpenTreasure()
{
    ClearScreen();
    cout << "你发现一处隐藏宝箱！" << endl;
    int goldGet = RandomInt(30, 120);
    int itemRan = RandomInt(0, 7);
    hero.gold += goldGet;
    hero.bag[itemRan].count++;
    cout << "获得金币x" << goldGet << endl;
    cout << "获得道具：" << hero.bag[itemRan].itemName << endl;
    worldMap.grid[hero.positionX][hero.positionY] = GRID_EMPTY;
    SleepTime(1500);
}

void StepTrap()
{
    int hurt = RandomInt(15, 40);
    hero.hp -= hurt;
    cout << "你踏入陷阱！受到" << hurt << "点伤害！" << endl;
    worldMap.grid[hero.positionX][hero.positionY] = GRID_EMPTY;
    SleepTime(1200);
    if (hero.hp <= 0)
    {
        cout << "你被陷阱重伤倒地，返回安全区域..." << endl;
        hero.hp = hero.maxHp / 2;
        hero.positionX = 5;
        hero.positionY = 5;
        SleepTime(1500);
    }
}

void RandomEvent()
{
    int r = RandomInt(1, 100);
    if (r <= 15)
    {
        int addHp = RandomInt(10, 30);
        hero.hp += addHp;
        if (hero.hp > hero.maxHp) hero.hp = hero.maxHp;
        cout << "偶遇灵泉，恢复生命" << addHp << "点！" << endl;
        SleepTime(800);
    }
    else if (r <= 25)
    {
        int addGold = RandomInt(10, 25);
        hero.gold += addGold;
        cout << "捡到散落银两，获得" << addGold << "金币！" << endl;
        SleepTime(800);
    }
}

void CalculateDamage(int atk, int def, int& hurt)
{
    hurt = atk - def;
    if (hurt < 1) hurt = 1;
    // 暴击判定 10%暴击
    if (RandomBool(10))
    {
        hurt *= 2;
        cout << "暴击！";
    }
}

void Battle(int monID)
{
    ClearScreen();
    Monster& m = monsterList[monID];
    cout << "========== 战斗开始 ==========" << endl;
    cout << "敌方：" << m.monName << " Lv." << m.level << endl;
    while (m.hp > 0 && hero.hp > 0)
    {
        ClearScreen();
        cout << "【" << m.monName << "】 HP：" << m.hp << "/" << m.maxHp << endl;
        cout << "【玩家】 HP：" << hero.hp << "/" << hero.maxHp
             << " MP：" << hero.mp << "/" << hero.maxMp << endl;
        cout << "-----------------------------" << endl;
        cout << "1.普通攻击  2.释放技能  3.使用道具  4.撤退" << endl;
        cout << "请选择战斗操作：";
        int op;
        cin >> op;
        switch (op)
        {
            case 1:
                PlayerAttack(monID);
                break;
            case 2:
                PlayerUseSkill(monID);
                break;
            case 3:
                PlayerUseItem();
                break;
            case 4:
                cout << "你选择撤退，逃离战斗！" << endl;
                SleepTime(1000);
                return;
            default:
                cout << "操作无效！" << endl;
                SleepTime(500);
                break;
        }
        if (m.hp <= 0) break;
        MonsterAttack(monID);
        ClearBuff();
    }
    // 战斗结算
    if (hero.hp <= 0)
    {
        cout << "你被" << m.monName << "击败了..." << endl;
        cout << "自动返回存档点复活，损失少量金币" << endl;
        hero.hp = hero.maxHp / 2;
        hero.mp = hero.maxMp / 2;
        hero.gold = hero.gold * 0.8;
        hero.positionX = 5;
        hero.positionY = 5;
    }
    else
    {
        cout << "战斗胜利！成功击杀" << m.monName << endl;
        cout << "获得经验：" << m.exp << "  获得金币：" << m.gold << endl;
        hero.exp += m.exp;
        hero.gold += m.gold;
        UpdateTaskKill(monID);
        // 掉落物品
        if (RandomBool(40))
        {
            hero.bag[m.dropItem].count++;
            cout << "掉落物品：" << hero.bag[m.dropItem].itemName << endl;
        }
        LevelUp();
    }
    // 怪物血量重置
    m.hp = m.maxHp;
    SleepTime(2000);
}

void PlayerAttack(int monID)
{
    int hurt;
    int atk = hero.attack + hero.buffAtk;
    int def = monsterList[monID].defense;
    CalculateDamage(atk, def, hurt);
    monsterList[monID].hp -= hurt;
    cout << "你发动普通攻击，造成" << hurt << "点伤害！" << endl;
    SleepTime(800);
}

void PlayerUseSkill(int monID)
{
    ClearScreen();
    cout << "===== 选择技能 =====" << endl;
    for (int i = 0; i < MAX_SKILL; i++)
    {
        if (hero.skill[i].isUnlock)
        {
            cout << i + 1 << "." << hero.skill[i].skillName
                 << " 耗蓝：" << hero.skill[i].mpCost << endl;
        }
    }
    cout << "请输入技能编号：";
    int sid;
    cin >> sid;
    sid--;
    if (sid < 0 || sid >= MAX_SKILL || !hero.skill[sid].isUnlock)
    {
        cout << "技能未解锁或输入无效！" << endl;
        SleepTime(1000);
        return;
    }
    if (hero.mp < hero.skill[sid].mpCost)
    {
        cout << "内力不足，无法释放该技能！" << endl;
        SleepTime(1000);
        return;
    }
    // 治疗技能特殊处理
    if (hero.skill[sid].type == 4)
    {
        hero.hp += hero.skill[sid].damage;
        if (hero.hp > hero.maxHp) hero.hp = hero.maxHp;
        cout << "你使用" << hero.skill[sid].skillName << "，恢复生命" << hero.skill[sid].damage << "点！" << endl;
    }
    else
    {
        int hurt;
        int atk = hero.attack + hero.buffAtk + hero.skill[sid].damage;
        int def = monsterList[monID].defense;
        CalculateDamage(atk, def, hurt);
        monsterList[monID].hp -= hurt;
        cout << "你释放" << hero.skill[sid].skillName << "，造成" << hurt << "点伤害！" << endl;
    }
    hero.mp -= hero.skill[sid].mpCost;
    SleepTime(1200);
}

void MonsterAttack(int monID)
{
    Monster& m = monsterList[monID];
    int hurt;
    int atk = m.attack;
    int def = hero.defense + hero.buffDef;
    CalculateDamage(atk, def, hurt);
    hero.hp -= hurt;
    cout << m.monName << "发动攻击，造成" << hurt << "点伤害！" << endl;
    SleepTime(1000);
}

void BossBattle()
{
    ClearScreen();
    cout << "警告！前方出现终极BOSS，是否**？(1是 0否)：";
    int op;
    cin >> op;
    if (op == 1)
    {
        Battle(14); // **最终BOSS武林魔尊
    }
}

void LevelUp()
{
    while (hero.exp >= hero.needExp)
    {
        hero.exp -= hero.needExp;
        hero.level++;
        // 升级属**提升
        hero.maxHp += 25;
        hero.maxMp += 15;
        hero.attack += 8;
        hero.defense += 5;
        // 满血满蓝
        hero.hp = hero.maxHp;
        hero.mp = hero.maxMp;
        // 升级所需经验提升
        hero.needExp = hero.needExp * 1.5;
        cout << "恭喜你升级！当前等级：Lv." << hero.level << endl;
        // 解锁技能
        for (int i = 0; i < MAX_SKILL; i++)
        {
            if (hero.level >= hero.skill[i].unlockLevel && !hero.skill[i].isUnlock)
            {
                hero.skill[i].isUnlock = true;
                cout << "解锁新技能：" << hero.skill[i].skillName << endl;
            }
        }
        SleepTime(1500);
    }
}

void RecoverHPMP()
{
    hero.hp = hero.maxHp;
    hero.mp = hero.maxMp;
    hero.buffAtk = 0;
    hero.buffDef = 0;
    hero.buffRound = 0;
}

// 存档函数（简化实现）
int SaveGame()
{
    ofstream out("save.dat", ios::binary);
    if (!out) return SAVE_FAIL;
    out.write((char*)&hero, sizeof(Player));
    out.close();
    return SAVE_OK;
}

// 读档函数（简化实现）
int LoadGame()
{
    ifstream in("save.dat", ios::binary);
    if (!in) return SAVE_FAIL;
    in.read((char*)&hero, sizeof(Player));
    in.close();
    return SAVE_OK;
}

// 主函数
int main()
{
    ShowStartMenu();
    return 0;
}