/*
 * $Header: /HexenWorld/HCode/hydra.hc 2     4/20/98 2:03p Rjohnson $
 */

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

Q:\art\models\monsters\hydra\final\hydra.hc

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

// For building the model
$cd Q:\art\models\monsters\hydra\final
$origin 0 0 0
$base base 450 200
$skin skin1
$flags 0

//
$frame hadie1    hadie2    hadie3    hadie4    hadie5    
$frame hadie6    hadie7    hadie8    hadie9    hadie10   
$frame hadie11   hadie12   hadie13   hadie14   hadie15   
$frame hadie16   hadie17   hadie18   hadie19   hadie20   
$frame hadie21   hadie22   hadie23   hadie24   hadie25   
$frame hadie26   hadie27   hadie28   hadie29   hadie30   
$frame hadie31   hadie32   hadie33   hadie34   hadie35   
$frame hadie36   

//
$frame hapan1    hapan2    hapan3    hapan4    hapan5    
$frame hapan6    hapan7    hapan8    hapan9    hapan10   

//
$frame hlft1     hlft2     hlft3     hlft4     hlft5     
$frame hlft6     hlft7     hlft8     hlft9     hlft10    
$frame hlft11    hlft12    hlft13    hlft14    hlft15    
$frame hlft16    hlft17    hlft18    hlft19    hlft20    
$frame hlft21    hlft22    hlft23    hlft24    hlft25    
$frame hlft26    hlft27    hlft28    hlft29    hlft30    

//
$frame hopen1    hopen2    hopen3    hopen4    hopen5    
$frame hopen6    hopen7    hopen8    

//
$frame hrit1     hrit2     hrit3     hrit4     hrit5     
$frame hrit6     hrit7     hrit8     hrit9     hrit10    
$frame hrit11    hrit12    hrit13    hrit14    hrit15    
$frame hrit16    hrit17    hrit18    hrit19    hrit20    
$frame hrit21    hrit22    hrit23    hrit24    hrit25    
$frame hrit26    hrit27    hrit28    hrit29    hrit30    

//
$frame hsdie1    hsdie2    hsdie3    hsdie4    hsdie5    
$frame hsdie6    hsdie7    hsdie8    hsdie9    hsdie10   
$frame hsdie11   hsdie12   hsdie13   hsdie14   hsdie15   
$frame hsdie16   hsdie17   hsdie18   hsdie19   hsdie20   
$frame hsdie21   hsdie22   hsdie23   hsdie24   hsdie25   
$frame hsdie26   hsdie27   hsdie28   hsdie29   hsdie30   
$frame hsdie31   hsdie32   hsdie33   hsdie34   hsdie35   
$frame hsdie36   

//
$frame hspan1    hspan2    hspan3    hspan4    hspan5    
$frame hspan6    hspan7    hspan8    hspan9    hspan10   

//
$frame hspit1    hspit2    hspit3    hspit4    hspit5    
$frame hspit6    hspit7    hspit8    hspit9    hspit10   
$frame hspit11   hspit12   

//
$frame hswim1    hswim2    hswim3    hswim4    hswim5    
$frame hswim6    hswim7    hswim8    hswim9    hswim10   
$frame hswim11   hswim12   hswim13   hswim14   hswim15   
$frame hswim16   hswim17   hswim18   hswim19   hswim20   

//
$frame htent1    htent2    htent3    htent4    htent5    
$frame htent6    htent7    htent8    htent9    htent10   
$frame htent11   htent12   htent13   htent14   htent15   
$frame htent16   htent17   htent18   htent19   htent20   
$frame htent21   htent22   htent23   htent24   



// Monster Stages
float HYDRA_STAGE_WAIT     = 0;
float HYDRA_STAGE_SWIM     = 1;
float HYDRA_STAGE_FLOAT    = 2;
float HYDRA_STAGE_STRAIGHT = 3;
float HYDRA_STAGE_REVERSE  = 4;
float HYDRA_STAGE_CHARGE   = 5;
float HYDRA_STAGE_ATTACK   = 10;

void hydra_attack(void);
void hydra_CloseFrames(void);
void hydra_move(float thrust);
void hydra_bob(void);

void hydra_init(void)
{  // Set the hydra ready for swim
	self.ideal_yaw = vectoyaw(self.enemy.origin - self.origin);
	self.think = self.th_run;
	thinktime self : random(.1,.6);
	self.count = 0;
	self.monster_stage = HYDRA_STAGE_SWIM;
	self.hydra_FloatTo = 0;
	self.goalentity = self.enemy;

	self.monster_awake = TRUE;
}

void hydra_wait(void)
{
	if (LocateTarget())
	{  // We found a target
		hydra_init();
	}		
}

// Starting frames for making a large turn
//void hydra_BigLeft(void);
//void hydra_BigRight(void);

// Starting frames for making a short turn
//void hydra_ShortLeft(void);
//void hydra_ShortRight(void); 

void hydra_OpenFrames(void);
void hydra_TentFrames(void);
void hydra_SpitFrames(void);

float hydra_check_blind_melee();


void hydra_charge_finish()
{
	self.yaw_speed = 5;
	self.cnt = time + random(5,10);

	if (CheckMonsterAttack(MA_MELEE, 3.0)) 
	{
		self.monster_stage += HYDRA_STAGE_ATTACK;
		self.monster_check = 0;
		self.think = hydra_attack;
		thinktime self : 0.05;
		return;
	}

	self.monster_stage = HYDRA_STAGE_SWIM;
	self.think = self.th_run;
	thinktime self : 0.1;
}

void hydra_charge()
{
	float dist;
	
	self.yaw_speed = 8;

	check_pos_enemy();

	ai_face();

	dist = vlen(self.enemy.origin - self.origin);

	movetogoal(dist / 8);

	if (range(self.enemy) == RANGE_MELEE) 
	{
		self.monster_check = 0;
		hydra_charge_finish();
		return;
	}

	if (self.hydra_chargeTime < time)
	{
		self.monster_check = 0;
		hydra_charge_finish();
		return;
	}

	self.think = hydra_charge;
	thinktime self : 0.05;
}

float hydra_check_blind_melee(void)
{
	float dist, c1;//, c2;

	if (self.enemy.watertype != CONTENT_WATER) return 0;
	if (self.cnt > time) return 0;

	dist = vhlen(self.enemy.origin - self.origin);

	traceline(self.origin, self.enemy.origin, FALSE, self);

	c1 = fov(self, self.enemy, 80);

	if ((dist < 256) && c1 && trace_ent == self.enemy)
	{
		if (random() < 0.2)
			return 1;
	}

	return 0;
}

void hydra_blind(void)
{
	stuffcmd (self.enemy, "df\n");

	self.hydra_chargeTime = time + 1;
	self.think = hydra_charge;
	thinktime self : 0.05;
}

void hydra_checkForBlind(void)
{
	float r;

	r = pointcontents(self.enemy.origin);

	if (r != CONTENT_WATER) 
	{
		self.think = self.th_run;
		thinktime self : 0.1;
		return;
	}

	r = vhlen(self.enemy.origin - self.origin);

	if ((r < 256) && (fov(self, self.enemy, 80)) && (fov(self.enemy, self, 80)))
	{
		thinktime self : 0.1;
		self.think = hydra_blind;
	}
	else 
	{
		self.think = self.th_run;
		thinktime self : 0.1;
	}
}

void hydra_swim(float thrust) 
{
	float dist;
	float temp;

	if (self.velocity) self.velocity = self.velocity * 0.7;
	
	if (!self.enemy.flags2 & FL_ALIVE)
	{
		self.goalentity = self.enemy = world;
		self.monster_stage = HYDRA_STAGE_WAIT;
		return;
	}
	
	dist = (4.0 + thrust*6);  // Movement distance this turn
		
	movetogoal(dist);
	
	if (self.hydra_FloatTo == 0)
	{
		dist = self.enemy.origin_z - self.origin_z;
		if (dist < -50) self.hydra_FloatTo = dist - random(60);
		else if (dist > 50) self.hydra_FloatTo = dist + random(60);
	}

	if (self.hydra_FloatTo < -10)
	{
		temp = random(-3.5,-2.5);
//		movestep(0,0,temp, FALSE);
		self.hydra_FloatTo -= temp;
	}
	else if (self.hydra_FloatTo > 10)
	{
		temp = random(2.5,3.5);
//		movestep(0,0,temp, FALSE);
		self.hydra_FloatTo -= temp;
	}
	else self.hydra_FloatTo = 0;

	self.th_save = self.think;

	//checkenemy();

	enemy_range = range (self.enemy);
	if (hydra_check_blind_melee())
	{
		self.monster_check = 2;
		hydra_attack();
	}

	dist = vlen(self.enemy.origin - self.origin);
	if (dist > 350)
	{
		if (CheckMonsterAttack(MA_MISSILE,8.0))
			return;
	}	
	else
		CheckMonsterAttack(MA_MELEE,3.0);
}

void hydra_float(void)
{
	float Length;

	if (self.velocity) self.velocity = self.velocity * 0.7;

	Length = vhlen(self.origin - self.enemy.origin);

	if (Length < 300.0)
	{
		self.monster_stage = HYDRA_STAGE_SWIM;
		self.hydra_FloatTo = 0;
		return;
	}

	/*self.ideal_yaw = vectoyaw(self.enemy.origin - self.origin);
	ChangeYaw();*/
	ai_face();
	
	self.th_save = self.think;
	enemy_range = range (self.enemy);
	if (hydra_check_blind_melee())
	{
		self.monster_check = 2;
		hydra_attack();
	}
	CheckMonsterAttack(MA_MISSILE,8.0);
}

void hydra_reverse(void)
{
	float retval;
	float dist;

	self.monster_duration -= 1;
	dist = 4.0;  // Movement distance this turn

	retval = walkmove(self.angles_y + 180, dist, FALSE);
	/*if (!retval)
	{
		self.ideal_yaw = FindDir();
		self.monster_duration = 0;//random(40,70);
		self.monster_stage = HYDRA_STAGE_STRAIGHT;
		ChangeYaw();//hydra_turn(200);
		return;
	}*/
	
	//self.monster_stage = HYDRA_STAGE_FLOAT;
	
}

void hydra_move(float thrust) 
{
	check_pos_enemy();

	if (self.monster_stage == HYDRA_STAGE_SWIM)
	{
		hydra_swim(thrust);
		return;
	}
	else if (self.monster_stage == HYDRA_STAGE_FLOAT)
	{
		hydra_float();	
		return;
	}
	else if (self.monster_stage == HYDRA_STAGE_WAIT)
	{
		hydra_wait();
		return;
	}
	else if (self.monster_stage == HYDRA_STAGE_REVERSE)
	{
//		hydra_reverse();
		return;
	}
}

void hydra_attack(void)
{
	if (self.monster_check > 0)
	{
		hydra_SpitFrames();
	}
	else
	{
		hydra_TentFrames();
	}
}

void hydra_fire(void)
{
	sound (self, CHAN_WEAPON, "hydra/spit.wav", 1, ATTN_NORM);
	do_spit('0 0 0');
	do_spit('0 0 0');
	do_spit('0 0 0');
}

void hydra_tent(float TryHit) 
{
	ai_face();

	check_pos_enemy();

	if (TryHit)
	{
		makevectors(self.angles);
		traceline(self.origin,self.origin+v_forward*128,FALSE,self);

		if (trace_ent.takedamage)
		{
			sound (self, CHAN_WEAPON, "hydra/tent.wav", 1, ATTN_NORM);
			T_Damage (trace_ent, self, self, random(1,2));
		}
		else
			movetogoal(15);
	}
}

void hydra_open(void)
{
	ai_face();
}

void hydra_bob(void)
{
	local float	 rnd1, rnd2, rnd3;
//	local vector vtmp1, modi;

	rnd1 = self.velocity_x + random(-10,10);
	rnd2 = self.velocity_y + random(-10,10);
	rnd3 = self.velocity_z + random(10);

	if (rnd1 > 10)
		rnd1 = 10;
	if (rnd1 < -10)
		rnd1 = -10;
		
	if (rnd2 > 10)
		rnd2 = 10;
	if (rnd2 < -10)
		rnd2 = -10;
		
/*	if (rnd3 < 10)
		rnd3 = 15;*/
	if (rnd3 > 55)
		rnd3 = 50;
	
	self.velocity_x = rnd1;
	self.velocity_y = rnd2;
	self.velocity_z = rnd3;
}

// Swimming
float hydra_Swim[20] =
{
	-0.2,
	-0.1,
	0.0,
	0.1,  // Top going down
	0.2,
	0.3,
	0.4,
	0.5,  // middle
	0.4,
	0.3,
	0.2,
	0.1,  // bottom
	0.0,
	-0.1,
	-0.2,
	-0.3,
	-0.4,
	-0.5,  // middle
	-0.4,
	-0.3
};

// Top = 1, tr = 2, br = 3, tl = 4, bl = 5
float hydra_TentAttacks[24] =
{
	0,
	0,
	0,
	0,
	1,
	0,
	3,
	0,
	4,
	0,
	0,
	5,
	0,
	0,
	0,
	2,
	0,
	0,
	0,
	4,
	3,
	1,
	0,
	0
};



















// Attacking others
void hydra_AttackDieFrames(void)
{
	self.think = hydra_AttackDieFrames;
	thinktime self : HX_FRAME_TIME;

	if (self.frame != $hadie36)
		AdvanceFrame($hadie1,$hadie36);

	if (self.frame == $hadie35)
	{
		self.solid = SOLID_NOT;
		MakeSolidCorpse();
	}

	if (self.frame >= $hadie13)
	    hydra_bob();

	if(self.health<-30)
		chunk_death();
}

void hydra_AttackPainFrames(void) 
{
	self.think = hydra_AttackPainFrames;
	thinktime self : HX_FRAME_TIME;

	AdvanceFrame($hapan1,$hapan10);
}

// Swimming others
void hydra_SwimDieFrames(void)
{
	self.think = hydra_SwimDieFrames;
	thinktime self : HX_FRAME_TIME;

	if (self.frame != $hsdie36)
		AdvanceFrame($hsdie1,$hsdie36);

	if (self.frame == $hsdie35)
	{
		self.solid = SOLID_NOT;
		MakeSolidCorpse();
	}

	if (self.frame >= $hsdie8)
	    hydra_bob();

	if(self.health<-30)
		chunk_death();
}

void hydra_SwimPainFrames(void) 
{
	self.think = hydra_SwimPainFrames;
	thinktime self : HX_FRAME_TIME;

	AdvanceFrame($hspan1,$hspan10);
}

// Attacking
void hydra_OpenFrames(void) 
{
	self.think = hydra_OpenFrames;
	thinktime self : HX_FRAME_TIME;

	if (self.enemy.watertype != CONTENT_WATER) 
	{			
		self.monster_stage = HYDRA_STAGE_FLOAT;
		self.think = self.th_run;
		thinktime self : 0.1;

		return;
	}

	hydra_open();
	if (AdvanceFrame($hopen1,$hopen8) == AF_END)
	{
		hydra_attack();
	}
}

void hydra_CloseFrames(void) 
{
	self.think = hydra_CloseFrames;
	thinktime self : HX_FRAME_TIME;

	if (RewindFrame($hopen8,$hopen1) == AF_END)
	{
		self.monster_stage -= HYDRA_STAGE_ATTACK;
		self.think = self.th_save; 
	}
}

void hydra_SpitFrames(void) 
{
	vector vecA,vecB;

	self.think = hydra_SpitFrames;
	thinktime self : HX_FRAME_TIME;

	self.angles_y = vectoyaw(self.enemy.origin - self.origin);

	if (AdvanceFrame($hspit1,$hspit12) == AF_END)
	{
		self.think = hydra_CloseFrames;
		self.monster_check = -1;
	}
	else if (self.frame == $hspit7 && self.monster_check == 2)
	{
		sound (self, CHAN_WEAPON, "hydra/spit.wav", 1, ATTN_NORM);	
		vecA = self.enemy.origin - self.origin + self.enemy.proj_ofs;
		vecA = vectoangles(vecA);
		makevectors(vecA);
		v_forward_z = 0 - v_forward_z;

		vecA = v_factor('-40 400 -40');
		vecB = v_factor('40 500 40');

		particle2(self.origin+v_forward*40,vecA,vecB,256,12,400);
		self.think = hydra_checkForBlind;
		thinktime self : 0.1;
	}
	else if (self.frame == $hspit8 && self.monster_check == 1)
	{
		hydra_fire();
	}
}

void hydra_TentFrames(void) 
{
	float r;

	if (!self.enemy.flags2 & FL_ALIVE)
	{
		self.goalentity = self.enemy = world;
		self.monster_stage = HYDRA_STAGE_WAIT;
		self.think = self.th_stand;
		thinktime self : 0.1;
		return;
	}

	self.think = hydra_TentFrames;
	thinktime self : 0.025;

	if (AdvanceFrame($htent1,$htent24) == AF_END)
	{
		r = range(self.enemy);
		if ((r == RANGE_MELEE) && (random(0, 1) < 0.3))
		{
			self.frame = $htent1;
			hydra_tent(hydra_TentAttacks[self.frame - $htent1]);
		}
		else		
			self.think = hydra_CloseFrames;
	}
	else
	{
		hydra_tent(hydra_TentAttacks[self.frame - $htent1]);
	}
}

// Regular swimming / movement
void hydra_SwimFrames(void) 
{
	self.think = hydra_SwimFrames;
	thinktime self : HX_FRAME_TIME;

	AdvanceFrame($hswim1,$hswim20);
	if (self.frame == $hswim1)
		sound (self, CHAN_WEAPON, "hydra/swim.wav", 1, ATTN_NORM);

	hydra_move((hydra_Swim[self.frame - $hswim1]) + 0.3);
}

/*QUAKED misc_fountain (0 1 0.8) (0 0 0) (32 32 32) 
New item for QuakeEd

-------------------------FIELDS-------------------------
angles    0 0 0  the direction it should move the particles
movedir   1 1 1  the force it should move them
color     256    the color
cnt       2      the number of particles each time
--------------------------------------------------------

*/
void misc_fountain(void)
{
	starteffect(CE_FOUNTAIN, self.origin, self.angles,self.movedir,self.color,self.cnt);
}

void do_hydra_spit(void)
{
	self.monster_check = 1;
	self.monster_stage += HYDRA_STAGE_ATTACK;

	sound (self, CHAN_WEAPON, "hydra/open.wav", 1, ATTN_NORM);
	hydra_OpenFrames();
}

void do_hydra_tent(void)
{
	self.monster_check = 0;
	self.monster_stage += HYDRA_STAGE_ATTACK;

	sound (self, CHAN_WEAPON, "hydra/open.wav", 1, ATTN_NORM);
	hydra_OpenFrames();
}

void do_hydra_die(void)
{
	self.flags (+) FL_SWIM;

	sound (self, CHAN_WEAPON, "hydra/die.wav", 1, ATTN_NORM);

	if (self.monster_stage >= HYDRA_STAGE_ATTACK)
		hydra_AttackDieFrames();
	else
		hydra_SwimDieFrames();
}

void hydra_retreat()
{
	self.monster_stage = HYDRA_STAGE_REVERSE;
	self.think = self.th_run;
	thinktime self : 0.1;
}
	
void hydra_pain(entity attacker, float damage) 
{
	sound (self, CHAN_WEAPON, "hydra/pain.wav", 1, ATTN_NORM);
}

void init_hydra(void)
{
	if (deathmatch)
	{
		remove(self);
		return;
	}

	self.monster_stage = HYDRA_STAGE_WAIT;

	precache_model ("models/hydra.mdl");
	precache_model ("models/spit.mdl");

	self.solid = SOLID_SLIDEBOX;
	self.movetype = MOVETYPE_SWIM;
	self.thingtype=THINGTYPE_FLESH;
	self.classname="monster_hydra";
	self.mass = 7;

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

	setsize (self, '-30 -30 -24', '30 30 24');
	self.hull = HULL_SCORPION;
//self.hull = HULL_HYDRA;
	self.health = 125;
	self.experience_value = 50;
	self.mintel = 4;

	self.th_stand = hydra_SwimFrames;
	self.th_walk = hydra_SwimFrames;
	self.th_run = hydra_SwimFrames;
	self.th_pain = hydra_pain;
	self.th_die = do_hydra_die;
	self.th_missile = do_hydra_spit;
	self.th_melee = do_hydra_tent;

	self.takedamage = DAMAGE_YES;
	self.flags2 (+) FL_ALIVE;

	self.ideal_yaw = self.angles * '0 1 0';
	if (!self.yaw_speed)
		self.yaw_speed = 5;
	self.view_ofs = '0 0 0';
	self.use = monster_use;

	self.flags (+) FL_SWIM | FL_MONSTER;

	self.pausetime = 99999999;

	total_monsters += 1;

	thinktime self : random(0.5);
	self.think = self.th_stand;
}


/*QUAKED monster_hydra (1 0.3 0) (-40 -40 -42) (40 40 42) STAND HOVER JUMP PLAY_DEAD DORMANT
New item for QuakeEd

-------------------------FIELDS-------------------------
NOTE:  Normal QuakEd monster spawnflags don't apply here (no_jump, play_dead, no_drop)
--------------------------------------------------------

*/
void monster_hydra(void)
{
	init_hydra();

	precache_sound("hydra/pain.wav");
	precache_sound("hydra/die.wav");
	precache_sound("hydra/open.wav");
	precache_sound5("hydra/turn-s.wav");
	precache_sound("hydra/turn-b.wav");
	precache_sound("hydra/swim.wav");
	precache_sound("hydra/tent.wav");
	precache_sound("hydra/spit.wav");
}