---

TBadGuy.cpp

Go to the documentation of this file.

// Copyright 2002 Kenneth Guy,
// 
// You are free to take the source and do as you wish with it.
// However it would be nice if you let me know if the code was useful
// to you and give me an acknowledgement if you use a significant portion
// of the code in an application.
// 
// TBadGuy.cpp

#include "TBadGuy.h"
#include "TPlayersShip.h"
#include "TBullet.h"
#include "CGame.h"
#include "TGamePanics.h"

#include "TMapLineType.h"
#include "TPathLineType.h"

TBadGuy::TBadGuy() {

}

void TBadGuy::Init(TInt16 aType,const  TInt16 aArgs[]) {
  SetSpriteNo(aArgs[0]);
  iX=aArgs[1];
  iY=aArgs[2];
  iHealth=aArgs[3];
  iXVel=0;
  iYVel=aArgs[5];
  iFlags=0;
  iPath=0;
  iId=0;
  iCounter=0;

  if(aType & EMapLineObjectMovementMapRelative) {
    iFlags |= TBadGuyFlags::EMapRelative;
  }

  if(aType & EMapLineObjectMovementSimple) {
    iXVel=aArgs[4];
    iFlags |= TBadGuyFlags::ESimpleMoves;
    if(aType & EMapLineObjectMovementBounceTop)
      iFlags |= TBadGuyFlags::EBounceTop;
    if(aType & EMapLineObjectMovementBounceBottom)
      iFlags |= TBadGuyFlags::EBounceBottom;
    if(aType & EMapLineObjectMovementBounceLeft)
      iFlags |= TBadGuyFlags::EBounceLeft;
    if(aType & EMapLineObjectMovementBounceRight)
      iFlags |= TBadGuyFlags::EBounceRight;

  } else if(aType & EMapLineObjectMovementHoming) {
    iXVel=aArgs[4];
    iFlags |= TBadGuyFlags::ESimpleMoves;
    if(aType & EMapLineObjectMovementHomingX)
      iFlags |= TBadGuyFlags::EHomingX;
    if(aType & EMapLineObjectMovementHomingY)
      iFlags |= TBadGuyFlags::EHomingY;

  } else if(aType & EMapLineObjectMovementPath) {
    iPath=aArgs[4];
    iXVel=0;
    iFlags |= TBadGuyFlags::EPathMove;
  }
  

  if(aType & EMapLineObjectBadGuy) {
    iScore=20;
    iFlags |= TBadGuyFlags::EKillsPlayer;
    iId=aArgs[6];
    // negative health means that this item can't be destroyed
    // (or is destroyed by shooting something else)
    if(iHealth < 0) {
      iHealth=-iHealth;
      iFlags |= TBadGuyFlags::EInvunerable;
    }
  } else if(aType & EMapLineObjectCollectable) {
    iFlags |= TBadGuyFlags::ETransparent;
    // gives player health, bullets don't effect it,
    // simple movement,
    if(aArgs[6]==0)
      iFlags |= TBadGuyFlags::EHealthBonus;
    else if(aArgs[6]==1)
      iFlags |= TBadGuyFlags::ELifeBonus;
    else if(aArgs[6]==2)
      iFlags |= TBadGuyFlags::EWeaponBonus;
  }
}


void TBadGuy::Move(TInt aPlayerX, TInt aPlayerY,
                   const TInt16 *aPaths,CGame &aGame) {
  // something that is dieing no movement just an explosion
  if(iHealth <= 0) {
    iHealth--;
    TInt16 spriteno= -(iHealth/2);
    spriteno+= aGame.FirstExplosionSprite();
    if(spriteno>aGame.LastExplosionSprite())
      ClearSprite();
    else 
      SetSpriteNo(spriteno);

  // things that just keep going in one direction, maybe bounce and maybe home
  }  else if(iFlags & TBadGuyFlags::ESimpleMoves) {
    SimpleMove(aPlayerX,aPlayerY);

    // things that follow a path
  } else if(iFlags & TBadGuyFlags::EPathMove) {
    PathMove(aPlayerX,aPlayerY,aPaths,aGame);
  }

  // if moving relative to the map then add the map velocity
  if(iFlags & TBadGuyFlags::EMapRelative) {
    iX+=aGame.MapSpeed();
  }

  // if the bad guy ends up off the sides of the offscreen map
  if(iY<-24 || iY>200 || iX<0 || iX>336) {
    ClearSprite();
  }
  
}


void TBadGuy::PathMove(TInt16 aPlayerX, TInt16 aPlayerY,
                       const TInt16 *aPaths, CGame &aGame) {
                   
  TBool foundMove=EFalse;

  // continue processing path commands until we hit a move command
  while(foundMove==EFalse) {
    // casting it to TPathLineType enum means we get warnings if
    // the switch statement doesn't handle one of the enum values.
    switch((TPathLineType) (aPaths[iPath*4])) {
    case EPathLineEnd:
      // do nothing except exit, really only a marker for level generation tool
      foundMove=ETrue;
      break;
    case EPathLineStart: //  really only a marker for level generation tool
      iPath+=aPaths[(iPath*4)+1];
      break;
      
    case EPathLineClone:
      {
        // other bad guy continues on path from arg 2
        // this bad guy continues on path from arg 1
        TInt oldpath=iPath+aPaths[(iPath*4)+1];
        // set iPath for cloned bad guy
        iPath+=aPaths[(iPath*4)+2];
        aGame.AddBadGuy(*this);
        // now set iPath back for this bad guy
        iPath=oldpath;
      }
      break;

      //movement
    case EPathLineMoveBy:
      iX+=aPaths[(iPath*4)+2];
      iY+=aPaths[(iPath*4)+3];
      iPath+=aPaths[(iPath*4)+1];
      foundMove=ETrue;
      break;
    case EPathLineMoveTo:
      iX=aPaths[(iPath*4)+2];
      iY=aPaths[(iPath*4)+3];
      iPath+=aPaths[(iPath*4)+1];
      foundMove=ETrue;
      break;
    case EPathLineMoveStepTo: {
      if(iX < aPaths[(iPath*4)+2]) {        
        iX += iXVel;
        // check we don't overshoot
        if(iX > aPaths[(iPath*4)+2])
          iX=aPaths[(iPath*4)+2];
      } else if(iX > aPaths[(iPath*4)+2]) {
        iX -= iXVel;
        // check we don't overshoot
        if(iX < aPaths[(iPath*4)+2])
          iX=aPaths[(iPath*4)+2];
      }

      if(iY < aPaths[(iPath*4)+3]) {        
        iY += iYVel;
        // check we don't overshoot
        if(iY > aPaths[(iPath*4)+3])
          iY=aPaths[(iPath*4)+3];
      } else if(iY > aPaths[(iPath*4)+3]) {
        iY -= iYVel;
        // check we don't overshoot
        if(iY < aPaths[(iPath*4)+3])
          iY=aPaths[(iPath*4)+3];
      }

      // stay on this command until we get to where we are going
      if(iX == aPaths[(iPath*4)+2] &&
         iY == aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+1];
      }
      foundMove=ETrue;
      break;
    }
    case EPathLineMoveSimple:
      SimpleMove(aPlayerX,aPlayerY);
      iPath+=aPaths[(iPath*4)+1];
      foundMove=ETrue;
      break;



      // conditionals
      
    case EPathLineIfXVelLess:
      if(iXVel < aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfXVelGreater:
      if(iXVel > aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfXVelEqual:
      if(iXVel == aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfYVelLess:
      if(iYVel < aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfYVelGreater:
      if(iYVel > aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfYVelEqual:
      if(iYVel == aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
      
    case EPathLineIfXLess:
      if(iX < aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfXGreater:
      if(iX > aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfXEqual:
      if(iX == aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfYLess:
      if(iY < aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfYGreater:
      if(iY > aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfYEqual:
      if(iY == aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
      
    case EPathLineIfHealthLess:
      if(iHealth < aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfHealthGreater:
      if(iHealth > aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfHealthEqual:
      if(iHealth == aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfCounterLess:
      if(iCounter < aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfCounterGreater:
      if(iCounter > aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      }
      break;
    case EPathLineIfCounterEqual:
      if(iCounter == aPaths[(iPath*4)+3]) {
        iPath+=aPaths[(iPath*4)+2];
      } else {
        iPath+=aPaths[(iPath*4)+1];
      } 
     break;
      // setting
      
    case EPathLineSetPoints:
      iScore = aPaths[(iPath*4)+2];
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineSetId:
      iId = aPaths[(iPath*4)+2];
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineSetHealth:
      iHealth = aPaths[(iPath*4)+2];
      // if health has got to zero die
      if(iHealth <= 0) {
        Die(aGame);
        // dead so end of path,
        foundMove=ETrue;
      }      
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineAddHealth:
      iHealth += aPaths[(iPath*4)+2];
      // if health has got to zero die
      if(iHealth <= 0) {
        Die(aGame);
        // dead so end of path,
        foundMove=ETrue;
      }      
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineSetVelocity:
      iXVel=aPaths[(iPath*4)+2];
      iYVel=aPaths[(iPath*4)+3];      
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineAddVelocity:
      iXVel+=aPaths[(iPath*4)+2];
      iYVel+=aPaths[(iPath*4)+3];      
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineSetSprite:
      SetSpriteNo(aPaths[(iPath*4)+2]);
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineSetClearFlags:
      iFlags |= aPaths[(iPath*4)+2];
      iFlags &= ~(aPaths[(iPath*4)+3]);
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineSetCounter:
      iCounter = aPaths[(iPath*4)+2];
      iPath+=aPaths[(iPath*4)+1];
      break;
    case EPathLineAddCounter:
      iCounter += aPaths[(iPath*4)+2];
      iPath+=aPaths[(iPath*4)+1];
      break;

    }
  }
}

void TBadGuy::SimpleMove(TInt16 aPlayerX, TInt16 aPlayerY) {
  if(iFlags & TBadGuyFlags::EHomingX) {
    if(iX < aPlayerX) {        
      iX += iXVel;
      if(iX > aPlayerX)
        iX=aPlayerX;
    } else if(iX > aPlayerX) {
      iX -= iXVel;
      if(iX < aPlayerX)
        iX=aPlayerX;
      }
  } else {
    iX+=iXVel;
    if(  (iX>303 && (iFlags & TBadGuyFlags::EBounceRight)) ||
         (iX<16 && (iFlags & TBadGuyFlags::EBounceLeft))) {
      iXVel= -iXVel;
      iX+= iXVel;
    }  
  }

  if(iFlags & TBadGuyFlags::EHomingY) {
    if(iY < aPlayerY) {        
      iY += iYVel;
      if(iY > aPlayerY)
          iY=aPlayerY;
    } else if(iY > aPlayerY) {
      iY -= iYVel;
      if(iY < aPlayerY)
        iY=aPlayerY;
    }
  } else {
    iY+=iYVel;
    if((iY<0 && (iFlags & TBadGuyFlags::EBounceTop)) ||
       (iY>176 && (iFlags & TBadGuyFlags::EBounceBottom))) {
      iYVel= -iYVel;
      iY+= iYVel;
    }            
  }
}

void TBadGuy::HitBullet(TBullet& aBullet, CGame &aGame) {
  if(iHealth<=0)
     return;

  if(iFlags & TBadGuyFlags::EInvunerable) {
    // these just absord bullets
    aBullet.ClearSprite();
  } else if(iFlags & TBadGuyFlags::ETransparent) {
    // has no effect on bullets and vice versa
  } else {
    // damage done can't be more than bad guys health,
    // damage done is subtracted from bad guys health and bullets health
    TInt damageTaken=aBullet.Health();
    if(damageTaken > iHealth)
      damageTaken=iHealth;

    if(damageTaken<0) {
      TGamePanics::Panic(TGamePanics::ENegativeDamage);
    }
    
    aBullet.AddHealth(-damageTaken);

    if(iId > 0) {
      aGame.DamageBadGuys(iId,damageTaken);
    } else if(iId < 0) {
      // negative ids don't get damaged when other parts get hit
      // so damage this one directly,
      aGame.DamageBadGuys(-iId,damageTaken);
      Damage(damageTaken,aGame);
    } else {
      Damage(damageTaken,aGame);
    }
  }
}

void TBadGuy::HitShip(TPlayersShip &aShip, CGame &aGame) {
  if(iHealth<=0)
     return;

  if(iFlags & TBadGuyFlags::EKillsPlayer) {
    if(iFlags & TBadGuyFlags::EInvunerable) {
      aShip.SetHealth(0);
    } else {
      aShip.AddHealth(-iHealth);
    }

    // if this is a multi part bad guy we need to damage the other
    // parts.
    if(iId > 0) {
      aGame.DamageBadGuys(iId,iHealth);
    } else if(iId < 0) {
      // negative ids don't get damaged when other parts get hit
      // so damage this one directly,
      aGame.DamageBadGuys(-iId,iHealth);
      Damage(iHealth,aGame);
    } else {
      Damage(iHealth,aGame);
    }

    
  } else {
    if(iFlags & TBadGuyFlags::EHealthBonus) {
      aShip.AddHealth(iHealth);
    }
    if(iFlags & TBadGuyFlags::ELifeBonus) {
      aGame.Bonus(CGame::EBonusLife);
    }
    if(iFlags & TBadGuyFlags::EWeaponBonus) {
      aGame.Bonus(CGame::EBonusPowerup);
    }
    Die(aGame);
  }
}

void TBadGuy::Damage(TInt aHealth, CGame &aGame) {
  iHealth-= aHealth;
  if(iHealth <=0) {
    Die(aGame);
  }  
}

void TBadGuy::Die(CGame &aGame) {
  iHealth=0;
  if(iFlags & TBadGuyFlags::EKillsPlayer) {
    aGame.AddScore(iScore);
  } else {
    ClearSprite();
  }
}

TInt16 TBadGuy::Id() {
  return iId;
}

---