别喷

@洛奇亚玩了你做的，挺好玩，也做了一篇
此帖全为AI所做，没有炫耀，张扬的意思，纯属好玩而已，轻点喷

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>
using namespace std;

enum Type {
    NORMAL, FIRE, WATER, GRASS, ELECTRIC,
    ICE, MARTIAL, POISON, EARTH, WING,
    CUTE, BUG, GHOST, DEMON,
    DRAGON, MECHANICAL, LIGHT, ILLUSION
};

// 天气枚举（避免与 Type::NORMAL 冲突）
enum Weather { SUNNY, RAIN, CLEAR };
Weather currentWeather = CLEAR;
int weatherTurns = 0;   // 剩余回合数，0表示无天气

string typeName(Type t) {
    switch(t) {
        case NORMAL: return "普通"; case FIRE: return "火"; case WATER: return "水";
        case GRASS: return "草"; case ELECTRIC: return "电"; case ICE: return "冰";
        case MARTIAL: return "武"; case POISON: return "毒"; case EARTH: return "地";
        case WING: return "翼"; case CUTE: return "萌"; case BUG: return "虫";
        case GHOST: return "幽"; case DEMON: return "恶";
        case DRAGON: return "龙"; case MECHANICAL: return "机械"; case LIGHT: return "光";
        case ILLUSION: return "幻"; default: return "未知";
    }
}

double getEffectiveness(Type atk, Type def) {
    if (atk == FIRE) {
        if (def == GRASS || def == BUG || def == ICE || def == MECHANICAL) return 2.0;
        if (def == FIRE || def == WATER || def == DRAGON) return 0.5;
    }
    if (atk == WATER) {
        if (def == FIRE || def == EARTH) return 2.0;
        if (def == WATER || def == GRASS || def == DRAGON) return 0.5;
    }
    if (atk == GRASS) {
        if (def == WATER || def == EARTH) return 2.0;
        if (def == FIRE || def == GRASS || def == POISON || def == WING || def == BUG || def == DRAGON || def == MECHANICAL) return 0.5;
    }
    if (atk == ELECTRIC) {
        if (def == WATER || def == WING) return 2.0;
        if (def == ELECTRIC || def == GRASS || def == DRAGON) return 0.5;
        if (def == EARTH) return 0.0;
    }
    if (atk == ICE) {
        if (def == GRASS || def == EARTH || def == WING || def == DRAGON) return 2.0;
        if (def == FIRE || def == WATER || def == ICE || def == MECHANICAL) return 0.5;
    }
    if (atk == MARTIAL) {
        if (def == NORMAL || def == ICE || def == DEMON || def == MECHANICAL) return 2.0;
        if (def == POISON || def == WING || def == CUTE || def == BUG || def == LIGHT) return 0.5;
        if (def == GHOST) return 0.0;
    }
    if (atk == POISON) {
        if (def == GRASS || def == CUTE || def == LIGHT) return 2.0;
        if (def == POISON || def == EARTH || def == GHOST || def == MECHANICAL) return 0.5;
    }
    if (atk == EARTH) {
        if (def == FIRE || def == ELECTRIC || def == POISON || def == MECHANICAL) return 2.0;
        if (def == GRASS || def == BUG) return 0.5;
        if (def == WING) return 0.0;
    }
    if (atk == WING) {
        if (def == GRASS || def == MARTIAL || def == BUG) return 2.0;
        if (def == ELECTRIC || def == MECHANICAL) return 0.5;
    }
    if (atk == CUTE) {
        if (def == MARTIAL || def == DEMON || def == DRAGON) return 2.0;
        if (def == POISON || def == MECHANICAL || def == LIGHT) return 0.5;
    }
    if (atk == BUG) {
        if (def == GRASS || def == CUTE || def == DEMON) return 2.0;
        if (def == FIRE || def == MARTIAL || def == POISON || def == WING || def == GHOST || def == MECHANICAL || def == LIGHT) return 0.5;
    }
    if (atk == GHOST) {
        if (def == CUTE || def == GHOST || def == LIGHT) return 2.0;
        if (def == DEMON || def == MECHANICAL) return 0.5;
        if (def == NORMAL) return 0.0;
    }
    if (atk == DEMON) {
        if (def == CUTE || def == GHOST || def == LIGHT) return 2.0;
        if (def == MARTIAL || def == DEMON || def == MECHANICAL) return 0.5;
    }
    if (atk == DRAGON) {
        if (def == DRAGON) return 2.0;
        if (def == MECHANICAL || def == LIGHT) return 0.5;
        if (def == CUTE) return 0.0;
    }
    if (atk == MECHANICAL) {
        if (def == ICE || def == CUTE || def == LIGHT) return 2.0;
        if (def == FIRE || def == WATER || def == ELECTRIC || def == MECHANICAL || def == DRAGON) return 0.5;
    }
    if (atk == LIGHT) {
        if (def == GHOST || def == DEMON || def == MECHANICAL) return 2.0;
        if (def == LIGHT || def == ILLUSION) return 0.5;
    }
    if (atk == ILLUSION) {
        if (def == MARTIAL || def == POISON || def == DEMON) return 2.0;
        if (def == ILLUSION || def == LIGHT) return 0.5;
    }
    return 1.0;
}

double calcTotalEffect(Type atk, Type def1, Type def2) {
    double e1 = getEffectiveness(atk, def1);
    if (def2 == def1) return e1;
    return e1 * getEffectiveness(atk, def2);
}

enum SkillCat { PHYSICAL, MAGICAL, STATUS };

struct Skill {
    string name;
    Type type;
    int power;
    int cost;
    SkillCat cat;
    Skill() : name(""), type(NORMAL), power(0), cost(0), cat(STATUS) {}
    Skill(string n, Type t, int p, int c, SkillCat ca) : name(n), type(t), power(p), cost(c), cat(ca) {}
};

struct Pet {
    string name;
    Type type1, type2;
    int maxHp, hp;
    int atk, matk, def, mdef, speed;
    string passive;
    Skill skill[4];
    bool isActive, isFainted;
    int atkStage, matkStage, defStage, mdefStage, spdStage;
    int energy;
    int maxEnergy;
    int doujiStacks;

    // 新增成员
    double damageReduction;
    int chuiHuoBonus;
    int fireSkillCount;

    Pet() : name(""), type1(NORMAL), type2(NORMAL), maxHp(0), hp(0),
            atk(0), matk(0), def(0), mdef(0), speed(0),
            passive(""), isActive(false), isFainted(false),
            atkStage(0), matkStage(0), defStage(0), mdefStage(0), spdStage(0),
            energy(0), maxEnergy(5), doujiStacks(0),
            damageReduction(0.0), chuiHuoBonus(0), fireSkillCount(0) {
        for (int i = 0; i < 4; i++) skill[i] = Skill();
    }

    Pet(string n, Type t1, Type t2, int mH, int a, int ma, int d, int md, int s, string ab,
        Skill s1, Skill s2, Skill s3, Skill s4) :
        name(n), type1(t1), type2(t2), maxHp(mH), hp(mH),
        atk(a), matk(ma), def(d), mdef(md), speed(s),
        passive(ab), isActive(false), isFainted(false),
        atkStage(0), matkStage(0), defStage(0), mdefStage(0), spdStage(0),
        energy(3), maxEnergy(5), doujiStacks(0),
        damageReduction(0.0), chuiHuoBonus(0), fireSkillCount(0) {
        skill[0]=s1; skill[1]=s2; skill[2]=s3; skill[3]=s4;
    }
};

double stageMultiplier(int stage) {
    if (stage >= 0) return (2.0 + stage) / 2.0;
    return 2.0 / (2.0 - stage);
}

void gainEnergy(Pet& p, int amount) {
    p.energy = min(p.maxEnergy, p.energy + amount);
}

bool consumeEnergy(Pet& p, int cost) {
    if (p.energy >= cost) {
        p.energy -= cost;
        return true;
    }
    return false;
}

double passiveAtkModifier(Pet& user, Pet& target, const Skill& s, bool userFirst) {
    double mod = 1.0;
    if (user.passive == "顺风" && userFirst && s.power > 0) mod *= 1.5;
    if (user.passive == "斗技" && s.power > 0 && user.doujiStacks > 0) {
        mod *= (1.0 + user.doujiStacks * 0.3);
    }
    return mod;
}

void passiveAfterAttack(Pet& user, Pet& target, Skill& s, double eff) {
    if (user.passive == "最好的伙伴" && eff >= 2.0) {
        user.atkStage = min(6, user.atkStage + 1);
        user.defStage = min(6, user.defStage + 1);
        user.spdStage = min(6, user.spdStage + 1);
        cout << "  ★【最好的伙伴】发动！攻防速提升！" << endl;
    }
    if (user.passive == "助燃" && s.type == FIRE && s.power > 0) {
        user.atkStage = min(6, user.atkStage + 1);
        user.matkStage = min(6, user.matkStage + 1);
        cout << "  ★【助燃】发动！双攻提升！" << endl;
    }
    if (user.passive == "氧循环" && s.type == GRASS && s.power > 0) {
        int heal = user.maxHp / 10;
        user.hp = min(user.maxHp, user.hp + heal);
        cout << "  ★【氧循环】发动！回复" << heal << "HP！" << endl;
    }
    if (user.passive == "浸润" && s.type == WATER && s.power > 0) {
        user.matkStage = min(6, user.matkStage + 1);
        cout << "  ★【浸润】发动！魔攻提升！" << endl;
    }
}

void passiveOnSwitchIn(Pet& user, Pet& opponent) {
    if (user.passive == "快锤") {
        cout << "  ★【快锤】发动！低费技能准备就绪！" << endl;
        gainEnergy(user, 2);
    }
    if (user.passive == "捉迷藏") {
        opponent.energy = max(0, opponent.energy - 1);
        cout << "  ★【捉迷藏】发动！对手能耗增加！" << endl;
    }
}

int calculateDamage(Pet& attacker, const Skill& s, Pet& defender, bool attackerFirst) {
    if (s.power == 0) return 0;
    double eff = calcTotalEffect(s.type, defender.type1, defender.type2);
    if (eff == 0.0) return 0;

    int atkStat = (s.cat == PHYSICAL) ? attacker.atk : attacker.matk;
    int defStat = (s.cat == PHYSICAL) ? defender.def : defender.mdef;
    int atkStg = (s.cat == PHYSICAL) ? attacker.atkStage : attacker.matkStage;
    int defStg = (s.cat == PHYSICAL) ? defender.defStage : defender.mdefStage;

    atkStat = (int)(atkStat * stageMultiplier(atkStg));
    defStat = (int)(defStat * stageMultiplier(defStg));
    if (defStat <= 0) defStat = 1;

    double stab = 1.0;
    if (s.type == attacker.type1 || s.type == attacker.type2) stab = 1.5;

    double passiveMod = passiveAtkModifier(attacker, defender, s, attackerFirst);
    // 【方法一】伤害系数从2.0改为1.5
    double damage = (s.power * 1.5) * ((double)atkStat / (defStat + 50)) * eff * stab * passiveMod;

    // 防御方减伤
    if (defender.damageReduction > 0) {
        damage *= (1 - defender.damageReduction);
        cout << "  ★ 减伤" << (int)(defender.damageReduction * 100) << "%生效！" << endl;
        defender.damageReduction = 0.0;
    }

    // 天气：下雨，水系伤害翻倍
    if (currentWeather == RAIN && s.type == WATER) {
        damage *= 2.0;
        cout << "  ★ 下雨天气：水系伤害翻倍！" << endl;
    }

    return max(1, (int)damage);
}

void printHp(Pet &p) {
    string f = p.isFainted ? " [阵亡]" : "";
    cout << "[" << p.name << "] HP:" << p.hp << "/" << p.maxHp
         << " 能量:" << p.energy << "/" << p.maxEnergy
         << " " << typeName(p.type1);
    if (p.type2 != p.type1) cout << "+" << typeName(p.type2);
    cout << " 特性:" << p.passive << f << endl;
}

void printTeam(vector<Pet>& team) {
    cout << "=== 队伍 ===" << endl;
    for (int i = 0; i < 3; i++) { cout << "  "; printHp(team[i]); }
    cout << "============" << endl;
}

int attack(Pet &user, Skill &s, Pet &target, bool userFirst) {
    // 特殊技能：闪燃
    if (s.name == "闪燃") {
        if (!consumeEnergy(user, s.cost)) {
            cout << "\n" << user.name << " 能量不足，无法使用【" << s.name << "】！" << endl;
            cout << " → 本回合蓄力，恢复5点能量。" << endl;
            gainEnergy(user, 5);
            return 0;
        }
        cout << "\n" << user.name << " 使用了【" << s.name << "】(" << typeName(s.type)
             << " 能耗:" << s.cost << ")" << endl;
        int baseDmg = 40;
        bool hasBuff = (target.atkStage > 0 || target.matkStage > 0 || target.spdStage > 0);
        if (hasBuff) baseDmg *= 5;
        target.hp -= baseDmg;
        if (target.hp < 0) target.hp = 0;
        cout << " → 闪燃！造成 " << baseDmg << " 点伤害" 
             << (hasBuff ? "（应对状态，伤害×5）" : "") << endl;
        gainEnergy(user, 1);
        if (s.type == FIRE) user.fireSkillCount++;
        return baseDmg;
    }

    if (!consumeEnergy(user, s.cost)) {
        cout << "\n" << user.name << " 能量不足，无法使用【" << s.name << "】！" << endl;
        cout << " → 本回合蓄力，恢复5点能量。" << endl;
        gainEnergy(user, 5);
        return 0;
    }

    Skill usedSkill = s;
    cout << "\n" << user.name << " 使用了【" << s.name << "】(" << typeName(s.type)
         << " 威力:" << s.power << " 能耗:" << s.cost << ")" << endl;

    if (s.power > 0) {
        if (s.name == "吹火") {
            usedSkill.power += user.chuiHuoBonus;
            cout << "  ★ 吹火累计加成+" << user.chuiHuoBonus << "，当前威力" << usedSkill.power << endl;
        }
        if (s.name == "山火") {
            usedSkill.power += user.fireSkillCount * 30;
            cout << "  ★ 山火火系计数加成+" << (user.fireSkillCount * 30) << "，当前威力" << usedSkill.power << endl;
        }
        int dmg = calculateDamage(user, usedSkill, target, userFirst);
        if (dmg == 0) { cout << " → 无效！" << endl; gainEnergy(user, 1); return 0; }
        double eff = calcTotalEffect(usedSkill.type, target.type1, target.type2);
        if (eff >= 2.0) cout << " → 克制！";
        else if (eff > 0 && eff <= 0.5) cout << " → 抵抗…";
        cout << endl;
        cout << " → 对【" << target.name << "】造成 " << dmg << " 点伤害！" << endl;
        target.hp -= dmg;
        if (target.hp < 0) target.hp = 0;
        passiveAfterAttack(user, target, s, eff);
        gainEnergy(user, 1);

        if (s.type == FIRE) user.fireSkillCount++;
        if (s.name == "吹火") {
            user.chuiHuoBonus += 20;
            cout << "  ★ 吹火威力永久+20，当前加成" << user.chuiHuoBonus << endl;
        }
        return dmg;
    }

    // ========== 变化技能 ==========
    if (s.name == "魔法增效" || s.name == "力量增效") {
        if (s.name == "力量增效") user.atkStage = min(6, user.atkStage + 2);
        else user.matkStage = min(6, user.matkStage + 2);
        cout << " → 攻击大幅提升！" << endl;
    } else if (s.name == "催眠粉") {
        cout << " → 尝试催眠！（简化）" << endl;
    } else if (s.name == "寄生种子") {
        cout << " → 种下种子！（简化）" << endl;
    } else if (s.name == "火焰护罩") {
        user.defStage = min(6, user.defStage + 1);
        user.mdefStage = min(6, user.mdefStage + 1);
        cout << " → 双防提升！" << endl;
    } else if (s.name == "雨之力") {
        user.matkStage = min(6, user.matkStage + 1);
        cout << " → 魔攻提升！" << endl;
    } else if (s.name == "乘风") {
        user.spdStage = min(6, user.spdStage + 2);
        cout << " → 速度大幅提升！" << endl;
    } else if (s.name == "扇风") {
        cout << " → 先发制人！" << endl;
    } else if (s.name == "有效预防") {
        user.defStage = min(6, user.defStage + 1);
        user.mdefStage = min(6, user.mdefStage + 1);
        cout << " → 全防提升！" << endl;
    } else if (s.name == "水弹枪") {
        cout << " → 水系干扰！" << endl;
    } else if (s.name == "取念") {
        cout << " → 偷取对手技能！（简化）" << endl;
    } else if (s.name == "晒太阳") {
        target.atkStage = max(-6, target.atkStage - 2);
        target.matkStage = max(-6, target.matkStage - 2);
        cout << " → 清除敌方强化！" << endl;
    } else if (s.name == "恶意逃离") {
        cout << " → 强制对手卡能量！（简化）" << endl;
    } else if (s.name == "虚假破产") {
        user.defStage = min(6, user.defStage + 2);
        cout << " → 高额减伤站场！" << endl;
    } else if (s.name == "聒噪") {
        cout << " → 大幅增加敌方能耗！（简化）" << endl;
    } else if (s.name == "超级糖果") {
        int dmg = calculateDamage(user, Skill("超级糖果", CUTE, 90, 3, MAGICAL), target, userFirst);
        cout << " → 萌系高额输出！造成 " << dmg << " 点伤害！" << endl;
        target.hp -= dmg;
        if (target.hp < 0) target.hp = 0;
        return dmg;
    } else if (s.name == "生日蛋糕") {
        user.matkStage = min(6, user.matkStage + 2);
        user.atkStage = min(6, user.atkStage + 1);
        cout << " → 自身增益翻倍！" << endl;
    } else if (s.name == "精神波动") {
        int dmg = calculateDamage(user, Skill("精神波动", CUTE, 70, 2, MAGICAL), target, userFirst);
        cout << " → 造成 " << dmg << " 点伤害！" << endl;
        target.hp -= dmg;
        if (target.hp < 0) target.hp = 0;
        return dmg;
    } else if (s.name == "防御") {
        user.damageReduction = 0.7;
        user.defStage = min(6, user.defStage + 1);
        cout << " → 进入防御姿态，物理减伤70%！" << endl;
        if (user.passive == "斗技") {
            user.doujiStacks++;
            cout << "  ★【斗技】叠层！当前" << user.doujiStacks << "层！" << endl;
        }
    } else if (s.name == "快速移动") {
        user.spdStage = min(6, user.spdStage + 1);
        cout << " → 速度提升！" << endl;
    } else if (s.name == "冬至") {
        cout << " → 挂上冰冻控场！（简化）" << endl;
    } else if (s.name == "暴风雪") {
        int dmg = calculateDamage(user, Skill("暴风雪", ICE, 110, 4, MAGICAL), target, userFirst);
        cout << " → 冰系高伤！造成 " << dmg << " 点伤害！" << endl;
        target.hp -= dmg;
        if (target.hp < 0) target.hp = 0;
        return dmg;
    } else if (s.name == "冰墙") {
        user.defStage = min(6, user.defStage + 2);
        user.mdefStage = min(6, user.mdefStage + 1);
        cout << " → 冰墙减伤站场！" << endl;
    } else if (s.name == "赤子之心") {
        cout << " → 全技能能耗-3！（简化）" << endl;
    } else if (s.name == "霜天") {
        cout << " → 高频冰冻控场！（简化）" << endl;
    } else if (s.name == "列王守护") {
        int heal = user.maxHp / 3;
        user.hp = min(user.maxHp, user.hp + heal);
        user.defStage = min(6, user.defStage + 1);
        cout << " → 回复" << heal << "HP并提升物防！" << endl;
    } else if (s.name == "纤维化") {
        user.defStage = min(6, user.defStage + 2);
        cout << " → 物防大幅提升！" << endl;
    } else if (s.name == "酶浓度调整") {
        user.damageReduction = 0.8;
        int heal = user.maxHp / 10;
        user.hp = min(user.maxHp, user.hp + heal);
        user.energy = min(user.maxEnergy, user.energy + 6);
        cout << " → 酶浓度调整！减伤80%，回复" << heal << "HP，能量+6" << endl;
    } else if (s.name == "水泡盾") {
        user.defStage = min(6, user.defStage + 2);
        user.mdefStage = min(6, user.mdefStage + 2);
        cout << " → 双防大幅提升！" << endl;
    } else if (s.name == "求雨") {
        currentWeather = RAIN;
        weatherTurns = 5;   // 持续5回合
        cout << " → 天气变为【下雨】！持续5回合，水系技能伤害翻倍！" << endl;
    } else if (s.name == "浸润") {
        gainEnergy(user, 1);
        cout << " → 能量回复1点！" << endl;
    } else {
        cout << " → 使用了变化技能！" << endl;
    }
    gainEnergy(user, 1);
    return 0;
}

void showSkills(Pet &p) {
    cout << "\n可用技能（能量:" << p.energy << "/" << p.maxEnergy << "）：" << endl;
    for (int i = 0; i < 4; i++) {
        string c = (p.skill[i].cat == PHYSICAL) ? "物" : (p.skill[i].cat == MAGICAL ? "魔" : "变");
        cout << i+1 << ". " << p.skill[i].name << " [" << typeName(p.skill[i].type) << "/" << c
             << "] 威力:" << p.skill[i].power << " 能耗:" << p.skill[i].cost << endl;
    }
}

int chooseSkill(Pet &p) {
    showSkills(p);
    int c; cout << "\n选择技能(1-4)："; cin >> c;
    while (c < 1 || c > 4) cin >> c;
    return c - 1;
}

bool playerFaster(Pet& a, Pet& b) {
    int sa = (int)(a.speed * stageMultiplier(a.spdStage));
    int sb = (int)(b.speed * stageMultiplier(b.spdStage));
    if (sa != sb) return sa > sb;
    return rand() % 2 == 0;
}

bool allFainted(vector<Pet>& t) { for (auto& p : t) if (!p.isFainted) return false; return true; }
int getActiveIndex(vector<Pet>& t) { for (int i=0;i<3;i++) if (t[i].isActive && !t[i].isFainted) return i; return -1; }

int selectPet(vector<Pet>& team) {
    cout << "\n请选择出战的宠物：\n";
    vector<int> alive;
    for (int i=0;i<3;i++) if (!team[i].isFainted) {
        cout << i+1 << ". " << team[i].name << " HP:" << team[i].hp << "/" << team[i].maxHp
             << " 能量:" << team[i].energy << "/" << team[i].maxEnergy << "\n";
        alive.push_back(i);
    }
    if (alive.empty()) return -1;
    int c; do { cout << "输入序号: "; cin >> c; } while (c<1 || c>(int)alive.size());
    int idx = alive[c-1];
    for (int i=0;i<3;i++) team[i].isActive = false;
    team[idx].isActive = true;
    return idx;
}

// ==================== 精灵定义 ====================

void Dimo(Pet &p) {
    p = Pet("迪莫", LIGHT, LIGHT, 240, 80, 80, 105, 105, 92, "最好的伙伴",
        Skill("光球", LIGHT, 80, 2, MAGICAL),
        Skill("冰爪", ICE, 80, 2, PHYSICAL),
        Skill("火焰箭", FIRE, 80, 2, PHYSICAL),
        Skill("超导", ELECTRIC, 80, 3, MAGICAL));
}

void Miaomiao(Pet &p) {
    p = Pet("喵喵", GRASS, GRASS, 130, 66, 66, 49, 91, 33, "氧循环",
        Skill("光能聚集", GRASS, 120, 7, MAGICAL),
        Skill("棘突", GRASS, 70, 3, PHYSICAL),
        Skill("纤维化", NORMAL, 0, 2, STATUS),
        Skill("酶浓度调整", NORMAL, 0, 2, STATUS));
}

void Molimao(Pet &p) {
    p = Pet("魔力猫", GRASS, GRASS, 216, 109, 109, 81, 151, 55, "氧循环",
        Skill("光能聚集", GRASS, 120, 4, MAGICAL),
        Skill("棘突", GRASS, 70, 3, PHYSICAL),
        Skill("纤维化", NORMAL, 0, 2, STATUS),
        Skill("酶浓度调整", NORMAL, 0, 2, STATUS));
}

void Huohua(Pet &p) {
    p = Pet("火花", FIRE, FIRE, 130, 70, 40, 50, 45, 65, "助燃",
        Skill("火苗", FIRE, 40, 0, MAGICAL),
        Skill("力量增效", NORMAL, 0, 1, STATUS),
        Skill("流星火雨", FIRE, 100, 3, MAGICAL),
        Skill("防御", NORMAL, 0, 1, STATUS));
}

void Huoshen(Pet &p) {
    p = Pet("火神", FIRE, FIRE, 210, 110, 70, 80, 75, 90, "助燃",
        Skill("吹火", FIRE, 50, 1, MAGICAL),
        Skill("山火", FIRE, 80, 2, MAGICAL),
        Skill("火云车", FIRE, 90, 5, PHYSICAL),
        Skill("闪燃", FIRE, 0, 1, STATUS));
}

void Shuiling(Pet &p) {
    p = Pet("水灵", WATER, WATER, 130, 48, 55, 40, 50, 60, "浸润",
        Skill("水泡盾", WATER, 0, 2, STATUS),
        Skill("天洪", WATER, 110, 7, MAGICAL),
        Skill("浸润", WATER, 0, 0, STATUS),
        Skill("求雨", WATER, 0, 5, STATUS));
}

void Lanniao(Pet &p) {
    p = Pet("岚鸟", WING, WING, 240, 110, 70, 45, 80, 115, "顺风",
        Skill("乘风", WING, 0, 2, STATUS),
        Skill("力量增效", NORMAL, 0, 3, STATUS),
        Skill("扇风", WING, 40, 1, PHYSICAL),
        Skill("闪击", WING, 0, 4, STATUS));
}

void Chuitouguan(Pet &p) {
    p = Pet("锤头鹳", WING, WATER, 220, 60, 100, 70, 85, 90, "快锤",
        Skill("水弹枪", WATER, 40, 2, MAGICAL),
        Skill("取念", NORMAL, 0, 2, STATUS),
        Skill("晒太阳", NORMAL, 0, 3, STATUS),
        Skill("恶意逃离", NORMAL, 0, 2, STATUS));
}

void Mengwang(Pet &p) {
    p = Pet("萌王", CUTE, CUTE, 255, 60, 130, 55, 90, 80, "萌幻之心",
        Skill("超级糖果", CUTE, 90, 3, MAGICAL),
        Skill("生日蛋糕", CUTE, 0, 3, STATUS),
        Skill("精神波动", CUTE, 70, 2, MAGICAL),
        Skill("防御", NORMAL, 0, 1, STATUS));
}

void KeliJi(Pet &p) {
    p = Pet("可立鸡", FIRE, FIRE, 200, 90, 40, 50, 45, 75, "斗技",
        Skill("力量增效", NORMAL, 0, 3, STATUS),
        Skill("烈焰冲击", FIRE, 80, 3, PHYSICAL),
        Skill("啄击", WING, 40, 1, PHYSICAL),
        Skill("防御", NORMAL, 0, 1, STATUS));
}

void XueyingWawa(Pet &p) {
    p = Pet("雪影娃娃", ICE, CUTE, 230, 80, 110, 45, 80, 95, "捉迷藏",
        Skill("超级糖果", CUTE, 90, 3, MAGICAL),
        Skill("暴风雪", ICE, 110, 4, MAGICAL),
        Skill("冰墙", ICE, 0, 2, STATUS),
        Skill("冬至", ICE, 0, 2, STATUS));
}

void ShengguangDimo(Pet &p) {
    p = Pet("圣光迪莫", LIGHT, LIGHT, 270, 90, 95, 110, 115, 98, "光之守护",
        Skill("光球", LIGHT, 60, 2, MAGICAL),
        Skill("冰爪", ICE, 70, 3, PHYSICAL),
        Skill("火焰箭", FIRE, 80, 3, PHYSICAL),
        Skill("超导", ELECTRIC, 80, 3, MAGICAL));
}

void WudouKumao(Pet &p) {
    p = Pet("武斗酷猫", GRASS, MARTIAL, 250, 115, 85, 90, 85, 85, "斗士",
        Skill("光能聚集", GRASS, 120, 4, MAGICAL),
        Skill("棘突", GRASS, 70, 3, PHYSICAL),
        Skill("纤维化", NORMAL, 0, 2, STATUS),
        Skill("酶浓度调整", NORMAL, 0, 2, STATUS));
}

Pet getPetByID(int id) {
    Pet p;
    switch(id) {
        case 1: Dimo(p); break;
        case 2: Miaomiao(p); break;
        case 3: Molimao(p); break;
        case 4: Huohua(p); break;
        case 5: Huoshen(p); break;
        case 6: Shuiling(p); break;
        case 7: Lanniao(p); break;
        case 8: Chuitouguan(p); break;
        case 9: Mengwang(p); break;
        case 10: KeliJi(p); break;
        case 11: XueyingWawa(p); break;
        case 12: ShengguangDimo(p); break;
        case 13: WudouKumao(p); break;
        default: Dimo(p);
    }
    return p;
}

vector<int> playerFinalForms = {1, 3, 5, 6, 7, 8, 9, 10, 11};
vector<int> allFinalForms = {1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13};

vector<Pet> playerSelectTeam() {
    vector<Pet> team(3);
    cout << "\n===== 选择3只宠物 (输入ID) =====\n";
    cout << "1迪莫 3魔力猫 5火神 6水灵\n";
    cout << "7岚鸟 8锤头鹳 9萌王 10可立鸡 11雪影娃娃\n";
    cout << "（首领：12圣光迪莫、13武斗酷猫不可选）\n";
    cout << "==================================\n";
    int a,b,c; cin >> a >> b >> c;
    team[0] = getPetByID(a); team[1] = getPetByID(b); team[2] = getPetByID(c);
    team[0].isActive = true;
    return team;
}

vector<Pet> randomEnemyTeam() {
    vector<Pet> team(3);
    for (int i=0;i<3;i++) {
        int id = allFinalForms[rand() % allFinalForms.size()];
        team[i] = getPetByID(id);
    }
    team[0].isActive = true;
    return team;
}

int main() {
    srand((unsigned)time(NULL));
    currentWeather = CLEAR;
    weatherTurns = 0;
    cout << "===============================\n";
    cout << " 洛克王国手游对战·聚能版 v5.0 \n";
    cout << "===============================\n";

    vector<Pet> player = playerSelectTeam();
    vector<Pet> enemy = randomEnemyTeam();

    cout << "\n对手阵容：【";
    for (int i=0;i<3;i++) { cout << enemy[i].name; if(i<2) cout << ", "; }
    cout << "】\n";

    int pi0 = getActiveIndex(player), ei0 = getActiveIndex(enemy);
    passiveOnSwitchIn(player[pi0], enemy[ei0]);
    passiveOnSwitchIn(enemy[ei0], player[pi0]);

    while (true) {
        if (allFainted(player)) { cout << "\n挑战失败！\n"; break; }
        if (allFainted(enemy)) { cout << "\n挑战成功！\n"; break; }

        int pi = getActiveIndex(player), ei = getActiveIndex(enemy);
        if (player[pi].hp <= 0) {
            player[pi].isFainted = true; player[pi].isActive = false;
            cout << "\n【" << player[pi].name << "】阵亡！\n";
            if (allFainted(player)) { cout << "挑战失败！\n"; break; }
            int newIdx = selectPet(player);
            pi = getActiveIndex(player);
            ei = getActiveIndex(enemy);
            passiveOnSwitchIn(player[pi], enemy[ei]);
        }
        if (enemy[ei].hp <= 0) {
            enemy[ei].isFainted = true; enemy[ei].isActive = false;
            cout << "\n【" << enemy[ei].name << "】阵亡！\n";
            if (allFainted(enemy)) { cout << "挑战成功！\n"; break; }
            for (int i=0;i<3;i++) if (!enemy[i].isFainted) {
                for (int j=0;j<3;j++) enemy[j].isActive=false;
                enemy[i].isActive=true; ei=i;
                cout << "对手换上【" << enemy[i].name << "】！\n";
                pi = getActiveIndex(player);
                passiveOnSwitchIn(enemy[ei], player[pi]);
                break;
            }
        }
        pi = getActiveIndex(player); ei = getActiveIndex(enemy);
        if (pi==-1||ei==-1) break;

        cout << "\n========================================\n";
        printTeam(player); printTeam(enemy);

        int sk = chooseSkill(player[pi]);
        bool pFast = playerFaster(player[pi], enemy[ei]);
        if (pFast) {
            int d = attack(player[pi], player[pi].skill[sk], enemy[ei], true);
            if (enemy[ei].hp <= 0) { enemy[ei].hp = 0; continue; }
            cout << "\n--- 敌方回合 ---\n";
            int esk=rand()%4;
            int ed = attack(enemy[ei], enemy[ei].skill[esk], player[pi], false);
            player[pi].hp -= ed;
        } else {
            cout << "--- 敌方先手 ---\n";
            int esk=rand()%4;
            int ed = attack(enemy[ei], enemy[ei].skill[esk], player[pi], false);
            player[pi].hp -= ed;
            if (player[pi].hp<=0) { player[pi].hp=0; continue; }
            cout << "\n========================================\n";
            int d = attack(player[pi], player[pi].skill[sk], enemy[ei], true);
            enemy[ei].hp -= d;
        }

        // ===== 回合结束，更新天气 =====
        if (currentWeather != CLEAR) {
            weatherTurns--;
            if (weatherTurns <= 0) {
                currentWeather = CLEAR;
                cout << "\n★ 天气恢复晴朗。\n";
            } else {
                cout << "\n★ 下雨天气剩余 " << weatherTurns << " 回合。\n";
            }
        }
    }
    cout << "\n对战结束，感谢游玩洛克王国手游！\n";
    return 0;
}