#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#define MAX(a,b) ((a)>(b)?(a):(b)) 
#define MIN(a,b) ((a)<(b)?(a):(b)) 

struct Hit {
        unsigned spell;
        unsigned strength; 
        Hit() { spell=strength=0;}
        Hit(unsigned p, unsigned s) { spell=p;strength=s;}
};

class Player {
        char name[40];
        char army[40];
protected:
        int moral;
        int health;
        virtual Hit shield(Hit h) { return h; }
        virtual Hit counterspell(Hit h) { return h; }
        virtual Hit hitpower(Hit h) { return h; }
        virtual Hit castspell(Hit h) { return h; }
public:
        virtual int isFellowship() { return 0;}
        virtual void addplayer(Player *) { throw(-1); }

        virtual Hit attackpower() {
                                        Hit t;
                                        t=hitpower(t);
                                        t=castspell(t);
                                        return t;
                                   }
        virtual Hit defensepower(Hit h) {
                                h=shield(h);
                                h=counterspell(h);
                                return h;
                                }
        Player(char n[], char a[]) {
                strncpy(name,n,40); name[39]=0;
                strncpy(army,a,40); army[39]=0;
                moral=health=10000;
        }
        virtual const char *getname() { return name;}
        const char *getarmy() { return army;}
        virtual Hit attack() ;
        virtual void defense(Hit);
        virtual void operator++() {
                                moral=MIN(10000,moral+250);
                                health=MIN(10000,health+250);
                          }
		virtual ~Player() {}
};

class Cavalry:virtual public Player {
protected:
	virtual Hit shield(Hit h);
	virtual Hit hitpower(Hit h);
public:
	Cavalry(char n[],char a[]):Player(n,a){}
};

class Swordsman:virtual public Player {
protected:
	virtual Hit shield(Hit h);
	virtual Hit hitpower(Hit h);
public:
	Swordsman(char n[],char a[]):Player(n,a){}
};

class Wizard:virtual public Player {
protected:
	virtual Hit castspell(Hit h);
	virtual Hit counterspell(Hit h);
public:
	Wizard(char n[],char a[]):Player(n,a){}
};

class Knight:public Cavalry,public Swordsman {
protected:
	Hit shield(Hit h){return Cavalry::shield(h);}
	Hit hitpower(Hit h){return Swordsman::hitpower(h);}
public:
	Knight(char n[],char a[]):Player(n,a),Cavalry(n,a),Swordsman(n,a){}
};

class Magicmaster:public Cavalry,public Wizard {
protected:
	Hit shield(Hit h){return Cavalry::shield(h); }
	Hit counterspell(Hit h) {return Wizard::counterspell(h); }

	Hit hitpower(Hit h) {return Cavalry::hitpower(h); }
	Hit castspell(Hit h) {return Wizard::castspell(h); }
public:
	Magicmaster(char n[],char a[]):Player(n,a),Cavalry(n,a),Wizard(n,a){}
};

class Magicsword:public Swordsman,public Wizard {
protected:
	Hit shield(Hit h) {return Swordsman::shield(h); }
	Hit counterspell(Hit h) {return Wizard::counterspell(h); }
	Hit hitpower(Hit h) {return Swordsman::hitpower(h); }
	Hit castspell(Hit h) {return Wizard::castspell(h);}
public:
	Magicsword(char n[],char a[]):Player(n,a),Swordsman(n,a),Wizard(n,a){}
};

class Fellowship:public Player {
	Player *myplyrs[5];
	int playercount;
	friend void mergefellowships(Player *,Player *);
public:
	Fellowship(char [],Player *,Player *);
	void addplayer(Player *p) {myplyrs[playercount++]=p;}
	const char *getname();
	int isFellowship() { return playercount;}
	void operator++(){  for(int i=0;i<playercount;i++)
						myplyrs[i]->operator++(); }			
	Hit attack();
	void defense(Hit);
	Hit attackpower();
	Hit defensepower(Hit h);
};

class Arena  {
        struct playerpos {        
                int x,y;
                Player *p;
        } players[100];
        int playercount;
public:
        Arena() { playercount=0; }
        ~Arena() { for (int i=0;i<playercount;i++) delete players[i].p;}
        void addplayer(Player *p, int px=0, int py=0) {
                        players[playercount].x=px;
                        players[playercount].y=py;
                        players[playercount++].p=p;
        }
        void dump();
        void cycle();
};