C++实现魔兽世界大作业

魔兽世界大作业是一道经典的C++编程作业，需要实现一个模拟魔兽世界的程序。下面是一个简单的实现思路，供你参考：

1.定义士兵类Warrior和司令部类Headquarters，其中士兵类包括基本属性（生命值、攻击力等）和行为（前进、攻击等），司令部类包括基本属性（生命元、制造士兵序列等）和行为（制造士兵、报告士兵情况等）。

2.定义游戏类Warcraft，包括基本属性（游戏时间、总生命元等）和行为（游戏初始化、执行游戏流程等）。

3.在游戏初始化中，读取输入数据，包括每个司令部的初始生命元数、制造士兵的顺序等。

4.在执行游戏流程中，按照时间顺序执行每个司令部的行为，包括制造士兵、前进、攻击等。

5.在游戏结束后，输出游戏结果，包括每个司令部剩余的生命元数、制造的士兵数量等。

你可以参考以下代码实现魔兽世界大作业：

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

const int MAX_TIME = 1000;
const int MAX_CITY_NUM = 20;
const int MAX_WARRIOR_NUM = 5;

enum Color { RED, BLUE };
enum WarriorType { DRAGON, NINJA, ICEMAN, LION, WOLF };
enum WeaponType { SWORD, BOMB, ARROW };

const string COLOR_NAME[2] = {"red", "blue"};
const string WARRIOR_NAME[5] = {"dragon", "ninja", "iceman", "lion", "wolf"};
const string WEAPON_NAME[3] = {"sword", "bomb", "arrow"};

int M, N, R, K, T;
int warriorInitialLife[MAX_WARRIOR_NUM];
int warriorInitialAttack[MAX_WARRIOR_NUM];
int cityInitialLife[MAX_CITY_NUM];

class Weapon {
public:
    Weapon(WeaponType weaponType, int attackValue): m_weaponType(weaponType), m_attackValue(attackValue) {}
    WeaponType getType() const { return m_weaponType; }
    int getAttackValue() const { return m_attackValue; }
private:
    WeaponType m_weaponType;
    int m_attackValue;
};

class Warrior {
public:
    Warrior(int id, Color color, WarriorType warriorType, int lifeValue, int attackValue):
        m_id(id), m_color(color), m_warriorType(warriorType), m_lifeValue(lifeValue), m_attackValue(attackValue), m_weapon(NULL) {}
    virtual ~Warrior() {}
    int getId() const { return m_id; }
    Color getColor() const { return m_color; }
    WarriorType getWarriorType() const { return m_warriorType; }
    int getLifeValue() const { return m_lifeValue; }
    int getAttackValue() const { return m_attackValue; }
    void setLifeValue(int lifeValue) { m_lifeValue = lifeValue; }
    void setAttackValue(int attackValue) { m_attackValue = attackValue; }
    void setWeapon(Weapon* weapon) { m_weapon = weapon; }
    Weapon* getWeapon() const { return m_weapon; }
private:
    int m_id;
    Color m_color;
    WarriorType m_warriorType;
    int m_lifeValue;
    int m_attackValue;
    Weapon* m_weapon;
};

class Dragon: public Warrior {
public:
    Dragon(int id, Color color, int lifeValue, int attackValue, Weapon* weapon):
        Warrior(id, color, DRAGON, lifeValue, attackValue) {
        setWeapon(weapon);
    }
    virtual ~Dragon() {}
    virtual void yell() const {
        cout << "Dragon " << getId() << " yelled in city " << getId() << endl;
    }
};

class Ninja: public Warrior {
public:
    Ninja(int id, Color color, int lifeValue, int attackValue, Weapon* weapon1, Weapon* weapon2):
        Warrior(id, color, NINJA, lifeValue, attackValue) {
        setWeapon(weapon1);
        m_weapon2 = weapon2;
    }
    virtual ~Ninja() {}
    Weapon* getWeapon2() const { return m_weapon2; }
private:
    Weapon* m_weapon2;
};

class Iceman: public Warrior {
public:
    Iceman(int id, Color color, int lifeValue, int attackValue, Weapon* weapon):
        Warrior(id, color, ICEMAN, lifeValue, attackValue) {
        setWeapon(weapon);
    }
    virtual ~Iceman() {}
    virtual void march() {
        setLifeValue(getLifeValue() - getLifeValue() / 10);
        setAttackValue(getAttackValue() + 20);
    }
};

class Lion: public Warrior {
public:
    Lion(int id, Color color, int lifeValue, int attackValue):
        Warrior(id, color, LION, lifeValue, attackValue) {
        m_loyalty = R;
    }
    virtual ~Lion() {}
    int getLoyalty() const { return m_loyalty; }
    void setLoyalty(int loyalty) { m_loyalty = loyalty; }
private:
    int m_loyalty;
};

class Wolf: public Warrior {
public:
    Wolf(int id, Color color, int lifeValue, int attackValue):
        Warrior(id, color, WOLF, lifeValue, attackValue) {}
    virtual ~Wolf() {}
};

class Headquarters {
public:
    Headquarters(Color color, int initialLifeValue, int* warriorMakingSequence):
        m_color(color), m_initialLifeValue(initialLifeValue), m_lifeValue(initialLifeValue), m_warriorMakingSeq(NULL),
        m_warriorCount(0), m_curMakingSeqIdx(0) {
        m_warriorMakingSeq = new int[MAX_WARRIOR_NUM];
        for (int i = 0; i < MAX_WARRIOR_NUM; ++i) {
            m_warriorMakingSeq[i] = warriorMakingSequence[i];
        }
    }
    virtual ~Headquarters() {
        if (m_warriorMakingSeq != NULL) {
            delete[] m_warriorMakingSeq;
            m_warriorMakingSeq = NULL;
        }
        for (int i = 0; i < m_warriors.size(); ++i) {
            if (m_warriors[i] != NULL) {
                delete m_warriors[i];
                m_warriors[i] = NULL;
            }
        }
        m_warriors.clear();
        for (int i = 0; i < m_warriorsInCity.size(); ++i) {
            if (m_warriorsInCity[i] != NULL) {
                delete m_warriorsInCity[i];
                m_warriorsInCity[i] = NULL;
            }
        }
        m_warriorsInCity.clear();
    }
    Color getColor() const { return m_color; }
    int getLifeValue() const { return m_lifeValue; }
    int getWarriorCount() const { return m_warriorCount; }
    void setLifeValue(int lifeValue) { m_lifeValue = lifeValue; }
    Warrior* getWarrior(int idx) const { return m_warriors[idx]; }
    void addWarrior(Warrior* warrior) {
        m_warriors.push_back(warrior);
        ++m_warriorCount;
    }
    void removeWarrior(int idx) {
        m_warriors.erase(m_warriors.begin() + idx);
        --m_warriorCount;
    }
    void addWarriorInCity(Warrior* warrior) {
        m_warriorsInCity.push_back(warrior);
    }
    void removeWarriorInCity(int idx) {
        m_warriorsInCity.erase(m_warriorsInCity.begin() + idx);
    }
    int getWarriorInCityCount() const { return m_warriorsInCity.size(); }
    Warrior* getWarriorInCity(int idx) const { return m_warriorsInCity[idx]; }
    int getWarriorMakingSeq(WarriorType warriorType) const { return m_warriorMakingSeq[warriorType]; }
    void produceWarrior(int time) {
        if (m_lifeValue < warriorInitialLife[m_warriorMakingSeq[m_curMakingSeqIdx]]) {
            return;
        }
        ++m_warriorCount;
        m_lifeValue -= warriorInitialLife[m_warriorMakingSeq[m_curMakingSeqIdx]];
        switch (m_warriorMakingSeq[m_curMakingSeqIdx]) {
            case DRAGON:
                addWarrior(new Dragon(m_warriorCount, m_color, warriorInitialLife[DRAGON], warriorInitialAttack[DRAGON], NULL));
                break;
            case NINJA:
                addWarrior(new Ninja(m_warriorCount, m_color, warriorInitialLife[NINJA], warriorInitialAttack[NINJA], NULL, NULL));
                break;
            case ICEMAN:
                addWarrior(new Iceman(m_warriorCount, m_color, warriorInitialLife[ICEMAN], warriorInitialAttack[ICEMAN], NULL));
                break;
            case LION:
                addWarrior(new Lion(m_warriorCount, m_color, warriorInitialLife[LION], warriorInitialAttack[LION]));
                break;
            case WOLF:
                addWarrior(new Wolf(m_warriorCount, m_color, warriorInitialLife[WOLF], warriorInitialAttack[WOLF]));
                break;
            default:
                break;
        }
        cout << COLOR_NAME[m_color] << " " << WARRIOR_NAME[m_warriorMakingSeq[m_curMakingSeqIdx]] << " " << m_warriorCount
            << " born with strength " << warriorInitialLife[m_warriorMakingSeq[m_curMakingSeqIdx]] << ","
            << getWarriorCount(m_warriorMakingSeq[m_curMakingSeqIdx]) << " " << WARRIOR_NAME[m_warriorMakingSeq[m_curMakingSeqIdx]]
            << " in " << COLOR_NAME[m_color] << " headquarter" << endl;
        m_curMakingSeqIdx = (m_curMakingSeqIdx + 1) % MAX_WARRIOR_NUM;
    }
    int getNextWarriorType() const { return m_warriorMakingSeq[m_curMakingSeqIdx]; }
private:
    Color m_color;
    int m_initialLifeValue;
    int m_lifeValue;
    int* m_warriorMakingSeq;
    int m_warriorCount;
    int m_curMakingSeqIdx;
    vector<Warrior*> m_warriors;
    vector<Warrior*> m_warriorsInCity;
};

class City {
public:
    City(int id): m_id(id), m_flag(-1), m_redWarrior(NULL), m_blueWarrior(NULL), m_redWinCount(0), m_blueWinCount(0) {}
    virtual ~City() {}
    int getId() const { return m_id; }
    int getFlag() const { return m_flag; }
    void setFlag(int flag) { m_flag = flag; }
    Warrior* getWarrior(Color color) const {
        if (color == RED) {
            return m_redWarrior;
        } else {
            return m_blueWarrior;
        }
    }
    void setWarrior(Color color, Warrior* warrior) {
        if (color == RED) {
            m_redWarrior = warrior;
        } else {
            m_blueWarrior = warrior;
        }
    }
    void removeWarrior(Color color) {
        if (color == RED) {
            m_redWarrior = NULL;
        } else {
            m_blueWarrior = NULL;
        }
    }
    int getRedWinCount() const { return m_redWinCount; }
    int getBlueWinCount() const { return m_blueWinCount; }
    void setRedWinCount(int redWinCount) { m_redWinCount = redWinCount; }
    void setBlueWinCount(int blueWinCount) { m_blueWinCount = blueWinCount; }
private:
    int m_id;
    int m_flag;
    Warrior* m_redWarrior;
    Warrior* m_blueWarrior;
    int m_redWinCount;
    int m_blueWinCount;
};

class Warcraft {
public:
    Warcraft(int m, int n, int r, int k, int t, int* warriorInitialLife, int* warriorInitialAttack, int* cityInitialLife,
             int** redWarriorMakingSeq, int** blueWarriorMakingSeq):
        M(m), N(n), R(r), K(k), T(t), m_time(0), m_redHeadquarters(NULL), m_blueHeadquarters(NULL) {
        for (int i = 0; i < MAX_WARRIOR_NUM; ++i) {
            ::warriorInitialLife[i] = warriorInitialLife[i];
            ::warriorInitialAttack[i] = warriorInitialAttack[i];
        }
        for (int i = 0; i < MAX_CITY_NUM; ++i) {
            ::cityInitialLife[i] = cityInitialLife[i];
        }
        m_redHeadquarters = new Headquarters(RED, M, redWarriorMakingSeq[0]);
        m_blueHeadquarters = new Headquarters(BLUE, M, blueWarriorMakingSeq[0]);
        for (int i = 1; i <= N; ++i) {
            m_cities.push_back(new City(i));
        }
        m_redHeadquarters->addWarriorInCity(NULL);
        for (int i = 0; i < N; ++i) {
            m_cities[i]->setFlag(-1);
            m_cities[i]->setWarrior(RED, NULL);
            m_cities[i]->setWarrior(BLUE, NULL);
            m_redHeadquarters->addWarriorInCity(NULL);
            m_blueHeadquarters->addWarriorInCity(NULL);
        }
        m_blueHeadquarters->addWarriorInCity(NULL);
    }
    virtual ~Warcraft() {
        if (m_redHeadquarters != NULL) {
            delete m_redHeadquarters;
            m_redHeadquarters = NULL;
        }
        if (m_blueHeadquarters != NULL) {
            delete m_blueHeadquarters;
            m_blueHeadquarters = NULL;
        }
        for (int i = 0; i < m_cities.size(); ++i) {
            if (m_cities[i] != NULL) {
                delete m_cities[i];
                m_cities[i] = NULL;
            }
        }
        m_cities.clear();
    }
    void start() {
        while (m_time <= T) {
            // Produce warrior
            m_redHeadquarters->produceWarrior(m_time);
            m_blueHeadquarters->produceWarrior(m_time);
            // March
            for (int i = 0; i < m_cities.size(); ++i) {
                City* city = m_cities[i];
                if (city->getWarrior(RED) != NULL) {
                    city->getWarrior(RED)->march();
                }
                if (city->getWarrior(BLUE) != NULL) {
                    city->getWarrior(BLUE)->march();
                }
            }
            if (m_time == T) {
                break;
            }
            // Take city
            for (int i = 0; i < m_cities.size(); ++i) {
                City* city = m_cities[i];
                if (city->getWarrior(RED) != NULL && city->getWarrior(BLUE) != NULL) {
                    if (city->getFlag() == RED) {
                        city->getWarrior(BLUE)->setLifeValue(city->getWarrior(BLUE)->getLifeValue() - city->getWarrior(RED)->getAttackValue());
                        if (city->getWarrior(BLUE)->getLifeValue() <= 0) {
                            city->removeWarrior(BLUE);
                            m_redHeadquarters->addWarriorInCity(city->getWarrior(RED));
                            city->setWarrior(RED, NULL);
                            city->setFlag(-1);
                            m_redHeadquarters->setLifeValue(m_redHeadquarters->getLifeValue() + city->getLifeValue());
                            cout << m_time << " " << COLOR_NAME[RED] << " " << WARRIOR_NAME[m_redHeadquarters->getNextWarriorType()]
                                << " " << m_redHeadquarters->getWarriorInCityCount() << " earned "
                                << city->getLifeValue() << " elements for his headquarter" << endl;
                        }
                    } else if (city->getFlag() == BLUE) {
                        city->getWarrior(RED)->setLifeValue(city->getWarrior(RED)->getLifeValue() - city->getWarrior(BLUE)->getAttackValue());
                        if (city->getWarrior(RED)->getLifeValue() <= 0) {
                            city->removeWarrior(RED);
                            m