A-Star Guard

// Check if we should mMove, or if we are 'close enough'
      // AStar clearence is used to give us enough room to get around corners
      if (mFabs(xDiff) < tol && mFabs(yDiff) < tol) {
         if (path.size())
         {
            mMoveDestination = path[1];
            path.pop_front();
         }

// Check if we should mMove, or if we are 'close enough'
      // AStar clearence is used to give us enough room to get around corners
      if (mFabs(xDiff) < tol && mFabs(yDiff) < tol) {
         if (path.size() > 1)
         {
            mMoveDestination = path[1];
            path.pop_front();
         }

if (!%obj || %obj.getstate $="Dead")
			return;

if (!%obj || %obj.getstate() $="Dead")
			return;

function AIGuard::respawn(%this, %name, %obj)
{
   // Create the demo player object
   %player = new AIGuard() {
   dataBlock = GuardPlayer;

function AIGuard::respawn(%this, %name, %obj, %block)
{
   // Create the demo player object
   %player = new AIGuard() {
   dataBlock = %block;

function GuardPlayer::OnDamage(%this, %obj, %delta)
{
   		
   	if (obj.action !$="GetHealth")

function GuardPlayer::OnDamage(%this, %obj, %delta)
{
   		
   	if (%obj.action !$="GetHealth")

//This is the spawn function for the bot.
function AIGuard::spawn(%name, %obj, %block)
{
   // Create the player on the datablock, so that we can tune parameters by
   // player type.
   %player = %block.spawn(%name,%obj);
   MissionCleanup.add(%player);
   
  	// Sets whether the bot will respawn or not based on it's markers 
  	// dynamic variable. If not set on marker, use the bot's default.
   if (%obj.respawn !$= "" )
  	{
  		if (%obj.respawn == true)
  			%player.respawn=true;
  		else
  			%player.respawn=false;
  	}
   	
   // if the field is not blank, set the weapon variable to the weapon
   // otherwise, use the default for the bot.
   if (%obj.Weapon !$= "")
   {
      %player.Weapon = %marker.Weapon;
      %player.Ammo = %marker.Weapon @ "Ammo";
      %player.AmmoCount = %marker.AmmoCount;
   }

   //Equipbot is called to set the bots beginning inventory.
   %player.EquipBot(%player); 
   //Sets the name displayed in the hud above the bot.
   %player.setShapeName(%name);
   //Sets the bot's initial position to that of it's marker.
   %player.setTransform(%obj.gettransform());
   
   
   //Sets the bot to begin thinking after waiting the length of $AI_GUARD_CREATION_DELAY
   %chance = getRandom(($AI_GUARD_CREATION_DELAY-1)) +1000;
   %player.schedule(%chance,"Think", %player);
   return %player;
}

%prevaction=%obj.action;

// NEW >>>
      // Check to see if the creature processes his own thinking for his current state. 
      %scTime = %obj.dataBlock.DoThink(%this, %obj);
      if (%scTime > 0)
      {
         %this.ailoop=%this.schedule(%scTime  ,"Think" , %obj);
          return;
      }
      // NEW <<<

//You can specifiy as many datablocks as you have characters.
// the first variable after PlayerData must be a unique name.  the second variable (after :) 
// must be a valid body type.

datablock PlayerData(BoombotPlayer : BoomBotData)
{
   //The next three variables control the bot's movement speed.
   //These are set slightly lower than the stock AIPlayer values.
   //Since I wanted the guards to be more lumbering.
   maxForwardSpeed = 8;
   maxBackwardSpeed = 6;
   maxSideSpeed = 8;
   // maxDamage = 100;   // hitpoints
   
   shootingDelay = 100;
};


// Create our AIGuard here
function BoombotPlayer::spawn(%this,%name, %marker)
{
   %maxAttention = 10;
   %holdcountmax = 5;
   
   // Create the demo player object
   %player = new AIGuard() 
   {
      dataBlock = %this;        // Datablock to initialize with
      marker = %marker;          // Spawning Marker
      botname = %name;           // Name of the bot.
      isbot=true;                // True if a bot.
      defaultfov = 240;          // for restoring FOV
      fov=240;                   // Sets the bots field of vision
      respawn = true;            // Respawn on death?
      //Thinking variables
      firing = false;            //Firing tells whether or not we're in the midst of a firing sequence.
      action = "search";         //The 'action' variable holds the state of the bot - which controls how it thinks.
      
      holdcountmax = %holdcountmax;   //The number of think cycles that the bot will 'hold' for before trying
      holdcnt=%holdcountmax-1;        //to return to his post.
											
      maxAttention = %maxAttention;       //The maximum attention level (higher is slower)
      attentionlevel = %maxAttention/2;   //The bots starting attention level is set to half of it's range.
                                          //This number and scantime are multiplied to set the delay in the
														//thinking loop. Used to free up processor time on bots out of the mix.
														
      //Oldpos holds the position of the bot at the end of it's last 'think' cycle
      //This is used to help determine if a bot is stuck or not.
      oldpos = %marker.getposition();
      Weapon = "RocketLauncher";
      Ammo = "RocketLauncherAmmo";
      AmmoCount = 10;
   };
   
   return %player;
}

// *****************************************************************************
// DoThink retuns the next scheduled "think" time. If zero is returned,
// that means the think process wants the default Think process
// to continue.
// *****************************************************************************
function BoombotPlayer::DoThink(%aiguard, %player)
{
   
   return 0;
}

//The onReachDestination function is responsible for setting the bots 'action'
//state to the appropriate setting depending on what action the bot was following
//to reach the destination.
function BoombotPlayer::onReachDestination(%this,%obj)
{
  	//Picks an appropriate set of actions based on the bots 'action' variable
  	switch$(%obj.action)
  	{
  		//If the bot is attacking when it reaches it's target it will go into a hold.
  		case "Attacking":
  			%obj.action="Holding";
  		//If the bot is returning it has two possible scenarios for reaching a destination
  		//The first case is the the bot sidestepped and has reached it's sidestep location.
  		//If that is the case, then the bot goes into a quick hold. (Which sets the bot to
  		//only hold for 1 cycle before returning to his post.)
  		//The other alternative is that the bot has returned as is back at it's original position.
  		//If this is the case, then the bot's transform is set to match that of it's marker's
  		//transformation.
  		//This will cause a snapping into position - but it ensures that your guard always faces the
  		//direction you want it to when it returns to it's post.
  		//(It also helps to make sure that your markers are set as close to the ground as possible.
  		//Otherwise your bots will hop up and drop from the sky when they return to post.)
  		case	"Returning":
  			//basedist is the distance from the bot to it's original position
  			%basedist = vectorDist(%obj.getposition(), %obj.marker.getposition());
  			//if the bot is close to his original position then set it's action to
  			//Guarding and set it to it's original facing and position.
  			if(%basedist < 1.0)
  				{
  					%obj.action = "Guarding";
  					%obj.settransform(%obj.marker.gettransform());
  					%obj.clearaim();
  				}
  				//if the bot is away from his post, then he must have gotten here
  				//as a result of sidestepping so set him to do a quick hold to scan
  				//for targets then return to post.
  				else
  				{
  					//Sets holdcnt to 1 less than the max. Ensures that the bot only holds for 1 cycle.
  					//before trying to return.
  					%obj.holdcnt=$AI_GUARD_HOLDCNT_MAX-1;
  					%obj.action="Holding";
  				}
  			//The bot was defending and sidestepped. So set him to 'hold' to check for targets
  			//and to prepare to return to post if no targets are found.
  		case "Defending":
  			%obj.action = "Holding";
  	
			case "RetrievingItem":
				%obj.holdcnt=$AI_GUARD_HOLDCNT_MAX-1;
  			%obj.action="Holding";
				
				
			
			
  	}
   
}

//The OnDamage function sets the bots action to 'Dead' and starts the respawn process
//if called for.
function BoombotPlayer::OnDamage(%this, %obj, %delta)
{
   		
      //echo("GuardPlayer::OnDamage");
   	if (%obj.action !$="GetHealth")
   	{
   			%obj.action = "Defending";
   	}
   	
   	if(%obj.getstate() $="Dead") %obj.action="Dead";
   		
   	if(%obj.getState() $= "Dead" && %obj.respawn == true)
   		{
            //echo("GuardPlayer::OnDamage - Guard is Dead!");
   			%obj.ScheduleRespawn(%obj.botname, %obj.marker, 20000, %obj.dataBlock);
   			%this.player=0;
   		}
   	
}

//I dont use this function but left it in - just in case it does something I'm not privy to.
function BoombotPlayer::onEndSequence(%this,%obj,%slot)
{
   %obj.stopThread(%slot);
   %obj.nextTask();
}

// Add the default equipment to the bot, based on player type.
function AIGuard::EquipBot(%this, %obj)
{
   //This adds a weapon to the bots inventory.
   %obj.incinventory(%obj.Weapon,1);

   //This mounts the weapon on the bot.
   %obj.mountImage(%obj.Weapon @ "Image",0);

   //This sets the bots beginning inventory of ammo.
   %obj.setInventory(%obj.Ammo,%obj.AmmoCount);
}

Quote:
//Restore FOV sets the bot's FOV back to it's regular default setting.
function AIGuard::restoreFOV(%this, %obj)
{
%obj.fov = %obj.defaultfov;
}

function AIGuard::TargetAcquired(%this, %obj,%tgt)
{
   //Set the bots action to 'Attacking' and set it to attack quickly.
   %obj.action = "Attacking";
	
   //Set the bot to aim at the target.
   //(The code uses the VectorAdd to adjust the aim of the bot to correct for the
   //bot trying to shoot at the targets feet.)
   %obj.setAimObject(%tgt.player, "0 0 1");
   %dest = %tgt.player.getposition();
   %obj.findPathTo(%dest);
   %this.ailoop=%this.schedule(500,"Think" , %obj);   
}

%tgtid = %this.GetClosestHumanInSightandRange(%obj);
	//If %tgtid >0 then a target is in sight and range.
	if(%tgtid >=0)
	{
	// Adjust the aiming before we fire!  
	%tgt = ClientGroup.getobject(%tgtid);
	%this.TargetAcquired(%obj,%tgt);
	}

Quote:I'm thinking about releasing an updated version as a resource, but I'm not sure if anyone would be interested.