hexen2-siege-hc/rider.hc

/*QUAKED rider_path (0.5 0.3 0) (-8 -8 -8) (8 8 8)
Specifies a path point for a rider.  You can specify
up to 4 other places that the rider can go after this
point.
-------------------------FIELDS-------------------------
path_id: number (id) of this path point
next_path_1: number (id) of a possible next point
next_path_2: number (id) of a possible next point
next_path_3: number (id) of a possible next point
next_path_4: number (id) of a possible next point
--------------------------------------------------------

*/
void rider_path(void)
{
}

void riderpath_init(void)
{
entity search,found;

	found = world;
	search = find(world, classname, "rider_path");
	while(search != world && found == world)
	{
		if (search.path_id == 1) 
			found = search;
		else
			search = find(search, classname, "rider_path");
	}

	if (found==world)
	{
		dprint("No starting point for rider\n");
		remove(self);
		return;
	}
	self.path_current=self.path_last = found;
}

void riderpath_findnext(void)
{
	entity search,found;
	float next,num_points,position;

	num_points = 0;
	if (self.path_current.next_path_1) 
		num_points += 1;
	if (self.path_current.next_path_2) 
		num_points += 1;
	if (self.path_current.next_path_3) 
		num_points += 1;
	if (self.path_current.next_path_4) 
		num_points += 1;

	if (!num_points)
	{
		dprintf("rider path %s has no next points\n",self.path_id);
		remove(self);
		return;
	}

	position = random(num_points);
//	dprintf("Num_points is %s   ",num_points);
//	dprintf("position is %s\n",position);

	num_points = next = 0;
	if (self.path_current.next_path_1) 
	{
		num_points += 1;
		if (position <= num_points && !next) 
			next = self.path_current.next_path_1;
	}
	if (self.path_current.next_path_2) 
	{
		num_points += 1;
		if (position <= num_points && !next) 
			next = self.path_current.next_path_2;
	}

	if (self.path_current.next_path_3) 
	{
		num_points += 1;
		if (position <= num_points && !next) 
			next = self.path_current.next_path_3;
	}

	if (self.path_current.next_path_4) 
	{
		num_points += 1;
		if (position <= num_points && !next) 
			next = self.path_current.next_path_4;
	}

	if (!next)
	{
		dprint("Internal error for rider path\n");
		dprintf("   Next is %s\n",next);
		dprintf("   Num_points is %s\n",num_points);
		dprintf("   position is %s\n",position);
		return;
	}

	found = world;
	search = find(world, classname, "rider_path");
	while(search != world && found == world)
	{
		if (search.path_id == next) 
			found = search;
		else
			search = find(search, classname, "rider_path");
	}

	if (!found)
	{
		dprintf("Could not find rider path %s\n",next);
		remove(self);
		return;
	}
	else
		self.path_current = found;

}

void rider_die(void);

void riderpath_move(float move_speed)
{
float distance, altitude, temp;
vector displace;
entity save_ent;

	if(self.velocity!='0 0 0')
		self.velocity='0 0 0';

	self.ideal_yaw = vectoyaw(self.path_current.origin - self.origin);
	self.rider_last_y_change = self.rider_y_change;
	self.rider_y_change = ChangeYaw();

//rj rider_die();

	if (self.movetype == MOVETYPE_FLY)
	{
		distance = vhlen(self.origin - self.path_current.origin);
		altitude = self.path_current.origin_z - self.origin_z;

		if (distance < 400)
		{
//			altitude *= 0.06;
			temp = (distance - self.rider_path_distance) / (400-self.rider_path_distance);
			temp = 1-temp;
			temp = temp / 6;

			if (altitude > 30)
			{
				self.angles_x = temp * 200;
				self.rider_move_adjustment -= 0.1;
			}
			else if (altitude < -30)
			{
				self.angles_x = 0 - (temp * 200);
				self.rider_move_adjustment += 0.15;
			}

			if (altitude > 60)
			{
				self.rider_move_adjustment -= 0.1;
			}
			else if (altitude < -60)
			{
				self.rider_move_adjustment += 0.15;
			}

			altitude *= temp;
		}
		else 
		{
			altitude = 0;
			self.angles_x -= self.angles_x / 10;
			self.rider_move_adjustment -= self.rider_move_adjustment / 15;
		}
//		dprintf("Move adjustment %s\n",self.rider_move_adjustment);

		self.origin_z += altitude;

//		altitude = self.path_current.origin_z - self.origin_z;
//		dprintf("Flying: distance %s",distance);
//		dprintf("  Alt is %s\n",altitude);
	}

	move_speed += self.rider_move_adjustment;

	if(!walkmove(self.angles_y, move_speed, TRUE))
	{
		save_ent=self.goalentity;
		self.goalentity=self.path_current;
		movetogoal(move_speed);
		self.goalentity=save_ent;
	}
	
	if (self.classname != "rider_famine")  // Famine doesn't do radius pain
	{
		if (trace_ent)//!=world&&trace_ent.classname!="ghost")
		{
			displace = normalize(trace_ent.origin - self.origin);
			if (infront(trace_ent))
			{
				trace_ent.velocity += displace*random(1000,1600);
				T_Damage (trace_ent, self, self, random(25,35));
				if(trace_ent.flags&FL_CLIENT)
				{
					trace_ent.punchangle_x = random(-9,-1);
					trace_ent.punchangle_y = random(-10,10);
					trace_ent.punchangle_z = random(-10,10);
				}
			}
			else
			{
				trace_ent.velocity += displace*random(700,900);
				T_Damage (trace_ent, self, self, random(15,20));
				if(trace_ent.flags&FL_CLIENT)
				{
					trace_ent.punchangle_x = random(-3,2);
					trace_ent.punchangle_y = random(-5,5);
					trace_ent.punchangle_z = random(-5,5);
				}
			}
		}
	}

	distance = vhlen(self.origin - self.path_current.origin);
	if (distance < self.rider_path_distance)
		riderpath_findnext();
}



void rider_multi_wait(void)
{
	if (self.max_health)
	{
		self.health = self.max_health;
		self.takedamage = DAMAGE_NO_GRENADE;
		self.solid = SOLID_BBOX;
	}
}

void rider_multi_trigger(void)
{
	if (self.nextthink > time)
	{
		return;		// allready been triggered
	}
	if (self.enemy.classname != "rider_war")
	{
		return;
	}

	if (random() <= self.rt_chance)
	{
		if (self.noise) sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);

	// don't trigger again until reset
		self.takedamage = DAMAGE_NO;

		activator = self.enemy;

		SUB_UseTargets();
	}

	if (self.wait > 0)	
	{
		self.think = rider_multi_wait;
		thinktime self : self.wait;
	}
	else
	{	// we can't just remove (self) here, because this is a touch function
		// called while C code is looping through area links...
		self.touch = SUB_Null;
		thinktime self : 0.1;
		self.think = SUB_Remove;
	}
}


void rider_multi_use(void)
{
	if (time < self.attack_finished)
		return;

	self.enemy = activator;
	rider_multi_trigger();
}

void rider_multi_touch(void)
{
	if (time < self.attack_finished)
		return;

// if the trigger has an angles field, check player's facing direction

	if (self.movedir != '0 0 0')
	{
		makevectors (other.angles);
		if (v_forward * self.movedir < 0)
			return;		// not facing the right way
	}

	self.enemy = other;

	rider_multi_trigger ();
}

/*QUAKED rider_trigger_multiple (0.5 0.15 0) ?
-------------------------FIELDS-------------------------
rt_chance: chance (0-1) that the trigger will be run
--------------------------------------------------------

*/
void rider_trigger_multiple(void)
{
	if (!self.wait)
		self.wait = 0.2;
	self.use = rider_multi_use;

	InitTrigger ();

	if (self.health)
	{
		self.max_health = self.health;
		self.th_die = multi_killed;
		self.takedamage = DAMAGE_NO_GRENADE;
		self.solid = SOLID_BBOX;
		setorigin (self, self.origin);	// make sure it links into the world
	}
	else
	{
		self.touch = rider_multi_touch;
	}
}

/*QUAKED rider_trigger_once (0.5 0.15 0) ?
-------------------------FIELDS-------------------------
rt_chance: chance (0-1) that the trigger will be run
--------------------------------------------------------

*/
void rider_trigger_once(void)
{
	self.wait = -1;
	rider_trigger_multiple();
}


void beam_move(void)
{
	thinktime self : HX_FRAME_TIME;

	if (self.scale < self.beam_max_scale)
		self.scale += 0.6;
	else
		self.scale = self.beam_max_scale;

	if (self.beam_direction)
	{
		self.beam_angle_a += self.beam_speed;
		if (self.beam_angle_a >= 360) self.beam_angle_a -= 360;
	}
	else
	{
		self.beam_angle_a -= self.beam_speed;
		if (self.beam_angle_a < 0) self.beam_angle_a += 360;
	}

	self.angles_x = cos(self.beam_angle_a) * self.beam_angle_b;
	self.angles_z = sin(self.beam_angle_a) * self.beam_angle_b;
}

void star_think(void)
{
	thinktime self : HX_FRAME_TIME;

	self.velocity = self.velocity * 1.05;

	if (self.scale < 2)
		self.scale *= 1.08;
}

void rider_star(void)
{
	entity star;
	float angle;

	if (random() < 0.5) 
		return;

	star = spawn();

	setmodel(star,"models/boss/star.mdl");
	setorigin(star,self.origin);

	setsize (star, '0 0 0', '0 0 0');		
	star.owner = self.owner;
	star.movetype = MOVETYPE_FLYMISSILE;
	star.solid = SOLID_BBOX;
	star.avelocity = randomv('40 40 40', '100 100 100');
	star.scale = 0.1;

	angle = random(360);
	star.velocity_x = cos(angle)*300;
	star.velocity_y = sin(angle)*300;

	star.classname = "rider_temp";
	star.think = star_think;
	star.touch = SUB_Remove;

	thinktime star : HX_FRAME_TIME;
}

void circle_think(void)
{
	thinktime self : HX_FRAME_TIME;

	rider_star();

	if (self.monster_stage == 0)
	{
		self.scale *= 1.0275;
		if (self.scale >= 2.5) 
		{
			self.monster_stage = 1;
			self.scale = 2.5;
		}
	}
	else if (self.monster_stage == 1)
	{
		self.scale -= random(.1);
		if (self.scale < 1.5 || random() < 0.1) 
			self.monster_stage = 2;
	}
	else if (self.monster_stage == 2)
	{
		self.scale += random(.1);
		if (self.scale >= 2.5)
		{
			self.monster_stage = 1;
			self.scale = 2.5;
		}
		else if (random() < 0.1) 
			self.monster_stage = 1;
	}
}

void rider_eol(void)
{
	entity search;

	if (self.count == 0)
	{
		self.count = 1;
		self.effects (-) EF_BRIGHTLIGHT;
		self.effects (+) EF_NODRAW;
		if(self.movechain!=world)
			self.movechain.effects (+) EF_NODRAW;
		
		thinktime self : 5;

		search = find(world, classname, "rider_temp");
		while (search != world)
		{
			remove(search);
			search = find(search, classname, "rider_temp");
		}

		return;
	}

//	return;

	nextmap = self.map;
	nextstartspot = self.target;
//rj nextmap = "rick1";

	intermission_running = 1;

	if (deathmatch)
		intermission_exittime = time + 5;
	else if (self.classname == "monster_eidolon")
		intermission_exittime = time + 99999;
	else
		intermission_exittime = time + 2;


	//Remove cross-level trigger server flags for next hub
	serverflags(-)(SFL_CROSS_TRIGGER_1|
				SFL_CROSS_TRIGGER_2|
				SFL_CROSS_TRIGGER_3|
				SFL_CROSS_TRIGGER_4|
				SFL_CROSS_TRIGGER_5|
				SFL_CROSS_TRIGGER_6|
				SFL_CROSS_TRIGGER_7|
				SFL_CROSS_TRIGGER_8);

	search=find(world,classname,"player");
	while(search)
	{//Take away all their goodies
		search.puzzle_inv1 = string_null;
		search.puzzle_inv2 = string_null;
		search.puzzle_inv3 = string_null;
		search.puzzle_inv4 = string_null;
		search.puzzle_inv5 = string_null;
		search.puzzle_inv6 = string_null;
		search.puzzle_inv7 = string_null;
		search.puzzle_inv8 = string_null;
		search=find(search,classname,"player");
	}

	WriteByte (MSG_ALL, SVC_INTERMISSION);
	if (!cvar("registered") && cvar("oem"))
	{
		WriteByte (MSG_ALL, 9);
		intermission_exittime = time + 99999;
	}
	else if (self.classname == "rider_famine")
		WriteByte (MSG_ALL, 1);
	else if (self.classname == "rider_death")
		WriteByte (MSG_ALL, 2);
	else if (self.classname == "rider_pestilence")
		WriteByte (MSG_ALL, 3);
	else if (self.classname == "rider_war")
		WriteByte (MSG_ALL, 4);
	else if (self.classname == "monster_eidolon")
		WriteByte (MSG_ALL, 6);
	else
		dprint("Invalid boss creature\n");

	FreezeAllEntities();
}

void rider_die(void)
{
entity beam;
entity save;
entity found;
vector new_origin;

	if (self.think != rider_die)
	{
		SUB_UseTargets();

		self.think = rider_die;
		self.count = 0;
		thinktime self : HX_FRAME_TIME;
		self.rider_death_speed = 0.2;
//		self.effects = EF_NODRAW;

		return;
	}

	if (self.count == 0)
	{
		sound (self, CHAN_AUTO, "famine/flashdie.wav", 1, ATTN_NONE);  // Start of the death flash
		found=find(world,classname,"player");
		while(found)
		{//Give them all the exp
//			AwardExperience(found,self,self.experience_value);
			found=find(found,classname,"player");
		}
		self.experience_value=FALSE;
		self.drawflags = self.drawflags | MLS_ABSLIGHT;
		self.abslight = 3;
		if(self.noise)
			sound(self,CHAN_VOICE,self.noise,1,ATTN_NONE);
		self.movetype=MOVETYPE_NONE;
		self.velocity='0 0 0';
	}

	thinktime self : self.rider_death_speed;
	self.rider_death_speed += 0.1;

	if (self.count >= 10) 
	{
		if (self.count == 3)
		{
			beam = spawn();

			new_origin = self.origin + '0 0 50';

			setmodel(beam,"models/boss/circle.mdl");
			setorigin(beam,new_origin);

			setsize (beam, '0 0 0', '0 0 0');		
			beam.owner = self;
			beam.movetype = MOVETYPE_FLYMISSILE;
			beam.solid = SOLID_NOT;
			beam.drawflags = SCALE_TYPE_UNIFORM;
			beam.scale = .1;
			beam.skin = 0;
			beam.avelocity = '0 0 300';
			beam.think = circle_think;
			thinktime beam : HX_FRAME_TIME;
			self.count = 13;
		}

		self.count = 0;
		self.think = rider_eol;
		thinktime self : .5;

		return;
	}
	else
	{
		self.effects = EF_BRIGHTLIGHT;
//		self.effects = EF_NODRAW;

		if (self.count == 3)
		{
			beam = spawn();

			new_origin = self.origin + '0 0 50';

			setmodel(beam,"models/boss/circle.mdl");
			setorigin(beam,new_origin);

			setsize (beam, '0 0 0', '0 0 0');		
			beam.owner = self;
			beam.movetype = MOVETYPE_FLYMISSILE;
			beam.solid = SOLID_NOT;
			beam.drawflags = SCALE_TYPE_UNIFORM;
			beam.scale = .1;
			beam.skin = 0;
			beam.avelocity = '0 0 300';
			beam.classname = "rider_temp";
			beam.think = circle_think;
			thinktime beam : HX_FRAME_TIME;
		}
		else if (self.count == 0)
		{
			starteffect(18, self.origin + '0 0 40');
		}

	}

	self.count += 1;

	beam = spawn();

	makevectors(self.angles);
//	new_origin = v_factorrange('-3 -25 45', '3 25 50') + self.origin;
	new_origin = self.origin + '0 0 50';

	setmodel(beam,"models/boss/shaft.mdl");
	setorigin(beam,new_origin);

	setsize (beam, '0 0 0', '0 0 0');		
	beam.owner = self;
	beam.drawflags = SCALE_ORIGIN_BOTTOM | SCALE_TYPE_XYONLY;
	beam.movetype = MOVETYPE_FLYMISSILE;
	beam.solid = SOLID_NOT;
	beam.think = beam_move;
	beam.angles = '0 0 0';
	beam.angles_x = random(-50,50);
	beam.angles_z = random(-50,50);
	beam.beam_angle_a = random(360);
	beam.beam_angle_b = random(20,130);
	beam.scale = .1;
	beam.beam_max_scale = random(.5,1.5);
	beam.classname = "rider_temp";
	if (random() > 0.5) 
		beam.beam_direction = 1;

	beam.beam_speed = random(2,4.5);

	save = self;
	self = beam;
	beam_move();
	self = save;
}

void rider_use(void)
{
	thinktime self : 0.2; // wait for path points to spawn
}

void rider_init(void)
{
    precache_model3 ("models/boss/shaft.mdl");
    precache_model3 ("models/boss/circle.mdl");
    precache_model3 ("models/boss/star.mdl");
	precache_sound3 ("famine/flashdie.wav");

	total_monsters += 1;

	self.takedamage = DAMAGE_YES;
	self.flags(+)FL_MONSTER;
	self.flags2(+)FL_ALIVE;
	self.thingtype=THINGTYPE_FLESH;

	if(self.classname!="monster_eidolon")
		self.monsterclass=CLASS_BOSS;

	self.th_die = rider_die;
	self.use = rider_use;

	if (!(self.spawnflags & 1))
		thinktime self : 0.2; // wait for path points to spawn
}