worm.cpp

Go to the documentation of this file.

/* worm.cpp deals with a single worm */

#include "worm.hpp"

#define headSeg(wp) (wp->body + wp->nsegs)
#define xOf(wp)     (headSeg(wp)->x)
#define yOf(wp)     (headSeg(wp)->y)
/*@ nsegs >= 0 && 0 <= direction <= 7 && stomach >= 0 && connected(wp) &&  */ 

/* Show a single worm.  pre: wp != 0.  post: It is drawn on passive[]
   if it is dead.  If alive, it is drawn on screen[].  If eaten, not
   drawn. ; */

void Worm::showOneWorm()
{
  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;
    }
  }
}

/* It is hungry if its tummy is at least 25% empty.  pre: wp != 0;
   post: Return 1 if worm wp is hungry; otherwise return 0.  */

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

/* pre: wp != 0 */

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

/* pre: this->status == ALIVE; post: if stomach is 0 or less, mark it
   dead, and send its body to the cemetary. */

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

/* Eat a carrot, if available.  pre: this->status == ALIVE; post:
   ...; */

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

/* Check if any segment of worm wp is at (col, row).  Return this
   segment's number.  Recall that body[0] is just an eraser-blank, not
   really a part of the worm.  pre: wp != 0; post: ...; */

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

/* The following two vars should be 'out' parameters (var params), but
   for ease of understanding, let us declare these as globals. */

Worm *victimWormp;
int victimSegNum;

/* Find a worm that is on the same square as "my" head.  pre: me != 0;
   post: victimSegNum > 0 => victimWormp != 0 and victimWormp's
   victimSegNum segment is at the same square as the head of me.  */

void Worm::setVictimWorm()
{
  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
      }
    }
  }
}

/* Copy the body segments.  pre: vp != 0 && 0 < vsn <= vp->nsegs;
   post: old body[vsn+1..end] should become new body[1..new-length];
   body[0] remains as the eraser-blank */

void Worm::shiftBodyDown(Worm * vp, int vsn)
{
  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();
}

/* A scissor-head or cannibal hit the victim at segment number vsn.
   Slice the victim into two.  pre: vp != 0 && 0 < vsn <= vp->nsegs;
   post: The first one with vp->body[1..vsn-1] and the second one with
   vp->body[vsn+1..vp->nsegs] as its new body.  */

Worm * Worm:: sliceTheVictim(Worm * vp, int vsn)
{
  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;
}


/* Eat whatever you find at the wp's head position.  If wp is a
   cannibal or scissor-head it will also eat a carrot, if available.
   Update the stomach contents.  pre: isHungry(wp) && wp->status ==
   ALIVE; post: ...; */

void Worm::eat()
{
  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();
}

// dx/dy changes, indexed by DIRECTION; (+0 just to line up)
const int dxa[] = { +0, +1, +1, +1, +0, -1, -1, -1 };
const int dya[] = { -1, -1, +0, +1, +1, +1, +0, -1 };

const int nextTurn[16] = {  // experiment with other values
  0, 0, 0, 0,  0, 0, 0, 0,  // think: why 16?
  1, 1, 1, 7,  7, 7, 2, 6
};

/* One moment in the life of a worm: crawl by one step using one unit
   of food, may change direction, eat if hungry, mark as dead if
   stomach is now empty.  */

void Worm::live()
{
  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();
}

/* Create a worm.  It should be just long enough to carry the phrase
   sy[].  It is going to crawl out of a random hole.  pre: sy != 0;
   post: ...; */

void Worm::createWorm(WormKind type, const char * sy)
{
  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] ++;
}