Reality Factory

Code: Select all

{
	//	 Perfect AI Version 1.1
	//	 by Peter Coleman
	//   monster will fire missiles or melee if close enough
	//   Changes to ai-run and Check-Any-Attack


	SCALE				[1]			// scale of actor
	GROUP				[Zombie]	// name of monster group
	BOXWIDTH			[25]		// width and depth of bounding box
	HOSTILEPLAYER		[true]		// hostile to player
	HOSTILEDIFFERENT	[false]		// hostile to different Pawn group
	HOSTILESAME			[false]		// hostile to same Pawn group
	HEALTHATTRIBUTE		[health]	// name of health attribute
	HEALTH				[50]		// initial amount of health
	SIGHTDIST			[2000]		// max distance monster can see at idle
	ALERTSIGHTDIST		[1500]		// max distance monster can see when alert
	FOV					[360]		// field of view in degrees
	ATTACKFOV			[360]		// attacking field of view
	YAWSPEED			[360]		// speed of rotation in deg/sec
	DAMAGEATTRIBUTE		[health]	// attribute damaged by attack
	ALERTTRIGGER		[AlertG]	// name of alert trigger

	// define the type of monster this will be

	ATTACKTYPE			[melee]	// type of attack - melee or missile
	PATROL				[false]		// false - ambush or true - patrol
	PC					[0]			// make any visible point the next point

	// idling and turning

	STAND				[Idle]		// idle animation
	TURNL				[Idle]		// turn left animation
	TURNR				[Idle]		// turn right animation

	// when in pain

	PAIN				[Hit]		// pain animations
	PAIN1				[Hit]
	PAIN2				[Hit]
	PAIN3				[Hit]
	PAINPERCENT			[50]				// percentage of time pain is shown
	PAINSOUND			[pl_pain6.wav]		// sounds played when in pain
	PAINSOUND1			[injuryl.wav]
	PAINSOUND2			[injury1.wav]
	PAINSOUND3			[injury1.wav]

	// when dying

	DIE					[Die]		// dying animations
	DIE1				[Die_de_frente]
	DIE2				[Die_rodilla]
	DIE3				[Die_vueltas]
	DIEHOLD				[false]				// time corpse still appears
	DIEFADE				[false]				// fadeout time of corpse
	DIESOUND			[deathyell.wav]		// sounds played when dying
	DIESOUND1			[die.wav]
	DIESOUND2			[death1.wav]
	DIESOUND3			[deathyell.wav]

		// when running to attack

	RUN					[Run]			// running animation
	RUNSPEED			[90]			// average run speed
	RUNSOUNDDELAY		[2]				// delay between making sounds when running to attack
	RUNSOUND			[breath.wav]	// sound played while running to attack

	// when walking while patroling

	WALK				[Walk]			// walking animation
	WALKSPEED			[30]			// average walking speed
	WALKSOUND			[breath.wav]	// walking sound

// the melee attack mode

	MELEEATTACK			[Shoot]	// melee attacking animations
	MELEEATTACK1		[Hit]
	MELEEATTACK2		[Shoot]
	MELEESOUND			[uuh.wav]				// sounds played when melee attacking
	MELEESOUND1			[uuh.wav]
	MELEESOUND2			[uuh.wav]
	MELEERANGE			[55]					// max distance to start melee attack
	MAXMELEERANGE		[200]					// max distance for melee mode
	MINMELEEDAMAGE		[10]					// minimum amount of damage per melee attack
	MAXMELEEDAMAGE		[10]					// maximum amount of damage per melee attack
	MELEEDELAY			[2]						// number of seconds between melee damages
	MELEEDAMAGESOUND	[melee2.wav]			// sound played when damage is done

	// search for enemy

	LOSTTIME			[10]	// time to search for enemy before giving up
	POINTRADIUS			[20]	// radius from point when considered there

	// obstacle avoidance forces for jumping

	FORCEUP				[15]	// obstacle avoidance jump speed
	FORCEFORWARD		[20]	// obstacle avoidance forward speed
	FORCESIDE			[20]	// obstacle avoidance sideways speed

	// local variables - do not change

	
	RUNFUNC				[monster_run_start]			// monster run to attack function
	MELEEFUNC			[monster_melee_start]		// monster melee function
	LOSTFUNC			[monster_lost_target_start]	// monster lost target function

	AS_NONE				[0]
	AS_MELEE			[1]
	AS_STRAIGHT			[3]
	attack_delay		[0]
	melee_time			[0]
	lost_time			[0]
	back_up				[false]
	back_time			[0]
	left_time			[0]
	back_flag			[false]
	skill_time			[0]
	attack_state		[0]
	run_sound_time		[0]

	// spawn pawn and do setup work

	Spawn[ ()
	{
		Console(true);
		Scale(SCALE);	// scale the actor
		if(BOXWIDTH > 0)
		{
			BoxWidth(BOXWIDTH*SCALE);	// set bounding box width/depth
		}
		AttributeOrder(HEALTHATTRIBUTE, HEALTH, "Death");	// give monster health
		HostilePlayer(HOSTILEPLAYER);						// set who monster is hostile to
		HostileSame(HOSTILESAME);
		HostileDifferent(HOSTILEDIFFERENT);
		SetFOV(360,"Bip01 Head");							// set field of view
		SetGroup(GROUP);									// assign a group to belong to
		FindTargetOrder(SIGHTDIST, "FoundTarget", DAMAGEATTRIBUTE);	// seen a target to chase
		AddPainOrder("IdlePain", 100);							// show pain and trigger alert
		AvoidOrder("Avoidance"); 								// avoid obstacles
		AddTriggerOrder("IdleToAlert", ALERTTRIGGER, 0);	// go to alert when triggered
		RotateToPoint(STAND, YAWSPEED, false, ""); 			// go to point if any specified
		MoveToPoint(WALK, WALKSPEED*SCALE, WALKSOUND);
		if(PATROL = true)
		{
			NewOrder("Idle");
		}
		else
		{
			NewOrder("Patrol");
		}
	} ]

	// avoid objects when doing a MoveToPoint

	Avoidance[ ()
	{
		if(random(1,10)<3)	// backup and move sideways sometimes
		{
			MoveBackward(WALK, WALKSPEED*SCALE, (WALKSPEED/2)*SCALE, "");
			MoveRight(WALK, WALKSPEED*SCALE, (WALKSPEED/2)*SCALE, "");
		}
		else
		{
			Jump(RUN, FORCEUP*SCALE, true, "");
			if(random(1,10)<6)
			{
				Move("", FORCEFORWARD*SCALE, (FORCEFORWARD/2)*SCALE, 0, 90, 0, "");
			}
			else
			{
				Move("", FORCEFORWARD*SCALE, (FORCEFORWARD/2)*SCALE, 0, -90, 0, "");
			}
		}
		Return();
	} ]

	// idle in place waiting for something to happen

	Idle[ ()
	{
		PlayAnimation(STAND, true, "");
		}
			else
			{
			NewOrder("FoundTarget");
		}
	} ]	

	// walk the beat from point to point

	Patrol[ ()
	{
		NextPoint();
		RotateMoveToPoint(WALK, YAWSPEED, WALKSPEED*SCALE, false, WALKSOUND);
		MoveToPoint(WALK, WALKSPEED*SCALE, WALKSOUND);
		RestartOrder();
	} ]

	// show pain at idle then trigger to alert

	IdlePain[ ()
	{
		
		NewOrder("FoundTarget");
	} ]	

	// start shifting from idle to alert

	IdleToAlert[ ()
	{
		NewOrder("FoundTarget");
	} ]

	// look around at alert looking for enemy

	Alert[ ()
	{
		NewOrder("FoundTarget");
	} ]	

	// show pain at alert

	AlertPain[ ()
	{
		NewOrder("FoundTarget");
	} ]	

	// timed out at alert

	AlertToIdle[ ()
	{
		if(PATROL = true)
		{
			NewOrder("FoundTarget");
		}
		else
		{
			NewOrder("FoundTarget");
		}
	} ]

	// found a target to attack

	FoundTarget[ ()
	{
		SetFOV(360,"Bip01 Head");	// set field of view
		LowLevel(RUNFUNC);			// attack functions are low level
	} ]

	// lost target while attacking so go back to idle again

	LostTarget[ ()
	{
		FindTargetOrder(SIGHTDIST, "FoundTarget", DAMAGEATTRIBUTE);	// seen a target to chase
		FindPointOrder("Patrol");	// do point stuff
		NextPoint();		// recent addition - sets a clear path - avoides bouncing here
		if(PATROL = true)
		{
			NewOrder("Patrol");
		}
		else
		{
			NewOrder("Idle");
		}
	} ]

	// you died

	Death[ ()
	{
		//SetNoCollision();					// remove bounding box so there are no collisions with corpse
		Remove = false;						// remove actor
	    RemoveWeapon = false; 				// remove the current weapon actor.
	    return 0;
    }]

	// Low level attack routines

	// Start of run to attack

	monster_run_start[ ()
	{
		TargetPlayer();
		UpdateEnemyVis(true); 				//always aware of player position
		UpdateTarget();
		Animate(RUN);						// play run animation
		self.ThinkTime = 0;					// start thinking on next frame
		self.think = "monster_run";			// go to run attack routine
		self.ideal_yaw = enemy_yaw;			// set direction to run
		self.yaw_speed = YAWSPEED;			// set rotation speed
		back_up = false;					// initialize obstacle avoidance
		attack_state = AS_NONE;				// not attacking yet
		melee_time = time;
		run_sound_time = time;
	} ]

	// run to enemy to attack

	monster_run[ ()
	{ 
		self.ThinkTime = 0;		
		if(self.health<=1)
		{ 
			self.think = "death_biz"; 	// in pain
			return 0;
			}
		if((self.in_pain = true) and (random(1,100)<PAINPERCENT))
		{
			self.think = "monster_run_pain_start"; // in pain
			return 0;
		}
		if(EnemyExist(DAMAGEATTRIBUTE) < 3)
		{
			HighLevel("LostTarget"); 			// enemy is gone or dead
			return 0;
		}
		if(enemy_vis = false)
		{
			self.think = LOSTFUNC; 				// lost sight of enemy
			lost_time = time + LOSTTIME;
			return 0;
		}
		if(run_sound_time < time)
		{
			if(random(1,10)>7)
			{
				run_sound_time = time + RUNSOUNDDELAY;
				PlaySound(RUNSOUND);
			}
		}
		ai_run(random((RUNSPEED-2)*SCALE,(RUNSPEED+2)*SCALE)); // run toward enemy
	} ]

	// start of pain while running

	monster_run_pain_start[ ()
	{
		switch(random(1,4)) 					// play one of 4 pain animations
		{
			case 1
			{
				Animate(PAIN);
				PlaySound("pl_pain2.wav", 500);
			}
			case 2
			{
				Animate(PAIN1);
				PlaySound("pl_pain2.wav", 500);
			}
			case 3
			{
				Animate(PAIN2);
				PlaySound("pl_pain2.wav", 500);
			}
			case 4
			{
				Animate(PAIN3);
				PlaySound("pl_pain2.wav", 500);
			}
		}
		SetHoldAtEnd(true);						// set to stop at animation end
		self.ThinkTime = 0;
		self.think = "monster_run_pain";
	} ]

	// wait for animation to stop

	monster_run_pain[ ()
	{
		self.ThinkTime = 0;
		if(self.animate_at_end = true) 			// wait for end of animation
		{
			self.think = "monster_run_start"; 	// start running again
			SetHoldAtEnd(false); 				// remove animation stop
			self.ThinkTime = 0;
		}
	} ]

	// start of lost sight of enemy routine

	monster_lost_target_start[ ()
	{
		Animate(RUN); 							// play run animation
		self.ThinkTime = 0;						// start thinking on next frame
		self.think = "monster_lost_target";
		run_sound_time = time + RUNSOUNDDELAY;
	} ]

	// go to last known location of enemy

	monster_lost_target[ ()
	{
		self.ThinkTime = 0;
		if(lost_time<time)
		{
			HighLevel("LostTarget"); 			// timed out while looking
			return 0;
		}
		self.ThinkTime = 0;
		if(self.health<=0)
		{
			self.think = "death_biz"; 	// in pain
			return 0;
			}
		if((self.in_pain = true) and (random(1,100)<PAINPERCENT))
		{
			self.think = "monster_lost_pain_start"; // in pain
			return 0;
		}
		if(EnemyExist(DAMAGEATTRIBUTE) < 3)
		{
			HighLevel("LostTarget"); 			// enemy died or was removed
			return 0;
		}
		if(enemy_vis = true)
		{
			PlaySound("overhere_a.wav", 500);
			self.think = "monster_run_start"; 	// seen again so run to attack
			self.ThinkTime = 0;
			return 0;
		} 
		if(run_sound_time < time)
		{
			if(random(1,10)>7)
			{
				run_sound_time = time + RUNSOUNDDELAY;
				PlaySound(RUNSOUND);
			}
		}
		if((enemy_range>POINTRADIUS) and (RUNSPEED > 0)) // get close to last known location
		{
			walk_movetogoal(random((RUNSPEED-2)*SCALE,(RUNSPEED+2)*SCALE));
					} 
		else
		{
			HighLevel("LostTarget"); // can't find at last known location
			return 0;
		}
	} ]

	// start of showing pain while searching

	monster_lost_pain_start[ ()
	{
		switch(random(1,4)) // play one of 4 pain animations
		{
			case 1
			{
				Animate(PAIN);
				PlaySound("pl_pain2.wav", 500);
			}
			case 2
			{
				Animate(PAIN1);
				PlaySound("pl_pain2.wav", 500);
			}
			case 3
			{
				Animate(PAIN2);
				PlaySound("pl_pain2.wav", 500);
			}
			case 4
			{
				Animate(PAIN3);
				PlaySound("pl_pain2.wav", 500);
			}
		}
		SetHoldAtEnd(true);	// set to stop at end
		self.ThinkTime = 0;
		self.think = "monster_lost_pain";
	} ]

	// wait till animation is done

	monster_lost_pain[ ()
	{
		self.ThinkTime = 0;
		if(self.animate_at_end = true) // animation done
		{
			self.think = "monster_lost_target_start"; 	// go back to finding target
			SetHoldAtEnd(false); 						// remove stop at end
			self.ThinkTime = 0;
		}
	} ]
	
	CheckForPoints[()
{
self.ThinkTime=0; // Process every frame
if(self.point_vis)
NextPoint();
{
// point is visible - go to high level for nav and targetting
HighLevel("LostTarget");
return 0;
}
else
{
// Point not visible - cycle points
PC=PC+1; // Increment point counter variable
if(PC > 110)
{
// Point count has exceeded max - set to 0. (Max 110)
PC=1;
}
NextPoint();
}

}]

	// start of melee attack

	monster_melee_start[ ()
	{
		switch(random(1,3)) 	// play one of 3 melee animations
		{
			case 1
			{
				Animate(MELEEATTACK);
			}
			case 2
			{
				Animate(MELEEATTACK1);
			}
			case 3
			{
				Animate(MELEEATTACK2);
			}
		}
		SetHoldAtEnd(true);						// set to stop at end
		self.ThinkTime = 0.1;
		self.think = "monster_melee";
	} ]

	// melee attack

	monster_melee[ ()
	{
		self.ThinkTime = 0;
		if(self.health<=0)
		{
			PlaySound("deathyell.wav", 500);
			self.think = "death_biz"; 	// in pain
			return 0;
		}
		if((self.in_pain = true) and (random(1,100)<PAINPERCENT))
		{
			SetHoldAtEnd(false);
			self.think = "monster_melee_pain_start"; 		// in pain
			return 0.1;
		}
		exist = EnemyExist(DAMAGEATTRIBUTE); 				// see if target is around
		if(exist < 2)
		{
			SetHoldAtEnd(false);
			HighLevel("LostTarget"); 				// enemy is dead and gone
			return 0;
		}
		if(exist = 2)
		{
			SetHoldAtEnd(false);
			HighLevel("DeadTarget"); 				// enemy is dead but body remains
			return 0;
		}
		if(enemy_vis = false)
		{
			SetHoldAtEnd(false);
			self.think = LOSTFUNC; 					// lost sight of enemy
			lost_time = time + LOSTTIME;
			return 0;
		}
		if(enemy_range>(MELEERANGE*SCALE))
		{
			SetHoldAtEnd(false);
			self.think = RUNFUNC; 					// too far away so run toward
			return 0;
		}
		ai_face();							// face enemy while attacking
		if(self.animate_at_end = true) 					// animation is done
		{
			SetHoldAtEnd(false);
			switch(random(1,3)) 					// play one of 3 melee animations
			{
				case 1
				{
					Animate(MELEEATTACK);
				}
				case 2
				{
					Animate(MELEEATTACK1);
				}	
				case 3
				{
					Animate(MELEEATTACK2);
				}
			}
			SetHoldAtEnd(true);									// set to stop at end
		}
		if(time>melee_time) 									// if time then damage
		{
			damage = random(MINMELEEDAMAGE, MAXMELEEDAMAGE); 	// get damage amount
			Damage(damage, DAMAGEATTRIBUTE); 					// damage target
			melee_time = time + MELEEDELAY; 					// reset time until next damage
		}
	} ]

	// start of showing pain

	monster_melee_pain_start[ ()
	{
		switch(random(1,4)) // play one of 4 pain animations
		{
			case 1
			{
				Animate(PAIN);
				PlaySound("pl_pain2.wav", 500);
			}
			case 2
			{
				Animate(PAIN1);
				PlaySound("pl_pain2.wav", 500);
			}
			case 3
			{
				Animate(PAIN2);
				PlaySound("pl_pain2.wav", 500);
			}
			case 4
			{
				Animate(PAIN3);
				PlaySound("pl_pain2.wav", 500);
			}
		}
		SetHoldAtEnd(true);	// set to stop at end
		self.ThinkTime = 0.1;
		self.think = "monster_melee_pain";
	} ]

	// wait until animation is done

	monster_melee_pain[ ()
	{
		self.ThinkTime = 0.1;
		if(self.animate_at_end = true) // animation is done
		{
			self.think = "monster_melee_start"; // go back to melee attack
			SetHoldAtEnd(false);
			self.ThinkTime = 0.1;
			melee_time = time + MELEEDELAY; // reset attack deley
		}
	} ]

	// basic AI routines

	// run toward enemy and see if you are ready to attack

	ai_run[ (dist)
	{
		if (attack_state = AS_MELEE) 			// do melee attack
		{
			ai_run_melee();
		}
attack_state = AS_NONE;

		if (CheckAnyAttack()) 				// check if you can start the actual attack
		{
			return 0;
		}
		if(RUNSPEED > 0)
		{
			walk_movetogoal(dist); 			// else move toward the enemy
		}
	} ]

	// check if ready to do actual attacking

	CheckAnyAttack[ ()
	{
		if(enemy_range<MAXMELEERANGE)
		{
			if(enemy_range<(MELEERANGE*SCALE)) 		// inside melee range
			{
				attack_state = AS_MELEE; 		// do a melee attack
				return true;
		}
		return false;
	} ]

	// melee attack setup

	ai_run_melee[ ()
	{
		ai_face(); // turn to face target
		if(FacingIdeal()) // got close enough
		{
			self.think = MELEEFUNC;	// start melee attack
			self.attack_state = AS_STRAIGHT;
		}
	} ]

	// face enemy

	ai_face[ ()
	{
		self.ideal_yaw = enemy_yaw;
		ChangeYaw(); // rotate to face enemy
	} ]

	// use walkmove to naviagte to enemy

	walk_movetogoal[ (dist)
	{
		if(IsFalling = true)
		{
			return 0;	// don't move while falling
		} 
		if(dist < 0)
		{
			return 0;
		}
		if(back_up = false)
		{
			ai_face();	// turn to face enemy
			if(FacingIdeal())
			{
				if(walkmove(self.current_yaw, dist) = true)
				{
					return 0;	// can move in current direction
				}
				else
				{
					if(random(1,10)<3)	// backup and move sideways
					{
						back_up = true;
						back_time = time + 0.5;
						back_flag = false;
						return 0;
					}
					else 
					{ 
						ForceUp(FORCEUP*SCALE);				// jump up, forward and to side
						ForceForward(FORCEFORWARD*SCALE);
						if(random(1,10)<6)
						{
							ForceRight(FORCESIDE*SCALE);
						}
						else
						{
							ForceLeft(FORCESIDE*SCALE);
						} 
					} 
				} 
			}
		}
		else
		{
			if(back_flag = false) // go backward 1/2 sec
			{
				if(back_time > time)
				{
					walkmove((self.current_yaw-(180*0.0174532925199433)), dist);
					return 0;
				}
				else
				{
					back_time = time + 0.5;
					back_flag = true;
				}
			}
			if(back_time > time) // go sideways 1/2 sec
			{
				walkmove((self.current_yaw-(90*0.0174532925199433)), dist);
				return 0;
			}
			back_up = false;
		}
	} ]

	// check if nearly facing enemy

	FacingIdeal[ ()
	{
		selfangle = self.current_yaw/0.0174532925199433; 	// your direction in degrees
		idealangle = self.ideal_yaw/0.0174532925199433;		// his direction in degrees
		delta = selfangle - idealangle; 					// difference in directions
		if (delta > -20 and delta < 20) 					// within 20 degrees is close enough
		{
			return true;
		}
		return false;
	} ]

}