Untitled

#include<iostream>
using namespace std;

const int WarriorNum = 5;
const int WeaponNum = 3;
const int WarriorsMax = 10000;

int Head_Red_Warrior_MakeSeq[WarriorNum] = {2,3,4,1,0};
int Head_Blue_Warrior_MakeSeq[WarriorNum] = {3, 0, 1, 2, 4};
int WarriorHp[WarriorNum] ={};
char *colors[2]= {"red", "blue"};
char *WarriorName[WarriorNum] ={"dragon" ,"ninja","iceman","lion","wolf"};
char *WeaponName[WeaponNum] = {"sword", "bomb","arrow"};

class Headquarters;
class Warrior;
class Dragon;
class Ninja;
class Iceman;
class Lion;
class Wolf;
class Weapon;

class Weapon{
private:
    int Kind;//武器种类sword、bomb、arrow
public:
    void Init(int Kind_){
        Kind = Kind_;
    }
    int GetWeapon()const{
        return Kind;
    }
};

class Warrior{
protected:
    int Hp;//武士生命值
    int Kind; //武士类别dragon、ninja、iceman、lion、wolf
    int ArrayNum; //武士队列编号
    Headquarters * team; //指针指回Headquarters
public:
    Warrior(Headquarters * p,int ArrayNum_):team(p),ArrayNum(ArrayNum_){}
    virtual void PrintProduce(int time) = 0;
    void PrintProduce(int time,int ) ;
    ~Warrior(){};
};


class Headquarters{
private:
    int Hp;//司令部生命值
    int Color; //0红，1蓝。
    Warrior * WarriorsArray[WarriorsMax]; //武士队列
    int WarriorsArrayNum;
    int Warrior_MakeSeq[WarriorNum];//该司令部生产顺序
    int MakeNum; //当前生产顺序编号
    bool ProduceState;//判断是否生产
    int WarriorsNums[WarriorNum]; //每种武士的数量
public:
    Headquarters(int Color_, int Hp_, int * Warrior_MakeSeq_):Color(Color_),Hp(Hp_){
        for(int i = 0; i < WarriorNum ;i++){
            Warrior_MakeSeq[i] = Warrior_MakeSeq_[i];
            WarriorsNums[i] = 0;
        }
        WarriorsArrayNum = 0;
        MakeNum = 0;
        ProduceState = true;
    }
    ~Headquarters(){
        for(int i = 0; i < WarriorsArrayNum; i++) delete WarriorsArray[i];
    }

    bool produce(int time);
    int GetHp()const {
        return Hp;
    }
    int GetColor()const{
        return Color;
    }
    int GetWarriorsNums(int Kind){
        return WarriorsNums[Kind];
    }
};

void Warrior::PrintProduce(int time,int) {
    int color = team->GetColor();
    printf("%03d %s %s %d born with strength %d,%d %s in %s headquarter\n",
           time,colors[color],WarriorName[Kind],ArrayNum,
           Hp,team->GetWarriorsNums(Kind),WarriorName[Kind],colors[color]);
};

class Dragon:public Warrior{
private:
    Weapon wp_d;
    float Morale;
public:
    Dragon(Headquarters * p,int ArrayNum_):Warrior(p,ArrayNum_){
        Kind = 0;
        Hp = WarriorHp[Kind];
        wp_d.Init(ArrayNum % WeaponNum);
        Morale = team->GetHp() * 1.0 / Hp;
    }
    virtual void PrintProduce(int time){
        Warrior::PrintProduce(time,0);
        printf("It has a %s,and it's morale is %.02f\n",WeaponName[wp_d.GetWeapon()],Morale);
    }
};

class Ninja:public Warrior{
private:
    Weapon wp_n[2];
public:
    Ninja(Headquarters * p,int ArrayNum_):Warrior(p,ArrayNum_){
        Kind = 1;
        Hp = WarriorHp[Kind];
        wp_n[0].Init(ArrayNum % WeaponNum);
        wp_n[1].Init((ArrayNum + 1) % WeaponNum);
    }
    virtual void PrintProduce(int time){
        Warrior::PrintProduce(time,0);
        printf("It has a %s and a %s\n",WeaponName[wp_n[0].GetWeapon()],WeaponName[wp_n[1].GetWeapon()]);
    }
};

class Iceman:public Warrior{
private:
    Weapon wp_i;
public:
    Iceman(Headquarters * p,int ArrayNum_):Warrior(p,ArrayNum_){
        Kind = 2;
        Hp = WarriorHp[Kind];
        wp_i.Init(ArrayNum % WeaponNum);
    }
    virtual void PrintProduce(int time){
        Warrior::PrintProduce(time,0);
        printf("It has a %s\n",WeaponName[wp_i.GetWeapon()]);
    }
};

class Lion:public Warrior{
private:
    int loyalty;
public:
    Lion(Headquarters * p,int ArrayNum_):Warrior(p,ArrayNum_){
        Kind = 3;
        Hp = WarriorHp[Kind];
        loyalty = team->GetHp();
    }
    virtual void PrintProduce(int time){
        Warrior::PrintProduce(time,0);
        printf("It's loyalty is %d\n",loyalty);
    }
};

class Wolf:public Warrior{
public:
    Wolf(Headquarters * p,int ArrayNum_):Warrior(p,ArrayNum_){
        Kind = 4;
        Hp = WarriorHp[Kind];
    }
    virtual void PrintProduce(int time){
        Warrior::PrintProduce(time,0);
    }
};

bool Headquarters::produce(int time){
    if(!ProduceState) return false;
    for(int i = 0; i < WarriorNum ; i++){
        if(Hp >= WarriorHp[Warrior_MakeSeq[(MakeNum + i) % WarriorNum]]){
            MakeNum = (MakeNum + i) % WarriorNum;
            ProduceState = true;
            Hp -= WarriorHp[Warrior_MakeSeq[MakeNum]];
            switch (Warrior_MakeSeq[MakeNum]) {
                case 0:
                    WarriorsArray[WarriorsArrayNum] = new Dragon(this,WarriorsArrayNum + 1);
                    break;
                case 1:
                    WarriorsArray[WarriorsArrayNum] = new Ninja(this,WarriorsArrayNum + 1);
                    break;
                case 2:
                    WarriorsArray[WarriorsArrayNum] = new Iceman(this,WarriorsArrayNum + 1);
                    break;
                case 3:
                    WarriorsArray[WarriorsArrayNum] = new Lion(this,WarriorsArrayNum + 1);
                    break;
                case 4:
                    WarriorsArray[WarriorsArrayNum] = new Wolf(this,WarriorsArrayNum + 1);
                    break;
            }
            WarriorsNums[Warrior_MakeSeq[MakeNum]] ++;
            WarriorsArray[WarriorsArrayNum++]->PrintProduce(time);
            MakeNum = (MakeNum + 1) % WarriorNum;
            return true;
        }
    }
    ProduceState = false;
    printf("%03d %s headquarter stops making warriors\n",time,colors[Color]);
    return false;
}


int main(){
    int n,m;
    cin >> n;
    int Case = 0;
    while (n--) {
        Case++;
        bool Red_flag = true , Blue_flag = true;
        int time = 0;
        cout << "Case:" << Case <<endl;
        cin >> m;
        for(int i = 0; i < WarriorNum ; i++){
            cin >> WarriorHp[i];
        }
        Headquarters Head_Red(0,m,Head_Red_Warrior_MakeSeq);
        Headquarters Head_Blue(1,m,Head_Blue_Warrior_MakeSeq);
        while(Red_flag || Blue_flag){
            Red_flag = Head_Red.produce(time);
            Blue_flag= Head_Blue.produce(time);
            time ++;
        }
    }
    return 0;
}