#include <worm.hpp>

Collaboration diagram for Worm:

Classes
struct	SEGMENT

Public Types
enum	WormKind { VEGETARIAN, CANNIBAL, SCISSORHEAD }

Public Member Functions
void	createWorm (WormKind type, const char *sy)

Private Types
enum	LIFE { EATEN, DEAD, ALIVE }

Private Member Functions
void	checkStomach ()

void	eat ()

void	eatACarrot ()

void	gotEaten ()

int	isAt (int row, int col)

int	isHungry ()

void	live ()

void	setVictimWorm ()

void	shiftBodyDown (Worm *vp, int vsn)

void	showOneWorm ()

Worm *	sliceTheVictim (Worm *vp, int vsn)

Private Attributes
SEGMENT	body [MAXsegs]

int	direction

int	nsegs

LIFE	status

int	stomach

WormKind	type

Detailed Description

Definition at line 20 of file worm.hpp.

Member Enumeration Documentation

enum Worm::LIFE

private

Enumerator
EATEN
DEAD
ALIVE

Definition at line 31 of file worm.hpp.

                {
     EATEN, DEAD, ALIVE
   } LIFE;

enum Worm::WormKind

Enumerator
VEGETARIAN
CANNIBAL
SCISSORHEAD

Definition at line 23 of file worm.hpp.

                {
     VEGETARIAN, CANNIBAL, SCISSORHEAD
   } WormKind;           // 0, 1, 2

Member Function Documentation

void Worm::checkStomach ( )

private

Definition at line 51 of file worm.cpp.

References DEAD, showOneWorm(), status, stomach, type, and xworms.

Referenced by live(), shiftBodyDown(), and sliceTheVictim().

 {
   if (this->stomach <= 0) {
     this->status = DEAD;
     xworms[this->type] --;
     this->showOneWorm();        // mv the body to passive
   }
 }

void Worm::createWorm	(	WormKind	type,
		const char *	sy
	)

Definition at line 208 of file worm.cpp.

References ALIVE, asogCols, asogRows, body, Worm::SEGMENT::c, WormInfo::capacity, direction, findSlot(), headSeg, MAXsegs, min, NORTH, nsegs, random, status, stomach, type, worm_info, Worm::SEGMENT::x, xworms, and Worm::SEGMENT::y.

 {
   Worm *wp = findSlot();
   if (wp == 0)
     return;         // no room for a new worm
 
   int n = wp->nsegs = min(strlen(sy), MAXsegs - 1);
   wp->stomach = n * worm_info[type].capacity;
   wp->direction = NORTH;
   wp->status = ALIVE;
   wp->type = type;
 
   SEGMENT * bp = wp->body;
   int yy = bp->y = random(asogRows);    // birth place of this worm
   int xx = bp->x = random(asogCols);
   bp->c = ' ';              // works as an "eraser"
 
   SEGMENT * hp = headSeg(wp);
   for (bp++; bp <= hp; bp++) {
     bp->c = *sy++;      // store the phrase s[]
     bp->x = xx;         // worm hangs down in the z-axis
     bp->y = yy;
   }
   xworms[type] ++;
 }

void Worm::eat ( )

private

Definition at line 155 of file worm.cpp.

References ALIVE, CANNIBAL, eatACarrot(), WormInfo::foodValue, gotEaten(), nsegs, setVictimWorm(), sliceTheVictim(), status, stomach, type, VEGETARIAN, victimSegNum, and worm_info.

Referenced by live().

 {
   if (this->type != VEGETARIAN) {
     this->setVictimWorm();
     if (victimWormp != 0) {
       this->stomach += worm_info[victimWormp->type].foodValue;
       Worm * zp = sliceTheVictim(victimWormp, victimSegNum);
       if (this->type == CANNIBAL && zp->status == ALIVE) {
     this->stomach += zp->nsegs * worm_info[zp->type].foodValue;
     zp->gotEaten();
       }
     }
   }
   this->eatACarrot();
 }

void Worm::eatACarrot ( )

private

Definition at line 63 of file worm.cpp.

References asog, CARROT, ASOG::onec, passive, stomach, xOf, and yOf.

Referenced by eat().

 {
   ASOG *sg = asog(passive, yOf(this), xOf(this));
   if (CARROT == sg->onec) {
     this->stomach += 2;     // food value of one carrot
     sg->onec = ' ';
   }
 }

void Worm::gotEaten ( )

private

Definition at line 40 of file worm.cpp.

References ALIVE, EATEN, status, type, and xworms.

Referenced by eat().

 {
   if (this->status == ALIVE) {
     this->status = EATEN;
     xworms[this->type] --;
   }
 }

int Worm::isAt	(	int	row,
		int	col
	)

private

Definition at line 76 of file worm.cpp.

References headSeg, nsegs, Worm::SEGMENT::x, and Worm::SEGMENT::y.

 {
   SEGMENT *bp = headSeg(this);
   for (int sn = this->nsegs; sn > 0; sn--, bp--)
     if ((bp->y == row) && (bp->x == col))
       return sn;
 }

int Worm::isHungry ( )

private

Definition at line 31 of file worm.cpp.

References ALIVE, WormInfo::capacity, nsegs, status, stomach, type, and worm_info.

Referenced by live().

 {
   int m = this->stomach;
   int n = this->nsegs * worm_info[this->type].capacity;
   return (this->status == ALIVE && 4*m < 3*n);
 }

void Worm::live ( )

private

Definition at line 184 of file worm.cpp.

References asogCols, asogRows, body, checkStomach(), direction, dxa, dya, eat(), headSeg, isHungry(), nextTurn, random, and stomach.

 {
   SEGMENT *hp = headSeg(this);
   for (SEGMENT * bp = this->body; bp < hp; bp++) // < not <=
     bp->x = (bp + 1)->x, bp->y = (bp + 1)->y;  // crawl
 
   int dir = this->direction = (this->direction + nextTurn[random(16)]) % 8;
   hp->y += dya[dir];
   hp->x += dxa[dir];
   if (hp->y < 0) hp->y = asogRows-1;
   if (hp->x < 0) hp->x = asogCols-1;
   if (hp->y >= asogRows) hp->y = 0;
   if (hp->x >= asogCols) hp->x = 0;
 
   this->stomach--;
   if (this->isHungry())
     this->eat();
   this->checkStomach();
 }

void Worm::setVictimWorm ( )

private

Definition at line 94 of file worm.cpp.

References ALIVE, hxWorms, status, victimSegNum, wormArray, xOf, and yOf.

Referenced by eat().

 {
   Worm *headWorm = wormArray + hxWorms;
   victimWormp = 0;
   victimSegNum = 0;
   for (Worm * wp = wormArray; wp < headWorm; wp++) {
     if (wp != this && this->status == ALIVE) {
       victimSegNum = wp->isAt(yOf(this), xOf(this));
       if (victimSegNum > 0) {
     victimWormp = wp;
     return;         // found the victim
       }
     }
   }
 }

void Worm::shiftBodyDown	(	Worm *	vp,
		int	vsn
	)

private

Definition at line 114 of file worm.cpp.

References body, checkStomach(), headSeg, nsegs, and stomach.

Referenced by sliceTheVictim().

 {
   SEGMENT *dp = vp->body + 1;       // dp destination, sp source
   SEGMENT *hp = headSeg(vp);
   for (SEGMENT *sp = vp->body + vsn + 1; sp <= hp; )
     *dp++ = *sp++;
   int tsegs = vp->nsegs;
   vp->nsegs -= vsn;
   vp->stomach = vp->stomach / tsegs * vp->nsegs;
   vp->checkStomach();
 }

void Worm::showOneWorm ( )

private

Definition at line 15 of file worm.cpp.

References ALIVE, asog, ASOG::attr, body, Worm::SEGMENT::c, WormInfo::color, EATEN, headSeg, ASOG::onec, passive, screen, status, type, worm_info, Worm::SEGMENT::x, and Worm::SEGMENT::y.

Referenced by checkStomach().

 {
   if (this->status != EATEN) {
     ASOG *f = (this->status == ALIVE ? screen : passive);
     SEGMENT *bp, *hp = headSeg(this);
     for (bp = this->body + 1; bp <= hp; bp++) {
       ASOG *g = asog(f, bp->y, bp->x);
       g->attr = worm_info[this->type].color;
       g->onec = bp->c;
     }
   }
 }

Worm * Worm::sliceTheVictim	(	Worm *	vp,
		int	vsn
	)

private

Definition at line 131 of file worm.cpp.

References checkStomach(), findSlot(), nsegs, shiftBodyDown(), stomach, type, and xworms.

Referenced by eat().

 {
   int tsegs = vp->nsegs;
   Worm *wp = findSlot();
   if (wp == 0)          // could not find a slot
     return vp;
 
   xworms[vp->type]++;
 
   *wp = *vp;            // bottom-half
   wp->nsegs = vsn - 1;
   wp->stomach = vp->stomach / tsegs * wp->nsegs;
   wp->checkStomach();
 
   shiftBodyDown(vp, vsn);   // the top-half
   return wp;
 }