/*
 * $Header: /HexenWorld/HCode/pstboar.hc 1     2/04/98 1:59p Rjohnson $
 */

/*
==============================================================================

Q:\art\models\monsters\RdrPest\BOAR\final\Hpest.hc

==============================================================================
*/

// For building the model
$cd Q:\art\models\monsters\RdrPest\BOAR\final
$origin 0 0 0
$base base skin
$skin skin
$flags 0

// Boar frames
$frame Bcharg1      Bcharg2      Bcharg3      Bcharg4      Bcharg5      
$frame Bcharg6      Bcharg7      Bcharg8      

//
$frame BtranA1      BtranA2      BtranA3      BtranA4      BtranA5      
$frame BtranA6      BtranA7      BtranA8      BtranA9      BtranA10     
$frame BtranA11     BtranA12     BtranA13     

//
$frame BtranB1      BtranB2      BtranB3      BtranB4      BtranB5      
$frame BtranB6      BtranB7      BtranB8      BtranB9      BtranB10     
$frame BtranB11     BtranB12     

//
$frame BtranC1      BtranC2      BtranC3      BtranC4      BtranC5      
$frame BtranC6      BtranC7      BtranC8      

//
$frame BtranD1      BtranD2      BtranD3      BtranD4      BtranD5      
$frame BtranD6      BtranD7      BtranD8      

//
$frame Btrot1       Btrot2       Btrot3       Btrot4       Btrot5       
$frame Btrot6       Btrot7       Btrot8       Btrot9       Btrot10      
$frame Btrot11      Btrot12      

$framevalue 0

// Rider Frames
$frame Parrow1      Parrow2      Parrow3      Parrow4      Parrow5      
$frame Parrow6      

//
$frame Pcharg1      Pcharg2      Pcharg3      Pcharg4      Pcharg5      
$frame Pcharg6      Pcharg7      Pcharg8      

//
$frame Phive1       Phive2       Phive3       Phive4       Phive5       
$frame Phive6       Phive7       Phive8       Phive9       Phive10      
$frame Phive11      Phive12      Phive13      Phive14      Phive15      
$frame Phive16      Phive17      Phive18      Phive19      Phive20      
$frame Phive21      Phive22      Phive23      Phive24      Phive25      
$frame Phive26      Phive27      Phive28      Phive29      Phive30      
$frame Phive31      Phive32      Phive33      Phive34      Phive35      
$frame Phive36      Phive37      Phive38      

//
$frame PtranA1      PtranA2      PtranA3      PtranA4      PtranA5      
$frame PtranA6      PtranA7      PtranA8      PtranA9      PtranA10     
$frame PtranA11     PtranA12     PtranA13     

//
$frame PtranB1      PtranB2      PtranB3      PtranB4      PtranB5      
$frame PtranB6      PtranB7      PtranB8      PtranB9      PtranB10     
$frame PtranB11     PtranB12     

//
$frame PtranC1      PtranC2      PtranC3      PtranC4      PtranC5      
$frame PtranC6      PtranC7      PtranC8      

//
$frame PtranD1      PtranD2      PtranD3      PtranD4      PtranD5      
$frame PtranD6      PtranD7      PtranD8      

//
$frame Ptrot1       Ptrot2       Ptrot3       Ptrot4       Ptrot5       
$frame Ptrot6       Ptrot7       Ptrot8       Ptrot9       Ptrot10      
$frame Ptrot11      Ptrot12      

float pst_start[8] =
{
	$Btrot1,
	$Btrot1,
	$Btrot1,
	$Bcharg1,
	$BtranC1,
	$BtranD1,
	$BtranB1,
	$Btrot1
};

float pst_end[8] =
{
	$Btrot12,
	$Btrot12,
	$Btrot12,
	$Bcharg8,
	$BtranC8,
	$BtranD8,
	$BtranB1,
	$Btrot12
};

float pst_speed[8] =
{
	7,
	7,
	7,
	20,
	15,
	15,
	7,
	7
};

// Array to align frames
float PstRiderFrames[8] =
{
	$Ptrot1,			// Animation for trot
	$Parrow1,			// Animation for trot
	$Phive1,		// Animation for trot
	$Pcharg1,			// Animation for trot
	$PtranC1,			// Animation for trot
	$PtranD1,			// Animation for trot
	$PtranB1,		// Animation for trot
	$Ptrot1			// Animation for trot
};

float PB_STAGE_NORMAL		= 0;
float PB_STAGE_ATTACK		= 1;
float PB_STAGE_ATTACK2		= 2;
float PB_STAGE_CHARGE		= 3;
float PB_STAGE_CHARGE_ST	= 4;
float PB_STAGE_CHARGE_END	= 5;
float PB_STAGE_STAND		= 6;
float PB_STAGE_BACKUP		= 7;

void rider_death();


void hive_trail ()
{
	if(self.lifetime<time)
	{
	    self.think=self.th_die;
		thinktime self : 0;
	}
	else
	{
//		particle4(self.origin,0.5,284,PARTICLETYPE_SLOWGRAV,3);
		thinktime self : 0.05;
	}
}
void()hive_touch;
void throw_hive (void)
{
	entity newmis;
	vector diff;

    makevectors(self.movechain.angles);
	sound(self,CHAN_AUTO,"misc/whoosh.wav",1,ATTN_NORM);
    newmis=spawn();
    newmis.owner=self;
    newmis.classname="hive";
    newmis.movetype=MOVETYPE_BOUNCE;
    newmis.solid=SOLID_BBOX;
	newmis.takedamage=DAMAGE_YES;
	newmis.touch=newmis.th_die=hive_touch;
	newmis.lifetime=time + 2.5;

	newmis.speed=500;
	
	setorigin (newmis, self.origin + '0 0 110' + v_forward * 25);
	diff = (self.enemy.origin + self.enemy.view_ofs) - newmis.origin;
	newmis.velocity = normalize(diff)+v_up*0.5;
	newmis.velocity = newmis.velocity * newmis.speed;

	newmis.avelocity=randomv('-300 -300 -300','300 300 300');
    setmodel(newmis,"models/boss/hive.mdl");
	newmis.scale=2;
	newmis.drawflags=MLS_POWERMODE;
    setsize(newmis,'0 0 0','0 0 0');

	newmis.think=hive_trail;
	thinktime newmis : 0;
}

void poison_think ()
{
	self.enemy.deathtype="poison";
	T_Damage (self.enemy, self, self.owner, 1 );
	if(self.enemy.flags&FL_CLIENT)
		stuffcmd(self.enemy,"bf\n");
	if(self.lifetime<time||self.enemy.health<=0)
		self.think=SUB_Remove;
	thinktime self : 1;
}

void spawn_poison ()
{
	newmis=spawn();
	newmis.think=poison_think;
	newmis.enemy=self.enemy;
	newmis.owner=self.owner;

	thinktime newmis : 0.05;
	newmis.lifetime=time+random(5,10);
}

void pestilence_missile_touch(void)
{
	float damg;

	if (pointcontents(self.origin) == CONTENT_SKY)
	{
		remove(self);
		return;
	}

	damg = random(10,20);

	self.origin = self.origin - 8 * normalize(self.velocity) - '0 0 40';
	if(other.takedamage)
	{
		self.enemy=other;
		if(other.flags&FL_CLIENT)
			stuffcmd(other,"bf\n");
		if(other.classname!="rider_pestilence")
			spawn_poison();
		other.deathtype="poison";
		T_Damage (other, self, self.owner, damg );
		sound (self, CHAN_WEAPON, "pest/xbowhit.wav", 1, ATTN_NORM);
	}
	else
		sound (self, CHAN_WEAPON, "weapons/expsmall.wav", 1, ATTN_NORM);

	CreateGreenSpark (self.origin); 

	remove(self);
}


void pestilence_missile_think (void)
{
	if (self.lifetime < time)
	{
		sound (self, CHAN_WEAPON, "pest/xbowhit.wav", 1, ATTN_NORM);
		CreateGreenSpark (self.origin); 
		remove(self);
	}
	else
	{
		HomeThink();
		
		self.think=pestilence_missile_think;
		thinktime self : HX_FRAME_TIME;
	}
}

void pestilence_missile(void)
{
	entity newmis;

	sound(self,CHAN_AUTO,"pest/xbowfire.wav",1,ATTN_NORM);	
	newmis = spawn ();
	newmis.owner = self;
	newmis.movetype = MOVETYPE_FLYMISSILE;
	newmis.solid = SOLID_BBOX;
	newmis.drawflags=MLS_POWERMODE;
		
    setmodel (newmis, "models/pestshot.mdl");
	setsize (newmis, '0 0 0', '0 0 0');		

	newmis.angles = self.movechain.angles;

	makevectors(self.movechain.angles);	
	newmis.velocity = normalize(v_forward);
	newmis.angles = vectoangles(newmis.velocity);
	newmis.avelocity_z=700;

	setorigin (newmis, self.origin + '0 0 90' + v_forward * 20);
	
	newmis.speed=700;	//Speed
	newmis.classname = "faminemissile";

	newmis.veer=FALSE;	//No random wandering
	newmis.turn_time=3;	//Lower the number, tighter the turn
	newmis.ideal_yaw=FALSE;//Only track things in front
	newmis.lifetime = time + 2;
	newmis.think=pestilence_missile_think;
	thinktime newmis : 0;

	newmis.touch = pestilence_missile_touch;
}

void pest_hurt (entity attacker,float total_dam)
{
	self.pain_finished=time+0.5;
	if(attacker!=world&&attacker!=self)
		if(self.enemy==world||(random()<0.2&&attacker!=self.enemy))
		{
			if(random()<0.2)
				sound(self,CHAN_VOICE,"pest/sight.wav",1,ATTN_NONE);	
			self.enemy=self.goalentity=attacker;
			self.lifespan=time+4;
		}
}

void pest_use ()
{
	self.monster_awake=TRUE;
	self.lifespan=time+10;
}

void psthorse_move(void)
{
float chance;
vector displace;
entity oself;

	self.think = psthorse_move;
	thinktime self : HX_FRAME_TIME;

	if(self.monster_stage!=PB_STAGE_STAND)
		AdvanceFrame(pst_start[self.monster_stage],pst_end[self.monster_stage]);

	if(self.frame!=$BtranB1)
	{
		if(!self.goalentity)
			self.goalentity=self.enemy;

		if (random(100)==1)
			if(self.monster_stage>=PB_STAGE_CHARGE&&self.monster_stage<PB_STAGE_STAND)
				sound(self,CHAN_BODY,"pest/snort2.wav",1,ATTN_NORM);	
			else
				sound(self,CHAN_BODY,"pest/snort.wav",1,ATTN_NORM);	

		if(self.t_width<time)
		{
			if(self.monster_stage>=PB_STAGE_CHARGE&&self.monster_stage<PB_STAGE_STAND)
				sound(self,CHAN_ITEM,"pest/gallop.wav",1,ATTN_NORM);	
			else
			{
				chance = random();
				if (chance < .33)
					sound (self, CHAN_ITEM, "pest/clop1.wav", 1, ATTN_NORM);
				else if (chance < .66)
					sound (self, CHAN_ITEM, "pest/clop2.wav", 1, ATTN_NORM);
				else
					sound (self, CHAN_ITEM, "pest/clop3.wav", 1, ATTN_NORM);
			}
			self.t_width=time+0.5;
		}

		self.wallspot=self.origin;
		if(self.enemy!=world&&visible(self.enemy)||self.search_time>time)
		{
			if(!walkmove(self.angles_y,self.speed,TRUE))
			{
				if (trace_ent!=world&&trace_ent.takedamage&&self.torchtime<time)
				{//hit once every 1/2 sec
					self.torchtime=time+0.5;
					sound(trace_ent,CHAN_AUTO,"imp/swoophit.wav",1,ATTN_NORM);
					displace = normalize(trace_ent.origin - self.origin);
					if (infront(trace_ent))
					{
						trace_ent.velocity += displace*random(1000,1600);
						trace_ent.punchangle= randomv('-9 -10 -10','-1 10 10');
						T_Damage (trace_ent, self, self, random(25,35));
					}
					else
					{
						trace_ent.velocity += displace*random(700,900);
						trace_ent.punchangle = randomv('-3 -5 -5','2 5 5');
						T_Damage (trace_ent, self, self, random(15,20));
					}
				}
				movetogoal(self.speed);
				if(self.monster_stage==PB_STAGE_BACKUP)
					self.monster_stage=self.rider_gallop_mode=PB_STAGE_NORMAL;
			}
		}
		else if(self.monster_awake)
		{
			if (!self.path_current)
				riderpath_init();
			riderpath_move(self.speed);
		}


		if(vlen(self.origin-self.wallspot)<self.speed*0.75&&self.turn_time<time&&!trace_ent)
			self.aflag+=1;
		else
			self.aflag=0;
		self.ideal_yaw=vectoyaw(self.goalentity.origin-self.origin);
		if(self.aflag>30)
		{
			self.monster_stage=PB_STAGE_BACKUP;
			self.aflag=0;
			self.turn_time=time+3;//Back up for 3 secs
		}
		if(self.aflag)
		{
			makevectors(self.angles);
			tracearea(self.origin,self.origin+v_forward*200,'-48 -48 0','48 48 100',TRUE,self);
			if(trace_plane_normal!='0 0 0')
				self.ideal_yaw=vectoyaw((trace_plane_normal+v_forward)*0.5);
			navigate(fabs(self.speed));
		}
		ChangeYaw();
	}

	if ((!self.enemy) || (self.enemy.health <= 0))
	{
		if(self.enemy)
			sound(self,CHAN_VOICE,"pest/laugh.wav",1,ATTN_NONE);	
		
		if (!FindTarget(TRUE))
		{
			self.enemy = world;
			if(!self.monster_awake)
				self.monster_stage = self.rider_gallop_mode = PB_STAGE_STAND;
		}
		else
			sound(self,CHAN_VOICE,"pest/sight.wav",1,ATTN_NONE);	
		self.goalentity = self.enemy;
	}
	else
		self.monster_awake=TRUE;

	enemy_vis=visible(self.enemy);
	if(enemy_vis)
		self.search_time=time+5-coop*2;

	if(self.rider_gallop_mode<PB_STAGE_CHARGE_ST&&enemy_vis)
	{
		self.movechain.ideal_yaw=vectoyaw(self.enemy.origin-self.movechain.origin);
		if(self.movechain.ideal_yaw>self.angles_y+89&&self.movechain.ideal_yaw<self.angles_y+180)	//Flexible guy!
			self.movechain.ideal_yaw=self.angles_y+89;
		else if(self.movechain.ideal_yaw<self.angles_y - 89&&self.movechain.ideal_yaw>self.angles_y - 180)
			self.movechain.ideal_yaw=self.angles_y - 89;
	}
	else
		self.movechain.ideal_yaw=self.angles_y;
	oself=self;
	self=self.movechain;
	ChangeYaw();
	self=oself;
	
	if(self.rider_gallop_mode==PB_STAGE_ATTACK||self.rider_gallop_mode==PB_STAGE_ATTACK2)
		self.movechain.frame+=1;
	else if(self.rider_gallop_mode<PB_STAGE_STAND)
		self.movechain.frame = PstRiderFrames[self.rider_gallop_mode] + 
			(self.frame - pst_start[self.rider_gallop_mode]);

	// Is rider attacking player
	if (self.rider_gallop_mode == PB_STAGE_ATTACK)
	{
		if (self.movechain.frame == $Parrow4)
			pestilence_missile();

		if (self.movechain.frame >= $Parrow6)
			if(self.monster_stage==PB_STAGE_BACKUP)
				self.rider_gallop_mode=PB_STAGE_NORMAL;
			else
				self.rider_gallop_mode=self.monster_stage;
	}
	else if(self.rider_gallop_mode == PB_STAGE_ATTACK2)
	{
		if (self.movechain.frame == $Phive33)
			throw_hive();

		if (self.movechain.frame >= $Phive38)
			if(self.monster_stage==PB_STAGE_BACKUP)
				self.rider_gallop_mode=PB_STAGE_NORMAL;
			else
				self.rider_gallop_mode=self.monster_stage;
	}

	if(self.monster_stage >= PB_STAGE_CHARGE&&self.monster_stage<PB_STAGE_STAND)
	{
		if(random()<0.3)
		{
			makevectors(self.angles);
			CreateWhiteSmoke(self.origin-v_forward*random(50,160)+v_right*random(-30,30),v_up*random(10,30)+v_forward*random(-10,-30),HX_FRAME_TIME*2);
		}
		if(self.frame==$BtranC8)
		{
			self.movechain.frame=$Pcharg1;
			self.monster_stage=self.rider_gallop_mode=PB_STAGE_CHARGE;
		}
		if (self.frame == $Bcharg8 &&self.monster_stage == PB_STAGE_CHARGE)
		{
			self.level+=1;
			if(self.level>=random(20,40))
			{
				self.movechain.frame=$PtranD1;
				self.monster_stage=self.rider_gallop_mode=PB_STAGE_CHARGE_END;
			}
		}
		if(self.frame==$BtranD8)
		{
			self.lifespan=time + 5;
			self.monster_stage = self.rider_gallop_mode=PB_STAGE_NORMAL;
			self.yaw_speed=4;
		}
		if(self.rider_gallop_mode==PB_STAGE_CHARGE)
		{
			if(random(1000)<=5)
			{
				enemy_infront=infront_of_ent(self.enemy,self.movechain);
				if(enemy_vis&&(enemy_infront||random()<0.2))
					if (random()<0.1&&self.cnt<=0) // Shoot 
					{
						self.rider_gallop_mode = PB_STAGE_ATTACK2;
						self.movechain.frame = $Phive1;
					}
					else
					{
						self.rider_gallop_mode = PB_STAGE_ATTACK;
						self.movechain.frame = $Parrow1;
					}
			}
		}
	}

	if (fabs(pst_speed[self.monster_stage] - fabs(self.speed)) < 0.2)
		self.speed = pst_speed[self.monster_stage];
	else if (pst_speed[self.monster_stage] > fabs(self.speed)) 
		self.speed = fabs(self.speed)+0.2;
	else
		self.speed=fabs(self.speed) - 0.2;

	if(self.monster_stage==PB_STAGE_BACKUP)
		if(self.turn_time<time)
			self.monster_stage=self.rider_gallop_mode=PB_STAGE_NORMAL;
		else
			self.speed*=-1;

	if(self.enemy!=world||self.monster_awake)
	{
		enemy_vis=visible(self.enemy);
		enemy_infront=infront_of_ent(self.enemy,self.movechain);
		if (self.rider_gallop_mode == PB_STAGE_NORMAL&&self.enemy!=world&&enemy_vis&&enemy_infront) 
		{
			// Force a new gallop frame in

			chance = random(100);

			if(self.pain_finished>time)
				chance/=3;

			if(random(100)<3)
				sound(self,CHAN_VOICE,"pest/laugh.wav",1,ATTN_NONE);	

			if (chance < 3&&self.cnt<=0) // Shoot 
			{
				self.rider_gallop_mode = PB_STAGE_ATTACK2;
				self.movechain.frame = $Phive1;
			}
			else if(chance < 5) // Shoot 
			{
				self.rider_gallop_mode = PB_STAGE_ATTACK;
				self.movechain.frame = $Parrow1;
			}
			else if(chance < 8&&self.monster_stage<PB_STAGE_CHARGE&&self.lifespan<time) // Charge
			{
				sound(self,CHAN_VOICE,"pest/charge.wav",1,ATTN_NORM);	
				self.rider_gallop_mode = 
				self.monster_stage = PB_STAGE_CHARGE_ST;
				self.movechain.frame = $PtranC1;
				self.yaw_speed=8;
			}
		}
		else if (self.monster_stage == PB_STAGE_STAND) 
			if(self.frame==$BtranB12)
			{
				self.frame=$Btrot1;
				self.movechain.frame=$Ptrot1;
				self.monster_stage=self.rider_gallop_mode=PB_STAGE_NORMAL;
			}
			else
			{
				AdvanceFrame($BtranB1,$BtranB12);
				self.movechain.frame+=1;
			}
	}
	else
		self.rider_gallop_mode=self.monster_stage=PB_STAGE_STAND;
}


// Frame Code
void create_pstrider(entity horse)
{
entity rider;

	rider = spawn();

	rider.solid = SOLID_NOT;
	rider.movetype = MOVETYPE_NOCLIP;
	rider.origin = horse.origin;
	rider.angles = self.angles;

	setmodel (rider, "models/boss/pstrider.mdl");
	setsize(rider,'0 0 0','0 0 0');
	rider.skin = 0;

	horse.movechain = rider;
	rider.flags (+) FL_MOVECHAIN_ANGLE;
}

void swarm_touch(void)
{
	if(other!=world&&other.classname!="swarm"&&other.monsterclass<CLASS_BOSS)
	{
		if(random()<0.1)
			if (other.takedamage&&other.thingtype==THINGTYPE_FLESH)
			{
			float r;
				if(self.pain_finished<time)
				{
					r=random();
					if(r<.34)
						self.noise="pest/sting1.wav";
					else if(r<.67)
						self.noise="pest/sting2.wav";
					else
						self.noise="pest/sting3.wav";
					sound(self,CHAN_AUTO,self.noise,1,ATTN_NORM);
					self.pain_finished=time+1;
				}
				T_Damage (other,self,self,random(3,10));
			}
	}
}

void hive_die(void)
{
	if (AdvanceFrame(40 + self.beginframe,54 + self.beginframe) == AF_END)
	{
		self.owner.cnt-=1;
		remove(self);
	}
	else
	{
		if(self.t_width<time)
		{
			sound(self,CHAN_BODY,"pest/buzz.wav",0.5,ATTN_NORM);	
			self.t_width=time+0.5;
		}
		self.think = hive_die;
		thinktime self : HX_FRAME_TIME;
	}
}

void hive_live(void)
{
	movetogoal(10);
	self.velocity = normalize(self.enemy.origin - self.origin)* 100;
	AdvanceFrame(10 + self.beginframe,39 + self.beginframe);

	if (self.lifetime < time)
		hive_die();
	else
	{
		if(self.t_width<time)
		{
			sound(self,CHAN_BODY,"pest/buzz.wav",1,ATTN_NORM);	
			self.t_width=time+0.5;
		}
		self.think = hive_live;
		thinktime self : HX_FRAME_TIME;
	}
}

void hive_grow(void)
{
	if (AdvanceFrame(0 + self.beginframe,9 + self.beginframe) == AF_END)
	{
		self.lifetime = time + 20;	
		hive_live();
	}
	else
	{
		if(self.t_width<time)
		{
			sound(self,CHAN_BODY,"pest/buzz.wav",0.5,ATTN_NORM);	
			self.t_width=time+0.5;
		}
		self.think = hive_grow;
		thinktime self : HX_FRAME_TIME;
	}
}


void bugcloud_spawn (float cloudtype)
{
entity swarm;

	CreateWhiteSmoke(self.origin,'0 0 20',HX_FRAME_TIME * 4);
	CreateWhiteSmoke(self.origin,'0 0 21',HX_FRAME_TIME * 4);

	swarm = spawn();
	swarm.owner=self.owner;
	swarm.classname="swarm";
	swarm.solid = SOLID_TRIGGER;
	swarm.movetype = MOVETYPE_FLYMISSILE;
	swarm.flags(+)FL_FLY;
	
	swarm.touch = swarm_touch;
	swarm.scale = 2.5;		
	swarm.enemy = swarm.goalentity = self.owner.enemy;

	if (cloudtype == 1)
	{
		swarm.beginframe = 0;
		swarm.avelocity_y = random(-450,-600);
	}
	else if (cloudtype == 2)
	{
		swarm.beginframe = 54;
		swarm.avelocity_y = random(450,600);
	}
	else if (cloudtype == 3)
	{
		swarm.beginframe = 109;
		swarm.avelocity_y = random(450,600);
	}

	swarm.frame=swarm.beginframe;
	setmodel (swarm,"models/boss/swarm.mdl");
	setsize(swarm,'-50 -50 -50','50 50 50');
	swarm.hull=HULL_CROUCH;
	setorigin (swarm,self.origin + '0 0 5');

	swarm.think = hive_grow;
	thinktime swarm : HX_FRAME_TIME;
}

void hive_touch(void)
{
	sound(self,CHAN_AUTO,"pest/hivehit.wav",1,ATTN_NORM);

	bugcloud_spawn(1);
	bugcloud_spawn(2);
	bugcloud_spawn(3);

	self.owner.cnt+=3;
	self.level=-666;//Just a flag to turn off chunk sounds
	chunk_death();
}


void create_swarm (void)
{
entity newmis;
vector diff;
	newmis = spawn ();
	newmis.owner = self;
	newmis.movetype = MOVETYPE_TOSS;
	newmis.solid = SOLID_BBOX;
	newmis.thingtype = THINGTYPE_FLESH;
	newmis.classname="hive";
		
	setmodel (newmis,"models/boss/hive.mdl");
	setsize(newmis,'0 0 0','0 0 0');
	makevectors (self.v_angle);

	setorigin (newmis,self.origin + (v_forward * 14) + (v_up * 40));

	diff = ((self.origin  + (100 * v_forward)) - self.origin);
	newmis.velocity = normalize(diff);
	newmis.velocity = newmis.velocity * 1000;
	newmis.angles = vectoangles(newmis.velocity);

	newmis.enemy = self;
	newmis.touch = hive_touch;
}

/*QUAKED rider_pestilence (1 0 0)  (-55 -55 -24) (55 55 100) TRIGGER_WAIT
Pestilence rider monster.  You must place rider_path entites
on the map.  The rider will first proceed to the 
rider_path point with a path_id of 1.
-------------------------FIELDS-------------------------
map: next map to go to when you kill the rider
target: start spot on the next map
--------------------------------------------------------

*/
void rider_pestilence(void)
{
	if (deathmatch)
	{
		remove(self);
		return;
	}

	precache_model2 ("models/boss/boar.mdl");
	precache_model2 ("models/boss/pstrider.mdl");
	precache_model2 ("models/boss/hive.mdl");
	precache_model2 ("models/boss/swarm.mdl");
    precache_model2 ("models/boss/shaft.mdl");
	precache_model2 ("models/pestshot.mdl");
	precache_sound2 ("pest/snort.wav");
	precache_sound2 ("pest/clop1.wav");
	precache_sound2 ("pest/clop2.wav");
	precache_sound2 ("pest/clop3.wav");
	precache_sound2 ("pest/gallop.wav");
	precache_sound2 ("pest/sight.wav");
	precache_sound2 ("pest/sting1.wav");
	precache_sound2 ("pest/sting2.wav");
	precache_sound2 ("pest/sting3.wav");
	precache_sound2 ("pest/buzz.wav");
	precache_sound2 ("pest/hivehit.wav");
	precache_sound2 ("pest/xbowfire.wav");
	precache_sound2 ("pest/xbowhit.wav");
	precache_sound2 ("pest/die.wav");
	precache_sound2 ("pest/charge.wav");
	precache_sound2 ("pest/laugh.wav");
	precache_sound2 ("pest/snort2.wav");
	rider_init();

	self.noise="pest/die.wav";
	self.solid = SOLID_SLIDEBOX;
	self.movetype = MOVETYPE_STEP;
    self.flags (+) FL_MONSTER;
	self.flags2(+) FL_ALIVE;
	self.yaw_speed = 4;
	self.speed=7;

	setmodel (self, "models/boss/boar.mdl");
	self.skin = 0;

	setsize (self, '-84 -84 0', '84 84 100');
	self.health = 4400;
	self.experience_value = 1500;
	self.th_pain = pest_hurt;
	self.rider_gallop_mode = self.monster_stage = PB_STAGE_NORMAL;
	self.speed = pst_speed[self.rider_gallop_mode];
	self.rider_path_distance = 200;
	self.mass = 30000;

	create_pstrider(self);

	self.use=pest_use;
	self.hull=HULL_GOLEM;

	self.frame=$BtranB1;
	self.movechain.frame=$PtranB1;
	self.movechain.yaw_speed=10;
	self.monster_stage=self.rider_gallop_mode=PB_STAGE_STAND;
	self.monster_awake=FALSE;
	self.th_save=psthorse_move;

	self.think = multiplayer_health;
	thinktime self : 1;
}