xing

#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <windows.h> // 用于控制台颜色和睡眠功能

using namespace std;

// 设置控制台文本颜色
void setColor(int color) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color);
}

// 显示缓慢打字效果
void typeWriter(const string& text, int delay = 50, int color = 7) {
setColor(color);
for (char c : text) {
cout << c;
Sleep(delay);
}
setColor(7);
cout << endl;
}

// 角色类
class Character {
private:
string name;
string path; // 星穹铁道中的"命途"
string element; // 元素属性
string gender; // 性别
int hp;
int maxHp;
int attack;
int defense;
int energy; // 能量值，用于释放大招
int maxEnergy; // 最大能量值

public:
// 构造函数
Character(string n, string g, string p, string e, int mHp, int atk, int def, int mEnergy = 100)
: name(n), gender(g), path(p), element(e), maxHp(mHp), hp(mHp), attack(atk), defense(def),
energy(0), maxEnergy(mEnergy) {
}

// 获取角色名称
string getName() const { return name; }

// 获取性别
string getGender() const { return gender; }

// 获取命途
string getPath() const { return path; }

// 获取元素属性
string getElement() const { return element; }

// 获取当前HP
int getHp() const { return hp; }

// 获取最大HP
int getMaxHp() const { return maxHp; }

// 获取当前能量
int getEnergy() const { return energy; }

// 获取最大能量
int getMaxEnergy() const { return maxEnergy; }

// 普通攻击
void basicAttack(Character& target) {
    // 计算伤害 (考虑防御)
    int damage = max(1, attack - target.defense / 4);

    // 元素克制加成
    checkElementBonus(damage, target);

    target.takeDamage(damage);
    setColor(12); // 红色
    cout << name << "使用了普通攻击，对" << target.getName() << "造成了" << damage << "点伤害！" << endl;
    setColor(7); // 恢复白色

    // 普通攻击获得能量
    gainEnergy(20);
}

// 技能攻击
void skillAttack(Character& target);

// 大招攻击
void ultimateSkill(vector<Character>& targets);

// 受到伤害
void takeDamage(int damage) {
    hp = max(0, hp - damage);
}

// 恢复HP
void heal(int amount) {
    hp = min(maxHp, hp + amount);
    setColor(10); // 绿色
    cout << name << "恢复了" << amount << "点HP！" << endl;
    setColor(7); // 恢复白色
}

// 获得能量
void gainEnergy(int amount) {
    energy = min(maxEnergy, energy + amount);
    setColor(11); // 亮青色
    cout << name << "获得了" << amount << "点能量！(" << energy << "/" << maxEnergy << ")" << endl;
    setColor(7); // 恢复白色
}

// 检查是否存活
bool isAlive() const {
    return hp > 0;
}

// 检查元素克制
void checkElementBonus(int& damage, const Character& target) {
    if ((element == "物理" && target.getElement() == "量子") ||
        (element == "量子" && target.getElement() == "虚数") ||
        (element == "虚数" && target.getElement() == "物理") ||
        (element == "雷" && target.getElement() == "风") ||
        (element == "风" && target.getElement() == "冰") ||
        (element == "冰" && target.getElement() == "火") ||
        (element == "火" && target.getElement() == "雷")) {
        damage = damage * 1.5;
        setColor(11); // 亮青色
        cout << name << "触发了元素克制！" << endl;
        setColor(7); // 恢复白色
    }
}

// 显示角色状态
void showStatus() const {
    cout << name << " (" << gender << " / " << path << "/" << element << "): ";
    setColor(12); // 红色
    cout << "HP: " << hp << "/" << maxHp << " ";
    setColor(14); // 黄色
    cout << "攻击: " << attack << " ";
    setColor(9);  // 蓝色
    cout << "防御: " << defense << " ";
    setColor(11); // 亮青色
    cout << "能量: " << energy << "/" << maxEnergy;
    setColor(7);  // 恢复白色
    cout << endl;
}

};

// 技能实现
void Character::skillAttack(Character& target) {
int damage = 0;

if (name == " Stelle " || name == " Caelus ") { // 开拓者技能
    damage = max(1, attack * 1.2 - target.defense / 3);
    checkElementBonus(damage, target);
    target.takeDamage(damage);
    setColor(13); // 紫色
    cout << name << "使用了技能「粉碎」，对" << target.getName() << "造成了" << damage << "点伤害！" << endl;
    setColor(7);
    gainEnergy(30);
}
else if (name == "三月七") { // 三月七技能
    int shield = 20 + defense / 2;
    setColor(9); // 蓝色
    cout << name << "使用了技能「冻结」，对" << target.getName() << "造成了" << attack / 2 << "点伤害，并为自己附加了" << shield << "点护盾！" << endl;
    setColor(7);
    target.takeDamage(attack / 2);
    heal(shield); // 用治疗模拟护盾效果
    gainEnergy(30);
}
else if (name == "丹恒") { // 丹恒技能
    damage = max(1, attack * 1.5 - target.defense / 3);
    checkElementBonus(damage, target);
    target.takeDamage(damage);
    setColor(10); // 绿色
    cout << name << "使用了技能「流泉」，对" << target.getName() << "造成了" << damage << "点伤害！" << endl;
    setColor(7);
    gainEnergy(30);
}
else if (name == "自动机兵·精英型") { // 精英自动机兵技能
    damage = max(1, attack * 1.2 - target.defense / 4);
    target.takeDamage(damage);
    setColor(12); // 红色
    cout << name << "使用了技能「电荷冲击」，对" << target.getName() << "造成了" << damage << "点伤害！" << endl;
    setColor(7);
}
else if (name == "银鬃铁卫队长") { // 铁卫队长技能
    damage = max(1, attack * 1.1 - target.defense / 4);
    target.takeDamage(damage);
    setColor(12); // 红色
    cout << name << "使用了技能「命令射击」，对" << target.getName() << "造成了" << damage << "点伤害！" << endl;
    setColor(7);
}
else { // 普通攻击作为默认技能
    basicAttack(target);
}

}

// 大招实现
void Character::ultimateSkill(vector<Character>& targets) {
if (energy < maxEnergy) {
setColor(12); // 红色
cout << name << "的能量不足，无法释放大招！" << endl;
setColor(7);
return;
}

if (name == " Stelle " || name == " Caelus ") { // 开拓者大招
    setColor(13); // 紫色
    cout << endl << "===== " << name << "释放了大招「星河破碎」！=====" << endl;
    setColor(7);

    for (auto& target : targets) {
        if (target.isAlive()) {
            int damage = max(1, attack * 2 - target.defense / 3);
            checkElementBonus(damage, target);
            target.takeDamage(damage);
            setColor(12); // 红色
            cout << name << "对" << target.getName() << "造成了" << damage << "点巨额伤害！" << endl;
            setColor(7);
        }
    }
}
else if (name == "三月七") { // 三月七大招
    setColor(9); // 蓝色
    cout << endl << "===== " << name << "释放了大招「守护之冰」！=====" << endl;
    setColor(7);

    for (auto& target : targets) {
        if (target.isAlive()) {
            int shield = 30 + defense;
            target.heal(shield); // 用治疗模拟护盾效果
            setColor(9); // 蓝色
            cout << target.getName() << "获得了" << shield << "点护盾！" << endl;
            setColor(7);
        }
    }
}
else if (name == "丹恒") { // 丹恒大招
    setColor(10); // 绿色
    cout << endl << "===== " << name << "释放了大招「岚断」！=====" << endl;
    setColor(7);

    // 优先攻击生命值最低的目标
    if (!targets.empty()) {
        int lowestHpIndex = 0;
        for (int i = 1; i < targets.size(); i++) {
            if (targets[i].isAlive() && targets[i].getHp() < targets[lowestHpIndex].getHp()) {
                lowestHpIndex = i;
            }
        }

        Character& target = targets[lowestHpIndex];
        if (target.isAlive()) {
            int damage = max(1, attack * 3 - target.defense / 2);
            checkElementBonus(damage, target);
            target.takeDamage(damage);
            setColor(12); // 红色
            cout << name << "对" << target.getName() << "造成了" << damage << "点致命伤害！" << endl;
            setColor(7);
        }
    }
}

// 释放大招后能量清零
energy = 0;

}

// 游戏类
class HonkaiGame {
private:
vector<Character> playerTeam;
vector<Character> enemyTeam;
bool isRunning;
int storyProgress; // 剧情进度标记
string currentLocation; // 当前所在位置
string playerName; // 玩家名称（含ID）
string playerGender; // 玩家性别
string trailblazerName; // 开拓者本名（ Stelle / Caelus）

public:
// 构造函数
HonkaiGame() : isRunning(true), storyProgress(0), currentLocation("星穹列车") {
// 初始化游戏前先进行角色创建
createPlayerCharacter();
// 初始化其他角色
initOtherCharacters();
}

// 创建玩家角色（选择性别和名字）
void createPlayerCharacter() {
    system("cls");
    setColor(13); // 紫色
    cout << "=========================================" << endl;
    cout << "           角色创建" << endl;
    cout << "=========================================" << endl << endl;
    setColor(7);

    // 选择性别
    int genderChoice;
    do {
        typeWriter("请选择你的性别:", 60);
        typeWriter("1. 男性", 60);
        typeWriter("2. 女性", 60);
        cout << "选择: ";
        cin >> genderChoice;

        if (genderChoice == 1) {
            playerGender = "男";
            trailblazerName = " Caelus "; // 男开拓者名字
        }
        else if (genderChoice == 2) {
            playerGender = "女";
            trailblazerName = " Stelle "; // 女开拓者名字
        }
        else {
            cout << "请输入有效的选择！" << endl;
            Sleep(1000);
            system("cls");
        }
    } while (genderChoice < 1 || genderChoice > 2);

    // 输入名字
    cin.ignore(); // 清除输入缓冲区
    string name;
    typeWriter("\n请输入你的名字:", 60);
    getline(cin, name);

    // 生成随机ID（4位数字）
    int randomId = 1000 + rand() % 9000;
    playerName = name + "#" + to_string(randomId);

    typeWriter("\n角色创建成功！你的身份是: " + playerName + " (" + trailblazerName + " / " + playerGender + ")", 60, 10);
    Sleep(1000);

    cout << endl << "按回车键开始你的旅程...";
    cin.get();
}

// 初始化其他角色
void initOtherCharacters() {
    // 玩家队伍（包含自定义的开拓者）
    playerTeam.emplace_back(playerName, playerGender, "毁灭", "物理", 120, 28, 18);
    playerTeam.emplace_back("三月七", "女", "保存", "冰", 100, 22, 22, 100);
    playerTeam.emplace_back("丹恒", "男", "巡猎", "风", 90, 32, 15, 100);
}

// 显示游戏标题
void showTitle() {
    system("cls");
    setColor(13); // 紫色 (崩坏星穹铁道主题色)
    cout << "=========================================" << endl;
    cout << "           崩坏：星穹铁道" << endl;
    cout << "         (C++ 控制台版体验)" << endl;
    cout << "=========================================" << endl;
    setColor(7); // 恢复白色
    cout << endl;
}

// 显示序章剧情（卡芙卡和银狼）
void showPrologue() {
    system("cls");
    setColor(13); // 紫色
    cout << "=========================================" << endl;
    cout << "              序章：星核" << endl;
    cout << "=========================================" << endl << endl;
    setColor(7);

    typeWriter("意识如同沉入深海...", 80);
    Sleep(1000);
    typeWriter("你在一片陌生的空间中醒来，周围是闪烁的全息投影。", 60);
    Sleep(800);

    typeWriter("\n一个穿着红色长裙的女子站在你面前，嘴角带着神秘的微笑。", 60);
    Sleep(1000);
    typeWriter("卡芙卡: 感觉怎么样？睡了这么久，终于醒了呢。", 60, 12);
    Sleep(600);

    typeWriter("\n旁边一个戴着耳机的蓝发少女正在操作着什么设备。", 60);
    Sleep(800);
    typeWriter("银狼: 卡芙卡，数据同步完成了。这家伙的意识已经稳定下来。", 60, 9);
    Sleep(600);
    typeWriter("卡芙卡: 很好。那么，" + trailblazerName + "，你还记得自己是谁吗？", 60, 12);
    Sleep(800);

    typeWriter("\n你的脑海中一片空白，只有零碎的记忆碎片闪过。", 60);
    Sleep(800);
    typeWriter("卡芙卡: 看来还是一片空白呢...没关系，很快你就会明白一切。", 60, 12);
    Sleep(600);
    typeWriter("银狼: 星核已经植入，系统检测正常。", 60, 9);
    typeWriter("银狼: 不过卡芙卡，列车的追踪信号越来越近了，我们该走了。", 60, 9);
    Sleep(800);

    typeWriter("\n卡芙卡缓步走到你面前，轻轻抚摸你的脸颊。", 60);
    Sleep(800);
    typeWriter("卡芙卡: 好好活下去，" + trailblazerName + "。", 60, 12);
    typeWriter("卡芙卡: 我们还会再见面的...在那之前，先找到属于自己的答案吧。", 60, 12);
    Sleep(1000);

    typeWriter("\n光影闪烁，两人的身影消失在空间中。", 60);
    Sleep(800);
    typeWriter("周围的环境开始剧烈震动，仿佛整个空间都在崩塌。", 60);
    typeWriter("在失去意识前，你听到了一个新的声音...", 60);
    Sleep(1000);

    typeWriter("\n姬子 (远处): 这里有生命反应！准备救援！", 60, 14);
    Sleep(1500);

    cout << endl << "按回车键继续...";
    cin.ignore();
    cin.get();
}

// 显示开场剧情
void showOpeningStory() {
    // 先显示卡芙卡和银狼的序章
    showPrologue();

    system("cls");
    setColor(13); // 紫色
    cout << "=========================================" << endl;
    cout << "           崩坏：星穹铁道" << endl;
    cout << "=========================================" << endl << endl;
    setColor(7);

    typeWriter("你在一张舒适的床上醒来，周围是金属质感的房间。", 60);
    Sleep(500);
    typeWriter("一个红发女子正关切地看着你。", 60);
    Sleep(300);

    typeWriter("\n姬子: 你终于醒了！我是姬子，星穹列车的领航员。", 60, 14);
    Sleep(500);
    typeWriter("姬子: 我们在废弃的空间站找到了你，当时你处于昏迷状态。", 60, 14);
    Sleep(500);
    typeWriter(playerName + ": 我...是谁？这里是哪里？", 60, 10);
    Sleep(500);

    typeWriter("\n姬子: 看来你失去了记忆。我们叫你开拓者，因为你的命运才刚刚开始。", 60, 14);
    Sleep(800);
    typeWriter("姬子: 这里是星穹列车，我们穿越银河，寻找星核的秘密。", 60, 14);
    Sleep(500);

    typeWriter("\n一个粉发少女蹦蹦跳跳地跑了进来。", 60);
    Sleep(500);
    typeWriter("三月七: 哇，你醒啦！我是三月七，也是列车上的成员！", 60, 11);
    Sleep(500);
    typeWriter("一个蓝发少年跟在后面，表情严肃。", 60);
    Sleep(500);
    typeWriter("丹恒: 我是丹恒，负责列车的运行和情报分析。", 60, 9);
    Sleep(500);

    typeWriter("\n姬子: 我们发现你体内有星核的反应，这可能和你的过去有关。", 60, 14);
    typeWriter("姬子: 现在我们有两个目的地可以选择，你想先去哪里调查？", 60, 14);
    Sleep(500);

    int choice;
    do {
        typeWriter("\n请选择你的第一个目的地:", 60);
        typeWriter("1. 黑塔空间站", 60);
        typeWriter("2. 雅利洛-VI", 60);
        cout << "选择: ";
        cin >> choice;

        if (choice == 1) {
            currentLocation = "黑塔空间站";
            storyProgress = 10; // 空间站剧情线起始
            typeWriter("\n姬子: 明智的选择，黑塔空间站的情况可能更为紧急。", 60, 14);
        }
        else if (choice == 2) {
            currentLocation = "雅利洛-VI";
            storyProgress = 1; // 雅利洛剧情线起始
            typeWriter("\n姬子: 雅利洛-VI的星核问题已经持续了很久，是该解决了。", 60, 14);
        }
        else {
            cout << "请输入有效的选择！" << endl;
        }
    } while (choice < 1 || choice > 2);

    Sleep(1000);
    typeWriter("\n列车开始调整航线，前往" + currentLocation + "...", 60);
    Sleep(1500);

    cout << endl << "按回车键继续...";
    cin.ignore();
    cin.get();
}

// 空间站开场剧情
void showSpaceStationIntro() {
    system("cls");
    setColor(13); // 紫色
    cout << "=========================================" << endl;
    cout << "           黑塔空间站" << endl;
    cout << "=========================================" << endl << endl;
    setColor(7);

    typeWriter("星穹列车停靠在黑塔空间站的 docking 舱位。", 60);
    Sleep(500);
    typeWriter("这里是银河系中最顶尖的科研机构之一，由天才少女黑塔主持。", 60);
    Sleep(800);

    typeWriter("\n三月七: 哇，这里就是黑塔空间站吗？比想象中还要先进！", 60, 11);
    Sleep(500);
    typeWriter("丹恒: 保持警惕，根据信号分析，这里的自动防御系统似乎被激活了。", 60, 9);
    Sleep(500);

    typeWriter("\n一个机械声音在走廊中回荡:", 60);
    typeWriter("警告：未授权人员入侵，启动清除程序。", 60, 12);
    Sleep(800);

    typeWriter("\n" + playerName + ": 看来我们不受欢迎啊。", 60, 10);
    Sleep(500);
    typeWriter("丹恒: 跟我来，我知道一条通往主控室的捷径。", 60, 9);
    Sleep(1000);

    cout << endl << "按回车键继续...";
    cin.ignore();
    cin.get();
}

// 遭遇黑塔剧情
void meetHertaScene() {
    system("cls");
    setColor(13); // 紫色
    cout << "=========================================" << endl;
    cout << "           黑塔的私人实验室" << endl;
    cout << "=========================================" << endl << endl;
    setColor(7);

    typeWriter("你们穿过重重阻碍，终于来到了空间站的核心区域。", 60);
    Sleep(800);
    typeWriter("一个漂浮在全息投影前的少女身影出现在你们面前。", 60);
    Sleep(800);

    typeWriter("\n黑塔: 哦？终于来了吗？我还以为阿兰的安保系统能撑更久呢。", 60, 14);
    Sleep(500);
    typeWriter("三月七: 你就是黑塔？为什么空间站的防御系统会攻击我们？", 60, 11);
    Sleep(500);
    typeWriter("黑塔: 当然是为了测试你们的实力啦，毕竟能得到星穹列车青睐的人可不多。", 60, 14);
    Sleep(500);

    typeWriter("\n丹恒: 我们收到了求助信号，这里发生了什么？", 60, 9);
    Sleep(500);
    typeWriter("黑塔: 哦，那个啊，是我放出去的。我对\"星核\"很感兴趣，", 60, 14);
    typeWriter("黑塔: 而你们似乎很擅长处理这种麻烦，不是吗？", 60, 14);
    Sleep(800);

    typeWriter("\n" + playerName + ": 你知道星核的来历？", 60, 10);
    Sleep(500);
    typeWriter("黑塔: 略知一二。但在告诉你之前，你们得帮我个小忙。", 60, 14);
    typeWriter("黑塔: 空间站的数据库被一种奇怪的程序感染了，帮我清除它。", 60, 14);
    Sleep(1000);

    cout << endl << "按回车键接受任务...";
    cin.ignore();
    cin.get();
}

// 黑塔剧情结束
void hertaQuestComplete() {
    system("cls");
    setColor(13); // 紫色
    cout << "=========================================" << endl;
    cout << "           任务完成" << endl;
    cout << "=========================================" << endl << endl;
    setColor(7);

    typeWriter("在你们的帮助下，数据库中的异常程序被成功清除。", 60);
    Sleep(800);

    typeWriter("\n黑塔: 干得不错，比阿兰那家伙靠谱多了。", 60, 14);
    Sleep(500);
    typeWriter("阿兰 (通讯): 博士！我听到了！", 60, 8);
    typeWriter("黑塔: 闭嘴，阿兰。", 60, 14);
    Sleep(500);

    typeWriter("\n黑塔: 关于星核，我确实有一些研究。它们是宇宙中的异常存在，", 60, 14);
    typeWriter("黑塔: 能够扭曲现实，放大生物的欲望和负面情绪。", 60, 14);
    Sleep(800);

    typeWriter("三月七: 那我们该怎么处理它们？", 60, 11);
    Sleep(500);
    typeWriter("黑塔: 你们星穹列车上的\"星穹\"应该能中和星核的力量。", 60, 14);
    typeWriter("黑塔: 下一个出现星核的地方是雅利洛-VI，你们可以去那里试试。", 60, 14);
    Sleep(1000);

    typeWriter("\n丹恒: 我们会去调查的。", 60, 9);
    Sleep(500);
    typeWriter("黑塔: 这是我的联系方式，有什么发现随时告诉我。", 60, 14);
    typeWriter("黑塔: 说不定...我会给你们一些意想不到的奖励哦~", 60, 14);
    Sleep(1000);

    // 切换到雅利洛剧情线
    currentLocation = "雅利洛-VI";
    storyProgress = 1;

    cout << endl << "按回车键返回列车，前往下一个目的地...";
    cin.ignore();
    cin.get();
}

// 主菜单
void mainMenu() {
    // 首次运行显示开场剧情
    if (storyProgress == 0) {
        showOpeningStory();
        // 根据选择的地点显示相应的开场
        if (currentLocation == "黑塔空间站" && storyProgress == 10) {
            showSpaceStationIntro();
        }
    }

    int choice;
    do {
        showTitle();
        cout << "当前位置: " << currentLocation << endl << endl;
        cout << "1. 开始探索" << endl;
        cout << "2. 查看角色" << endl;
        cout << "3. 退出游戏" << endl;
        cout << "请选择: ";
        cin >> choice;

        switch (choice) {
        case 1:
            startExploration();
            break;
        case 2:
            showCharacters();
            break;
        case 3:
            isRunning = false;
            cout << "感谢游玩！再见！" << endl;
            break;
        default:
            cout << "无效的选择，请重试！" << endl;
            Sleep(1000);
        }
    } while (isRunning);
}

// 显示角色
void showCharacters() {
    showTitle();
    setColor(14); // 黄色
    cout << "====== 玩家队伍 ======" << endl;
    setColor(7); // 恢复白色
    for (const auto& chara : playerTeam) {
        chara.showStatus();
    }

    cout << endl << "按回车键返回主菜单...";
    cin.ignore();
    cin.get();
}

// 开始探索
void startExploration() {
    // 根据剧情进度和当前位置生成不同的敌人
    generateEnemies();

    showTitle();
    setColor(11); // 亮青色

    // 空间站剧情线
    if (currentLocation == "黑塔空间站") {
        if (storyProgress == 10) {
            typeWriter("你们沿着丹恒所说的路线前进，走廊里的灯光忽明忽暗。", 50);
            typeWriter("突然，几道激光屏障落下，挡住了你们的去路。", 50);
            typeWriter("自动机兵从两侧的舱门中走了出来，将武器对准了你们！", 50);
        }
        else if (storyProgress == 11) {
            typeWriter("你们来到了数据库控制室门口，但门禁被密码锁死了。", 50);
            typeWriter("三月七: 怎么办？我们不知道密码啊！", 50);
            typeWriter("话音刚落，一群经过改装的精英自动机兵出现了！", 50);
        }
    }
    // 雅利洛剧情线
    else if (currentLocation == "雅利洛-VI") {
        if (storyProgress == 1) {
            typeWriter("你们走出星穹列车，踏入了被冰雪覆盖的土地。", 50);
            typeWriter("突然，几只裂界造物从雪堆中窜了出来！", 50);
        }
        else if (storyProgress == 2) {
            typeWriter("你们继续深入雅利洛-VI，来到了一个废弃的**站。", 50);
            typeWriter("这里似乎有银鬃铁卫的踪迹，但他们的行为看起来很奇怪...", 50);
        }
    }

    setColor(7); // 恢复白色
    Sleep(1000);

    startBattle();

    // 战斗结束后推进剧情
    if (checkAllEnemiesDead()) {
        storyProgress++;
        postBattleDialogue();
    }
}

// 生成敌人（根据剧情进度和当前位置）
void generateEnemies() {
    enemyTeam.clear();

    // 空间站敌人
    if (currentLocation == "黑塔空间站") {
        if (storyProgress == 10) {
            // 初期自动机兵
            enemyTeam.emplace_back("自动机兵·基础型", "无", "智识", "物理", 60, 20, 12);
            enemyTeam.emplace_back("自动机兵·射击型", "无", "巡猎", "物理", 55, 22, 8);
            enemyTeam.emplace_back("自动机兵·防御型", "无", "保存", "物理", 75, 15, 18);
        }
        else if (storyProgress == 11) {
            // 数据库守卫
            enemyTeam.emplace_back("自动机兵·精英型", "无", "智识", "雷", 90, 25, 15);
            enemyTeam.emplace_back("自动机兵·指挥官", "无", "虚无", "雷", 110, 28, 12);
        }
    }
    // 雅利洛敌人
    else if (currentLocation == "雅利洛-VI") {
        if (storyProgress == 1) {
            // 初期敌人
            enemyTeam.emplace_back("裂界造物", "无", "虚无", "量子", 70, 18, 8);
            enemyTeam.emplace_back("裂界造物", "无", "虚无", "量子", 65, 16, 6);
        }
        else if (storyProgress == 2) {
            // 中期敌人
            enemyTeam.emplace_back("银鬃铁卫士兵", "男", "智识", "物理", 80, 22, 12);
            enemyTeam.emplace_back("银鬃铁卫队长", "男", "智识", "物理", 100, 25, 15);
        }
    }
}

// 战斗后的对话
void postBattleDialogue() {
    showTitle();

    // 空间站剧情对话
    if (currentLocation == "黑塔空间站") {
        if (storyProgress == 11) {
            typeWriter("三月七: 呼...这些机器人还真难对付。", 60, 11);
            Sleep(500);
            typeWriter("丹恒: 它们的攻击模式很规律，应该是按照预设程序行动。", 60, 9);
            Sleep(500);
            typeWriter(playerName + ": 门禁还是锁着的，我们该怎么进去？", 60, 10);
            Sleep(500);

            typeWriter("\n一个声音从门禁扬声器中传出:", 60);
            typeWriter("看来你们通过了第二场测试，做得不错。", 60, 14);
            typeWriter("我是黑塔，空间站的主人。", 60, 14);
            Sleep(800);

            typeWriter("\n三月七: 黑塔？你一直在监视我们？", 60, 11);
            typeWriter("黑塔: 当然，这里可是我的地盘。跟我来我的私人实验室吧。", 60, 14);
            typeWriter("门禁已经解锁，沿着指示走就行。", 60, 14);
            Sleep(1000);

            // 显示黑塔相遇剧情
            meetHertaScene();
        }
        else if (storyProgress == 12) {
            // 完成黑塔任务
            hertaQuestComplete();
        }
    }
    // 雅利洛剧情对话
    else if (currentLocation == "雅利洛-VI") {
        if (storyProgress == 2) {
            typeWriter("三月七: 呼...这些怪物真难缠。", 60, 11);
            Sleep(500);
            typeWriter("丹恒: 这只是开始，这些裂界造物似乎受到了某种力量的影响。", 60, 9);
            Sleep(500);
            typeWriter(playerName + ": 我们需要继续前进，找到星核的位置。", 60, 10);
            Sleep(500);
            typeWriter("三月七: 前面好像有个**站，也许我们能在那里找到些线索。", 60, 11);
        }
        else if (storyProgress == 3) {
            typeWriter("丹恒: 这些银鬃铁卫看起来不太正常，像是被操控了。", 60, 9);
            Sleep(500);
            typeWriter("三月七: 难道和星核有关？", 60, 11);
            Sleep(500);
            typeWriter(playerName + ": 很有可能，我们得小心行事。", 60, 10);
            Sleep(500);
            typeWriter("丹恒: **站里有份报告提到了\"贝洛伯格\"，似乎是当地的主要城市。", 60, 9);
        }
    }

    Sleep(1000);
    cout << endl << "按回车键返回主菜单...";
    cin.ignore();
    cin.get();
}

// 开始战斗
void startBattle() {
    // 战斗循环
    while (true) {
        // 检查战斗是否结束
        if (checkAllEnemiesDead()) {
            setColor(10); // 绿色
            cout << endl << "恭喜！你赢得了战斗！" << endl;
            setColor(7); // 恢复白色
            break;
        }

        if (checkAllPlayersDead()) {
            setColor(12); // 红色
            cout << endl << "很遗憾，你输掉了战斗！" << endl;
            setColor(7); // 恢复白色
            break;
        }

        // 显示双方状态
        cout << endl << "----- 队伍状态 -----" << endl;
        for (const auto& chara : playerTeam) {
            chara.showStatus();
        }
        cout << endl << "----- 敌人状态 -----" << endl;
        for (const auto& chara : enemyTeam) {
            chara.showStatus();
        }

        // 玩家回合
        playerTurn();

        // 敌人回合
        enemyTurn();

        Sleep(2000);
        system("cls");
    }

    cout << endl << "按回车键继续...";
    cin.ignore();
    cin.get();
}

// 检查是否所有敌人都已死亡
bool checkAllEnemiesDead() {
    for (const auto& enemy : enemyTeam) {
        if (enemy.isAlive()) {
            return false;
        }
    }
    return true;
}

// 检查是否所有玩家都已死亡
bool checkAllPlayersDead() {
    for (const auto& player : playerTeam) {
        if (player.isAlive()) {
            return false;
        }
    }
    return true;
}

// 玩家回合
void playerTurn() {
    setColor(10); // 绿色
    cout << endl << "----- 你的回合 -----" << endl;
    setColor(7); // 恢复白色

    // 选择要行动的角色
    int charIndex;
    do {
        cout << "选择要行动的角色 (1-" << playerTeam.size() << "): ";
        cin >> charIndex;
        charIndex--; // 转换为0-based索引

        if (charIndex < 0 || charIndex >= playerTeam.size() || !playerTeam[charIndex].isAlive()) {
            cout << "无效的选择，请选择一个存活的角色！" << endl;
        }
    } while (charIndex < 0 || charIndex >= playerTeam.size() || !playerTeam[charIndex].isAlive());

    // 选择行动
    int action;
    cout << "选择行动:" << endl;
    cout << "1. 普通攻击" << endl;
    cout << "2. 技能" << endl;
    cout << "3. 恢复" << endl;
    cout << "4. 大招 (" << playerTeam[charIndex].getEnergy() << "/" << playerTeam[charIndex].getMaxEnergy() << ")" << endl;
    cin >> action;

    if (action == 1) {
        // 普通攻击
        int targetIndex;
        do {
            cout << "选择攻击目标 (1-" << enemyTeam.size() << "): ";
            cin >> targetIndex;
            targetIndex--; // 转换为0-based索引

            if (targetIndex < 0 || targetIndex >= enemyTeam.size() || !enemyTeam[targetIndex].isAlive()) {
                cout << "无效的目标，请选择一个存活的敌人！" << endl;
            }
        } while (targetIndex < 0 || targetIndex >= enemyTeam.size() || !enemyTeam[targetIndex].isAlive());

        playerTeam[charIndex].basicAttack(enemyTeam[targetIndex]);
    }
    else if (action == 2) {
        // 技能攻击
        int targetIndex;
        do {
            cout << "选择技能目标 (1-" << enemyTeam.size() << "): ";
            cin >> targetIndex;
            targetIndex--; // 转换为0-based索引

            if (targetIndex < 0 || targetIndex >= enemyTeam.size() || !enemyTeam[targetIndex].isAlive()) {
                cout << "无效的目标，请选择一个存活的敌人！" << endl;
            }
        } while (targetIndex < 0 || targetIndex >= enemyTeam.size() || !enemyTeam[targetIndex].isAlive());

        playerTeam[charIndex].skillAttack(enemyTeam[targetIndex]);
    }
    else if (action == 3) {
        // 恢复HP
        playerTeam[charIndex].heal(30);
    }
    else if (action == 4) {
        // 释放大招
        playerTeam[charIndex].ultimateSkill(enemyTeam);
    }
}

// 敌人回合
void enemyTurn() {
    setColor(12); // 红色
    cout << endl << "----- 敌人的回合 -----" << endl;
    setColor(7); // 恢复白色

    // 每个敌人行动
    for (auto& enemy : enemyTeam) {
        if (enemy.isAlive()) {
            // 选择一个随机的存活玩家作为目标
            vector<int> alivePlayers;
            for (int i = 0; i < playerTeam.size(); i++) {
                if (playerTeam[i].isAlive()) {
                    alivePlayers.push_back(i);
                }
            }

            if (!alivePlayers.empty()) {
                srand(time(0));
                int targetIndex = alivePlayers[rand() % alivePlayers.size()];

                // 敌人有一定概率使用技能
                int actionChance = rand() % 100;
                if (actionChance < 30) { // 30%概率使用技能
                    enemy.skillAttack(playerTeam[targetIndex]);
                }
                else { // 70%概率普通攻击
                    enemy.basicAttack(playerTeam[targetIndex]);
                }
                Sleep(1000);
            }
        }
    }
}

};

int main() {
// 设置控制台标题
SetConsoleTitleA("崩坏：星穹铁道 - C++控制**");

// 初始化随机数生成器
srand(time(0));

// 初始化并运行游戏
HonkaiGame game;
game.mainMenu();

return 0;

}