/////////////////////////////////////////////////////////////////////////
//                                                                     //
//            Header file for ANTHILL simulation program               //
//                                                                     //
//                    by Mark Weaver and Alex Lane                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

typedef unsigned char BOOLEAN;
#define TRUE  1
#define FALSE 0

#define BACKGROUND 0
#define MAX_FOOD_SIZE 30000

// Types of ants
enum antType { typeQueen, typeWorker, typeEgg } ;


// Function Prototypes
void moverDefaultDrawFunc(int, int, BOOLEAN, int);
int distance(int, int, int, int);
void showFood(int, int, BOOLEAN );
void showStatus(void);
void resetDefaults(void);
void displayValues(void);
unsigned getNumber(char *, unsigned, unsigned, 
						 unsigned );
char getChoice(void);


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//                        MOVER class definition                        // 
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class Mover {
private:
	 void moverDrawFunc(int, int, BOOLEAN, int); // Function to draw object
	 BOOLEAN bVisible;       // Is object currently visible on screen?
protected:
	 int nInitX, nInitY;     // Original position
	 int nVelX;              // Velocity in X direction
	 int nVelY;              // Velocity in Y direction
    unsigned uMaxRange;     // Max distance object moves from original pos.
	 unsigned uMaxSpeed;     // Max distance object moves in one cycle
	 int nX, nY;             // Current position
	 int color;              // Color of mover
public:
	 Mover(unsigned, unsigned, int, int );
	 BOOLEAN moveTo(int, int );
	 BOOLEAN move( void );
	 void show( void );
	 void erase( void );
	 void draw( void ); 
	 virtual int getX( void ) = 0; 
	 virtual int getY( void ) = 0;
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//                       CONSUMER class definition                      // 
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class Consumer {
public:
	 int nEnergy;           // If this reaches zero, it's curtains!
	 Consumer(int _nEnergy ) 
			 { nEnergy = _nEnergy; } // inline constructor
	 void eatFood( int );    // Eat food at current location
	 virtual int getX( void ) = 0;
	 virtual int getY( void ) = 0;
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//                          ANT class definition                        // 
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class Ant : public Consumer, public Mover { 
protected:
	 int nLifeSpan;         // Age at which ant dies
	 unsigned nAge;         // How old is this ant
	 BOOLEAN bEgg;          // Am I an egg still?
public:
	 BOOLEAN bDead;         // Does this ant bDead?
	 Ant( int, int, int, int, int );  // constructor 
	 void die(void);              // Assume room temperature
	 void doTheAntThing(void);    // Do whatever ants do
	 virtual int getX( void ) { return Mover::getX(); };
	 virtual int getY( void ) { return Mover::getY(); };
};


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//                       QUEEN class definition                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
class Queen : public Ant {                // queen is derived from ant
private:
	unsigned birthRate;
public:
	Queen( unsigned,int,int,int,int,unsigned ); // Constructor function
	void layEgg( void );                  // Queen can lay eggs
	void doTheAntThing( void );           // Do whatever queen ants do
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
//                      WORKER class definition                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
class Worker : public Ant {             // worker is derived from ant
  private:
	 Worker *nextWorker;    // Pointer to next ant in list
	 Worker *prevWorker;    // Pointer to previous ant in list
	 int nFood;             // Indicates worker carrying food

    void dropFood();             // Drop food for queen
    void grabFood(void);         // Pick up food
    void moveTowardQueen(void);  // Carry food toward queen
    void lookForFood(void);      // Search for more food
    void addToList(void);        // Add self to head of list
	 void die(void);              // Assume room temperature

  public:
	 Worker( BOOLEAN, int, int); // Constructor Function
	 ~Worker(void);

	 Worker *next(void){ return(nextWorker); } // Access function to next ptr
	 void doTheAntThing( void );
};
