Listing 1

/////////////////////////////////////////////////////////////
//                                                         //
//       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 );
};