I am trying to get this Zombie/Human agent based simulation running, but I am having problems with these derived classes (Human and Zombie) who have parent class "Creature". I have 3 virtual functions declared in "Creature" and all three of these are re-declared AND DEFINED in both "Human" and "Zombie". But for some reason when I have my program call "new" to allocate memory for objects of type Human or Zombie, it complains about the virtual functions being abstract. Here's the code:
definitions.h
#ifndef definitions_h
#define definitions_h
class Creature;
class Item;
class Coords;
class Grid
{
public:
Creature*** cboard;
Item*** iboard;
int WIDTH;
int HEIGHT;
Grid(int WIDTHVALUE, int HEIGHTVALUE);
void FillGrid(); //initializes grid object with humans and zombies
void Refresh(); //calls Creature::Die(),Move(),Attack(),Breed() on every square
void UpdateBuffer(char** buffer);
bool isEmpty(int startx, int starty, int dir);
char CreatureType(int xcoord, int ycoord);
char CreatureType(int startx, int starty, int dir);
};
class Random
{
public:
int* rptr;
void Print();
Random(int MIN, int MAX, int LEN);
~Random();
private:
bool alreadyused(int checkthis, int len, int* rptr);
bool isClean();
int len;
};
class Coords
{
public:
int x;
int y;
int MaxX;
int MaxY;
Coords() {x=0; y=0; MaxX=0; MaxY=0;}
Coords(int X, int Y, int WIDTH, int HEIGHT) {x=X; y=Y; MaxX=WIDTH; MaxY=HEIGHT; }
void MoveRight();
void MoveLeft();
void MoveUp();
void MoveDown();
void MoveUpRight();
void MoveUpLeft();
void MoveDownRight();
void MoveDownLeft();
void MoveDir(int dir);
void setx(int X) {x=X;}
void sety(int Y) {y=Y;}
};
class Creature
{
public:
bool alive;
Coords Location;
char displayletter;
Creature() {Location.x=0; Location.y=0;}
Creature(int i, int j) {Location.setx(i); Location.sety(j);}
virtual void Attack() =0;
virtual void AttackCreature(Grid G, int attackdirection) =0;
virtual void Breed() =0;
void Die();
void Move(Grid G);
int DecideSquare(Grid G);
void MoveTo(Grid G, int dir);
};
class Human : public Creature
{
public:
bool armed; //if armed, chances of winning fight increased for next fight
bool vaccinated; //if vaccinated, no chance of getting infected
int bitecount; //if a human is bitten, bite count is set to a random number
int breedcount; //if a human goes x steps without combat, will breed if next to a human
int starvecount; //if a human does not eat in x steps, will die
Human() {displayletter='H';}
Human(int i, int j) {displayletter='H';}
void Attack(Grid G);
void AttackCreature(Grid G, int attackdirection);
void Breed(Grid G); //will breed after x steps and next to human
int DecideAttack(Grid G);
};
class Zombie : public Creature
{
public:
Zombie() {displayletter='Z';}
Zombie(int i, int j) {displayletter='Z';}
void Attack(Grid G);
void AttackCreature(Grid G, int attackdirection);
void Breed() {} //does nothing
int DecideAttack(Grid G);
void AttackCreature(Grid G, int attackdirection);
};
class Item
{
};
#endif
definitions.cpp
#include <cstdlib>
#include "definitions.h"
Random::Random(int MIN, int MAX, int LEN) //constructor
{
len=LEN;
rptr=new int[LEN]; //allocate array of given length
for (int i=0; i<LEN; i++)
{
int random;
do {
random = rand() % (MAX-MIN+1) + MIN;
} while (alreadyused(random,LEN,rptr));
rptr[i]=random;
}
}
bool Random::alreadyused(int checkthis, int len, int* rptr)
{
for (int i=0; i<len; i++)
{
if (rptr[i]==checkthis)
return 1;
}
return 0;
}
Random::~Random()
{
delete rptr;
}
Grid::Grid(int WIDTHVALUE, int HEIGHTVALUE)
{
WIDTH = WIDTHVALUE;
HEIGHT = HEIGHTVALUE;
//builds 2d array of creature pointers
cboard = new Creature**[WIDTH];
for(int i=0; i<WIDTH; i++)
{
cboard[i] = new Creature*[HEIGHT];
}
//builds 2d array of item pointers
iboard = new Item**[WIDTH];
for (int i=0; i<WIDTH; i++)
{
iboard[i] = new Item*[HEIGHT];
}
}
void Grid::FillGrid()
{
/* For each creature pointer in grid, randomly selects whether to initalize
as zombie, human, or empty square. This methodology can be changed to initialize
different creature types with different probabilities */
int random;
for (int i=0; i<WIDTH; i++)
{
for (int j=0; j<HEIGHT; j++)
{
Random X(1,100,1); //create a single random integer from [1,100] at X.rptr
random=*(X.rptr);
if (random < 20)
cboard[i][j] = new Human(i,j);
else if (random < 40)
cboard[i][j] = new Zombie(i,j);
else
cboard[i][j] = NULL;
}
} //at this point every creature pointer should be pointing to either
//a zombie, human, or NULL with varying probabilities
}
void Grid::UpdateBuffer(char** buffer)
{
for (int i=0; i<WIDTH; i++)
{
for (int j=0; j<HEIGHT; j++)
{
if (cboard[i][j])
buffer[i][j]=cboard[i][j]->displayletter;
else
buffer[i][j]=' ';
}
}
}
bool Grid::isEmpty(int startx, int starty, int dir)
{
Coords StartLocation(startx,starty,WIDTH,HEIGHT);
switch(dir)
{
case 1:
StartLocation.MoveUp();
if (cboard[StartLocation.x][StartLocation.y])
return 0;
case 2:
StartLocation.MoveUpRight();
if (cboard[StartLocation.x][StartLocation.y])
return 0;
case 3:
StartLocation.MoveRight();
if (cboard[StartLocation.x][StartLocation.y])
return 0;
case 4:
StartLocation.MoveDownRight();
if (cboard[StartLocation.x][StartLocation.y])
return 0;
case 5:
StartLocation.MoveDown();
if (cboard[StartLocation.x][StartLocation.y])
return 0;
case 6:
StartLocation.MoveDownLeft();
if (cboard[StartLocation.x][StartLocation.y])
return 0;
case 7:
StartLocation.MoveLeft();
if (cboard[StartLocation.x][StartLocation.y])
return 0;
case 8:
StartLocation.MoveUpLeft();
if (cboard[StartLocation.x][StartLocation.y])
return 0;
}
return 1;
}
char Grid::CreatureType(int xcoord, int ycoord)
{
if (cboard[xcoord][ycoord]) //if there is a creature at location xcoord,ycoord
return (cboard[xcoord][ycoord]->displayletter);
else //if pointer at location xcoord,ycoord is null, return null char
return '\0';
}
char Grid::CreatureType(int startx, int starty, int dir)
{
Coords StartLocation(startx,starty,WIDTH,HEIGHT);
switch(dir)
{
case 1:
StartLocation.MoveUp();
if (cboard[StartLocation.x][StartLocation.y])
return (cboard[StartLocation.x][StartLocation.y]->displayletter);
case 2:
StartLocation.MoveUpRight();
if (cboard[StartLocation.x][StartLocation.y])
return (cboard[StartLocation.x][StartLocation.y]->displayletter);
case 3:
StartLocation.MoveRight();
if (cboard[StartLocation.x][StartLocation.y])
return (cboard[StartLocation.x][StartLocation.y]->displayletter);
case 4:
StartLocation.MoveDownRight();
if (cboard[StartLocation.x][StartLocation.y])
return (cboard[StartLocation.x][StartLocation.y]->displayletter);
case 5:
StartLocation.MoveDown();
if (cboard[StartLocation.x][StartLocation.y])
return (cboard[StartLocation.x][StartLocation.y]->displayletter);
case 6:
StartLocation.MoveDownLeft();
if (cboard[StartLocation.x][StartLocation.y])
return (cboard[StartLocation.x][StartLocation.y]->displayletter);
case 7:
StartLocation.MoveLeft();
if (cboard[StartLocation.x][StartLocation.y])
return (cboard[StartLocation.x][StartLocation.y]->displayletter);
case 8:
StartLocation.MoveUpLeft();
if (cboard[StartLocation.x][StartLocation.y])
return (cboard[StartLocation.x][StartLocation.y]->displayletter);
} //if function hasn't returned by now, square being looked at is pointer to null
return '\0'; //return null char
}
void Coords::MoveRight() {(x==MaxX)? (x=0):(x++);}
void Coords::MoveLeft() {(x==0)? (x=MaxX):(x--);}
void Coords::MoveUp() {(y==0)? (y=MaxY):(y--);}
void Coords::MoveDown() {(y==MaxY)? (y=0):(y++);}
void Coords::MoveUpRight() {MoveUp(); MoveRight();}
void Coords::MoveUpLeft() {MoveUp(); MoveLeft();}
void Coords::MoveDownRight() {MoveDown(); MoveRight();}
void Coords::MoveDownLeft() {MoveDown(); MoveLeft();}
void Coords::MoveDir(int dir)
{
switch(dir)
{
case 1:
MoveUp();
break;
case 2:
MoveUpRight();
break;
case 3:
MoveRight();
break;
case 4:
MoveDownRight();
break;
case 5:
MoveDown();
break;
case 6:
MoveDownLeft();
break;
case 7:
MoveLeft();
break;
case 8:
MoveUpLeft();
break;
case 0:
break;
}
}
void Creature::Move(Grid G)
{
int movedir=DecideSquare(G);
MoveTo(G,movedir);
}
int Creature::DecideSquare(Grid G)
{
Random X(1,8,8); //X.rptr now points to 8 unique random integers from [1,8]
for (int i=0; i<8; i++)
{
int dir=X.rptr[i];
if (G.isEmpty(Location.x,Location.y,dir))
return dir;
}
return 0;
}
void Creature::MoveTo(Grid G, int dir)
{
Coords OldLocation=Location;
Location.MoveDir(dir);
G.cboard[Location.x][Location.y]=this; //point new location to this creature
G.cboard[OldLocation.x][OldLocation.y]=NULL; //point old location to NULL
}
void Creature::Die()
{
if (!alive)
{
delete this;
this=NULL;
}
}
void Human::Breed(Grid G)
{
if (!breedcount)
{
Coords BreedLocation=Location;
Random X(1,8,8);
for (int i=0; i<8; i++)
{
BreedLocation.MoveDir(X.rptr[i]);
if (!G.cboard[BreedLocation.x][BreedLocation.y])
{
G.cboard[BreedLocation.x][BreedLocation.y])=new Human(BreedLocation.x,BreedLocation.y);
return;
}
}
}
}
int Human::DecideAttack(Grid G)
{
Coords AttackLocation=Location;
Random X(1,8,8);
int attackdir;
for (int i=0; i<8; i++)
{
attackdir=X.rptr[i];
switch(G.CreatureType(Location.x,Location.y,attackdir))
{
case 'H':
break;
case 'Z':
return attackdir;
case '\0':
break;
default:
break;
}
}
return 0; //no zombies!
}
int AttackRoll(int para1, int para2)
{
//outcome 1: Zombie wins, human dies
//outcome 2: Human wins, zombie dies
//outcome 3: Human wins, zombie dies, but human is bitten
Random X(1,100,1);
int roll= *(X.rptr);
if (roll < para1)
return 1;
else if (roll < para2)
return 2;
else
return 3;
}
void Human::AttackCreature(Grid G, int attackdirection)
{
Coords AttackLocation=Location;
AttackLocation.MoveDir(attackdirection);
int para1=33;
int para2=33;
if (vaccinated)
para2=101; //makes attackroll > para 2 impossible, never gets infected
if (armed)
para1-=16; //reduces chance of zombie winning fight
int roll=AttackRoll(para1,para2);
//outcome 1: Zombie wins, human dies
//outcome 2: Human wins, zombie dies
//outcome 3: Human wins, zombie dies, but human is bitten
switch(roll)
{
case 1:
alive=0; //human (this) dies
return;
case 2:
G.cboard[AttackLocation.x][AttackLocation.y]->alive=0;
return; //zombie dies
case 3:
G.cboard[AttackLocation.x][AttackLocation.y]->alive=0; //zombie dies
Random X(3,7,1); //human is bitten
bitecount=*(X.rptr);
return;
}
}
int Zombie::DecideAttack(Grid G)
{
Coords AttackLocation=Location;
Random X(1,8,8);
int attackdir;
for (int i=0; i<8; i++)
{
attackdir=X.rptr[i];
switch(G.CreatureType(Location.x,Location.y,attackdir))
{
case 'H':
return attackdir;
case 'Z':
break;
case '\0':
break;
default:
break;
}
}
return 0; //no zombies!
}
void Zombie::AttackCreature(Grid G, int attackdirection)
{
int reversedirection;
if (attackdirection < 9 && attackdirection>0)
{
(attackdirection<5)? (reversedirection=attackdirection+4):(reversedirection=attackdirection-4);
}
else
reversedirection=0; //this should never happen
//when a zombie attacks a human, the Human::AttackZombie() function is called
//in the "reverse" direction, utilizing that function that has already been written
Coords ZombieLocation=Location;
Coords HumanLocation=Location;
HumanLocation.MoveDir(attackdirection);
if (G.cboard[HumanLocation.x][HumanLocation.y]) //if there is a human there, which there should be
G.cboard[HumanLocation.x][HumanLocation.y]->AttackCreature(G,reversedirection);
}
void Zombie::Attack(Grid G)
{
int attackdirection=DecideAttack(G);
AttackCreature(G,attackdirection);
}
main.cpp
#include <cstdlib>
#include <iostream>
#include "definitions.h"
using namespace std;
int main(int argc, char *argv[])
{
Grid G(500,500);
system("PAUSE");
return EXIT_SUCCESS;
}
