Train

#include maps\mp\_utility;
#include common_scripts\utility;

SOUND_DELAY_MIN = 0.1;
SOUND_DELAY_MAX = 1;

init()
{
	train = getEnt( "the_l_train", "targetname" );
	assertex( isdefined( train ), "Calling to setup train in map without having the train in map! [targetname: the_l_train]" );
	train thread train_setup();
}

train_setup()
{
	precacheItem( "train_mp" );	
	
	delay_until_first_train = 2;
	Units_per_second = 1200;// train speed
	train_cars = 24;
	distance_between_cars = 368;
	eq_radius = 900;// 	radius of earthquakes broadcast from the train tracks

	min_time_between_trains = 100;
	max_time_between_trains = 200;

	lead_in_dist = 8000;
	lead_out_dist = 4000;

	train_car_sound_interval = 3;
	
	flag_init( "train_running" );

	yaw = self.angles[ 1 ];
	while ( yaw >= 90 )
	{
		yaw -= 90;
	}
	assertEx( yaw == 0, "Trains must have a yaw of 0, 90, 180, or 270 currently( for collision purposes )" );

	wheels = getentarray( "wheel", "targetname" );
	wheel_model = wheels[ 0 ].model;
	wheel_offset = [];
	foreach ( wheel in wheels )
	{
		wheel linkto( self );
		wheel.offset = self.origin - wheel.origin;
	}

	// ****************
	// Set up the other cars
	// ****************	
	forward = anglestoforward( self.angles );
	forward *= distance_between_cars;
	car_separation_vec = forward;
	cars = [];
	for ( i = 0; i < train_cars - 1; i++ )// - 1 car self is the lead car
	{
		car = spawn( "script_model", self.origin - car_separation_vec );
		car.angles = self.angles;
		car setmodel( self.model );
		car linkto( self );
		car_separation_vec += forward;
		cars[ cars.size ] = car;
		car.wheels = [];

		foreach ( owner_wheel in wheels )
		{
			wheel = spawn( "script_model", car.origin + owner_wheel.offset );
			wheel setmodel( wheel_model );
			wheel.angles = owner_wheel.angles;
			wheel linkto( car );
			car.wheels[ car.wheels.size ] = wheel;
		}
	}

	// ****************
	// The start and end points for the train, set from script origins
	// ****************	
	start = getent( self.target, "targetname" );
	start.origin = ( start.origin[ 0 ], start.origin[ 1 ], self.origin[ 2 ] );
	
	end = getent( start.target, "targetname" );
	end.origin = ( end.origin[ 0 ], end.origin[ 1 ], self.origin[ 2 ] );
	forward = anglestoforward( self.angles );
	start.origin = start.origin - forward * lead_in_dist;
	end.origin = end.origin + forward * lead_out_dist;

	track_dist = distance( start.origin, end.origin );
	travel_dist = track_dist + train_cars * distance_between_cars;
	travel_time = travel_dist / Units_per_second;
	track_time = track_dist / Units_per_second;
	full_train_time = train_cars * distance_between_cars / Units_per_second;



	// ****************
	// set up the earthquakes that play to make the train tracks rattle
	// ****************	
	distance_between_eq_orgs = eq_radius * 0.5;
	eq_count = track_dist / distance_between_eq_orgs;

	// the amount of time it takes for all the EQs to start before the train moves in
	delay_between_eqs = track_time / eq_count;
	travel_time_segment = track_time / eq_count;
	min_time_between_trains -= track_time;
	if ( min_time_between_trains < 0.1 )
		min_time_between_trains = 0.1;
	max_time_between_trains -= track_time;
	if ( max_time_between_trains < min_time_between_trains )
		max_time_between_trains = min_time_between_trains + 0.1;

	eq_points = [];
	for ( i = 0; i < eq_count; i++ )
	{
		progress = i / eq_count;
		eq_points[ i ] = start.origin * ( 1 - progress ) + end.origin * progress;
	}

	self.cars = cars;
	self.wheels = wheels;

	self.origin = start.origin;
	wait( delay_until_first_train );
	
	for ( ;; )
	{
		hide_trains();
		wait( 0.05 );
		self.origin = start.origin;


		// First there is a lead in of small EQs to shake the platform
		timer = gettime();
		for ( i = 0; i < eq_count; i++ )
		{
			thread train_eq( eq_points[ i ], eq_radius, track_time, full_train_time );
			wait( delay_between_eqs );
		}

		show_trains();
		thread train_kills_players( train_cars, distance_between_cars );
		thread train_spawns_dust();

		// Now the train goes by
		self moveto( end.origin + car_separation_vec, travel_time );
		train_play_sounds( train_car_sound_interval );
		
		wait( travel_time );
		hide_trains();

		train_stop_sounds( train_car_sound_interval );

		flag_set( "train_running" );
		self notify( "train_stops_killing_players" );
		// Wait until the next train
		wait( randomfloatrange( min_time_between_trains, max_time_between_trains ) );
	}
}

train_play_sound_delayed( alias )
{
	wait( randomfloatrange( SOUND_DELAY_MIN, SOUND_DELAY_MAX ) );	
	self playLoopSound( alias );
}

train_play_sounds( max )
{	
	self thread train_play_sound_delayed( "veh_train_eng_dist1_loop" );
	self thread train_play_sound_delayed( "veh_train_eng_dist2_loop" );
	self thread train_play_sound_delayed( "veh_train_eng_mid_loop" );
	self thread train_play_sound_delayed( "veh_train_eng_close1_loop" );
	self thread train_play_sound_delayed( "veh_train_eng_close2_loop" );
	
	// dont play sounds on every car
	count = 0;
	for ( i = 0; i < self.cars.size; i++ )
	{
		count++;
		if ( count < max )
			continue;
		count = 0;
	
		self.cars[ i ] thread train_play_sound_delayed( "veh_train_car_dist_loop" );
		self.cars[ i ] thread train_play_sound_delayed( "veh_train_car_mid_loop" );
		self.cars[ i ] thread train_play_sound_delayed( "veh_train_car_close_loop" );
	}
}

train_stop_sounds( max )
{
	self stopLoopSound( "veh_train_eng_dist1_loop" );   
	self stopLoopSound( "veh_train_eng_dist2_loop" );   
	self stopLoopSound( "veh_train_eng_mid_loop" );     
	self stopLoopSound( "veh_train_eng_close1_loop" );  
	self stopLoopSound( "veh_train_eng_close2_loop" );  

	count = 0;
	for ( i = 0; i < self.cars.size; i++ )
	{
		count++;
		if ( count < max )
			continue;
		count = 0;
	
		self.cars[ i ] stopLoopSound( "veh_train_car_dist_loop" );
		self.cars[ i ] stopLoopSound( "veh_train_car_mid_loop" );
		self.cars[ i ] stopLoopSound( "veh_train_car_close_loop" );
	}
}

hide_trains()
{
	// Hide the train while it warps to position
	self hide();
	foreach ( wheel in self.wheels )
	{
		wheel hide();
	}
	foreach ( car in self.cars )
	{
		car hide();
		foreach ( wheel in car.wheels )
		{
			wheel hide();
		}
	}
}

show_trains()
{
	// show the train while it warps to position
	self show();
	foreach ( wheel in self.wheels )
	{
		wheel show();
	}
	foreach ( car in self.cars )
	{
		car show();
		foreach ( wheel in car.wheels )
		{
			wheel show();
		}
	}
}

train_spawns_dust()
{
	if ( !isdefined( level._effect[ "train_dust" ] ) )
		return;
		
	range = 40;
	self endon( "train_stops_killing_players" );
	
	for ( ;; )
	{
		/*
		for ( i = 0; i < 10; i ++ )
		{
			x = randomfloatrange( self.min_x, self.max_x );
			y = randomfloatrange( self.min_y, self.max_y );
			PlayFX( level._effect[ "train_dust" ], ( x, y, self.origin[ 2 ] - 30 ) );
		}
		*/

		count = randomintrange( 1, 3 ); // which means 1 to 2 fx per frame
		for ( i = 0; i < count; i ++ )
		{
			x = randomfloatrange( self.min_x - range, self.max_x + range );
			y = randomfloatrange( self.min_y - range, self.max_y + range );
			PlayFX( level._effect[ "train_dust_linger" ], ( x, y, self.origin[ 2 ] - 10 ) );
		}
		wait( 0.05 );
	}
}

train_kills_players( train_cars, distance_between_cars )
{
	// find the extents of the train, presuming it is going straight n/s/e/w and then test vs player origins to see
	// if they should be run over
	train_width = 68;
	self endon( "train_stops_killing_players" );

	forward = anglestoforward( self.angles );
	right = anglestoright( self.angles );
	full_car_vec = forward * distance_between_cars;
	half_car_vec = full_car_vec * 0.5;
	train_width_vec = right * train_width;

	sides = [];
	sides[ "front" ] = self.origin + half_car_vec;
	sides[ "rear" ] = self.origin + train_cars * full_car_vec * - 1;
	sides[ "right" ] = self.origin + train_width_vec;
	sides[ "left" ] = self.origin - train_width_vec;
	start = self.origin;

	max_x = sides[ "front" ][ 0 ];
	min_x = sides[ "front" ][ 0 ];
	max_y = sides[ "front" ][ 1 ];
	min_y = sides[ "front" ][ 1 ];
	foreach ( side in sides )
	{
		if ( side[ 0 ] > max_x )
			max_x = side[ 0 ];
		if ( side[ 0 ] < min_x )
			min_x = side[ 0 ];
		if ( side[ 1 ] > max_y )
			max_y = side[ 1 ];
		if ( side[ 1 ] < min_y )
			min_y = side[ 1 ];
	}

	for ( ;; )
	{
		dif = start - self.origin;
		start = self.origin;
		max_x -= dif[ 0 ];
		min_x -= dif[ 0 ];
		max_y -= dif[ 1 ];
		min_y -= dif[ 1 ];
		
		// store it for the dust fx
		self.min_x = min_x;
		self.max_x = max_x;
		self.min_y = min_y;
		self.max_y = max_y;
		
		//print3d( ( max_x, max_y, self.origin[ 2 ] ), " * " );
		//print3d( ( min_x, max_y, self.origin[ 2 ] ), " * " );
		//print3d( ( max_x, min_y, self.origin[ 2 ] ), " * " );
		//print3d( ( min_x, min_y, self.origin[ 2 ] ), " * " );

		hit_ents = [];

		foreach ( player in level.players )
		{
			if ( !isalive( player ) )
				continue;
			if ( player.sessionstate != "playing" )
				continue;
			if ( !train_hits( player, min_x, min_y, max_x, max_y ) )
				continue;
				
			player playsound( "melee_knife_hit_watermelon" );

			pos = get_damageable_player_pos( player );
			hit_ents[ hit_ents.size ] = get_damageable_player( player, pos );
		}

		grenades = getentarray( "grenade", "classname" );
		foreach ( grenade in grenades )
		{
			if ( !train_hits( grenade, min_x, min_y, max_x, max_y ) )
				continue;

			pos = get_damageable_grenade_pos( grenade );
			hit_ents[ hit_ents.size ] = get_damageable_grenade( grenade, pos );
		}
	
		foreach ( ent in hit_ents )
		{				
			ent.damage = 5000;
			ent.pos = self.origin;
			ent.damageOwner = self;
			ent.eInflictor = self;

			ent maps\mp\gametypes\_weapons::damageEnt(
				ent.eInflictor, // eInflictor = the entity that causes the damage (e.g. a claymore)
				ent.damageOwner, // eAttacker = the player that is attacking
				ent.damage, // iDamage = the amount of damage to do
				"MOD_PROJECTILE_SPLASH", // sMeansOfDeath = string specifying the method of death (e.g. "MOD_PROJECTILE_SPLASH")
				"train_mp", // sWeapon = string specifying the weapon used (e.g. "claymore_mp")
				ent.pos, // damagepos = the position damage is coming from
				vectornormalize(ent.damageCenter - ent.pos) // damagedir = the direction damage is moving in
			);			
		}
				
		wait( 0.05 );
	}
}

train_hits( entity, min_x, min_y, max_x, max_y )
{
	if ( entity.origin[ 2 ] < self.origin[ 2 ] - 5 )
		return false;

	if ( entity.origin[ 2 ] > self.origin[ 2 ] + 162 )
		return false;

	x = entity.origin[ 0 ];
	y = entity.origin[ 1 ];
	if ( x < min_x )
		return false;
	if ( y < min_y )
		return false;
	if ( x > max_x )
		return false;
	if ( y > max_y )
		return false;
	return true;
}


train_eq( origin, eq_radius, track_time, full_train_time )
{
	train_eq_lerp_for_time( origin, 0.0, 0.09, eq_radius, track_time, 0.5 );
	train_eq_for_time( origin, 0.17, eq_radius, full_train_time, 0.5 );
	train_eq_lerp_for_time( origin, 0.09, 0, eq_radius, track_time, 0.5 );
	//level notify( "stop_train_debug" + origin );
}

train_eq_for_time( origin, eq, eq_radius, eq_time, eq_time_slice )
{
	// earthquake makes the quake taper off over time so we
	// are going to do a lot of earthquakes to simulate a steady quake
	//thread print3d_eq( origin, eq );
	steps = int( eq_time / eq_time_slice );
	for ( i = 0; i < steps; i++ )
	{
		Earthquake( eq, eq_time_slice * 3, origin, eq_radius );
		wait( eq_time_slice );
	}
	remainder = eq_time - steps * eq_time_slice;
	if ( remainder > 0 )
	{
		wait( remainder );
	}
}

train_eq_lerp_for_time( origin, eq1, eq2, eq_radius, eq_time, eq_time_slice )
{
	// earthquake makes the quake taper off over time so we
	// are going to do a lot of earthquakes to simulate a steady quake
	//thread print3d_eq( origin, eq );
	steps = int( eq_time / eq_time_slice );
	for ( i = 0; i < steps; i++ )
	{
		progress = i / steps;
		eq = eq2 * progress + eq1 * ( 1 - progress );
		if ( eq > 0 )
			Earthquake( eq, eq_time_slice * 3, origin, eq_radius );
		wait( eq_time_slice );
	}
	remainder = eq_time - steps * eq_time_slice;
	if ( remainder > 0 )
	{
		wait( remainder );
	}
}

print3d_eq( origin, msg )
{
	level notify( "stop_train_debug" + origin );
	level endon( "stop_train_debug" + origin );
	for ( ;; )
	{
		Print3d( origin, msg );
		wait( 0.05 );
	}
}