C++RPG游戏《传说》2.5.3.5正式上线

具体更新内容已经发布，话不多说直接上代码（下载链接没有必要了，没人下载，不过可以找作者要）

代码如下：

#include <iostream>
#include <windows.h>
#include <conio.h>
#include <vector>
#include <string>
#include <ctime>
#include <fstream>
#include <algorithm>
#include <sstream>

// 设置控制台颜色和背景
void setConsoleColorAndBackground(int color, int background) {
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hConsole, background | color);
}

// 开始界面
void startMenu() {
    setConsoleColorAndBackground(6, 0); // 金黄色文字，黑色背景
    std::string floatingIsland[] = {
        "          __..--''``---....___   _.._",
        "     __..-'  `-.     ``---...__.-'   `-_",
        "   .'           `.           :        `-.",
        "  :               ``.__.     :          `.",
        "  :           _..---...  `-.;           :",
        "  :       _..-''        `-.:           :",
        "   `._..-'                `:           :",
        "     `-.__.-'``---...__..-'           :",
        "        ``---..__..-'                  :",
        "            ``---..__.-'``---...___..-'"
    };

    for (const auto& line : floatingIsland) {
        std::cout << line << std::endl;
    }

    std::cout << "\t\t传说2.5.3.5" << std::endl; // 修改版本号
    std::cout << "主要制作人：山岚   制作团队：喵星人工作室" << std::endl;
    std::cout << "\t\t按回车进入游戏" << std::endl;
    while (_getch() != 13); // 等待回车键
}

// 加载界面
void loadingScreen() {
    setConsoleColorAndBackground(6, 0); // 金黄色文字，黑色背景
    for (int i = 0; i <= 100; ++i) {
        system("cls");
        std::cout << i << "/100" << std::endl;
        Sleep(50); // 5 秒内从 0 到 100
    }
    system("cls");
}

// 敌人类
class Enemy {
public:
    std::string name;
    int hp;
    int attack;
    bool doubleAttack = false; // 是否能造成两次伤害

    Enemy(const std::string& n, int h, int a, bool d = false) : name(n), hp(h), attack(a), doubleAttack(d) {}
};

// 生成随机敌人
Enemy generateRandomEnemy(const std::string& currentMap) {
    std::vector<Enemy> enemies;
    if (currentMap == "虚空领域") {
        enemies = {
            Enemy("虚空令使", 40000, 2500),
            Enemy("虚空凋零", 2800000, 8000),
            Enemy("虚空", 3450000, 50000),
            Enemy("神之使徒", 500000, 24000)
        };
    }
    else if (currentMap == "传说之海") {
        enemies = {
            Enemy("神之海王", 50000000, 50000),
            Enemy("海洋领主", 29800000, 32000),
            Enemy("海怪", 15000000, 28000),
            Enemy("变异海盗王", 10000000, 28000),
            Enemy("海盗王", 5800000, 20000)
        };
    }
    else if (currentMap == "浮空岛屿") {
        enemies = {
            Enemy("原始之神", 1500000000, 100000),
            Enemy("传说之神", 1250000000, 120000),
            Enemy("地狱之神", 1500000000, 120000),
            Enemy("虚空之神", 1800000000, 200000, true),
            Enemy("虚无之神", 1600000000, 180000)
        };
    }
    else {
        enemies = {
            Enemy("神之令使", 15000, 2300),
            Enemy("毁灭者", 15000, 12000),
            Enemy("神之雕塑", 32000, 4500),
            Enemy("地狱使徒", 18000, 2300),
            Enemy("地狱魔神", 45000, 9800),
            Enemy("神之地狱亚魔", 230000, 17200)
        };
    }
    int index = rand() % enemies.size();
    return enemies[index];
}

// 玩家类
class Player {
public:
    int level = 1;
    int hp = 20000; // 当前生命值
    int maxHp = 20000; // 生命值上限
    int attack = 2100; // 当前攻击力
    std::string armor; // 当前护甲
    std::string weapon; // 当前武器
    std::vector<std::string> backpack; // 背包
    int healthPotions = 0; // 回血药数量
    int bigHealthPotions = 0; // 大补药数量
    int legendCoins = 0; // 传说币数量
    std::string currentMap = "使命之地"; // 当前地图
    int normalAttackLevel = 1; // 普通攻击等级
    int heavyAttackLevel = 1; // 重击攻击等级
    int ultimateSkillLevel = 1; // 终极技能等级
    int normalAttackCost = 500; // 普通攻击升级费用
    int heavyAttackCost = 500; // 重击攻击升级费用
    int ultimateSkillCost = 500; // 终极技能升级费用
    int defeatedEnemies = 0; // 击败敌人数量
    int maxLevel = 200; // 当前等级上限，默认为200
    bool achievements[3] = { false, false, false }; // 成就：传说之人、比肩神明、超越神明

    // 装备护甲
    void equipArmor(const std::string& armorName) {
        if (!armor.empty()) {
            // 脱掉旧护甲并放回背包
            backpack.push_back(armor);
        }
        armor = armorName;
        std::cout << "你装备了 " << armor << std::endl;
    }

    // 装备武器
    void equipWeapon(const std::string& weaponName) {
        if (!weapon.empty()) {
            // 脱掉旧武器并放回背包
            backpack.push_back(weapon);
        }
        weapon = weaponName;
        std::cout << "你装备了 " << weapon << std::endl;
    }

    // 自动存档
    void autoSave() {
        std::ofstream saveFile("savegame.txt");
        if (saveFile.is_open()) {
            saveFile << level << " " << hp << " " << maxHp << " " << attack << " "
                << armor << " " << weapon << " "
                << legendCoins << " " << healthPotions << " "
                << bigHealthPotions << " " << currentMap << " "
                << normalAttackLevel << " " << heavyAttackLevel << " "
                << ultimateSkillLevel << " " << defeatedEnemies << " " << maxLevel << " ";
            for (int i = 0; i < 3; ++i) {
                saveFile << achievements[i] << " ";
            }
            saveFile << std::endl;
            for (const auto& item : backpack) {
                saveFile << item << std::endl;
            }
            saveFile.close();
        }
    }

    // 删除存档
    void deleteSave() {
        std::remove("savegame.txt");
        std::cout << "已删除存档" << std::endl;
        Sleep(3000);
        exit(0);
    }

    // 使用回血药
    void useHealthPotion() {
        if (healthPotions > 0) {
            hp += 2000;
            if (hp > maxHp) {
                hp = maxHp;
            }
            healthPotions--;
            std::cout << "你使用了一个回血药，恢复了 2000 生命值。当前生命值: " << hp << "/" << maxHp << std::endl;
        }
        else {
            std::cout << "你没有回血药。" << std::endl;
        }
    }

    // 使用大补药
    void useBigHealthPotion() {
        if (bigHealthPotions > 0) {
            hp = maxHp;
            bigHealthPotions--;
            std::cout << "你使用了一个大补药，恢复了全部生命值。当前生命值: " << hp << "/" << maxHp << std::endl;
        }
        else {
            std::cout << "你没有大补药。" << std::endl;
        }
    }

    // 商店
    void tradeEquipment() {
        std::cout << "1. 贩卖装备 2. 购买装备 3. 购买道具 4. 清空背包" << std::endl;
        int choice;
        std::cin >> choice;

        if (choice == 1) {
            std::cout << "你的背包:" << std::endl;
            for (size_t i = 0; i < backpack.size(); ++i) {
                std::cout << i + 1 << ". " << backpack[i] << std::endl;
            }
            std::cout << "输入要贩卖的装备编号 (0退出): ";
            int sellChoice;
            std::cin >> sellChoice;
            if (sellChoice > 0 && sellChoice <= static_cast<int>(backpack.size())) {
                std::string item = backpack[sellChoice - 1];
                int price = 0;
                if (item == "灭世战甲" || item == "灭世神剑") {
                    price = 15000;
                }
                else if (item == "虚空魔神铠" || item == "虚空魔神剑") {
                    price = 20000;
                }
                else if (item == "神圣之护铠" || item == "神圣之神剑") {
                    price = 50000;
                }
                else if (item == "原始之铠" || item == "原始之剑" || item == "传说之铠" || item == "传说之剑" ||
                    item == "地狱之铠" || item == "地狱之剑" || item == "虚空之铠" || item == "虚空之剑" ||
                    item == "虚无之铠" || item == "虚无之剑") {
                    price = 100000;
                }
                else {
                    price = 500;
                }
                legendCoins += price;
                backpack.erase(backpack.begin() + sellChoice - 1);
                std::cout << "你卖出了 " << item << "，获得了 " << price << " 传说币。当前传说币: " << legendCoins << std::endl;
            }
        }
        else if (choice == 2) {
            std::vector<std::string> availableItems = { "创世铠甲", "战神圣衣", "青铜法袍", "朱红护甲", "创世神剑", "天顶法杖", "青铜法器", "赤红魔剑" };
            std::cout << "可购买的装备:" << std::endl;
            for (size_t i = 0; i < availableItems.size(); ++i) {
                std::cout << i + 1 << ". " << availableItems[i] << " (1500 传说币)" << std::endl;
            }
            std::cout << "输入要购买的装备编号 (0退出): ";
            int buyChoice;
            std::cin >> buyChoice;
            if (buyChoice > 0 && buyChoice <= static_cast<int>(availableItems.size())) {
                std::string item = availableItems[buyChoice - 1];
                if (legendCoins >= 1500) {
                    legendCoins -= 1500;
                    backpack.push_back(item);
                    std::cout << "你购买了 " << item << "，花费了 1500 传说币。当前传说币: " << legendCoins << std::endl;
                }
                else {
                    std::cout << "传说币不足，无法购买。" << std::endl;
                }
            }
        }
        else if (choice == 3) {
            std::cout << "可购买的道具:" << std::endl;
            std::cout << "1. 回血药 (5传说币)" << std::endl;
            std::cout << "2. 大补药 (10传说币)" << std::endl;
            std::cout << "输入要购买的道具编号 (0退出): ";
            int buyChoice;
            std::cin >> buyChoice;
            if (buyChoice == 1) {
                if (legendCoins >= 5) {
                    legendCoins -= 5;
                    healthPotions += 1;
                    std::cout << "你购买了 1 个回血药，花费了 5 传说币。当前回血药数量: " << healthPotions << std::endl;
                }
                else {
                    std::cout << "传说币不足，无法购买。" << std::endl;
                }
            }
            else if (buyChoice == 2) {
                if (legendCoins >= 10) {
                    legendCoins -= 10;
                    bigHealthPotions += 1;
                    std::cout << "你购买了 1 个大补药，花费了 10 传说币。当前大补药数量: " << bigHealthPotions << std::endl;
                }
                else {
                    std::cout << "传说币不足，无法购买。" << std::endl;
                }
            }
        }
        else if (choice == 4) {
            if (backpack.empty()) {
                std::cout << "背包已为空，无需清空。" << std::endl;
                return;
            }

            int totalCoins = 0;
            for (const auto& item : backpack) {
                int price = 0;
                if (item == "灭世战甲" || item == "灭世神剑") {
                    price = 15000;
                }
                else if (item == "虚空魔神铠" || item == "虚空魔神剑") {
                    price = 20000;
                }
                else if (item == "神圣之护铠" || item == "神圣之神剑") {
                    price = 50000;
                }
                else if (item == "原始之铠" || item == "原始之剑" || item == "传说之铠" || item == "传说之剑" ||
                    item == "地狱之铠" || item == "地狱之剑" || item == "虚空之铠" || item == "虚空之剑" ||
                    item == "虚无之铠" || item == "虚无之剑") {
                    price = 100000;
                }
                else {
                    price = 500;
                }
                totalCoins += price;
            }

            std::cout << "你清空了背包，获得了 " << totalCoins << " 传说币。" << std::endl;
            legendCoins += totalCoins;
            backpack.clear();
        }
    }

    // 升级技能
    void upgradeSkill() {
        setConsoleColorAndBackground(6, 0); // 金黄色文字，黑色背景
        std::cout << "升级技能:" << std::endl;
        std::cout << "1. 普通攻击 (" << normalAttackLevel << "/10) 升级费用: " << normalAttackCost << " 传说币" << std::endl;
        std::cout << "2. 重击攻击 (" << heavyAttackLevel << "/10) 升级费用: " << heavyAttackCost << " 传说币" << std::endl;
        std::cout << "3. 终极技能 (" << ultimateSkillLevel << "/10) 升级费用: " << ultimateSkillCost << " 传说币" << std::endl;
        std::cout << "4. 返回" << std::endl;
        std::cout << "选择要升级的技能 (输入编号): ";
        int choice;
        std::cin >> choice;

        switch (choice) {
        case 1:
            if (legendCoins >= normalAttackCost && normalAttackLevel < 10) {
                legendCoins -= normalAttackCost;
                normalAttackLevel++;
                normalAttackCost += 50;
                std::cout << "普通攻击升级成功！当前等级: " << normalAttackLevel << std::endl;
            }
            else {
                std::cout << "传说币不足或已达到最大等级！" << std::endl;
            }
            break;
        case 2:
            if (legendCoins >= heavyAttackCost && heavyAttackLevel < 10) {
                legendCoins -= heavyAttackCost;
                heavyAttackLevel++;
                heavyAttackCost += 50;
                std::cout << "重击攻击升级成功！当前等级: " << heavyAttackLevel << std::endl;
            }
            else {
                std::cout << "传说币不足或已达到最大等级！" << std::endl;
            }
            break;
        case 3:
            if (legendCoins >= ultimateSkillCost && ultimateSkillLevel < 10) {
                legendCoins -= ultimateSkillCost;
                ultimateSkillLevel++;
                ultimateSkillCost += 50;
                std::cout << "终极技能升级成功！当前等级: " << ultimateSkillLevel << std::endl;
            }
            else {
                std::cout << "传说币不足或已达到最大等级！" << std::endl;
            }
            break;
        case 4:
            std::cout << "返回游戏主界面。" << std::endl;
            break;
        default:
            std::cout << "无效的选择，请重新输入。" << std::endl;
        }
        Sleep(1500); // 等待 1.5 秒
        system("cls"); // 刷新窗口
    }

    // 等级提升
    void levelUp() {
        defeatedEnemies++;
        if (defeatedEnemies % 2 == 0 && level < maxLevel) {
            level++;
            std::cout << "你击败了 2 个怪物，提升到了 " << level << " 级！" << std::endl;
        }
        if (level >= 500 && !achievements[2]) {
            achievements[2] = true; // 解锁“超越神明”成就
            std::cout << "成就解锁：超越神明！" << std::endl;
        }
    }
};

// 击败敌人后获得装备和传说币
void getEquipmentAndCoins(Player& player, const std::string& enemyName) {
    int num = 1; // 浮空岛屿的怪物掉落固定为1个装备
    int potions = 10; // 回血药数量
    player.healthPotions += potions;
    player.legendCoins += 10; // 每击败一个怪物获得10个传说币
    std::cout << "你获得了 " << potions << " 个回血药，当前回血药数量: " << player.healthPotions << std::endl;
    std::cout << "你获得了 10 传说币，当前传说币: " << player.legendCoins << std::endl;

    // 浮空岛屿特殊掉落逻辑
    if (player.currentMap == "浮空岛屿") {
        if (!player.achievements[1]) { // 如果未解锁“比肩神明”成就
            player.achievements[1] = true; // 解锁“比肩神明”成就
            std::cout << "成就解锁：比肩神明！" << std::endl;
        }
        if (enemyName == "原始之神") {
            player.backpack.push_back("原始之铠");
            player.backpack.push_back("原始之剑");
            std::cout << "你获得了原始之铠和原始之剑！" << std::endl;
        }
        else if (enemyName == "传说之神") {
            player.backpack.push_back("传说之铠");
            player.backpack.push_back("传说之剑");
            std::cout << "你获得了传说之铠和传说之剑！" << std::endl;
        }
        else if (enemyName == "地狱之神") {
            player.backpack.push_back("地狱之铠");
            player.backpack.push_back("地狱之剑");
            std::cout << "你获得了地狱之铠和地狱之剑！" << std::endl;
        }
        else if (enemyName == "虚空之神") {
            player.backpack.push_back("虚空之铠");
            player.backpack.push_back("虚空之剑");
            std::cout << "你获得了虚空之铠和虚空之剑！" << std::endl;
        }
        else if (enemyName == "虚无之神") {
            player.backpack.push_back("虚无之铠");
            player.backpack.push_back("虚无之剑");
            std::cout << "你获得了虚无之铠和虚无之剑！" << std::endl;
        }
    }
    else {
        // 其他地图的掉落逻辑保持不变
        for (int i = 0; i < num; ++i) {
            int randNum = rand() % 10000; // 使用10000作为基数，方便调整爆率
            if (randNum < 100) { // 1% 爆率
                player.backpack.push_back("创世铠甲");
                std::cout << "你获得了创世铠甲！" << std::endl;
            }
            else if (randNum < 200) { // 1% 爆率
                player.backpack.push_back("战神圣衣");
                std::cout << "你获得了战神圣衣！" << std::endl;
            }
            else if (randNum < 700) { // 5% 爆率
                player.backpack.push_back("青铜法袍");
                std::cout << "你获得了青铜法袍！" << std::endl;
            }
            else if (randNum < 1000) { // 3% 爆率
                player.backpack.push_back("朱红护甲");
                std::cout << "你获得了朱红护甲！" << std::endl;
            }
            else if (randNum < 1100) { // 0.1% 爆率
                player.backpack.push_back("灭世战甲");
                std::cout << "你获得了灭世战甲！" << std::endl;
            }

            randNum = rand() % 10000; // 使用10000作为基数，方便调整爆率
            if (randNum < 100) { // 1% 爆率
                player.backpack.push_back("创世神剑");
                std::cout << "你获得了创世神剑！" << std::endl;
            }
            else if (randNum < 200) { // 1% 爆率
                player.backpack.push_back("天顶法杖");
                std::cout << "你获得了天顶法杖！" << std::endl;
            }
            else if (randNum < 700) { // 5% 爆率
                player.backpack.push_back("青铜法器");
                std::cout << "你获得了青铜法器！" << std::endl;
            }
            else if (randNum < 1000) { // 3% 爆率
                player.backpack.push_back("赤红魔剑");
                std::cout << "你获得了赤红魔剑！" << std::endl;
            }
            else if (randNum < 1100) { // 0.1% 爆率
                player.backpack.push_back("灭世神剑");
                std::cout << "你获得了灭世神剑！" << std::endl;
            }
        }
    }

    // 玩家等级提升
    player.levelUp();
    player.autoSave(); // 自动存档
}

// 战斗界面
bool battle(Player& player, const std::string& currentMap) {
    setConsoleColorAndBackground(4, 0); // 血红色文字，黑色背景
    system("cls"); // 刷新窗口
    Enemy enemy = generateRandomEnemy(currentMap);
    std::cout << "你遭遇了 " << enemy.name << "！" << std::endl;
    while (player.hp > 0 && enemy.hp > 0) {
        std::cout << "你的生命值: " << player.hp << "/" << player.maxHp << " 敌人生命值: " << enemy.hp << std::endl;
        std::cout << "1. 普通攻击 2. 使用物品 3. 查看装备 4. 逃跑" << std::endl;
        int choice;
        std::cin >> choice;
        switch (choice) {
        case 1: {
            std::cout << "选择攻击方式:" << std::endl;
            std::cout << "1. 普通攻击" << std::endl;
            std::cout << "2. 重击攻击" << std::endl;
            std::cout << "3. 终极技能" << std::endl;
            int attackChoice;
            std::cin >> attackChoice;
            int playerDamage = player.attack;
            switch (attackChoice) {
            case 1:
                enemy.hp -= playerDamage * player.normalAttackLevel;
                std::cout << "你对 " << enemy.name << " 造成了 " << playerDamage * player.normalAttackLevel << " 点伤害！" << std::endl;
                break;
            case 2:
                enemy.hp -= playerDamage * player.heavyAttackLevel * 2;
                std::cout << "你对 " << enemy.name << " 造成了 " << playerDamage * player.heavyAttackLevel * 2 << " 点伤害！" << std::endl;
                break;
            case 3:
                enemy.hp -= playerDamage * player.ultimateSkillLevel * 10;
                std::cout << "你对 " << enemy.name << " 造成了 " << playerDamage * player.ultimateSkillLevel * 10 << " 点伤害！" << std::endl;
                break;
            default:
                std::cout << "无效的攻击选择。" << std::endl;
                break;
            }
            if (enemy.hp > 0) {
                player.hp -= enemy.attack;
                if (enemy.doubleAttack) {
                    player.hp -= enemy.attack; // 虚空之神造成两次伤害
                }
                std::cout << enemy.name << " 对你造成了 " << enemy.attack << " 点伤害！" << std::endl;
            }
            Sleep(1500); // 等待 1.5 秒
            system("cls"); // 刷新窗口
            break;
        }
        case 2: {
            std::cout << "选择使用物品:" << std::endl;
            std::cout << "1. 回血药" << std::endl;
            std::cout << "2. 大补药" << std::endl;
            int itemChoice;
            std::cin >> itemChoice;
            if (itemChoice == 1) {
                player.useHealthPotion();
            }
            else if (itemChoice == 2) {
                player.useBigHealthPotion();
            }
            break;
        }
        case 3:
            std::cout << "当前护甲: " << player.armor << std::endl;
            std::cout << "当前武器: " << player.weapon << std::endl;
            break;
        case 4: {
            int escapeChance = rand() % 100;
            if (escapeChance < 50) {
                std::cout << "你成功逃跑了！" << std::endl;
                setConsoleColorAndBackground(6, 0); // 变回金黄色文字
                return false;
            }
            else {
                std::cout << "你逃跑失败！" << std::endl;
                player.hp -= enemy.attack;
                if (enemy.doubleAttack) {
                    player.hp -= enemy.attack; // 虚空之神造成两次伤害
                }
                std::cout << enemy.name << " 对你造成了 " << enemy.attack << " 点伤害！" << std::endl;
            }
            break;
        }
        default:
            std::cout << "无效的选择，请重新输入。" << std::endl;
        }
    }
    if (player.hp > 0) {
        std::cout << "你击败了 " << enemy.name << "！" << std::endl;
        getEquipmentAndCoins(player, enemy.name);
        if (player.currentMap == "浮空岛屿" && !player.achievements[1]) {
            player.achievements[1] = true; // 解锁“比肩神明”成就
            std::cout << "成就解锁：比肩神明！" << std::endl;
        }
        player.autoSave(); // 自动存档
    }
    else {
        std::cout << "你被 " << enemy.name << " 击败了！" << std::endl;
        player.deleteSave(); // 删除存档
    }
    setConsoleColorAndBackground(6, 0); // 变回金黄色文字
    system("cls"); // 刷新窗口
    return player.hp > 0;
}

// 自动战斗逻辑
bool autoBattle(Player& player, const std::string& currentMap) {
    setConsoleColorAndBackground(4, 0); // 血红色文字，黑色背景
    system("cls"); // 刷新窗口
    Enemy enemy = generateRandomEnemy(currentMap);
    std::cout << "你遭遇了 " << enemy.name << "！" << std::endl;

    // 计算玩家和怪物的总伤害
    int playerTotalDamage = player.attack;
    int enemyTotalDamage = enemy.attack;

    // 比较总伤害，判断胜利方
    if (playerTotalDamage >= enemyTotalDamage) {
        std::cout << "你击败了 " << enemy.name << "！" << std::endl;
        getEquipmentAndCoins(player, enemy.name);
        if (player.currentMap == "浮空岛屿" && !player.achievements[1]) {
            player.achievements[1] = true; // 解锁“比肩神明”成就
            std::cout << "成就解锁：比肩神明！" << std::endl;
        }
        player.autoSave(); // 自动存档
        setConsoleColorAndBackground(6, 0); // 变回金黄色文字
        return true; // 玩家胜利
    }
    else {
        std::cout << "你被 " << enemy.name << " 击败了！" << std::endl;
        player.hp = 0; // 玩家血量归零
        player.deleteSave(); // 删除存档
        setConsoleColorAndBackground(6, 0); // 变回金黄色文字
        return false; // 玩家失败
    }
}

// 地图选择
void selectMap(Player& player) {
    std::cout << "选择地图:" << std::endl;
    std::cout << "1. 使命之地" << std::endl;
    if (player.level >= 50) {
        std::cout << "2. 虚空领域" << std::endl;
    }
    if (player.level >= 200) {
        std::cout << "3. 传说之海" << std::endl;
    }
    if (player.level >= 350) {
        std::cout << "4. 浮空岛屿" << std::endl;
    }
    int choice;
    std::cin >> choice;
    if (choice == 1) {
        player.currentMap = "使命之地";
        player.maxLevel = 200; // 使命之地的等级上限为200
    }
    else if (choice == 2 && player.level >= 50) {
        player.currentMap = "虚空领域";
        player.maxLevel = 200; // 虚空领域的等级上限为200
    }
    else if (choice == 3 && player.level >= 200) {
        player.currentMap = "传说之海";
        player.maxLevel = 350; // 传说之海的等级上限为350
        if (!player.achievements[0]) { // 解锁成就“传说之人”
            player.achievements[0] = true;
            std::cout << "成就解锁：传说之人！" << std::endl;
        }
    }
    else if (choice == 4 && player.level >= 350) {
        player.currentMap = "浮空岛屿";
        player.maxLevel = 500; // 浮空岛屿的等级上限为500
    }
    else {
        std::cout << "无效的选择，已自动选择使命之地。" << std::endl;
        player.currentMap = "使命之地";
        player.maxLevel = 200; // 默认选择使命之地，等级上限为200
    }
    std::cout << "当前地图：" << player.currentMap << "，等级上限：" << player.maxLevel << std::endl;
    player.autoSave(); // 自动存档
}

// 背包系统
void backpackSystem(Player& player) {
    setConsoleColorAndBackground(6, 0); // 金黄色文字，黑色背景
    std::cout << "你的背包:" << std::endl;
    for (size_t i = 0; i < player.backpack.size(); ++i) {
        std::cout << i + 1 << ". " << player.backpack[i] << std::endl;
    }
    std::cout << "选择要装备的物品 (输入编号, 0 退出): ";
    int choice;
    std::cin >> choice;
    if (choice > 0 && choice <= static_cast<int>(player.backpack.size())) {
        std::string item = player.backpack[choice - 1];
        if (item == "创世铠甲" || item == "战神圣衣" || item == "青铜法袍" || item == "朱红护甲" || item == "灭世战甲" || item == "虚空魔神铠" || item == "神圣之护铠" || item == "原始之铠" || item == "传说之铠" || item == "地狱之铠" || item == "虚空之铠" || item == "虚无之铠") {
            player.equipArmor(item);
        }
        else if (item == "创世神剑" || item == "天顶法杖" || item == "青铜法器" || item == "赤红魔剑" || item == "灭世神剑" || item == "虚空魔神剑" || item == "神圣之神剑" || item == "原始之剑" || item == "传说之剑" || item == "地狱之剑" || item == "虚空之剑" || item == "虚无之剑") {
            player.equipWeapon(item);
        }
        player.backpack.erase(player.backpack.begin() + choice - 1);
    }
}

// 加载存档
bool loadSave(Player& player) {
    std::ifstream saveFile("savegame.txt");
    if (!saveFile) {
        return false;
    }
    try {
        saveFile >> player.level >> player.hp >> player.maxHp >> player.attack
            >> player.armor >> player.weapon
            >> player.legendCoins >> player.healthPotions
            >> player.bigHealthPotions >> player.currentMap
            >> player.normalAttackLevel >> player.heavyAttackLevel
            >> player.ultimateSkillLevel >> player.defeatedEnemies >> player.maxLevel;
        for (int i = 0; i < 3; ++i) {
            saveFile >> player.achievements[i];
        }

        if (saveFile.fail()) {
            throw std::runtime_error("存档文件读取错误");
        }

        std::string item;
        player.backpack.clear();
        while (std::getline(saveFile >> std::ws, item) && !item.empty()) {
            player.backpack.push_back(item);
        }
    }
    catch (const std::exception& e) {
        std::cerr << "存档加载错误: " << e.what() << std::endl;
        return false;
    }
    return true;
}

// 游戏主循环
void gameLoop(Player& player) {
    setConsoleColorAndBackground(6, 0); // 金黄色文字，黑色背景

    // 加载存档
    if (loadSave(player)) {
        std::cout << "存档加载成功！" << std::endl;
    }
    else {
        std::cout << "未找到存档，将创建新游戏。" << std::endl;
    }
    system("cls"); // 刷新窗口

    while (true) {
        std::cout << "当前等级: " << player.level << "/" << player.maxLevel << std::endl;
        std::cout << "当前生命值: " << player.hp << "/" << player.maxHp << std::endl;
        std::cout << "当前攻击力: " << player.attack << std::endl;
        std::cout << "当前护甲: " << player.armor << std::endl;
        std::cout << "当前武器: " << player.weapon << std::endl;
        std::cout << "当前回血药数量: " << player.healthPotions << std::endl;
        std::cout << "当前大补药数量: " << player.bigHealthPotions << std::endl;
        std::cout << "当前传说币数量: " << player.legendCoins << std::endl;
        std::cout << "当前地图：" << player.currentMap << std::endl;
        std::cout << "成就：" << std::endl;
        if (player.achievements[0]) std::cout << " - 传说之人" << std::endl;
        if (player.achievements[1]) std::cout << " - 比肩神明" << std::endl;
        if (player.achievements[2]) std::cout << " - 超越神明" << std::endl;
        std::cout << "1. 移动 2. 背包 3. 升级技能 4. 查看成就 5. 退出游戏" << std::endl;
        int choice;
        std::cin >> choice;

        switch (choice) {
        case 1: {
            std::cout << "移动选项:" << std::endl;
            std::cout << "1. 战斗 2. 商店 3. 地图" << std::endl;
            int moveChoice;
            std::cin >> moveChoice;
            switch (moveChoice) {
            case 1: {
                std::cout << "选择战斗方式:" << std::endl;
                std::cout << "1. 普通战斗 2. 自动战斗" << std::endl;
                int battleChoice;
                std::cin >> battleChoice;
                if (battleChoice == 1) {
                    battle(player, player.currentMap);
                }
                else if (battleChoice == 2) {
                    autoBattle(player, player.currentMap);
                }
                break;
            }
            case 2:
                player.tradeEquipment();
                break;
            case 3:
                selectMap(player);
                break;
            default:
                std::cout << "无效的选择，请重新输入。" << std::endl;
            }
            break;
        }
        case 2:
            backpackSystem(player);
            break;
        case 3:
            player.upgradeSkill();
            break;
        case 4:
            std::cout << "成就：" << std::endl;
            if (player.achievements[0]) std::cout << " - 传说之人" << std::endl;
            if (player.achievements[1]) std::cout << " - 比肩神明" << std::endl;
            if (player.achievements[2]) std::cout << " - 超越神明" << std::endl;
            break;
        case 5:
            player.autoSave(); // 自动存档
            return;
        default:
            std::cout << "无效的选择，请重新输入。" << std::endl;
        }

        Sleep(1500); // 等待 1.5 秒
        system("cls"); // 刷新窗口
    }
}

int main() {
    srand(static_cast<unsigned int>(time(nullptr)));
    setConsoleColorAndBackground(6, 0); // 设置控制台默认颜色和背景
    startMenu();
    loadingScreen();

    Player player;
    gameLoop(player);
    return 0;
}