/*
 * $Header: /HexenWorld/HCode/mezzoman.hc 2     3/03/98 3:01p Rmidthun $
 */

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

Q:\art\models\monsters\mezzoman\FINAL\mezzoman.hc
MG!!!
==============================================================================
*/

// For building the model
$cd Q:\art\models\monsters\mezzoman\FINAL
$origin 0 0 -2
$base BASE skin1
$skin skin1
$skin Skin2
$flags 16384

//
$frame block1       block2       block3       block4       block5       
$frame block6       

//
$frame charge1      charge2      charge3      charge4      charge5      
$frame charge6      charge7      charge8      charge9      charge10     
$frame charge11     charge12     charge13     charge14     charge15     
$frame charge16     charge17     charge18     charge19     charge20     
$frame charge21     charge22     charge23     charge24     charge25     

//
$frame clober1      clober2      clober3      clober4      clober5      
$frame clober6      clober7      clober8      clober9      clober10     
$frame clober11     clober12     clober13     clober14     clober15     
$frame clober16     

//
$frame death1       death2       death3       death4       death5       
$frame death6       death7       death8       death9       death10      
$frame death11      death12      death13      death14      death15      
$frame death16      

//
$frame dive1        dive2        dive3        dive4        dive5        
$frame dive6        dive7        dive8        dive9        dive10       
$frame dive11       dive12       dive13       dive14       dive15       
$frame dive16       dive17       dive18       

//
$frame jump1        jump2        jump3        jump4        jump5        
$frame jump6        jump7        jump8        jump9        jump10       
$frame jump11       jump12       jump13       jump14       jump15       
$frame jump16       jump17       jump18       jump19       jump20       
$frame jump21       jump22       

//
$frame pain1        pain2        pain3        pain4        pain5        
$frame pain6        pain7        

//
$frame roar1        roar2        roar3        roar4        roar5        
$frame roar6        roar7        roar8        roar9        roar10       
$frame roar11       roar12       roar13       roar14       roar15       
$frame roar16       roar17       roar18       roar19       roar20       
$frame roar21       roar22       roar23       roar24       roar25       
$frame roar26       roar27       roar28       roar29       roar30       

//
$frame Roll1        Roll2        Roll3        Roll4        Roll5        
$frame Roll6        Roll7        Roll8        Roll9        Roll10       
$frame Roll11       Roll12       Roll13       Roll14       Roll15       
$frame Roll16       Roll17       Roll18       

//
$frame run1         run2         run3         run4         run5         
$frame run6         run7         run8         run9         run10        
$frame run11        run12        run13        run14        run15        
$frame run16        run17        run18        run19        run20        
$frame run21        run22        

//
$frame stand1       stand2       stand3       stand4       stand5       
$frame stand6       stand7       stand8       stand9       stand10      

//
$frame sword1       sword2       sword3       sword4       sword5       
$frame sword6       sword7       sword8       sword9       sword10      
$frame sword11      sword12      sword13      

//
$frame twirl1       twirl2       twirl3       twirl4       twirl5       
$frame twirl6       twirl7       twirl8       twirl9       twirl10      

//
$frame walk1        walk2        walk3        walk4        walk5        
$frame walk6        walk7        walk8        walk9        walk10       
$frame walk11       walk12       walk13       walk14       walk15       
$frame walk16       walk17       walk18       walk19       walk20       
$frame walk21       walk22       walk23       walk24       walk25       
$frame walk26       walk27       walk28       walk29       walk30       


void() mezzo_skid;
void() mezzo_block;
void() mezzo_block_wait;
void() mezzo_jump;
void() mezzo_roar;
void() mezzo_in_air;
void() mezzo_run_loop;
void()mezzo_charge;

void mezzo_idle_sound ()
{
string soundstr;
	if(random()<0.5)
		soundstr="mezzo/snort.wav";
	else
		soundstr="mezzo/growl.wav";
	sound(self,CHAN_VOICE,soundstr,1,ATTN_NORM);
}

/*
void mezzo_possum_up (void)// [-- $death14..$death1]
{
	if (cycle_wrapped)
		self.think=self.th_run;
}

void mezzo_playdead (void)
{
//	self.frame=$death14;
	self.think=mezzo_playdead;
	thinktime self : 0.1;
	ai_stand();
}
*/

void mezzo_roll_right () [-- $Roll18 .. $Roll1]
{
//	if(self.shield.velocity!='0 0 0'&&self.shield.model!="models/null.spr")
//		dprint("what the?\n");
//SOUND?
vector rollangle;
	makevectors(self.angles);
	rollangle=vectoangles(v_right);
//	if(!walkmove(rollangle_y,7,FALSE)&&self.frame>$Roll5 &&self.flags&FL_ONGROUND)
//		self.frame=$Roll5;
	walkmove(rollangle_y,7,FALSE);
	if(cycle_wrapped)
	{
		thinktime self : 0;
		if(!self.flags&FL_ONGROUND)
			self.think=mezzo_in_air;
		else
			self.think=self.th_run;
	}
}

void mezzo_roll_left () [++ $Roll1 .. $Roll18]
{
//	if(self.shield.velocity!='0 0 0'&&self.shield.model!="models/null.spr")
//		dprint("what the?\n");
//SOUND?
vector rollangle;
	makevectors(self.angles);
	rollangle=vectoangles(v_right);
//	if(!walkmove(rollangle_y,-7,FALSE)&&self.frame<$Roll14 &&self.flags&FL_ONGROUND)
//		self.frame=$Roll14;
	walkmove(rollangle_y,-7,FALSE);
	if(cycle_wrapped)
	{
		thinktime self : 0;
		if(!self.flags&FL_ONGROUND)
			self.think=mezzo_in_air;
		else
			self.think=self.th_run;
	}
}

void mezzo_roll_forward () [++ $dive1 .. $dive18]
{
//SOUND?
//vector rollangle;
//	if(!walkmove(self.angles_y,7,FALSE)&&self.frame<$dive12 &&self.flags&FL_ONGROUND)
//		self.frame=$dive12;
	if(!self.flags&FL_ONGROUND)
	{
		if(!infront(self.enemy))//stay facing enemy so if land behind him, will be facing him
			ai_face();
	}
	else
	{
		if(self.dflags)
		{
			sound(self,CHAN_BODY,"player/land.wav",1,ATTN_NORM);
			self.dflags=FALSE;
		}
		walkmove(self.angles_y,7,FALSE);
	}

	if(cycle_wrapped)
	{
		thinktime self : 0;
		if(!self.flags&FL_ONGROUND)
			self.think=mezzo_in_air;
		else
			self.think=self.th_run;
	}
}

void mezzo_duck () [++ $jump13 .. $jump22]
{
//FIXME:  Have him keep checking for befense when staying down for .5 sec
vector newmaxs;
	if(self.frame==$jump14)
	{
		newmaxs=self.maxs;
		newmaxs_z=self.maxs_z*0.5;
		setsize(self,self.mins,newmaxs);
	}
	else if(self.frame==$jump18)
	{
		newmaxs=self.maxs;
		newmaxs_z=self.maxs_z*2;
		setsize(self,self.mins,newmaxs);
	}
	else if(self.frame==$jump16)
		thinktime self : 0.5;
	else if(cycle_wrapped)
	{
		thinktime self : 0;
		self.think=self.th_run;
	}
}

float mezzo_check_duck (entity proj)
{
vector proj_mins,duck_hite,proj_dir;
	proj_mins=proj.origin;
	proj_mins_z=proj.origin_z - proj.mins_z;

	duck_hite=self.origin;
	duck_hite_z=self.origin_z + self.maxs_z/2;

	proj_dir=normalize(duck_hite-proj_mins);

	traceline(proj_mins,duck_hite+proj_dir*8,FALSE,self);

	if(trace_ent!=self||trace_endpos_z>duck_hite_z)
		return TRUE;
	else
		return FALSE;
}

float mezzo_check_jump (entity proj)
{
float impact_hite, jump_hite;
vector proj_dir, proj_top;

	if(!self.flags&FL_ONGROUND)
		return FALSE;

	proj_dir=normalize(proj.velocity);
	proj_top=proj.origin;
	proj_top_z=proj.absmax_z;
	traceline(proj_top,proj_top+proj_dir*1000,FALSE,proj);
	if(trace_ent!=self)
		return FALSE;

	impact_hite=trace_endpos_z;
	tracearea(self.origin,self.origin+'0 0 256',self.mins,self.maxs,FALSE,self);
	jump_hite=trace_fraction*256;
	if(jump_hite<24)
		return FALSE;
	else if(jump_hite>133)
		jump_hite=133;		
	else if(jump_hite<77)
		jump_hite=77;		

	if(self.origin_z+jump_hite/2>impact_hite+proj.maxs_z&&random()<0.7)
	{
		self.velocity_z=jump_hite*3;
		self.flags(-)FL_ONGROUND;
		return TRUE;
	}

	return FALSE;
}

void mezzo_choose_roll (entity proj)
{
float proj_dir;
	proj_dir=check_heading_left_or_right(proj);
	if(proj_dir==0)
	{
		if(mezzo_check_duck(proj))
		{
			thinktime self : 0;
			self.think=mezzo_duck;
		}
		else
		{
			thinktime self : 0;
			self.think=mezzo_block;
		}
		return;
	}
	else
	{
//FIXME: Probably shouldn't try to roll in the other direction
		makevectors(self.angles);
		if(solid_under(self.origin, self.origin+v_right*105*proj_dir))
			tracearea(self.origin, self.origin+v_right*105*proj_dir,self.mins,self.maxs,FALSE,self);
		else
			trace_fraction=FALSE;
		if(trace_fraction==1)
		{
			traceline(trace_endpos, trace_endpos-'0 0 300',TRUE,self);
			if(pointcontents(trace_endpos)!=CONTENT_EMPTY)
				trace_fraction=FALSE;
			else
				trace_fraction=TRUE;
		}
		if(trace_fraction==1)		
		{
			if(proj_dir>0)
			{
				thinktime self : 0;
				self.think=mezzo_roll_right;
			}
			else
			{
				thinktime self : 0;
				self.think=mezzo_roll_left;
			}
			return;
		}
		else if(mezzo_check_duck(proj))
		{
			thinktime self : 0;
			self.think=mezzo_duck;
		}
		else
		{
			thinktime self : 0;
			self.think=mezzo_block;
		}
/*		{
			tracearea(self.origin, self.origin+v_right*36*proj_dir*-1,self.mins,self.maxs,FALSE,self);
			if(trace_fraction==1)
			{
				if(proj_dir*-1>0)
				{
					thinktime self : 0;
					self.think=mezzo_roll_right;
				}
				else
				{
					thinktime self : 0;
					self.think=mezzo_roll_left;
				}
				return;
			}
		}
*/
	}
}

void mezzo_check_defense ()
{
//	if(self.shield.velocity!='0 0 0'&&self.shield.model!="models/null.spr")
//		dprint("what the?\n");
//NOTE: Add random chance of failure based on difficulty level - highest diff means no chance of failure here
	if(skill+self.skin/5<random(6))
		return;

	if((self.enemy.last_attack+0.5<time&&self.oldenemy.last_attack+0.5<time)||self.aflag)
		return;

entity enemy_proj;
float r;
	enemy_proj=look_projectiles();

	if(!enemy_proj)
		if(lineofsight(self,self.enemy))
		{
			enemy_proj=self.enemy;
			self.level=vlen(self.enemy.origin-self.origin)/1000;
		}
		else
			return;

	if(self.flags&FL_ONGROUND)
		self.velocity='0 0 0';//Clear velocity from last jump so he doesn't go nuts

	r=range(enemy_proj);
	if(self.enemy.weapon==IT_WEAPON1&&r<=RANGE_NEAR)
	{
		thinktime self : 0;
		if(r==RANGE_MELEE)
		{
			if(random()<0.7||self.enemy.v_angle_x>=0)
				self.think=mezzo_duck;
			else if(self.think==mezzo_block_wait)
			{
				self.t_width=time+1;
				return;
			}
			else if(self.think==mezzo_run_loop||random()<0.3)
				self.think=mezzo_charge;
			else
				self.think=mezzo_block;
			return;
		}
		else if(random()<0.5)
			mezzo_choose_roll(enemy_proj);
		else if(random()<0.7||self.enemy.v_angle_x>=0)
			self.think=mezzo_duck;
		else if(self.think==mezzo_block_wait)
		{
			self.t_width=time+1;
			return;
		}
		else if(self.think==mezzo_block_wait)
		{
			self.t_width=time+1;
			return;
		}
		else if(self.think==mezzo_run_loop||random()<0.3)
			self.think=mezzo_charge;
		else
			self.think=mezzo_block;
		return;
	}

	if(self.level>0.3)//I've got 0.3 seconds before impact
	{
		mezzo_choose_roll(enemy_proj);
		return;
	}
	else if(mezzo_check_duck(enemy_proj))
	{
		thinktime self : 0;
		tracearea(self.origin,self.origin+v_forward*64,self.mins,'16 16 20',FALSE,self);
		if(trace_fraction<1||random()<0.2||!infront(enemy_proj))
			self.think=mezzo_duck;
		else
			self.think=mezzo_roll_forward;
		return;
	}
	else if(mezzo_check_jump(enemy_proj))
	{
		self.think=mezzo_jump;
		enemy_infront=infront(self.enemy);
		enemy_vis=visible(self.enemy);
		trace_fraction=0;
		if((random()<0.3||self.think==mezzo_run_loop)&&enemy_infront&&enemy_vis&&self.enemy!=world)//Jump towards enemy
		{
		vector enemy_dir;
			enemy_dir=normalize(self.enemy.origin-self.origin);
			traceline(self.origin,self.origin+enemy_dir*64+'0 0 56',FALSE,self);
			if(trace_fraction==1)
			{
				traceline(trace_endpos,trace_endpos-'0 0 300',TRUE,self);
				if(pointcontents(trace_endpos)==CONTENT_EMPTY)
				{
					self.velocity_x=self.velocity_y=0;
					self.velocity+=enemy_dir*vlen(self.enemy.origin-self.origin);
					trace_fraction=1;
					if(random()<0.7)
						self.think=mezzo_roll_forward;
					else
						self.think=self.th_jump;
				}
				else
				{
//					dprint("might land in water or lava\n");
					trace_fraction=0;
				}
			}
			else
			{
//				dprint("not enough room in front \n");
				trace_fraction=0;
			}
		}
//		dprint(ftos(trace_fraction));
//		dprint(" is the trace_fraction\n");
		if(random()<0.5&&trace_fraction<1)//Jump to side
		{
//			dprint("checking to sides\n");
			if(random()<0.5)
				r=1;
			else
				r=-1;
			makevectors(self.angles);
			traceline(self.origin,self.origin+v_right*36*r+'0 0 56',FALSE,self);
			if(trace_fraction<1)
			{
				traceline(self.origin,self.origin-v_right*36*r+'0 0 56',FALSE,self);
				if(trace_fraction<1)
				{
//					dprint("not enough room to jump on that side\n");
					self.think=mezzo_jump;
				}
				else 
				{
					traceline(trace_endpos,trace_endpos-'0 0 300',TRUE,self);
					if(pointcontents(trace_endpos)!=CONTENT_EMPTY)
					{
//						dprint("might jump into water or lava\n");
						self.think=mezzo_jump;
					}
					else
					{
						self.velocity-=v_right*r*200;
						if(r*-1>0)
							self.think=mezzo_roll_right;
						else
							self.think=mezzo_roll_left;
					}
				}
			}
			else 
			{
				traceline(trace_endpos,trace_endpos-'0 0 300',TRUE,self);
				if(pointcontents(trace_endpos)!=CONTENT_EMPTY)
				{
//					dprint("might jump into water or lava\n");
					self.think=mezzo_jump;
				}
				else
				{
					self.velocity+=v_right*r*200;
					if(r>0)
						self.think=mezzo_roll_right;
					else
						self.think=mezzo_roll_left;
				}
			}
		}
		thinktime self : 0;
		if(self.think!=mezzo_jump&&self.think!=mezzo_roll_right&&self.think!=mezzo_roll_left&&self.think!=mezzo_roll_forward)
		{
//			dprint("What the FUCK!!!\n");
			self.think=mezzo_jump;
		}
//		return;
	}
	else if(infront(enemy_proj)&&random()<0.5)
	{
		thinktime self : 0;
		if(self.think==mezzo_block_wait)
		{
			self.t_width=time+1;
			return;
		}
		else if(self.think==mezzo_run_loop||random()<0.3)
			self.think=mezzo_charge;
		else
			self.think=mezzo_block;
		return;
	}
}

void() mezzo_charge_stop;
void mezzo_slam ()
{
	if(!other.movetype||other.mass>100||other.solid==SOLID_BSP)
		return;

	if(!infront(other)||other.safe_time>time)
		return;

	if(other.origin_z>self.absmax_z - 6||other.absmax_z<self.origin_z + 6)
		return;

	sound(self,CHAN_VOICE,"mezzo/slam.wav",1,ATTN_NORM);
	
float inertia;
	if(other.mass<10)
		inertia=1;
	else
		inertia=other.mass/10;

vector punchdir;
	makevectors(self.angles);
	punchdir=v_forward*300+'0 0 100';
	T_Damage(other,self,self,5*(self.skin+1)*(self.aflag+1)*(coop + 1));
	other.velocity+=punchdir*(1/inertia);
	other.flags(-)FL_ONGROUND;

	self.ltime+=1;
	other.safe_time=time+1.25;//So can't kill them instantly if they're moving against him or pinned on a wall
	if(self.think!=mezzo_charge_stop)
	{
		thinktime self : 0;
		self.think=mezzo_charge_stop;
	}
}

void mezzo_reflect_trig_touch ()
{
//vector newv;
vector  org, vec, dir;//, endspot,endplane, dif;
float magnitude;//remainder, reflect_count, 

	if (other.flags & FL_MONSTER || other.flags & FL_CLIENT || !other || other == self) return;

	if (other.safe_time>time) return;

	if(!self.owner.flags2&FL_ALIVE||self.owner.frozen>0)
	{
		if(self.owner.movechain==self)
			self.owner.movechain=world;
		remove(self);
	}

	if(other.classname=="funnal"||other.classname=="tornato")
		return;

	dir = normalize(other.velocity);
	magnitude=vlen(other.velocity);
	org = other.origin;
	vec = org + dir*100;
	traceline (org, vec, FALSE, other);	

	if(trace_ent!=self.owner)
		return;

	if(self.owner.classname=="monster_mezzoman")
		sound(self,CHAN_AUTO,"mezzo/slam.wav",1,ATTN_NORM);

	if(!self.owner.skin&&self.owner.classname=="monster_mezzoman")
	{//Just block it
		if(!other.flags2&FL_ALIVE)
			other.flags2(+)FL_NODAMAGE;
	}
	else
	{//reflect!
		if(self.owner.classname!="monster_mezzoman")
		{
			sound (self, CHAN_WEAPON, "fangel/deflect.wav", 1, ATTN_NORM);
			CreateWhiteFlash(trace_endpos);
			if(self.owner.classname=="monster_fallen_angel")
			{
				dir=dir*-1;
				makevectors(dir);
				dir=v_forward + v_up*random(-0.75,.75) + v_right*random(-0.75,.75);
				dir=normalize(dir);
			}
			else// if(visible(other.owner))
			{
				v_forward=normalize(other.owner.origin+other.owner.view_ofs-other.origin);
				dir+= 2*v_forward;
				dir=normalize(dir);
			}
//			else
//				dir=dir*-1;
		}
		else
		{
			sound(self,CHAN_AUTO,"mezzo/reflect.wav",1,ATTN_NORM);
			starteffect(CE_MEZZO_REFLECT,self.origin);
			makevectors(trace_ent.angles);
			dir+= 2*v_forward;
			dir=normalize(dir);
		}

		if(other.movedir)
			other.movedir=dir;
		if(other.o_angle)
			other.o_angle=dir;

		if(magnitude<other.speed)
		{
//			dprintf("Low mag : %s\n",magnitude);
			magnitude=other.speed;
		}
		other.velocity = dir*magnitude;
		other.angles = vectoangles(other.velocity);
		UpdateMissileVelocity(other);


		self.owner.last_attack=time;
		other.safe_time=time+100/magnitude;

		if(!other.controller)
			other.controller=other.owner;
		if(other.enemy==self.owner)
			other.enemy=other.owner;
		if(other.goalentity==self.owner)
			other.goalentity=other.owner;
		other.owner=self.owner;
	}
}

void reflect_think ()
{
	makevectors(self.owner.angles);
	setorigin(self,self.owner.origin+ v_forward*48+'0 0 40');
	self.think=reflect_think;
	thinktime self : 0.05;
}

void spawn_reflect ()
{
//FIXME: Picks up enemy missile as shield!  shield not necc?
	makevectors(self.angles);
	newmis=spawn();
	self.shield=newmis;
	newmis.movetype = MOVETYPE_NOCLIP;
	newmis.solid = SOLID_TRIGGER;
	newmis.owner = self;
	newmis.touch = mezzo_reflect_trig_touch;
	newmis.classname="mezzo_reflect";
	newmis.effects=EF_NODRAW;

	setmodel(newmis,"models/null.spr");
	if(self.classname=="monster_mezzoman")
	{
		setsize (newmis, '-32 -32 -10','32 32 30');
		setorigin(newmis,self.origin+ v_forward*48+'0 0 40');
  
		newmis.think=reflect_think;
		thinktime newmis : 0;
	}
	else
	{
		self.movechain=newmis;
		setsize (newmis, '-48 -48 -64','48 48 50');
		setorigin(newmis,self.origin);
	}
}

void mezzo_clobber() [++ $clober1 .. $clober16]
{
float zofs;
	ai_charge(1);
	if(self.frame==$clober7)
	{
		makevectors(self.angles);
		
		zofs = self.enemy.origin_z - self.origin_z;
		if(zofs>20)
			zofs=20;
		else if(zofs<-20)
			zofs=-20;

		traceline(self.origin+'0 0 30',self.origin+'0 0 30'+v_forward*36+v_up*zofs,FALSE,self);
		if(trace_fraction==1)
			return;

		sound(self,CHAN_VOICE,"mezzo/slam.wav",1,ATTN_NORM);

		if(trace_ent.movetype&&trace_ent.movetype!=MOVETYPE_PUSH)
			trace_ent.velocity+=v_forward*200-v_right*100+'0 0 100';
		if(trace_ent.takedamage)
			T_Damage(trace_ent,self,self,5*(self.skin+1)*(self.aflag+1)*(coop + 1));
		if(trace_ent.classname=="player")
			if(infront_of_ent(self,trace_ent))
				trace_ent.punchangle_y=4;
	}
	else if(cycle_wrapped)
	{
		self.attack_finished=time+0.5;
		thinktime self : 0;
		self.think=self.th_run;
	}
	else if(self.frame==$clober1)
	{
		self.last_attack=time;
		if(random()<0.5)
			sound(self,CHAN_VOICE,"mezzo/attack.wav",1,ATTN_NORM);
	}
}

void mezzo_sword() [++ $sword1 .. $sword13]
{
	ai_face();
	ai_charge(3);
	if(cycle_wrapped)
	{
		self.attack_finished=time+0.3;
		thinktime self : 0;
		self.think=self.th_run;
	}
	else if(self.frame==$sword1)
	{
		self.last_attack=time;
		sound(self,CHAN_WEAPON,"weapons/vorpswng.wav",1,ATTN_NORM);
		if(random()<0.5)
			sound(self,CHAN_VOICE,"mezzo/attack.wav",1,ATTN_NORM);
	}
	else if(self.frame>=$sword6 && self.frame<=$sword10)
	{
	float ofs,zofs;
	vector dir;
		makevectors(self.angles);
		ofs=($sword10 - self.frame)*4;
		dir_z=ofs - 8;
		dir+=v_right*(ofs - 8)+v_forward*(48 - fabs(16 - ofs));
		dir=normalize(dir);

		zofs = self.enemy.origin_z - self.origin_z;
		if(zofs>20)
			zofs=20;
		else if(zofs<-20)
			zofs=-20;

		traceline(self.origin+'0 0 37',self.origin+'0 0 37'+dir*48+v_up*zofs,FALSE,self);
		if(trace_fraction==1)
			return;

		if(self.t_width<time)
		{
			MetalHitSound(trace_ent.thingtype);
			self.t_width=time+1;
		}

		if(trace_ent.takedamage)
			T_Damage(trace_ent,self,self,2*(self.skin+1)*(self.aflag+1)*(coop + 1));
		if(trace_ent.thingtype==THINGTYPE_FLESH&&self.frame==$sword9)
		{
			MeatChunks (trace_endpos,v_right*random(-100,-300)+'0 0 200', 3,trace_ent);
			sound(self,CHAN_AUTO,"weapons/slash.wav",1,ATTN_NORM);
		}
		SpawnPuff (trace_endpos, '0 0 0', 3,trace_ent);
	}
}

void mezzo_melee ()
{
	if(random()<0.3)
		self.think=mezzo_clobber;
	else
		self.think=mezzo_sword;
	thinktime self : 0;
}

void mezzo_missile ()
{
	if(vlen(self.enemy.origin-self.origin)<84&&lineofsight(self.enemy,self))
		self.think=mezzo_charge;
	else
		self.think=self.th_run;
	thinktime self : 0;
}

void mezzo_die () [++ $death1 .. $death16]
{
	if(self.shield)
		remove(self.shield);
	if (self.health < -40)
	{
		chunk_death();
		return;
	}
	if(self.frame==$death1)
		sound(self,CHAN_VOICE,"mezzo/die.wav",1,ATTN_NORM);
	else if(self.frame==$death12)
		sound(self,CHAN_BODY,"player/land.wav",1,ATTN_NORM);
	else if(self.frame==$death16)
		MakeSolidCorpse();
	thinktime self : 0.1;
}

void mezzo_pain_seq () [++ $pain1 .. $pain7]
{
	ai_back(1);
	if(cycle_wrapped)
	{
		thinktime self : 0;
		if(!self.flags&FL_ONGROUND)
			self.think=mezzo_in_air;
		else
			self.think=self.th_run;
	}
}

void mezzo_pain (entity attacker, float damage)
{
	if(self.monster_awake)
		if(random(self.health)>damage*3||self.pain_finished>time)//only react to 33 percent of current health damage
			return;

	self.monster_awake=TRUE;

	if(self.shield)
		remove(self.shield);

	if(self.health<=100)
	{
		self.th_pain=SUB_Null;
		if(self.health<=100)
		{
			if(random()<0.5)
			{
				self.oldthink=self.th_run;
				self.think=mezzo_roar;
				self.speed=15;
				self.yaw_speed=20;
				self.aflag=TRUE;//Berzerk!
			}
			else if(!self.flags&FL_ONGROUND)
				self.think=mezzo_in_air;
			else
				self.think=self.th_run;
		}
	}
	else
	{
		sound(self,CHAN_VOICE,"mezzo/pain.wav",1,ATTN_NORM);
		if(!self.enemy||!visible(self.enemy))
		{
			if(self.enemy!=world&&self.enemy!=attacker)
				self.oldenemy=self.enemy;
			self.enemy=attacker;
		}
		self.pain_finished=time+1+self.skin;
		self.think=mezzo_pain_seq;
	}
	thinktime self : 0;
}

void mezzo_land () [++ $jump13 .. $jump22]
{
//SOUND?
//	dprint("landing\n");
	if(cycle_wrapped)
	{
		thinktime self : 0;
		self.think=self.th_run;
	}
	else if(self.frame==$jump13)
		sound(self,CHAN_BODY,"player/land.wav",1,ATTN_NORM);
}

void mezzo_in_air ()
{
//	dprint("in air\n");
	self.frame=$jump12;
	if(self.flags&FL_ONGROUND)
	{
		thinktime self : 0;
		self.think=mezzo_land;
	}
	else 
	{
		if(self.velocity=='0 0 0')
			self.velocity='0 0 -60';
		self.think=mezzo_in_air;
		if(vlen(self.velocity)>300)
		{
			if(random()<0.5)
			{
				self.dflags=TRUE;//in air
				self.think=mezzo_roll_forward;
			}
		}
		thinktime self : 0.05;
	}
}

void mezzo_jump () [++ $jump1 .. $jump11]
{
//SOUND?
//	dprint("jumping\n");
	ai_face();
	if(self.flags&FL_ONGROUND)
	{
		thinktime self : 0;
		self.think=mezzo_land;
	}
	else if(self.frame==$jump11)
	{
		thinktime self : 0.05;
		self.think=mezzo_in_air;
	}
}

void mezzo_charge_stop () [++ $charge15 .. $charge25]
{
	if(cycle_wrapped)
	{
		self.touch=obj_push;
		thinktime self : 0;
		self.think=self.th_run;
	}
	if(!walkmove(self.angles_y,$charge25 - self.frame,FALSE))
	{
		if(!self.ltime)
			self.think=mezzo_pain_seq;
		else
			self.think=self.th_run;
		thinktime self : 0;
	}
}

void mezzo_charge_leap () [++ $charge9 .. $charge14]
{
//SOUND?
	if(cycle_wrapped)
	{
		thinktime self : 0;
		self.think=mezzo_charge_stop;
	}
	else if(self.frame==$charge9)
	{
		makevectors(self.angles);
		traceline(self.origin+'0 0 25',self.origin+'0 0 25'+v_forward*256,FALSE,self);
//Used to make him not charge if you stepped aside, now
//only checks if will fall
		if(!trace_ent.takedamage)
		{
			self.think=mezzo_skid;
			thinktime self : 0;
		}
		else
		{
			traceline(trace_endpos,trace_endpos-'0 0 300',TRUE,self);
			if(pointcontents(trace_endpos)!=CONTENT_EMPTY||trace_fraction==1)
			{
				self.think=mezzo_skid;
				thinktime self : 0;
			}
			else if(self.flags&FL_ONGROUND)
		 	{
				if(random()<0.5)
					sound(self,CHAN_VOICE,"mezzo/attack.wav",1,ATTN_NORM);
				self.velocity=v_forward*700+'0 0 133';
				self.flags(-)FL_ONGROUND;
			}
			else
			{
				self.think=mezzo_in_air;
				thinktime self : 0;
			}
		}
	}
}

void mezzo_charge () [++ $charge1 .. $charge8]
{
	if(cycle_wrapped)
	{
		thinktime self : 0;
		self.think=mezzo_charge_leap;
	}
	else if(self.frame==$charge1)
	{
		self.last_attack=time;
		self.ltime=0;
		self.touch=mezzo_slam;
		self.attack_finished=time+1.25;
	}
	walkmove(self.angles_y,15,FALSE);
}

void mezzo_block_return () [-- $block6 .. $block1]
{
//	if(self.shield.velocity!='0 0 0'&&self.shield.model!="models/null.spr")
//		dprint("what the?\n");
	if(cycle_wrapped)
	{
	float r;
		if(self.shield)
			remove(self.shield);
		r=vlen(self.enemy.origin-self.origin);
		if(infront(self.enemy)&&r<100)
		{
			thinktime self : 0;
			self.think=self.th_melee;
		}
//		else if(random()<0.2&&r<177)
//		{
//			thinktime self : 0;
//			self.think=self.th_stand;
//		}
		else
		{
			thinktime self : 0;
			self.think=self.th_run;
		}
	}
}

void mezzo_block_wait ()
{
//	if(self.shield.velocity!='0 0 0'&&self.shield.model!="models/null.spr")
//		dprint("what the?\n");
	self.think=mezzo_block_wait;
	if(self.t_width<time)
	{
		thinktime self : 0;
		self.think=mezzo_block_return;
	}
	else
	{
		self.frame=$block6;
		ai_face();
		self.think=mezzo_block_wait;
		thinktime self : 0.05;
	}
	if(range(self.enemy)==RANGE_MELEE)
		if(CheckAnyAttack())
			return;
	if(!self.flags&FL_ONGROUND)
	{
//		dprint("what the fuck?!  off ground while blocking?!\n");
		if(!self.velocity_x&&!self.velocity_y)
			self.think=mezzo_in_air;
		else
			self.think=mezzo_roll_forward;
		thinktime self : 0;
	}
	self.shield.oldthink=self.shield.think;
	self.shield.think=SUB_Remove;
	thinktime self.shield : 0.2;
//	dprint("checking defense from block\n");
	mezzo_check_defense();
	if(self.think==mezzo_block_wait)
	{
		self.shield.think=self.shield.oldthink;
		thinktime self.shield : 0;
	}
//	else
//		dprint("wigging!\n");
}

void mezzo_block () [++ $block1 .. $block6]
{
	walkmove(self.angles_y,-1,FALSE);
//	dprint("blocking\n");

//	if(self.shield.velocity!='0 0 0'&&self.shield.model!="models/null.spr")
//		dprint("what the?\n");
	if(cycle_wrapped)
	{
		if(self.th_pain==SUB_Null&&self.health>77)
			self.th_pain=mezzo_pain;
		self.t_width=time+1;
		thinktime self : 0;
		self.think=mezzo_block_wait;
	}
	else if(self.frame==$block1)
		spawn_reflect();
}

void mezzo_skid () [++ $block1 .. $block6]
{
float skidspeed, anim_stretch;
	anim_stretch = 3;

	skidspeed=$block6 - self.frame + anim_stretch - self.level;
	if(walkmove(self.angles_y,skidspeed*2,FALSE))
	{
		particle(self.origin, '0 0 20'*skidspeed, 344, skidspeed);
		if(random()<0.2)
			CreateWhiteSmoke(self.origin,'0 0 8',HX_FRAME_TIME * 2);
	}
	else
	{
		thinktime self : 0;
		self.think=mezzo_block_return;
		return;
	}

	if(cycle_wrapped)
	{
		self.attack_finished=time+3;
		thinktime self : 0;
		self.think=mezzo_block_return;
	}
	else if(self.frame==$block1)
	{
		spawn_reflect();
		sound(self,CHAN_AUTO,"mezzo/skid.wav",1,ATTN_NORM);
	}
	else if(self.level<anim_stretch)
	{
		self.frame-=1;
		self.level+=1;
	}
	else
		self.level=0;
}

void mezzo_roar () [++ $roar1 .. $roar30] 
{
	self.health+=1.1;

	if(self.frame==$roar30)
	{
		if(!self.aflag)
			self.th_pain=mezzo_pain;
		if(!self.takedamage)
			self.takedamage=DAMAGE_YES;
		self.last_attack=time+3;
		thinktime self : 0;
		self.think=self.oldthink;
	}
	else if(self.frame==$roar1)
	{
		self.monster_awake=TRUE;
		if(self.health<100)
		{
			self.th_pain=SUB_Null;
			self.takedamage=DAMAGE_NO;
		}
		sound(self,CHAN_VOICE,"mezzo/roar.wav",1,ATTN_NORM);
	}
	else if(self.frame==$roar19)
		thinktime self : 2;

	if(self.takedamage)
		mezzo_check_defense();
}

void mezzo_run_think ()
{
//	if(self.shield.velocity!='0 0 0'&&self.shield.model!="models/null.spr")
//		dprint("what the?\n");
	mezzo_check_defense();
/*
	if(!self.flags&FL_ONGROUND)
	{
		if(self.velocity=='0 0 0')
			self.velocity='0 0 -60';
		else if(random()<0.5)
			self.think=mezzo_roll_forward;
		else
			self.think=mezzo_in_air;
		thinktime self : 0;
	}
*/ 
//	if(!self.flags2&FL_ALIVE)
//		dprint("Undead Mezzoman!!!\n");
	if(!self.takedamage)
	{
//		dprint("Invincible Mezzoman!!!\n");
		self.takedamage=DAMAGE_YES;
	}

	if(!self.enemy.flags2&FL_ALIVE&&self.enemy!=world)
	{
		self.monster_awake=FALSE;
		if(visible(self.enemy)&&infront(self.enemy))
		{
			self.oldthink=self.th_stand;
			self.think=mezzo_roar;
		}
		else
			self.think=self.th_stand;
		if(self.oldenemy.flags2&FL_ALIVE)
		{
			self.enemy=self.oldenemy;
			self.oldenemy=world;
			self.think=self.th_run;
		}
		else
			self.enemy=world;
		thinktime self : 0;
	}
	else if(self.enemy!=world)
	{
		if(visible(self.enemy))
		{
		float dist;
			dist=vlen(self.enemy.origin-self.origin);
			if(dist<177&&dist>33)
			{
				if(random()<0.5&&lineofsight(self.enemy,self))
				{
					thinktime self : 0;
					self.think=mezzo_charge;
				}
				else if(dist>84&&self.last_attack<time&&infront(self.enemy))
				{
					thinktime self : 0;
					self.think=mezzo_skid;
				}
			}
			else if(!infront(self.enemy))
			{
				if(self.last_attack<time&&random()<0.5)
				{
					if(!self.aflag)
						self.yaw_speed=10;
					self.last_attack=time+7;
					thinktime self : 0;
					self.think=mezzo_skid;
				}
				else
					self.yaw_speed=20;
			}
			else if(!self.aflag)
				self.yaw_speed=10;
		}
		else
			self.yaw_speed=10;
		ai_run(self.speed);
	}
	else
	{
		self.think=self.th_stand;
		thinktime self : 0;
	}
}

void mezzo_run_loop () [++ $run1 .. $run22]
{
	mezzo_run_think();
}

void mezzo_run () [++ $run6 .. $run22]
{
	mezzo_check_defense();
	self.last_attack=time+0.1;//So won't start running then skid suddenly
	if(!self.monster_awake)
		if(range(self.enemy)>RANGE_NEAR&&random()>0.3)
		{
			self.oldthink=self.th_run;
			self.think=mezzo_roar;
			thinktime self : 0;
			return;
		}
		else
		{
			sound(self,CHAN_VOICE,"mezzo/attack.wav",1,ATTN_NORM);
			self.monster_awake=TRUE;
		}

	if(cycle_wrapped)
	{
		self.think=mezzo_run_loop;
		thinktime self : 0;
	}
	else 
		mezzo_run_think();
}

void mezzo_walk () [++ $walk1 .. $walk30]
{
	if(self.frame==$stand3 &&random()<0.1)
		mezzo_idle_sound();
	mezzo_check_defense();
	ai_walk(3);
	if(self.enemy)
		if(CheckAnyAttack())
			return;
}

void()mezzo_stand;
void mezzo_twirl() [++ $twirl1 .. $twirl10]
{
	mezzo_check_defense();
	if(cycle_wrapped)
	{
		self.think=mezzo_stand;
		thinktime self : 0;
	}
	else if(self.frame==$twirl1)
	{
		sound(self,CHAN_WEAPON,"weapons/vorpswng.wav",0.7,ATTN_NORM);
		if(random()<0.5)
			mezzo_idle_sound();
	}
	ai_stand();
}

void mezzo_stand2 () [-- $stand10 .. $stand1]
{
	mezzo_check_defense();

	if(self.level<3&&self.frame<$stand10)
	{
		self.level+=1;
		self.frame+=1;
	}
	else
		self.level=0;

	if(self.frame==$stand1)
	{
		if(random()<0.1||(self.monster_awake&&random()<0.5))
			self.think=mezzo_twirl;
		else
			self.think=mezzo_stand;
		thinktime self : 0;
		return;
	}
	else if(self.frame==$stand10 &&random()<0.1)
		mezzo_idle_sound();

/*	if(self.monster_awake)
	{
	float r;
		r=vlen(self.enemy.origin-self.origin);
		if(random()<0.1||r>177)
		{
			if(r>177)
				self.think=self.th_run;
			else if(enemy_infront&&enemy_vis&&r<133)
				self.think=mezzo_charge;
			else if(random()<0.5)
				self.think=self.th_run;
			else
				self.think=self.th_walk;
			thinktime self : 0;
		}
		else
		{
			if(random()<0.8&&r>100)
				self.attack_finished=time+0.1;
			ai_run(0);
		}
	}
	else
*/		ai_stand();
}

void mezzo_stand () [++ $stand1 .. $stand10]
{
	if(random()<0.5)
	{
		mezzo_check_defense();

		if((!self.enemy.flags2&FL_ALIVE&&self.enemy!=world)||self.enemy==world)
		{
			self.monster_awake=FALSE;
			if(self.oldenemy.flags2&FL_ALIVE)
			{
				self.enemy=self.oldenemy;
				self.oldenemy=world;
			}
			else
				self.enemy=world;
		}
	}

	if(self.level<3&&self.frame>$stand1)
	{
		self.level+=1;
		self.frame-=1;
	}
	else
		self.level=0;

	if(self.frame==$stand10)
	{
		self.think=mezzo_stand2;
		thinktime self : 0;
		return;
	}
	else if(self.frame==$stand1 &&random()<0.1)
		mezzo_idle_sound();

	if(random()<0.5)
		ai_stand();
}


/*QUAKED monster_werejaguar (1 0.3 0) (-16 -16 0) (16 16 56) AMBUSH STUCK JUMP PLAY_DEAD DORMANT
WereCat with jaguar skin
If they're targetted by a trigger and used, they'll atack the activator of the target
If they can't see the activator, they'll roll left or right (in the direction of the activator)
Their roll is 128 units long, so place the mezzoman 128 units away from where you want the roll to stop

My babies!!! - MG
*/
//IDEA: Have mezzoman do ai_face while in air or rolling so always faces you when lands/gets up?
void() monster_werejaguar =
{
   if (deathmatch)
   {
      remove(self);
      return;
   }

	if (!self.flags2&FL_SUMMONED)
	{
		precache_model2 ("models/mezzoman.mdl");
		precache_model2 ("models/mezzoref.spr");
		precache_model2 ("models/h_mez.mdl");
		precache_sound2 ("mezzo/skid.wav");
		precache_sound2 ("mezzo/roar.wav");
		precache_sound2 ("mezzo/reflect.wav");
		precache_sound2 ("mezzo/slam.wav");
		precache_sound2 ("mezzo/pain.wav");
		precache_sound2 ("mezzo/die.wav");
		precache_sound2 ("mezzo/growl.wav");
		precache_sound2 ("mezzo/snort.wav");
		precache_sound2 ("mezzo/attack.wav");
	}
	self.solid = SOLID_SLIDEBOX;
	self.takedamage=DAMAGE_YES;
	self.thingtype=THINGTYPE_FLESH;
	self.movetype = MOVETYPE_STEP;
	self.view_ofs = '0 0 53';
	self.speed=10;
	self.yaw_speed = 10;
	self.health = 250;
	self.experience_value = 150;
	self.monsterclass = CLASS_HENCHMAN;
	self.mass = 10;
	self.mintel = 15;//Animal sense of smell makes him a good tracker
	if(self.classname=="monster_werepanther")
	{
		self.monsterclass = CLASS_LEADER;
		self.experience_value = 300;
		self.health=400;
		self.skin=1;
	}

	self.classname="monster_mezzoman";

	self.th_stand=mezzo_stand;
	self.th_walk=mezzo_walk;
	self.th_run=mezzo_run;
	self.th_pain=mezzo_pain;
	self.th_melee=mezzo_melee;
	self.th_missile=mezzo_missile;
	self.th_jump=mezzo_jump;
	self.th_die=mezzo_die;
//	self.th_possum = mezzo_playdead;
//	self.th_possum_up = mezzo_possum_up;

	self.spawnflags (+) JUMP;

	setmodel (self, "models/mezzoman.mdl");
	self.headmodel="models/h_mez.mdl";

	setsize (self, '-16 -16 0', '16 16 56');

	self.frame=$stand1;

	walkmonster_start();
};

void monster_mezzoman (void)
{
	monster_werejaguar();
}

/*QUAKED monster_werepanther (1 0.3 0) (-16 -16 0) (16 16 56) AMBUSH STUCK JUMP PLAY_DEAD DORMANT
WereCat with panther skin
If they're targetted by a trigger and used, they'll atack the activator of the target
If they can't see the activator, they'll roll left or right (in the direction of the activator)
Their roll is 128 units long, so place the mezzoman 128 units away from where you want the roll to stop

My babies!!! - MG
*/
void monster_werepanther (void)
{
	monster_werejaguar();
}