#include "g_local.h"


//
// cast weapons
//

//FIXME cast members should call these with a totally accurate direction
// and we can mess it up based on skill.  Spread should be for normal
// and we can tighten or loosen based on skill.  We could muck with
// the damages too, but I'm not sure that's such a good idea.
void cast_fire_bullet (edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype)
{
	fire_bullet (self, start, dir, damage, kick, hspread, vspread, MOD_UNKNOWN);

	gi.WriteByte (svc_muzzleflash2);
	gi.WriteShort (self - g_edicts);
	gi.WriteByte (flashtype);
	gi.multicast (start, MULTICAST_PVS);

}

void cast_fire_shotgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int count, int flashtype)
{
	fire_shotgun (self, start, aimdir, damage, kick, hspread, vspread, count, MOD_UNKNOWN);

	gi.WriteByte (svc_muzzleflash2);
	gi.WriteShort (self - g_edicts);
	gi.WriteByte (flashtype);
	gi.multicast (start, MULTICAST_PVS);
}

void cast_fire_blaster (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect)
{
	fire_blaster (self, start, dir, damage, speed, effect, false);

	gi.WriteByte (svc_muzzleflash2);
	gi.WriteShort (self - g_edicts);
	gi.WriteByte (flashtype);
	gi.multicast (start, MULTICAST_PVS);
}	

void cast_fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int flashtype)
{
	fire_grenade (self, start, aimdir, damage, speed, 2.5, damage+40);

	gi.WriteByte (svc_muzzleflash2);
	gi.WriteShort (self - g_edicts);
	gi.WriteByte (flashtype);
	gi.multicast (start, MULTICAST_PVS);
}

void cast_fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype)
{
	fire_rocket (self, start, dir, damage, speed, damage+20, damage);

	gi.WriteByte (svc_muzzleflash2);
	gi.WriteShort (self - g_edicts);
	gi.WriteByte (flashtype);
	gi.multicast (start, MULTICAST_PVS);
}	

void cast_fire_railgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int flashtype)
{
	fire_rail (self, start, aimdir, damage, kick);

	gi.WriteByte (svc_muzzleflash2);
	gi.WriteShort (self - g_edicts);
	gi.WriteByte (flashtype);
	gi.multicast (start, MULTICAST_PVS);
}

void cast_fire_bfg (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int kick, float damage_radius, int flashtype)
{
	fire_bfg (self, start, aimdir, damage, speed, damage_radius);

	gi.WriteByte (svc_muzzleflash2);
	gi.WriteShort (self - g_edicts);
	gi.WriteByte (flashtype);
	gi.multicast (start, MULTICAST_PVS);
}



//
// Cast utility functions
//

static void M_FliesOff (edict_t *self)
{
	self->s.effects &= ~EF_FLIES;
	self->s.sound = 0;
}

static void M_FliesOn (edict_t *self)
{
	if (self->waterlevel)
		return;
	self->s.effects |= EF_FLIES;
	self->s.sound = gi.soundindex ("infantry/inflies1.wav");
	self->think = M_FliesOff;
	self->nextthink = level.time + 60;
}

void M_FlyCheck (edict_t *self)
{
	if (self->waterlevel)
		return;

	if (random() > 0.5)
		return;

	self->think = M_FliesOn;
	self->nextthink = level.time + 5 + 10 * random();
}
/*
void AttackFinished (edict_t *self, float time)
{
	self->cast_info.attack_finished = level.time + time;
}
*/

void M_CheckGround (edict_t *ent)
{
	vec3_t		point;
	trace_t		trace;

	if (ent->flags & (FL_SWIM|FL_FLY))
		return;

	if (ent->velocity[2] > 100)
	{
		ent->groundentity = NULL;
		return;
	}

// if the hull point one-quarter unit down is solid the entity is on ground
	point[0] = ent->s.origin[0];
	point[1] = ent->s.origin[1];
	point[2] = ent->s.origin[2] - 0.25;

	trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, point, ent, MASK_PLAYERSOLID | MASK_MONSTERSOLID);

	// check steepness
// Xatrix/Ridah, make sure we hit something
if ( trace.fraction < 1 && !trace.allsolid )
// Xatrix/Ridah, make sure we hit something

	if ( trace.plane.normal[2] < 0.5 && !trace.startsolid)
	{
		ent->groundentity = NULL;

// Xatrix/Ridah, added this to help monsters slide off steep walls
		VectorScale (trace.plane.normal, 200 * (trace.plane.normal[2] + 0.1), ent->velocity);

//		if (ent->velocity[2] < 120)
//			ent->velocity[2] = 120;
// Xatrix/Ridah, added this to fix ladder climbing problem

		return;
	}

// Xatrix/Ridah, added this to fix ladder climbing problems
	if ( trace.fraction == 1 )
	{
		// if we're stuck in a solid, try and move out of it
		if (trace.allsolid && ent->health > 0)
		{
			float x, y, z;
			float dist;
			vec3_t vec, dest;

			for (dist = 4; dist < 64; dist+= 24)
			{
				for (x=-1; x<2; x++)
					for (y=-1; y<2; y++)
						for (z=-1; z<2; z++)
						{
							VectorSet( vec, x, y, z );
							VectorNormalize( vec );
							VectorMA( ent->s.origin, dist, vec, dest );

							trace = gi.trace (dest, ent->mins, ent->maxs, dest, ent, MASK_PLAYERSOLID | MASK_MONSTERSOLID);

							if (!trace.allsolid)
							{
								VectorCopy( dest, ent->s.origin );
								goto foundspot;
							}
						}
			}

		}

foundspot:

		ent->groundentity = NULL;
		return;
	}
// Xatrix/Ridah, end.

	// Ridah
	if (trace.ent->svflags & SVF_MONSTER)
	{
		ent->groundentity = NULL;
		return;
	}

//	ent->groundentity = trace.ent;
//	ent->groundentity_linkcount = trace.ent->linkcount;
//	if (!trace.startsolid && !trace.allsolid)
//		VectorCopy (trace.endpos, ent->s.origin);

	// JOSEPH 2-MAY-99
	// Xatrix/Ridah, make sure we hit something
	if ( trace.fraction < 1 )
	{
		// Xatrix/Ridah, make sure we hit something
		if (!trace.startsolid && !trace.allsolid)
		{
			vec3_t move;

			VectorCopy (trace.endpos, ent->s.origin);
			ent->groundentity = trace.ent;
			ent->groundentity_linkcount = trace.ent->linkcount;
			ent->velocity[2] = 0;

			VectorSubtract( ent->last_step_pos, ent->s.origin, move );
			move[2] = 0;

			if (ent->last_step_time < (level.time-0.2) && VectorLength(move) > 40)
			{
				trace_t		trace2;
				
				// JOSEPH 5-JUN-99
				if (ent->classname && strcmp(ent->classname, "cast_dog"))
				{
					ent->s.event = EV_FOOTSTEP0 + ent->footsteptype;
				}
				// END JOSEPH

				VectorCopy( ent->s.origin, ent->last_step_pos );
				ent->last_step_time = level.time;

				trace2 = gi.trace (ent->s.origin, ent->mins, ent->maxs, point, ent, MASK_PLAYERSOLID | MASK_MONSTERSOLID | MASK_WATER);

				
				if (trace2.contents & MASK_WATER)
				{
					ent->footsteptype = 8; 
				}
				else if (trace2.surface->flags & SURF_CONCRETE)
				{
					ent->footsteptype = 0; 
				}
				else if (trace2.surface->flags & SURF_FABRIC)
				{
					ent->footsteptype = 1; 
				}
				else if (trace2.surface->flags & SURF_GRAVEL)
				{
					ent->footsteptype = 2; 
				}	
				else if (trace2.surface->flags & SURF_METAL)
				{
					ent->footsteptype = 3; 
				}
				else if (trace2.surface->flags & SURF_METAL_L)
				{
					ent->footsteptype = 4; 
				}
				else if (trace2.surface->flags & SURF_SNOW)
				{
					ent->footsteptype = 5; 
				}	
				else if (trace2.surface->flags & SURF_TILE)
				{
					ent->footsteptype = 6; 
				}	
				else if (trace2.surface->flags & SURF_WOOD)
				{
					ent->footsteptype = 7; 
				}	
				else if (trace2.surface->flags & SURF_WATER)
				{
					ent->footsteptype = 8; 
				}
				else
				{
					ent->footsteptype = 0; 
				}
			}

			// if standing on an AI, get off
			if (ent->groundentity->svflags & SVF_MONSTER)
			{
				ent->nav_data.goal_index = 0;

				VectorSet( ent->velocity, rand()%400 - 200, rand()%400 - 200, 200 );

				if (ent->groundentity->maxs[2] == ent->groundentity->cast_info.standing_max_z)
				{	// duck
					if (ent->groundentity->cast_info.move_crouch_down)
						ent->groundentity->cast_info.currentmove = ent->groundentity->cast_info.move_crouch_down;
					ent->groundentity->maxs[2] = DUCKING_MAX_Z;
				}

				// avoid
				ent->groundentity->cast_info.avoid( ent->groundentity, ent, false );

			}

		}
	// Xatrix/Ridah, didn't hit anything, so clear ->groundentity
	}
	else
	{
		ent->groundentity = NULL;
	}
	// Xatrix/Ridah, didn't hit anything, so clear ->groundentity
	// END JOSEPH

	// Ridah, do pitch adjustments
	if (ent->cast_info.aiflags & AI_ADJUSTPITCH && ent->health > 0)
	{
		static vec3_t	mins = {-4, -4, 0};
		static vec3_t	maxs = { 4,  4, 4};
		vec3_t	p1, p2;
		vec3_t	start, end;
		vec3_t	fwd, angles;
		float	pitch_diff;
		trace_t	tr;

		AngleVectors( ent->s.angles, fwd, NULL, NULL );

		VectorMA( ent->s.origin, ent->maxs[0]-maxs[0], fwd, start );
		VectorCopy( start, end );
		end[2] += ent->mins[2] - 32;

		tr = gi.trace( start, mins, maxs, end, ent, MASK_PLAYERSOLID | MASK_MONSTERSOLID );

		VectorCopy( tr.endpos, p1 );

		VectorMA( ent->s.origin, -(ent->maxs[0]-maxs[0]), fwd, start );
		VectorCopy( start, end );
		end[2] += ent->mins[2] - 32;

		tr = gi.trace( start, mins, maxs, end, ent, MASK_PLAYERSOLID | MASK_MONSTERSOLID );

		VectorCopy( tr.endpos, p2 );


		VectorSubtract( p1, p2, fwd );
		VectorNormalize( fwd );
		fwd[2] *= 0.5;
		vectoangles( fwd, angles );

		pitch_diff = AngleDiff( ent->s.angles[PITCH], angles[PITCH] );

		if (fabs(pitch_diff) > 120*FRAMETIME)
		{
			if (pitch_diff > 0)
				pitch_diff =  120*FRAMETIME;
			else
				pitch_diff = -120*FRAMETIME;
		}

//		if (pitch_diff)
//			gi.dprintf("PITCH: %f -> ", ent->s.angles[PITCH]);

		ent->s.angles[PITCH] += pitch_diff;

//		if (pitch_diff)
//			gi.dprintf("%f\n", ent->s.angles[PITCH]);
	}
}


void M_CatagorizePosition (edict_t *ent)
{
	vec3_t		point;
	int			cont;

//
// get waterlevel
//
	point[0] = ent->s.origin[0];
	point[1] = ent->s.origin[1];
	point[2] = ent->s.origin[2] + ent->mins[2] + 1;	
	cont = gi.pointcontents (point);

	if (!(cont & MASK_WATER))
	{
		ent->waterlevel = 0;
		ent->watertype = 0;
		return;
	}

	ent->watertype = cont;
	ent->waterlevel = 1;
	point[2] += 26;
	cont = gi.pointcontents (point);
	if (!(cont & MASK_WATER))
		return;

	ent->waterlevel = 2;
	point[2] += 22;
	cont = gi.pointcontents (point);
	if (cont & MASK_WATER)
		ent->waterlevel = 3;
}


void M_WorldEffects (edict_t *ent)
{
	int		dmg;

	if (ent->health > 0)
	{
		if (!(ent->flags & FL_SWIM))
		{
			if (ent->waterlevel < 3)
			{
				ent->air_finished = level.time + 12;
			}
			else if (ent->air_finished < level.time)
			{	// drown!
				if (ent->pain_debounce_time < level.time)
				{
					dmg = 2 + 2 * floor(level.time - ent->air_finished);
					if (dmg > 15)
						dmg = 15;
					T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR, MOD_WATER);
					ent->pain_debounce_time = level.time + 1;
				}
			}
		}
		else
		{
			if (ent->waterlevel > 0)
			{
				ent->air_finished = level.time + 9;
			}
			else if (ent->air_finished < level.time)
			{	// suffocate!
				if (ent->pain_debounce_time < level.time)
				{
					dmg = 2 + 2 * floor(level.time - ent->air_finished);
					if (dmg > 15)
						dmg = 15;
					T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR, MOD_WATER);
					ent->pain_debounce_time = level.time + 1;
				}
			}
		}
	}
	
	if (ent->waterlevel == 0)
	{
		if (ent->flags & FL_INWATER)
		{	
			// JOSEPH 13-MAY-99
			gi.sound (ent, CHAN_BODY, gi.soundindex("actors/player/male/watr_out.wav"), 1, ATTN_NORM, 0);
			// END JOSEPH
			ent->flags &= ~FL_INWATER;
		}
		return;
	}

	if ((ent->watertype & CONTENTS_LAVA) && !(ent->flags & FL_IMMUNE_LAVA))
	{
		if (ent->damage_debounce_time < level.time)
		{
			ent->damage_debounce_time = level.time + 0.2;
			T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 10*ent->waterlevel, 0, 0, MOD_LAVA);
		}
	}
	if ((ent->watertype & CONTENTS_SLIME) && !(ent->flags & FL_IMMUNE_SLIME))
	{
		if (ent->damage_debounce_time < level.time)
		{
			ent->damage_debounce_time = level.time + 1;
			T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 4*ent->waterlevel, 0, 0, MOD_SLIME);
		}
	}
	
	if ( !(ent->flags & FL_INWATER) )
	{	
		if (!(ent->svflags & SVF_DEADMONSTER))
		{
			// JOSEPH 29-MAR-99
			if (ent->watertype & CONTENTS_LAVA)
			{
				//if (random() <= 0.5)
				//	gi.sound (ent, CHAN_BODY, gi.soundindex("actors/player/lava1.wav"), 1, ATTN_NORM, 0);
				//else
				//	gi.sound (ent, CHAN_BODY, gi.soundindex("actors/player/lava2.wav"), 1, ATTN_NORM, 0);
			}
			// END JOSEPH
			// JOSEPH 13-MAY-99
			else if (ent->watertype & CONTENTS_SLIME)
				gi.sound (ent, CHAN_BODY, gi.soundindex("actors/player/male/watr_in.wav"), 1, ATTN_NORM, 0);
			else if (ent->watertype & CONTENTS_WATER)
				gi.sound (ent, CHAN_BODY, gi.soundindex("actors/player/male/watr_in.wav"), 1, ATTN_NORM, 0);
			// END JOSEPH
		}

		ent->flags |= FL_INWATER;
		ent->damage_debounce_time = 0;
	}
}


void M_droptofloor (edict_t *ent)
{
	vec3_t		end;
	trace_t		trace;

	ent->s.origin[2] += 1;
	VectorCopy (ent->s.origin, end);
	end[2] -= 256;
	
	trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, end, ent, MASK_MONSTERSOLID);

	if (trace.fraction == 1 || trace.allsolid)
		return;

	VectorCopy (trace.endpos, ent->s.origin);

	if (ent->solid != SOLID_TRIGGER)
	{
		gi.linkentity (ent);
		M_CheckGround (ent);
		M_CatagorizePosition (ent);
	}
}


void M_SetEffects (edict_t *ent)
{
	ent->s.effects &= ~(EF_COLOR_SHELL|EF_POWERSCREEN);
	ent->s.renderfx &= ~(RF_SHELL_RED|RF_SHELL_GREEN|RF_SHELL_BLUE);

	if (ent->health <= 0)
		return;

}


void M_MoveFrame (edict_t *self)
{
	mmove_t	*move;
	int		index;

	// Ridah, allow for reverse animations
	qboolean	reverse_anim;
	int			lowest_frame, highest_frame;

	move = self->cast_info.currentmove;

	if (move->lastframe < move->firstframe)
	{
		reverse_anim = true;
		lowest_frame = move->lastframe;
		highest_frame = move->firstframe;
	}
	else
	{
		reverse_anim = false;
		lowest_frame = move->firstframe;
		highest_frame = move->lastframe;
	}

	self->nextthink = level.time + FRAMETIME;

	if ((self->cast_info.nextframe) && (self->cast_info.nextframe >= lowest_frame) && (self->cast_info.nextframe <= highest_frame))
	{
		self->s.frame = self->cast_info.nextframe;
		self->cast_info.nextframe = 0;
	}
	else
	{
		if (self->s.frame == move->lastframe)
		{
			if (move->endfunc)
			{
				move->endfunc (self);

				// regrab move, endfunc is very likely to change it
				move = self->cast_info.currentmove;

				if (move->lastframe < move->firstframe)
				{
					reverse_anim = true;
					lowest_frame = move->lastframe;
					highest_frame = move->firstframe;
				}
				else
				{
					reverse_anim = false;
					lowest_frame = move->firstframe;
					highest_frame = move->lastframe;
				}

				// check for death
				if (self->svflags & SVF_DEADMONSTER)
					return;
			}
		}

		if ((self->s.frame < lowest_frame) || (self->s.frame > highest_frame))
		{
			self->s.frame = move->firstframe;
		}
		else
		{
			if (reverse_anim)
			{
				self->s.frame--;

				if (self->s.frame < move->lastframe)
					self->s.frame = move->firstframe;
			}
			else
			{
				self->s.frame++;

				if (self->s.frame > move->lastframe)
					self->s.frame = move->firstframe;
			}
		}
	}

	if (!reverse_anim)
		index = self->s.frame - move->firstframe;
	else
		index = move->firstframe - self->s.frame;

	if (move->frame[index].aifunc)
	{
		move->frame[index].aifunc (self, move->frame[index].dist * self->cast_info.scale);

		// debugging
		if (!self->cast_info.currentmove)
		{	// we really shouldn't do this, but it's better than crashing
			// nasty fix to get the bum not to print this message
			if (strcmp (self->classname, "cast_bum_sit"))
				gi.dprintf( "M_MoveFrame: NULL currentmove\n" );
			self->cast_info.currentmove = move;
		}
	}

	if (move->frame[index].thinkfunc)
		move->frame[index].thinkfunc (self);
}

// thug2 HACK
extern mmove_t thug2_move_ambstand1;
extern void thug2_stand_up( edict_t *self );
extern void thug2_end_stand( edict_t *self );
extern void thug2_avoid ( edict_t *self, edict_t *other, qboolean face );

void cast_think (edict_t *self)
{
#include "ai_thug2.h"


	// Ridah, turn it off before each frame, so it's only on when being fired
	self->s.renderfx2 &= ~RF2_FLAMETHROWER;
	

	// Ridah, if in cutscene, only let those in the scene actually think
	if (level.cut_scene_time)
	{
//		if (!gi.inPVS(self->s.origin, level.cut_scene_origin))
		if (self->cast_group == 1)
		{
			self->nextthink = level.time + 0.3;
			return;
		}
	}

	if (self->enemy && (self->enemy->health <= 0))
	{
		self->enemy = NULL;

		// go back to the start pos if we're not doing anything
		if (	!(self->cast_info.aiflags & AI_TAKE_COVER)
			&&	!(self->goal_ent)
			&&	(self->cast_info.currentmove->frame->aifunc == ai_stand)
			&&	(self->start_ent)
			&&	(VectorDistance( self->s.origin, self->start_ent->s.origin) > 256))
		{
			self->goal_ent = self->start_ent;
		}
	}


	// HACK, make sure this gets cleared
	if ((self->cast_info.aiflags & AI_TAKECOVER_IGNOREHEALTH) && !(self->cast_info.aiflags & AI_TAKE_COVER))
		self->cast_info.aiflags &= ~AI_TAKECOVER_IGNOREHEALTH;

	// Another HACK, so thug_sit's do the proper sit -> stand animation when they need to
	if (	self->health > 0
		&&	self->cast_info.avoid == thug2_avoid
		&&	self->cast_info.move_stand != &thug2_move_ambstand1
		&&	(	(self->cast_info.currentmove->firstframe < FRAME_ambsit1_01)
			 ||	(self->cast_info.currentmove->firstframe > FRAME_cards7_18)))
	{	// they're doing something other than sitting, so clear the flag and prevent them from sitting again
		thug2_stand_up( self );
	}

	// so we know how far we've fallen from
	if (!self->groundentity)
	{
		if (self->last_offground < (level.time - 0.1))
			self->fall_height = self->s.origin[2];
		else if (self->fall_height < self->s.origin[2])
			self->fall_height = self->s.origin[2];

		self->last_offground = level.time;
	}
	else
	{
		self->last_onground = level.time;
	}

	if (self->cast_info.currentmove)
		M_MoveFrame (self);
	else
	{
		if (!strcmp (self->classname, "cast_bum_sit"))
		{
			self->health = 0;
			self->die (self, world, world, 10, self->s.origin, PART_BODY, 0);
			return;
		}
		else 
		// todo find out how the bum is getting here and causing the crash
		gi.dprintf ("classname:%s\n", self->classname);
	}

	if (self->linkcount != self->cast_info.linkcount)
	{
		self->cast_info.linkcount = self->linkcount;
		M_CheckGround (self);

		if (self->groundentity)
			VectorClear( self->velocity );
	}

	// make sure viewheight is correct
	self->viewheight = self->maxs[2] - 4;

	M_CatagorizePosition (self);

	M_WorldEffects (self);
	M_SetEffects (self);

	if (self->enemy && (self->enemy->health <= 0))
		self->enemy = NULL;

	// JOSEPH 30-NOV-98
	if (self->misstime && self->missent)
	{
		if (self->onarampage)
		{
			self->goal_ent = self->enemy;	
		}
		else if (visible(self, self->missent) && (self->timemissing <= self->misstime))
		{
			self->timemissing = 0;
		}
		else
		{
			self->timemissing += 1.0;

			if (self->timemissing > self->misstime)
			{
				if (visible(self, self->missent))
				{
					self->onarampage = 1;
				}
				else
				{
					self->goal_ent = self->missent;
				}
			}
		}
	}


	if (self->deadticks == 1) {
       self->take_cover_time = self->s.origin[2];
	}

	// inferno sink bodies
	if (self->deadticks >= despawn_time->value) {

		self->solid = SOLID_NOT;
		self->s.origin[2] -= 0.4;

		if (self->s.origin[2] + 7 < self->take_cover_time)
		{
			// done with this body
			self->svflags |= SVF_NOCLIENT;
			G_FreeEdict(self);

		}

	     //  self->nextthink = level.time + 5;
		//gi.dprintf("%i",self->deadticks);
	}

	// END JOSEPH
/*
	// Ridah, HACK: character's that don't die after flamedeath, force them to die now
	if (	(self->health <= 0)
		&&	(self->cast_info.currentmove->endfunc != AI_EndDeath))
	{
		extern void Killed (edict_t *targ, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point, int mdx_part, int mdx_subobject);

		self->deadflag = 0;
		// self->die( self, world, world, 10, self->s.origin, PART_BODY, 0);
		Killed (self, self, self, 10, self->s.origin, PART_BODY, 0);
	}
*/
}


/*
================
cast_use

Using a cast member makes it:

  if it has a combattarget, will run to it,
  ELSE get angry at the current activator
================
*/
void cast_use (edict_t *self, edict_t *other, edict_t *activator)
{
	cast_memory_t	*mem;

	if (self->next_combattarget)
	{
		self->combattarget = self->next_combattarget;
		self->next_combattarget = NULL;
	}

	if (self->combattarget)
		AI_Goto_CombatTarget( self );

	if (self->health <= 0)
		return;

	if (self->enemy)
		return;
	if (self->health <= 0)
		return;

	// check for special Episode script handling
	if (EP_CastUse( self, other, activator ))
		return;

	mem = level.global_cast_memory[self->character_index][activator->character_index];

	if (!mem || (mem->memory_type == MEMORY_TYPE_FRIEND))
		return;

	AI_MakeEnemy ( self, activator, 0 );

}


void cast_start_go (edict_t *self);


void cast_triggered_spawn (edict_t *self)
{
	self->s.origin[2] += 1;
	KillBox (self);

	self->solid = SOLID_BBOX;
	self->movetype = MOVETYPE_STEP;
	self->svflags &= ~SVF_NOCLIENT;
	self->air_finished = level.time + 12;
	gi.linkentity (self);

	cast_start_go (self);

	// Ridah, changed this, must set (spawnflags & 1) to make the AI hostile at the activator

/*
	if (self->enemy && !(self->spawnflags & 1) && !(self->enemy->flags & FL_NOTARGET))
	{
		AI_StartAttack (self, self->enemy);
	}
	else
	{
		self->enemy = NULL;
	}
*/
}

void cast_triggered_spawn_use (edict_t *self, edict_t *other, edict_t *activator)
{
	// we have a one frame delay here so we don't telefrag the guy who activated us
	self->think = cast_triggered_spawn;
	self->nextthink = level.time + FRAMETIME;

// Ridah, try to add them to the character list
	if (!AddCharacterToGame(self))
	{
		G_FreeEdict (self);
		return;
	}
// Ridah, done.

	if (activator->client && (self->spawnflags & 1))
		AI_MakeEnemy (self, activator, 0);

	self->use = cast_use;
}

void cast_triggered_start (edict_t *self)
{
	self->solid = SOLID_NOT;
	self->movetype = MOVETYPE_NONE;
	self->svflags |= SVF_NOCLIENT;
	self->nextthink = 0;
	self->use = cast_triggered_spawn_use;
}


/*
================
cast_death_use

When a cast member dies, they fire all of their targets with the current
enemy as activator.
================
*/
void cast_death_use (edict_t *self)
{
	self->flags &= ~(FL_FLY|FL_SWIM);

	if (self->item)
	{
		Drop_Item (self, self->item);
		self->item = NULL;
	}

	if (self->deathtarget)
	{
		self->target = self->deathtarget;
	}
	else
	{
		// So we can process a death even if they don't have a ->deathtarget
		EP_CastUse( self, self, self->enemy );

		return;		// Ridah, added this since we don't clear the ->target at startup anymore, and we don't went to fire a path_corner when we die
	}

//	if (!self->target)
//		return;

	G_UseTargets (self, self->enemy);
}


//============================================================================
// BEGLEITER
qboolean cast_start (edict_t *self)
{
	//if (deathmatch->value) EINZEL
	//{
	//	G_FreeEdict (self);
	//	return false;
	//}
 // qboolean monster_start (edict_t *self)
// Ridah, try to add them to the character list
	if (!(self->spawnflags & 2) && !AddCharacterToGame(self))
	{
		G_FreeEdict (self);
		return false;
	} 
// Ridah, done.

	AI_InitMemory( self );
	EP_SetNameIndex( self );

	EP_SpawnFlags (self);

	self->s.renderfx2 |= RF2_DIR_LIGHTS;
//self->s.renderfx2 |= RF2_FLAMETHROWER;

//self->flags |= FL_GODMODE;

	level.total_monsters++;

	self->cast_info.standing_max_z = self->maxs[2];

	if (!self->moral)
		self->moral = ((int)self->s.origin[0]) % MORAL_MAX;

	self->nextthink = level.time + FRAMETIME;
	self->svflags |= SVF_MONSTER;
	self->s.renderfx |= RF_FRAMELERP;
	self->takedamage = DAMAGE_AIM;
	self->air_finished = level.time + 12;
	self->use = cast_use;

	// Ridah, hired guys default to 200 health, so they don't die so quick
	if (self->cast_group == 1 && self->health == 100)
		self->health = 200;

	self->max_health = self->health;

	self->clipmask = MASK_MONSTERSOLID;

	self->s.skinnum = self->skin;
	self->deadflag = DEAD_NO;
	self->svflags &= ~SVF_DEADMONSTER;

	// talk by default
	self->cast_info.aiflags |= AI_TALK;

	if (!self->cast_info.checkattack)
		self->cast_info.checkattack = AI_CheckAttack;
	VectorCopy (self->s.origin, self->s.old_origin);

// Ridah, new AI system
	if (!self->cast_info.max_attack_distance)
		self->cast_info.max_attack_distance = DEFAULT_MAX_ATTACK_DISTANCE;

	if (!self->cast_info.max_sighting_distance)
		self->cast_info.max_sighting_distance = DEFAULT_MAX_SIGHTING_DISTANCE;
// Ridah, done.

	if (st.item)
	{
		self->item = FindItemByClassname (st.item);
		if (!self->item)
			gi.dprintf("%s at %s has bad item: %s\n", self->classname, vtos(self->s.origin), st.item);
	}

	// randomize what frame they start on
	if (self->cast_info.currentmove)
		self->s.frame = self->cast_info.currentmove->firstframe + (rand() % (self->cast_info.currentmove->lastframe - self->cast_info.currentmove->firstframe + 1));

//Xatrix/Ridah/Navigator: init nav data
	self->active_node_data = level.node_data;
	self->nav_data.cache_node = -1;
// END: Xatrix/Ridah/Navigator: init current node

	return true;
}

void cast_start_go (edict_t *self)
{
	vec3_t	v;

// Ridah, debugging ladders
//self->cast_group = 1;

	if (self->health <= 0)
		return;

/*
	// check for target to combat_point and change to combattarget
	if (self->target)
	{
		qboolean	notcombat;
		qboolean	fixup;
		edict_t		*target;

		target = NULL;
		notcombat = false;
		fixup = false;
		while ((target = G_Find (target, FOFS(targetname), self->target)) != NULL)
		{
			if (strcmp(target->classname, "point_combat") == 0)
			{
				self->combattarget = self->target;
				fixup = true;
			}
			else
			{
				notcombat = true;
			}
		}
		if (notcombat && self->combattarget)
			gi.dprintf("%s at %s has target with mixed types\n", self->classname, vtos(self->s.origin));
		if (fixup)
			self->target = NULL;
	}
*/
	// validate combattarget
	if (self->combattarget)
	{
		edict_t		*target;

		target = NULL;
		while ((target = G_Find (target, FOFS(targetname), self->combattarget)) != NULL)
		{
			if (strcmp(target->classname, "path_corner") != 0)
			{
				gi.dprintf("%s at (%i %i %i) has a bad combattarget %s : %s at (%i %i %i)\n",
					self->classname, (int)self->s.origin[0], (int)self->s.origin[1], (int)self->s.origin[2],
					self->combattarget, target->classname, (int)target->s.origin[0], (int)target->s.origin[1],
					(int)target->s.origin[2]);
			}
		}
	}

	// check for a guard_ent
	if (self->guard_target)
	{
		edict_t		*target;

		target = NULL;
		if ((target = G_Find (target, FOFS(targetname), self->guard_target)) != NULL)
		{
			self->guard_ent = target;
		}
		else
		{
			gi.dprintf("%s at (%i %i %i) has an un-matched guard_target (%s)\n",
				self->classname,
				(int)self->s.origin[0], (int)self->s.origin[1], (int)self->s.origin[2],
				self->guard_target );
		}
	}

	if (self->target)
	{
		self->goal_ent = G_PickTarget(self->target);
		if (!self->goal_ent)
		{
			gi.dprintf ("%s can't find target %s at %s\n", self->classname, self->target, vtos(self->s.origin));
			self->target = NULL;
		}
		else if (strcmp (self->goal_ent->classname, "path_corner") == 0)
		{
			VectorSubtract (self->goal_ent->s.origin, self->s.origin, v);
			self->ideal_yaw = self->s.angles[YAW] = vectoyaw(v);

// Ridah, 5-7-99, prevent guy at intro appearing upright after reloading SR1
			if (!(self->spawnflags & 2) && (!self->name || (strcmp(self->name, "IntroGuy") != 0)))
				self->cast_info.pausetime = level.time + 3;
			self->cast_info.currentmove = self->cast_info.move_stand;
		}
//		else
//		{
//			self->goal_ent = NULL;
//		}

		// so we actually start walking in ai_stand()
		self->goal_ent = NULL;
	}

	if (self->leader_target)
	{
		if (!(self->leader = G_Find( NULL, FOFS(name), self->leader_target )))
		{
			gi.dprintf( "%s has un-matched leader_target at: %s\n", self->classname, vtos( self->s.origin ));
		}
	}

//	if (!self->goal_ent)
	{	// make them return to this position in the future
		edict_t	*ent;

		ent = G_Spawn();
		VectorCopy( self->s.origin, ent->s.origin );
		VectorCopy( self->mins, ent->mins );
		VectorCopy( self->maxs, ent->maxs );
		ent->classname = "cast_origin";

		ent->owner = self;

		self->start_ent = ent;
	}

	// Health triggered events
	if (self->health_target)
	{
		if (!self->health_threshold)
			gi.dprintf( "Warning: %s has health_target without a health_threshold at %s\n", self->classname, vtos(self->s.origin) );
	}
	if (self->health_target2)
	{
		if (!self->health_threshold2)
			gi.dprintf( "Warning: %s has health_target2 without a health_threshold2 at %s\n", self->classname, vtos(self->s.origin) );
	}
	if (self->health_target3)
	{
		if (!self->health_threshold3)
			gi.dprintf( "Warning: %s has health_target3 without a health_threshold3 at %s\n", self->classname, vtos(self->s.origin) );
	}

	self->think = cast_think;
	self->nextthink = level.time + FRAMETIME;
}

void walking_cast_start_go (edict_t *self)
{
	if (!(self->spawnflags & 2) && level.time < 1)
	{
		M_droptofloor (self);

		if (self->groundentity)
			if (!M_walkmove (self, 0, 0))
				gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin));
	}
	
	if (!self->yaw_speed)
		self->yaw_speed = 40;
	self->viewheight = self->cast_info.standing_max_z - 4;

	cast_start_go (self);


	if (self->cast_group == 1 && !self->name)
	{
		gi.dprintf( "\n** WARNING: friendly %s without a NAME.\n  All friendly characters MUST have a name.\n\n", self->classname );
	}

	if (self->spawnflags & 2)
		cast_triggered_start (self);
}

void walking_cast_start (edict_t *self)
{

	if (!self->cast_info.scale)
		self->cast_info.scale = MODEL_SCALE;

	self->current_territory = self->cast_group;		// assume we start in our territory
	if (self->current_territory == 1)	// player's group doesn't have a territory as such
		self->current_territory = 0;

	self->s.scale = self->cast_info.scale - 1.0;
	
	self->think = walking_cast_start_go;
	cast_start (self);
}


void flying_cast_start_go (edict_t *self)
{
	if (!M_walkmove (self, 0, 0))
		gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin));

	if (!self->yaw_speed)
		self->yaw_speed = 10;
	self->viewheight = self->cast_info.standing_max_z - 4;

	cast_start_go (self);

	if (self->spawnflags & 2)
		cast_triggered_start (self);
}


void flying_cast_start (edict_t *self)
{
	self->flags |= FL_FLY;
	self->think = flying_cast_start_go;
	cast_start (self);
}


void swimming_cast_start_go (edict_t *self)
{
	if (!self->yaw_speed)
		self->yaw_speed = 10;
	self->viewheight = 10;

	cast_start_go (self);

	if (self->spawnflags & 2)
		cast_triggered_start (self);
}

void swimming_cast_start (edict_t *self)
{
	self->flags |= FL_SWIM;
	self->think = swimming_cast_start_go;
	cast_start (self);
}

qboolean DeathByGib( edict_t *self, edict_t *inflictor, edict_t *attacker, float damage )
{
	// Ridah, never show gibs if parental lock is on
	//if (cl_parental_lock->value)
	//	return false;

	if (inflictor->client) {

	
		if (inflictor->client->rampage_active == 1) {
			return true;
		}

		else if (inflictor->client->godlike_active == 1) {
			return true;
		}	
		else {
			return false;
		} 
	}

	if (inflictor == attacker)
	{
		return (damage > 80);	// so pistol doesn't gib
	}
	else	// rocket or grenade
	{
		return (damage >= 50);
	}
}
