#include maps\_utility;
#include common_scripts\utility;
#include maps\_anim;
#include animscripts\utility;
#include maps\_vehicle_spline_zodiac;
#include maps\_vehicle;

trigger_multiple_speed_think()
{
	speed = self.script_speed;
	AssertEx( IsDefined( speed ), "Trigger at " + self.origin + " has no script_speed" );

	for ( ;; )
	{
		self waittill( "trigger", other );
		if ( !isdefined( other.vehicle ) )
			continue;
		other.vehicle.veh_topspeed = speed;
	}
}

//hmmmmmmmm

/*QUAKED trigger_multiple_speed (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
defaulttexture="trigger"
Set the player vehicle maxspeed with script_speed.*/

ZODIAC_TREADFX_MOVETIME = .2;
ZODIAC_TREADFX_MOVETIMEFRACTION = 1 / ( ZODIAC_TREADFX_MOVETIME + .05 );
ZODIAC_TREADFX_HEIGHTOFFSET = ( 0, 0, 16 );

zodiac_treadfx_chaser( chaseobj )
{
	// self here is the invisible boat for playing leveled wake fx.
	PlayFXOnTag( getfx( "zodiac_wake_geotrail" ), self, "tag_origin" );
	self NotSolid();
	self Hide();
	self endon( "death" );
	chaseobj endon( "death" );

	// needs to be it's own thread so can cleanup after the thing dies.
	thread zodiac_treadfx_chaser_death( chaseobj );

	chaseobj ent_flag_init( "in_air" );

	childthread zodiac_treadfx_stop_notify( chaseobj );
	childthread zodiac_treadfx_toggle( chaseobj );

	while ( IsAlive( chaseobj ) )
	{
//		self DontInterpolate();
		self MoveTo( chaseobj GetTagOrigin( "tag_origin" ) + ZODIAC_TREADFX_HEIGHTOFFSET + ( chaseobj Vehicle_GetVelocity() / ZODIAC_TREADFX_MOVETIMEFRACTION ), ZODIAC_TREADFX_MOVETIME );
		self RotateTo( ( 0, chaseobj.angles[ 1 ], 0 ), ZODIAC_TREADFX_MOVETIME ) ;
		wait ZODIAC_TREADFX_MOVETIME + .05;// + .05 to get rid of silly jiggle at the end when issueing back to back moveto's. Code bug I believe.
		waittillframeend;
	}
	self Delete();
}

zodiac_treadfx_toggle( chaseobj )
{
	while ( 1 )
	{
		msg = chaseobj waittill_any_return( "zodiac_treadfx_stop", "veh_leftground" );
		if ( msg == "veh_leftground" )
			chaseobj ent_flag_set( "in_air" );

		StopFXOnTag( getfx( "zodiac_wake_geotrail" ), self, "tag_origin" );

		msg = chaseobj waittill_any_return( "zodiac_treadfx_go", "veh_landed" );
		if ( msg == "veh_landed" )
			chaseobj ent_flag_clear( "in_air" );

		PlayFXOnTag( getfx( "zodiac_wake_geotrail" ), self, "tag_origin" );
	}
}

zodiac_treadfx_stop_notify( chaseobj )
{
	while ( 1 )
	{
		if ( chaseobj Vehicle_GetSpeed() < 4 )
			chaseobj notify( "zodiac_treadfx_stop" );
		else if ( ! chaseobj ent_flag( "in_air" ) )
			chaseobj notify( "zodiac_treadfx_go" );
		wait .05;
	}
}

zodiac_treadfx_chaser_death( chaseobj )
{
	chaseobj waittill_any( "stop_bike", "death", "kill_treadfx" );
	self Delete();
}

zodiac_treadfx()
{
	chaser = Spawn( "script_model", self.origin );
	chaser SetModel( self.model );
	chaser.angles = ( 0, self.angles[ 1 ], 0 );
	chaser thread zodiac_treadfx_chaser( self );
}

enemy_chase_boat_breadcrumb()
{
	struct = SpawnStruct();
	struct.origin = self.origin;
	struct.angles = flat_angle( self.angles );
	struct.spawn_time = GetTime();
	level.breadcrumb[ level.breadcrumb.size ] = struct;
}

vehicle_dump()
{
	predumpvehicles = GetEntArray( "script_vehicle", "code_classname" );
	vehicles = [];

	// dumping can jump a frame in which the information could be altered, this stores the necessary info real quick
	foreach ( vehicle in predumpvehicles )
	{
		if ( IsSpawner( vehicle ) )
			continue;
		struct = SpawnStruct();
		struct.classname = vehicle.classname;
		struct.origin = vehicle.origin;
		struct.angles = vehicle.angles;
//		struct.spawner_id = vehicle.spawner_id;
		struct.speedbeforepause = vehicle Vehicle_GetSpeed();
		struct.script_VehicleSpawngroup = vehicle.script_vehiclespawngroup;
		struct.script_VehicleStartMove = vehicle.script_vehiclestartmove;
		struct.model = vehicle.model;
		struct.angles = vehicle.angles;
		if ( IsDefined( level.playersride ) && vehicle == level.playersride )
			struct.playersride = true;
		vehicles[ vehicles.size ] = struct;
	}

	fileprint_launcher_start_file();
	fileprint_map_start();

	foreach ( i, vehicle in vehicles )
	{
		origin = fileprint_radiant_vec( vehicle.origin );// convert these vectors to mapfile keypair format
		angles = fileprint_radiant_vec( vehicle.angles );

		fileprint_map_entity_start();
			fileprint_map_keypairprint( "classname", "script_struct" );
			fileprint_map_keypairprint( "model", vehicle.model );
			fileprint_map_keypairprint( "origin", origin );
			fileprint_map_keypairprint( "angles", angles );
			if ( IsDefined( vehicle.speedbeforepause ) )
				fileprint_map_keypairprint( "current_speed", vehicle.speedbeforepause );
			if ( IsDefined( vehicle.script_VehicleSpawngroup ) )
				fileprint_map_keypairprint( "script_vehiclespawngroup", vehicle.script_VehicleSpawngroup );
			if ( IsDefined( vehicle.script_VehicleStartMove ) )
				fileprint_map_keypairprint( "script_vehiclestartmove", vehicle.script_VehicleStartMove );
		fileprint_map_entity_end();
	}
	map_name = level.script + "_veh_ref.map";
	fileprint_launcher_end_file( "/map_source/" + map_name );
	launcher_write_clipboard( map_name );
}

draw_crumb( crumb, lastcrumb, fraction )
{
	if ( !flag( "debug_crumbs" ) )
		return;
	left_spot = crumb.origin + AnglesToRight( crumb.angles ) * -1000 ;
	right_spot = crumb.origin + AnglesToRight( crumb.angles ) * 1000 ;
	color = ( fraction, 1 - fraction, 0 );

	Line( left_spot, right_spot, color );

	if ( !isdefined( lastcrumb ) )
		return;

	left_spot_last = lastcrumb.origin + AnglesToRight( lastcrumb.angles ) * -1000 ;
	right_spot_last = lastcrumb.origin + AnglesToRight( lastcrumb.angles ) * 1000 ;
	Line( left_spot, left_spot_last, color );
	Line( right_spot, right_spot_last, color );
}

zodiac_physics()
{
	self.bigjump_timedelta = 500;
	self.event_time = -1;
	self.event = [];
	self.event[ "jump" ] = [];
	self.event[ "jump" ][ "driver" ] = false;
	self.event[ "jump" ][ "passenger" ] = false;
	self.event[ "bump" ] = [];
	self.event[ "bump" ][ "driver" ] = false;
	self.event[ "bump" ][ "passenger" ] = false;
	self.event[ "bump_big" ] = [];
	self.event[ "bump_big" ][ "driver" ] = false;
	self.event[ "bump_big" ][ "passenger" ] = false;
	self.event[ "sway_left" ] = [];
	self.event[ "sway_left" ][ "driver" ] = false;
	self.event[ "sway_left" ][ "passenger" ] = false;
	self.event[ "sway_right" ] = [];
	self.event[ "sway_right" ][ "driver" ] = false;
	self.event[ "sway_right" ][ "passenger" ] = false;
	self childthread watchVelocity();
	self childthread listen_leftground();
	self childthread listen_landed();
	self childthread listen_jolt();
	self childthread listen_bounce();
	self childthread listen_turn_spray();
//	self thread listen_collision();
}

zodiac_fx( fxName )
{
	tag = "tag_origin";

	if ( IsDefined( level._effect_tag[ fxName ] ) )
		tag = level._effect_tag[ fxName ];

	if ( IsDefined( level._effect[ fxName ] ) )
		PlayFXOnTag( level._effect[ fxName ], self, tag );
		//iprintlnbold( fxName );
	if ( IsDefined( level.zodiac_fx_sound[ fxname ] ) )
		thread play_sound_on_entity( level.zodiac_fx_sound[ fxname ] );
		//println( fxName );
}

listen_leftground()
{
	self endon( "death" );
	flag_wait( "player_on_boat" );
	for ( ;; )
	{
		self waittill( "veh_leftground" );
		self.event_time = GetTime();
		self.event[ "jump" ][ "driver" ] = true;
		self.event[ "jump" ][ "passenger" ] = true;

		zodiac_fx( "zodiac_leftground" );
	}
}

listen_landed()
{
	self endon( "death" );
	wait 2; // no ignore the land that happens when they spawn above the water.
	flag_wait( "player_on_boat" );
	for ( ;; )
	{
		self waittill( "veh_landed" );
		if ( self.event_time + self.bigjump_timedelta < GetTime() )
		{
			self.event[ "bump_big" ][ "driver" ] = true;
			self.event[ "bump_big" ][ "passenger" ] = true;
			if ( ! flag( "player_in_sight_of_boarding" ) )
				thread water_bump( "bump_big" );
			if ( self == level.players_boat )
				zodiac_fx( "player_zodiac_bumpbig" );
			else
				zodiac_fx( "zodiac_bumpbig" );


		}
		else
		{
			self.event[ "bump" ][ "driver" ] = true;
			self.event[ "bump" ][ "passenger" ] = true;
			if ( ! flag( "player_in_sight_of_boarding" ) )
				thread water_bump( "bump" );
			if ( self == level.players_boat )
				zodiac_fx( "player_zodiac_bump" );
			else
				zodiac_fx( "zodiac_bump" );
		}
	}
}

trigger_set_water_sheating_time( bump_small, bump_big )
{
	self waittill( "trigger" );
	set_water_sheating_time( bump_small, bump_big );
}

set_water_sheating_time( bump_small, bump_big )
{
	// duplicated in af_chase_knife_fight_code
	level.water_sheating_time[ "bump" ] = level.water_sheating_time[ bump_small ];
	level.water_sheating_time[ "bump_big" ] = level.water_sheating_time[ bump_big ];
}

water_bump( bumptype )
{
	if ( !isdefined( level.players_boat ) ||  self != level.players_boat )
		return;
	level endon( "missionfailed" );
	if ( flag( "missionfailed" ) )
		return;

	if ( bumptype == "bump_big" )
		level.player PlayRumbleOnEntity( "damage_heavy" );
	else
		level.player PlayRumbleOnEntity( "damage_light" );

	if ( !flag( "no_more_physics_effects" ) )
		level.player SetWaterSheeting( 1, level.water_sheating_time[ bumptype ] );
}

listen_jolt()
{
	self endon( "death" );
	flag_wait( "player_on_boat" );
	for ( ;; )
	{
		self waittill( "veh_jolt", jolt );
		if ( jolt[ 1 ] >= 0 )
		{
			self.event[ "sway_left" ][ "driver" ] = true;
			self.event[ "sway_left" ][ "passenger" ] = true;

			zodiac_fx( "zodiac_sway_left" );
		}
		else
		{
			self.event[ "sway_right" ][ "driver" ] = true;
			self.event[ "sway_right" ][ "passenger" ] = true;

			zodiac_fx( "zodiac_sway_right" );
		}
	}
}

listen_bounce()
{
	self endon( "death" );
	flag_wait( "player_on_boat" );

	for ( ;; )
	{
		self waittill( "veh_boatbounce", force );

//		if ( self == level.players_boat )
//			IPrintLnBold( force );

		if ( force < 50.0 )
		{
			//PlayFXOnTag( getfx( "zodiac_bounce_small_left" ), self, "TAG_FX_LF" );
			//PlayFXOnTag( getfx( "zodiac_bounce_small_left" ), self, "TAG_FX_RF" );
			zodiac_fx( "zodiac_bounce_small_left" );
			zodiac_fx( "zodiac_bounce_small_right" );
		}
		else
		{
			//PlayFXOnTag( getfx( "zodiac_bounce_large_left" ), self, "TAG_FX_LF" );
			//PlayFXOnTag( getfx( "zodiac_bounce_large_left" ), self, "TAG_FX_RF" );
			zodiac_fx( "zodiac_bounce_large_left" );
			zodiac_fx( "zodiac_bounce_large_right" );
		}
	}
}

listen_turn_spray()
{
    self endon( "death" );
    while ( 1 )
    {
        velocity = self Vehicle_GetBodyVelocity();

        if ( self Vehicle_GetSpeed() > 40 )
        {
            if ( velocity[ 1 ] < -150.0 )
                zodiac_fx( "zodiac_sway_right" );
            else if ( velocity[ 1 ] > 150.0 )
                zodiac_fx( "zodiac_sway_left" );
        }
        else if ( self Vehicle_GetSpeed() > 10 )
        {
            if ( velocity[ 1 ] < -30.0 )
                zodiac_fx( "zodiac_sway_right_light" );
            else if ( velocity[ 1 ] > 30.0 )
                zodiac_fx( "zodiac_sway_left_light" );
        }
        wait .05;
    }
}

listen_collision()
{
	self endon( "death" );

	for ( ;; )
	{
		self waittill( "veh_collision", collision, start_vel );

		foreach ( rider in self.riders )
		{
			if ( IsAlive( rider ) && !isdefined( rider.magic_bullet_shield ) )
			{
//				rider.specialDeathFunc = animscripts\snowmobile::snowmobile_collide_death;
				rider Kill();
			}
		}
		zodiac_fx( "zodiac_collision" );
	}
}

watchVelocity()
{
	self endon( "death" );
	vel = self Vehicle_GetVelocity();
	for ( ;; )
	{
		self.prevFrameVelocity = vel;
		vel = self Vehicle_GetVelocity();
		wait .05;
	}
}

autosave_boat_chase()
{
	// I should just replace these with real autosave triggers.
	self waittill( "trigger" );

	if ( IsDefined( self.targetname ) )
		autosave_by_name( self.targetname );
	else
		autosave_by_name( "boat_chase" );
}

autosave_boat_check_trailing()
{
	return bread_crumb_get_player_trailing_fraction() < .5;
}

autosave_boat_check_player_speeding_along()
{
	return level.players_boat Vehicle_GetSpeed() > 20;
}

bread_crumb_get_player_trailing_fraction()
{
	if ( ! level.breadcrumb.size )
		return 0;
	crumb = level.breadcrumb[ 0 ];
	time = ( GetTime() - crumb.spawn_time ) / 1000;
	return time / level.breadcrumb_settings.fail_time;
}

bread_crumb_chase()
{
	/#
	SetDvarIfUninitialized( "scr_debug_breadcrumbs", 1 );
	#/

	/#
	if ( GetDvarInt( "scr_zodiac_test" ) )
		return;
	#/

	currenttime = GetTime();
	lastcrumb = undefined;
	test_array = [];
	count = 0;

	foreach ( crumb in level.breadcrumb )
	{
		time = ( currenttime - crumb.spawn_time ) / 1000;
		trailing_fraction = time / level.breadcrumb_settings.fail_time;

		if ( trailing_fraction > 1 )
			bread_crumb_fail();

		if ( ! count )
			breadcrumb_docatchup( trailing_fraction );

		if ( count < level.breadcrumb_settings.checkdepth )
			test_array[ count ] = crumb;

		if ( is_breadcrumb_debug() )
			draw_crumb( crumb, lastcrumb, trailing_fraction );

		lastcrumb = crumb;
		count++;
	}

//	skipped = false;
	foreach ( crumb in test_array )
	{
		vec = AnglesToForward( crumb.angles );
		vec2 = VectorNormalize( ( level.player.origin - crumb.origin ) );
		vecdot = VectorDot( vec, vec2 );
		if ( vecdot > 0 )
			level.breadcrumb = array_remove( level.breadcrumb, crumb );
	}
}

breadcrumb_docatchup( trailing_fraction )
{
	if ( trailing_fraction < .25 )
		flag_set( "zodiac_catchup" );
	else
		flag_clear( "zodiac_catchup" );
}

bread_crumb_fail()
{
	if ( !isalive( level.player ) )
		return;

	/#
	if ( GetDvarInt( "scr_zodiac_test" ) )
		return;
	#/

	// Shepherd got away.
	level notify ( "stop_deadquote_for_gettingout_of_bounds" );
	SetDvar( "ui_deadquote", &"AF_CHASE_MISSION_FAILED_KEEP_UP" );
	if ( level.start_point != "test_boat_current" )
		missionFailedWrapper();
}

is_breadcrumb_debug()
{
	return GetDvarInt( "scr_debug_breadcrumbs" );
}

zodiac_monitor_player_trailing_time()
{
	self endon( "death" );
	flag_wait( "player_on_boat" );
	while ( 1 )
	{
		level waittill( "zodiac_catchup" );

		if ( flag( "zodiac_boarding" ) )
			return;

		if ( flag( "zodiac_catchup" ) )
		{
			player_boat_speed_plus = level.players_boat Vehicle_GetSpeed() + 5;
			if ( self Vehicle_GetSpeed() < player_boat_speed_plus )
				self Vehicle_SetSpeed( player_boat_speed_plus, 15, 15 );
			player_boat_speed_plus = undefined;
		}
		else
			self ResumeSpeed( 15 );
	}
}

zodiac_catchup()
{
	player_speed_plus = level.players_boat Vehicle_GetSpeed() + 5;
	if ( self Vehicle_GetSpeed() < player_speed_plus )
		self Vehicle_SetSpeed( player_speed_plus, 15, 15 );
}

is_main_enemy_boat()
{
	if ( !isdefined( self.targetname ) )
		return false;
	return self.targetname == "enemy_chase_boat";
}

zodiac_boat_ai( boat )
{
// kill _vehicle_anim stuff. not completely just gets them out of idle loop
	if ( !isai( self ) )
		return;
	self notify( "newanim" );

	//make them crouch
	self.desired_anim_pose = "crouch";
	self AllowedStances( "crouch" );
	self thread animscripts\utility::UpdateAnimPose();
	self AllowedStances( "crouch" );

	self.baseaccuracy = 0;// don't get accurate untill they are in range.
	self.accuracystationarymod = .5;
}

heli_attack_player_idle()
{
	self waittill( "trigger", heli );

	level.players_boat endon( "death" );
	heli thread mgoff();

	heli endon( "death" );

	heli thread handle_fire_missiles();

	while ( Distance( level.player.origin, self.origin ) > 8500 )
		wait .05;

	heli thread mgon();
	foreach ( turret in heli.mgturret )
	{
		turret SetAISpread( 2 );
		turret SetConvergenceTime( 5 );
		turret.accuracy = .5;
	}

	if ( ! flag( "rapids_trigger" ) )// don't care about this particular dialog after the rapids.
		level notify( "dialog_helicopter_ahead" );

	heli SetLookAtEnt( level.player );


	while ( in_front( level.players_boat, heli ) )
		wait .05;

	if ( ! flag( "rapids_trigger" ) )// don't care about this particular dialog after the rapids.
		level notify( "dialog_helicopter_six" );


	foreach ( turret in heli.mgturret )
	{
		turret SetAISpread( 20 );
		turret SetConvergenceTime( 7 );
		turret.accuracy = 0;
	}

	wait 3;// let it try to converge then turn it off.

	heli thread mgoff();

}

rumble_with_throttle()
{
	rumble_ent = get_rumble_ent();

	throttle_leveling_time = 3.4;

	level_throttle = .01;

	full_throttled_time = 0;

	rumble_fraction = .13;

	while ( 1 )
	{
		throttle = self Vehicle_GetThrottle();

		full_throttled_time += .05;

		if ( throttle < .5 )
		{
			full_throttled_time = 0;
			throttle_level_fraction = 1;
		}
		else
		{
			throttle_level_fraction = 1 - ( full_throttled_time / throttle_leveling_time );
		}

		rumble_ent.intensity = ( throttle * rumble_fraction * throttle_level_fraction );

		if ( full_throttled_time > throttle_leveling_time || self Vehicle_GetSpeed() > 43 )
		{
			full_throttled_time = throttle_leveling_time;// probably not necessary. just keeping the number from going really high.
			rumble_ent.intensity = 0;
		}

		wait .05;
		if ( flag( "player_in_sight_of_boarding" ) )
			break;
	}
	rumble_ent Delete();
}

kill_ai_in_volume()
{
	volume = GetEnt( self.target, "targetname" );
	Assert( IsDefined( volume ) );

	self waittill( "trigger" );
	ai = GetAIArray();

	foreach ( guy in ai )
		if ( guy IsTouching( volume ) && !guy is_hero() )
			guy Delete();

	//hack.. shortcutting adding another volume. want to delete these fx forever.
	tester = Spawn( "script_origin", ( 0, 0, 0 ) );

	inc = 0;
	foreach ( createfxent in level.createfxent )
	{
		inc++;
		if ( IsDefined( createfxent.looper ) )
		{
			level.createfxent = array_remove( level.createfxent, createfxent );
			tester.origin = createfxent.v[ "origin" ];
			if ( tester IsTouching( volume ) )
				createfxent.looper Delete();
		}
		if ( inc > 3 )
		{
			inc = 0;
			wait .05;
		}
	}
	tester Delete();
}

kill_all_the_ai_and_fx_from_boatride()
{
	kill_ai_in_volume = GetEntArray( "kill_ai_in_volume", "targetname" );
	foreach ( trigger in kill_ai_in_volume )
	{
		wait( 0.1 );
		trigger notify( "trigger", level.player );
	}
}

kill_destructibles_and_barrels_in_volume()
{
	volume = GetEnt( self.target, "targetname" );
	Assert( IsDefined( volume ) );

	self waittill( "trigger" );

	shootable_stuff = GetEntArray( "destructible_toy", "targetname" );

	inc = 0;
	foreach ( thing in shootable_stuff )
	{
		thing delete_shootable_stuff_in_volume( volume );
		inc++;
		if ( inc > 3 )
		{
			inc = 0;
			wait .05;
		}
	}

 	//dupping script for speed.
	shootable_stuff = GetEntArray( "explodable_barrel", "targetname" );
	foreach ( thing in shootable_stuff )
	{
		thing delete_shootable_stuff_in_volume( volume );
		inc++;
		if ( inc > 3 )
		{
			inc = 0;
			wait .05;
		}
	}

}

delete_shootable_stuff_in_volume( volume )
{
	if ( ! self IsTouching( volume ) )
		return;

	self notify( "delete_destructible" );// kill the effects looping first.
	self Delete();
}

disable_origin_offset()
{
	// I need this for more precise hovering with the ramp in the water.
	self.originheightoffset = undefined;

}


destructible_fake()
{
	self waittill( "trigger" );
	destructible_org = GetEnt( self.target, "targetname" );

	radius = 600;
	if ( IsDefined( destructible_org.radius ) )
		radius = destructible_org.radius;

	count = 3;

	destructible_damage_count_in_radius( count, radius, destructible_org.origin );

}

destructible_damage_count_in_radius( count, radius, origin )
{
	destructible_toys = get_array_of_closest( origin, GetEntArray( "destructible_toy", "targetname" ), undefined, count, radius, 0 )  ;
	foreach ( toy in destructible_toys )
	{
		wait RandomFloatRange( .1, .4 );
//		toy thread common_scripts\_destructible::force_explosion();
		thread destroy_fast( toy );
	}
}

destroy_fast( toy )
{
	for ( i = 0; i < 5; i++ )
	{
		toy notify( "damage", 160, level.player, self.origin, toy.origin, "MOD_PISTOL_BULLET", "", "" );
		wait RandomFloatRange( .1, .2 );
	}

}

raise_attacker_accuracy_on_nearby_boats()
{
	flag_wait( "player_on_boat" );

	level.players_boat endon( "death" );
	while ( 1 )
	{
		attack_boats_in_range_in_front();
		wait .05;
	}
}

SQRT_BOATS_IN_RANGE = 1400 * 1400;
SQRT_BOATS_IN_RANGE_BEHIND = 50 * 50;

attack_boats_in_range_in_front( range, backrange )
{
	boats = GetEntArray( "script_vehicle_zodiac_physics", "classname" );

	return_boats = [];
	foreach ( boat in boats )
	{
		if ( boat  == level.players_boat )
			continue;
		if ( IsSpawner( boat ) )
			continue;
		if ( ! boat_in_range_in_front( boat ) )
			continue;

		boat thread raise_attacker_accuracy_while_in_range();
	}
	return return_boats;
}

raise_attacker_accuracy_while_in_range()
{
	self notify( "raise_attacker_accuracy_while_in_range" );
	self endon( "raise_attacker_accuracy_while_in_range" );
	self endon( "death" );

	foreach ( rider in self.riders )
	{
		rider.baseaccuracy = 6;
//		rider.baseaccuracy = 10;
		rider.suppressionwait = 1000;
	}

	while ( boat_in_range_in_front( self ) )
		wait .05;

	foreach ( rider in self.riders )
	{
		rider.baseaccuracy = 0;
//		rider.ignoreSuppression = false;
	}
}

boat_in_range_in_front( boat )
{
	if ( flag( "player_in_open" ) )
		return true;
	if ( DistanceSquared( boat.origin, level.players_boat.origin ) > SQRT_BOATS_IN_RANGE )
		return false;
	dot = get_dot( level.players_boat.origin, level.players_boat.angles, boat.origin );
//	if ( dot < 0 && DistanceSquared( boat.origin, level.players_boat.origin ) > SQRT_BOATS_IN_RANGE_BEHIND )
	if ( dot < 0.642787 )// ~50
		return false;
	return true;
}

conveyerbelt_speed( yaw, speed, rate )
{
	level.VehPhys_SetConveyorBelt_yaw = yaw;

	speeddiff = speed - level.VehPhys_SetConveyorBelt_speed;

	if ( speeddiff == 0 )
		return;

	time = abs( speeddiff / rate );

	level notify( "conveyerbelt_speed" );
	level endon( "conveyerbelt_speed" );

	iterations = Int( time / .05 ) ;

	speedinc = 0;
	if ( iterations != 0 )
		speedinc = speeddiff / iterations;
	else
		return;

	for ( i = 0; i < iterations; i++ )
	{
		wait .05;
		level.VehPhys_SetConveyorBelt_speed += speedinc;
	}

	level.VehPhys_SetConveyorBelt_speed = speed;

}

CONVEYERBELT_PLAYER_MAX_SPEED = 40;
CONVEYERBELT_PLAYER_MIN_SPEED = 20;

conveyerbelt_player_speed_mod()
{
	mod = 1;
	dif = CONVEYERBELT_PLAYER_MAX_SPEED - CONVEYERBELT_PLAYER_MIN_SPEED;

	velocity =  level.players_boat Vehicle_GetVelocity();
	speed = Distance( velocity, ( 0, 0, 0 ) ) / 17.6;

	velocity = flat_origin( velocity );

	normal = VectorNormalize( velocity );
	forward = AnglesToForward( ( 0, level.VehPhys_SetConveyorBelt_yaw, 0 ) );
	dot = VectorDot( forward, normal );

//	speed = level.players_boat Vehicle_GetSpeed();

	if ( flag( "enemy_heli_takes_off" ) )
		mod = 1;
	if ( speed > CONVEYERBELT_PLAYER_MAX_SPEED )
		mod = 0;
	else if ( speed < CONVEYERBELT_PLAYER_MIN_SPEED )
		mod = 1;
	else
	{
		players_dif = speed - CONVEYERBELT_PLAYER_MIN_SPEED;
		mod = 1 - ( players_dif / dif );
	}
	level.conveyerbelt_player_speed_mod = level.VehPhys_SetConveyorBelt_speed * mod;// for debugging

	level.conveyerbelt_player_speed_mod *= level.VehPhys_SetConveyorBelt_speed_fraction;

	self VehPhys_SetConveyorBelt( level.VehPhys_SetConveyorBelt_yaw, level.conveyerbelt_player_speed_mod );
}

conveyerbelt_set_speed_fraction( dest_fraction, time )
{
	level notify( "conveyerbelt_set_speed_fraction" );
	level endon( "conveyerbelt_set_speed_fraction" );

	if ( time == 0 )
	{
		level.VehPhys_SetConveyorBelt_speed_fraction = dest_fraction;
		return;
	}

	current_fraction = level.VehPhys_SetConveyorBelt_speed_fraction;
	incs = Int( time * 20 );
	fraction_increment = ( dest_fraction - current_fraction ) / incs;

	for ( i = 0; i < incs; i++ )
	{
		level.VehPhys_SetConveyorBelt_speed_fraction += fraction_increment;
		wait .05;
	}

	level.VehPhys_SetConveyorBelt_speed_fraction = dest_fraction;
}

conveyerbelt_clear_speed_fraction()
{
	conveyerbelt_set_speed_fraction( 1 );
}

set_fixed_node_after_seeing_player_spawn_func()
{
	self endon( "death" );

	if ( IsSubStr( self.classname, "shepherd" ) )
		return;

	while ( !self CanSee( level.player ) && Distance( self.origin, level.player.origin ) > 3500 )
		wait .1;
	self.fixednode = true;

	self.pathenemyfightdist = 0;
	self.pathenemylookahead = 0;
}

CONVEYER_RATE = 4;
river_current( noteworthy )
{
	level notify( "new_river_current" );
	level endon( "new_river_current" );

	/#
	if ( GetDvarInt( "scr_zodiac_test" ) )
		return;
	#/

	current_node = getstruct( noteworthy, "script_noteworthy" );
	next_node = getstruct( current_node.target, "targetname" );

	maxdropspeed_cos = Cos( 35 );
	maxdropspeed = 45;
	maxdropspeed_lower_cap = maxdropspeed;
	mindropspeed_cos = Cos( 3 );
	mindropspeed = 10;

	if ( IsDefined( current_node.script_speed ) )
		mindropspeed = current_node.script_speed;

	next_angle = get_next_angle( next_node );

	level.VehPhys_SetConveyorBelt_speed = 4;

	flag_wait( "player_on_boat" );

	level.players_boat endon( "death" );

	level endon( "player_over_the_waterfall" );
	level endon( "water_cliff_jump_splash_sequence" );

	childthread river_current_apply();

	flat_angle = ( 0, 0, 0 );

	while ( 1 )
	{
		dot = get_dot( next_node.origin, next_angle, level.players_boat.origin );
		if ( dot < 0 )
		{
//			draw_arrow( current_node.origin , next_node.origin, (0,1,0) );

			dot = get_dot( current_node.origin, flat_angle( VectorToAngles( next_node.origin - current_node.origin ) ), level.players_boat.origin );
			if ( dot > 0 )
			{
				wait .05;
				continue;
			}
			else
			{
				current_node = getstruct( current_node.targetname, "target" );
				if ( !isdefined( current_node ) )
				{
					current_node = getstruct( next_node.targetname, "target" );// reset to the first node..
					level.players_boat thread conveyerbelt_speed( flat_angle[ 1 ], 0, CONVEYER_RATE );
				}
			}
		}
		else
		{
			current_node = next_node;
		}

		if ( IsDefined( current_node.script_speed ) )
			mindropspeed = current_node.script_speed;
		if ( !isdefined( current_node.target ) )
			break;

		if ( mindropspeed > maxdropspeed_lower_cap )
			maxdropspeed = mindropspeed + 20;
		else
			maxdropspeed = maxdropspeed_lower_cap;
		next_node = getstruct( current_node.target, "targetname" );
		if ( !isdefined( next_node ) )
		{
			next_node = current_node;
			current_node = getstruct( next_node.targetname, "target" );// keep cycling the last section in this case.
			wait .05;
			continue;
		}

		if ( IsDefined( next_node.target ) )
			next_angle = get_next_angle( next_node );

		speed = mindropspeed;
		flat_angle =  flat_angle( VectorToAngles( next_node.origin - current_node.origin ) );

		dot = get_dot( current_node.origin, flat_angle, next_node.origin );
		dot = abs( dot );

		if ( dot > mindropspeed_cos )
			speed = mindropspeed;
		else if ( dot < maxdropspeed_cos )
			speed = maxdropspeed;
		else
			speed = maxdropspeed_cos / dot * maxdropspeed;

		level.boatdropspeed = speed;
		level.players_boat childthread conveyerbelt_speed( flat_angle[ 1 ], speed, CONVEYER_RATE );

		wait .05;
	}
	level.players_boat childthread conveyerbelt_speed( 0, 0, CONVEYER_RATE );
}

river_current_apply()
{

	if ( !isdefined( level.VehPhys_SetConveyorBelt_speed_fraction ) )
		level.VehPhys_SetConveyorBelt_speed_fraction = 1;

	while ( !isdefined( level.vehphys_setconveyorbelt_yaw ) )
		wait .05;

	level.players_boat endon( "death" );

	while ( 1 )
	{
		level.players_boat conveyerbelt_player_speed_mod();
		wait .05;
	}
}

get_next_angle( current_node, currentangles )
{
	next_node = getstruct( current_node.target, "targetname" );
	Assert( IsDefined( next_node ) );
	return VectorToAngles( next_node.origin - current_node.origin );
}

enable_bread_crumb_chase()
{
	s = SpawnStruct();
	s.checkdepth = 3;// how far up the chain do I crawl to see if we're caught up.
	s.fail_time = 10;// how far behind the player is allowed to trail..

	level endon( "quit_bread_crumb" );

	level.breadcrumb_settings = s;

	level.breadcrumb = [];

//	thread bread_crumb_button();

	while ( 1 )
	{
		bread_crumb_chase();
		wait .05;
	}
}

set_breadcrumb_fail_time( fail_time, transition_time )
{
	if ( !isdefined( transition_time ) )
	{
		level.breadcrumb_settings.fail_time = fail_time;
		return;
	}

	level notify( "set_breadcrumb_fail_time" );
	level endon( "set_breadcrumb_fail_time" );

	last_time = level.breadcrumb_settings.fail_time;
	increase_time_by = fail_time - last_time;
	increments = transition_time * 20;
	inc_step = increase_time_by / increments;

	for ( i = 0; i < increments; i++ )
	{
		level.breadcrumb_settings.fail_time += inc_step;
		wait .05;
	}

	level.breadcrumb_settings.fail_time = fail_time;

}

bread_crumb_button()
{
	while ( 1 )
	{
		while ( !level.player ButtonPressed( "BUTTON_Y" ) )
			wait .05;
		if ( flag( "debug_crumbs" ) )
			flag_clear( "debug_crumbs" );
		else
			flag_set( "debug_crumbs" );
		while ( level.player ButtonPressed( "BUTTON_Y" ) )
			wait .05;
	}
}

test_m203()
{
	level.price endon( "death" );
	effect = LoadFX( "muzzleflashes/m203_flshview" );
	while ( ! flag( "exit_caves" ) )
	{
		start = level.price GetTagOrigin( "tag_flash" );
		angles = level.price GetTagAngles( "tag_flash" );
		if ( level.price has_good_enemy_for_grenade_launcher( start, angles ) )
		{
			 PlayFXOnTag( effect, level.price, "tag_flash" );
			shootpos = level.price.enemy GetShootAtPos() + ( 0, 0, 150 );
			if ( Distance( level.price.origin, level.price.enemy.origin ) > 1700 )
				shootpos += ( 0, 0, 150 );// I'm just guessing here.  magical numbers make grenads go farther..
			MagicBullet( "m203", start, shootpos );
			wait 2.5;
		}
		wait .05;
	}
}

test_m203_again()
{
	level.price endon( "death" );
	effect = LoadFX( "muzzleflashes/m203_flshview" );
	while ( 1 )
	{
		start = level.price GetTagOrigin( "tag_flash" );
		angles = level.price GetTagAngles( "tag_flash" );
		if ( level.price has_good_enemy_for_grenade_launcher( start, angles ) )
		{
			 PlayFXOnTag( effect, level.price, "tag_flash" );
			shootpos = level.price.enemy GetShootAtPos() + ( 0, 0, 190 );
			if ( Distance( level.price.origin, level.price.enemy.origin ) > 1700 )
				shootpos += ( 0, 0, 120 );// I'm just guessing here.  magical numbers make grenads go farther..
			MagicBullet( "m203", start, shootpos );
			wait 2.5;
		}
		wait .05;
	}
}

FOV_M203 = 0.965925;// Cos( 15 )
DIST_M203_SQRD = 650 * 650;

//good_spot_for_grenade_launcher

has_good_enemy_for_grenade_launcher( start, angles )
{
	if ( !isdefined( self.enemy ) )
		return false;
	if ( ! DistanceSquared( start, self.enemy.origin ) > DIST_M203_SQRD )
		return false;
	if ( ! within_fov( start, angles, self.enemy GetShootAtPos(), FOV_M203 ) )
		return false;

	good_spot_for_grenade_launcher = getstructarray( "good_spot_for_grenade_launcher", "targetname" );
	foreach ( spot in good_spot_for_grenade_launcher )
	{
		Assert( IsDefined( spot.radius ) );
		if ( Distance( spot.origin, self.enemy.origin ) < spot.radius )
			if ( ! burning_barrel_in_spots_radius( spot ) )
				return true;
	}

	return false;
}

burning_barrel_in_spots_radius( spot )
{
	barrels = GetEntArray( "explodable_barrel", "targetname" );
	squaredist = spot.radius * spot.radius;
	foreach ( barrel in barrels )
	{
		if ( DistanceSquared( spot.origin, barrel.origin ) > squaredist )
			continue;
		if ( barrel.damagetaken )
			return true;
	}
	return false;
}

price_position_switch()
{
	Assert( IsDefined( self.script_noteworthy ) );

	self waittill( "trigger" );

	level.price.scripted_boat_pose = self.script_noteworthy;
}

bobbing_boat_spawn()
{
	self VehPhys_Crash();
}

in_front( ent1, ent2 )
{
	return get_dot( ent1.origin, ent1.angles, ent2.origin ) > 0 ;
}

in_front_by_velocity( ent1, ent2 )
{
	return get_dot( ent1.origin, VectorToAngles( ent1 Vehicle_GetVelocity() ), ent2.origin ) > 0 ;
}

delete_when_not_in_view()
{
	cosa = Cos( 55 );
	while ( within_fov_of_players( self.origin, cosa ) )
		wait .05;
	self Delete();
}

//movewithrate( dest, destang, moverate, endrate, gravity, accelfraction, decelfraction )
movewithrate( dest, moverate, accelfraction, decelfraction )
{
	self notify( "newmove" );
	self endon( "newmove" );

	if ( !isdefined( accelfraction ) )
		accelfraction = 0;
	if ( !isdefined( decelfraction ) )
		decelfraction = 0;
	self.movefinished = false;
	// moverate = units / persecond
	if ( !isdefined( moverate ) )
		moverate = 200;

	dist = Distance( self.origin, dest );
	movetime = dist / moverate;
	movevec = VectorNormalize( dest - self.origin );

	accel = 0;
	decel = 0;

	if ( accelfraction > 0 )
		accel = movetime * accelfraction;
	if ( decelfraction > 0 )
		decel = movetime * decelfraction;

	self MoveTo( dest, movetime, accel, decel );
//	self RotateTo( destang, movetime, accel, decel );
	wait movetime;

	if ( !isdefined( self ) )
		return;
	self.velocity = movevec * ( dist / movetime );
	self.movefinished = true;
}

price_anim_single_on_boat( anim_scene, relink )
{
	self endon( "death" );
	if ( !isdefined( relink ) )
		relink  = true;

	level.price notify( "new_price_anim_single_on_boat" );
	level.price endon( "new_price_anim_single_on_boat" );

	flag_set( "price_anim_on_boat" );

	level.price radio_dialogue_stop();
	level.price LinkTo( level.players_boat, "tag_guy2" );
	level.players_boat anim_generic_queue( level.price, anim_scene, "tag_guy2" );

	if ( ! relink )
		return;// assuming a looped anim call follows

	price_link_and_think();

	flag_clear( "price_anim_on_boat" );
}

price_anim_loop_on_boat( anim_scene, notify_str, relink )
{
	if ( !isdefined( relink ) )
		relink  = true;

	level.price notify( "new_price_anim_single_on_boat" );
	level.price endon( "new_price_anim_single_on_boat" );

	level.players_boat thread anim_generic_loop( level.price, anim_scene, notify_str, "tag_guy2" );

	level.players_boat waittill( notify_str );

	if ( relink )
		price_link_and_think();

	flag_clear( "price_anim_on_boat" );
}


boatrider_link( vehicle )
{
	self LinkToBlendToTag( vehicle, "tag_guy2", false );

}


boatrider_think( vehicle )
{
	boatrider_link( vehicle );

	self AllowedStances( "crouch" );
	self.vehicle = vehicle;
	self.force_canAttackEnemyNode = true;

	self thread boatrider_targets();
	self.fullAutoRangeSq = 2000 * 2000;

	// make Price know about all enemies (helps enemy selection when moving fast)
	self.highlyAwareRadius = 2048;

	self AnimCustom( maps\_zodiac_ai::think );
}


boatrider_targets()
{
	level.price endon( "stop_boatrider_targets" );
	level.price endon( "death" );
	while ( 1 )
	{
		wait .05;
		end = level.price maps\_zodiac_drive::drive_magic_bullet_get_end( level.players_boat, level.player GetEye(), true );// piggyback this functionality. Price finds the same targets interesting.

		if ( !isdefined( end.obj ) )
		{
			level.price ClearEntityTarget();
			continue;
		}
		if ( !isai( end.obj ) )
		{
			level.price SetEntityTarget( end.obj );
			level.price.favoriteenemy = undefined;
			if ( IsDefined( end.shootable_driver ) )
				end.obj thread enable_shoot_driver();
		}
		else
		{
			level.price ClearEntityTarget();
			level.price.favoriteenemy = end.obj;
		}
	}
}


enable_shoot_driver()
{
	self notify( "enable_shoot_driver" );
	self endon( "enable_shoot_driver" );

	self.allowdeath = 1;
	self SetCanDamage( true );

	self waittill( "damage" );
	maps\_zodiac_drive::driver_death( self );
}



price_link_and_think()
{
	level.price boatrider_link( level.players_boat );
	level.price AnimCustom( maps\_zodiac_ai::think );
}

player_lerplink_fov( opts )
{
	time = opts.time;
	ent = opts.ent;
	tag = opts.tag;
	base_fov = opts.base_fov;
	dest_fov = opts.dest_fov;

	level.player FreezeControls( true );
	// this is ghetto hack..
	Assert( time > 0.0 );
	timeincs = time * 20;
	current_fov = base_fov;
	fov_dif = dest_fov - base_fov;
	fov_inc = fov_dif / timeincs;
	timeincs = Int( timeincs );

	for ( i = 0; i < timeincs; i++ )
	{
		current_fov += fov_inc;
		level.player PlayerLinkToDelta( ent, tag, 1, current_fov, current_fov, current_fov, current_fov );
		wait .05;
	}
	level.player FreezeControls( false );
}

trigger_thread_the_needle()
{
	targetent = getstruct( self.target, "targetname" );
	Assert( IsDefined( targetent ) );

	self waittill( "trigger" );

	normal = VectorNormalize( self.origin - targetent.origin );
	forward = VectorNormalize( level.players_boat Vehicle_GetVelocity() );
	dot = VectorDot( forward, normal );

	if ( dot > 0.984807 )// cos 10
		level.price radio_dialogue( "afchase_pri_threadtheneedle", 1 );
}

_objective_onentity( id, ent )
{
	Objective_OnEntity( id, ent, ( 0, 0, 80 ) );
	ent waittill( "death" );
	Objective_Position( id, ( 0, 0, 0 ) );

	/*
	ent endon( "death" );
	while ( 1 )
	{
		eye_pos = level.player GetEye();
		Objective_Position( id, (ent.origin[0],ent.origin[1],eye_pos[2]) );
		wait .05;
	}
	*/
}

crashable_whizby_boats()
{
	self.veh_pathtype = "follow";
	self VehPhys_EnableCrashing();
	while ( 1 )
	{
		self waittill( "veh_jolt" );// veh_collision wasn't working, just make it crash when it jolts around the player that should do.
		if ( Distance( self.origin, level.player.origin ) < 512 )
			break;
	}
	self VehPhys_Crash();
}

get_farthest_struct( org, array )
{
	if ( array.size < 1 )
		return;

	dist = DistanceSquared( array[ 0 ].origin, org );
	ent = array[ 0 ];
	for ( i = 0; i < array.size; i++ )
	{
		newdist = DistanceSquared( array[ i ].origin, org );
		if ( newdist < dist )
			continue;
		dist = newdist;
		ent = array[ i ];
	}
	return ent;
}

ignoreall_till_not_touch( guy )
{
	prevteam = guy.team;
	guy endon( "death" );
	guy.ignoreall = true;
	while ( guy IsTouching( self ) )// teehee
		wait .05;
	guy.ignoreall = false;
}

dump_on_command()
{
	while ( 1 )
	{
		while ( ! level.player ButtonPressed( "BUTTON_B" ) )
			wait .05;
		vehicle_dump();
		while ( level.player ButtonPressed( "BUTTON_B" ) )
			wait .05;

	}
}

set_lerp_opts( time, ent, tag, base_fov, dest_fov )
{
	opts = SpawnStruct();
	opts.time = time;
	opts.ent = ent;
	opts.tag = tag;
	opts.base_fov = base_fov;
	opts.dest_fov = dest_fov;
	return opts;
}

player_full_heath()
{
	return level.player.health / level.player.maxhealth == 1;
}

trigger_neutral_enemies()
{
	while ( 1 )
	{
		self waittill( "trigger", other );
		if ( !isalive( other ) )
			continue;

		if ( !first_touch( other ) )
			continue;

		thread ignoreall_till_not_touch( other );
	}
}

draw_arrow_forward()
{
	self endon( "death" );
	while ( 1 )
	{
		draw_arrow( self.origin, self.origin + AnglesToForward( self.angles ) * 200, ( 0, 0, 1 ) );
		wait .05;
	}
}

dvar_warn()
{
	if ( ! GetDvarInt( "scr_zodiac_test" ) )
		return;
	wait 3;
	IPrintLnBold( "you will need to reset scr_zodiac_test to play the level normally again ( restart the game )" );
}

get_boat_rider( num )
{
	if ( !isdefined( level.boatrider ) )
		level.boatrider = [];
	else
	if ( IsDefined( level.boatrider[ num ] ) )
		return level.boatrider[ num ];

	level.boatrider[ num ] = spawn_targetname( num, true );
	level.boatrider[ num ] magic_bullet_shield();
	level.boatrider[ num ] disable_pain();
	level.boatrider[ num ].ignoreSuppression = true;
	level.boatrider[ num ] set_battlechatter( false );  // got enough chatter on the boat.
	return level.boatrider[ num ];
}





set_price_auto_switch_pose()
{
	level.price.scripted_boat_pose = undefined;
	level.price.use_auto_pose = true;
}

ZODIAC_DIALOGUE_RANGE = 3000 * 3000;
zodiac_enemy_setup()
{
	self.dontunloadonend = true;
//	self thread zodiac_monitor_player_trailing_time();
	foreach ( rider in self.riders )
	{
		rider thread zodiac_boat_ai( self );
	}
	flag_wait( "player_on_boat" );

	self endon( "death" );
	level.players_boat endon( "death" );


	while ( 1 )
	{
		start_origin = level.players_boat.origin;
		end_origin = self.origin;
//		normal = VectorNormalize( end_origin - start_origin );
//		forward = AnglesToRight( level.players_boat.angles );
//		dot = VectorDot( forward, normal );

		if ( DistanceSquared( self.origin, level.players_boat.origin ) > ZODIAC_DIALOGUE_RANGE )
		{
			wait .05;
			continue;
		}

		level.dialog_dir = animscripts\battlechatter::getDirectionFacingClock( level.players_boat.angles, start_origin, end_origin );
		level notify( "dialog_direction" );
		wait .05;
	}
}

exp_fade_overlay( target_alpha, fade_time )
{
	self notify( "exp_fade_overlay" );
	self endon( "exp_fade_overlay" );

	fade_steps = 4;
	step_angle = 90 / fade_steps;
	current_angle = 0;
	step_time = fade_time / fade_steps;

	current_alpha = self.alpha;
	alpha_dif = current_alpha - target_alpha;

	for ( i = 0; i < fade_steps; i++ )
	{
		current_angle += step_angle;

		self FadeOverTime( step_time );
		if ( target_alpha > current_alpha )
		{
			fraction = 1 - Cos( current_angle );
			self.alpha = current_alpha - alpha_dif * fraction;
		}
		else
		{
			fraction = Sin( current_angle );
			self.alpha = current_alpha - alpha_dif * fraction;
		}

		wait step_time;
	}
}


handle_fire_missiles()
{
	self endon( "death" );
	level.players_boat endon( "death" );

	while ( 1 )
	{
		dofire = true;
		predictorg = fire_volley_of_missiles_predict( level.players_boat Vehicle_GetVelocity() );
//		draw_arrow( self.origin, predictorg, (1,0,0) );
		if ( !within_fov_2d( self.origin, self.angles, predictorg, 0.984807753 ) )
			dofire = false;
		if ( Distance( self.origin, predictorg ) < 2000 )
			dofire = false;
		if ( Distance( self.origin, predictorg ) > 5000 )
			dofire = false;
		if ( ! player_full_heath() )
			dofire = false;

		if ( dofire )
		{
			thread fire_volley_of_missiles_at_player();
			flag_waitopen( "heli_firing" );
			wait RandomFloatRange( 1.2, 2.4 );
		}
		wait .05;
	}
}

fire_volley_of_missiles_predict( velocity )
{
	return level.players_boat.origin + ( velocity * 1.50 );// guessing
}

dialog_fire_volley_of_missiles_at_player( base_origin )
{
	if ( flag( "rapids_trigger" ) )
		return;
	normal = VectorNormalize( base_origin - level.players_boat.origin );
	forward = AnglesToRight( level.players_boat.angles );
	dot = VectorDot( forward, normal );
	if ( dot < 0 )
	{
		if ( cointoss() )
			level.price thread generic_dialogue_queue( "afchase_pri_rightright", .5 );
		else
			level.price thread generic_dialogue_queue( "afchase_pri_right", .5 );

	}
	else
	{
		if ( cointoss() )
			level.price thread generic_dialogue_queue( "afchase_pri_leftleft", .5 );
		else
			level.price thread generic_dialogue_queue( "afchase_pri_left", .5 );
	}

}

fire_volley_of_missiles_at_player()
{
	if ( !isalive( self ) )
		return;

	if ( flag( "heli_firing" ) )
		return;
	flag_set( "heli_firing" );

	timer = GetTime() + 3000;

	if ( !isalive( self ) )
	{
			flag_clear( "heli_firing" );
			return;
	}

	number_of_shots = RandomIntRange( 4, 5 );
	velocity = level.players_boat Vehicle_GetVelocity();
	base_origin = fire_volley_of_missiles_predict( velocity );
	base_origin += flat_origin( randomvectorrange( -120, 120 ) );

	dialog_fire_volley_of_missiles_at_player( base_origin );


//	base_origin += ( 0, 0, 24 );
	shot_origin = base_origin;

	shotorgs = [];

	linkorg = Spawn( "script_origin", level.players_boat.origin );
	linkorg thread linkorg( level.players_boat );

//	if( IsDefined( level.players_boat ) )
//		thread draw_line_from_ent_to_ent_until_notify( linkorg , level.players_boat , 0 , 1 , 0 , linkorg , "balls" );

	for ( i = 0; i < number_of_shots; i++ )
	{
			shotorgs[ i ] = Spawn( "script_origin", shot_origin );
			shotorgs[ i ] LinkTo( linkorg );
			shot_origin += velocity * .1;
//			thread draw_line_from_ent_to_ent_until_notify( linkorg , shotorgs[i] , 1 , 0 , 1 , linkorg , "balls" );
	}

	tags = [];
	tags[ 0 ] = "tag_missile_right";
	tags[ 1 ] = "tag_missile_left";
	ents = [];


	for ( i = 0; i < number_of_shots; i++ )
	{
		if ( !isalive( self ) )
			break;
		self SetVehWeapon( "littlebird_FFAR" );
		self SetTurretTargetEnt( shotorgs[ i ] );
		missile = self FireWeapon( tags[ i % tags.size ], shotorgs[ i ], ( 0, 0, 0 ) );
		missile Missile_SetFlightmodeDirect();
		missile Missile_SetTargetEnt( shotorgs[ i ] );
		missile thread kill_rpg_shot_behind_player();
//		missile delayCall( 2.51, ::Missile_ClearTarget );
		wait RandomFloatRange( 0.2, 0.3 );
	}
	linkorg notify( "balls" );
	flag_clear( "heli_firing" );
	wait 15;
	foreach ( ent in shotorgs )
		ent Delete();
	linkorg Delete();
}

linkorg( linkent )
{
	self endon( "death" );
	linkent endon( "death" );
	offset = self.origin - linkent.origin;
	while ( 1 )
	{
		self MoveTo( linkent.origin + offset, .05, 0, 0 );
//		self.origin = linkent.origin + offset;
		wait .05;
	}
}


get_generic_anim( anime )
{
	return level.scr_anim[ "generic" ][ anime ];
}

cleanup_stuff_on_players_boat()
{
	level.players_boat notify( "cleanup" );
	if ( IsDefined( level.players_boat.gun_attached ) )
	{
		level.players_boat Detach( level.zodiac_gunModel, "tag_weapon_left" );
		level.players_boat.gun_attached = undefined;
	}
	level.players_boat Detach( level.zodiac_playerHandModel, "tag_player" );
}



TEST_FLIP = false;

flip_when_player_dies()
{
	level endon( "water_cliff_jump_splash_sequence" );

	if ( !TEST_FLIP )
		level.player waittill( "death" );

	if ( TEST_FLIP )
	{
		while ( ! level.player ButtonPressed( "BUTTON_B" ) )
			wait .05;
	}

	thread radio_dialogue_stop();

	set_water_sheating_time( "bump_small_player_dies", "bump_big_player_dies" );

	cleanup_stuff_on_players_boat();


	linkobj = Spawn( "script_model", level.player.origin );
	linkobj.angles = level.player.angles;
	linkobj Hide();
	linkobj SetModel( "zodiac_head_roller" );
	linkobj LinkTo( self, "tag_player", ( 0, 0, 60 ), ( 0, 0, 0 ) );

	offset_obj = Spawn( "script_model", level.player.origin );
	offset_obj SetModel( "zodiac_head_roller" );
	offset_obj LinkTo( linkobj, "tag_player", ( 0, 0, -60 ), ( 0, 0, 0 ) );
	offset_obj.angles = level.player.angles;
	offset_obj Hide();


	blend_time = 1;

	if ( TEST_FLIP )
	{
		level.player DismountVehicle();
		level.player.drivingVehicle = level.players_boat;

	}

	wait .1;

//	level.player PlayerLinkWeaponViewToDelta( linkobj, "tag_player", 1.0 );
	level.player PlayerLinkToDelta( offset_obj, "tag_player", 1.0, 0, 0, 0, 0 );
	level.player PlayerSetGroundReferenceEnt( offset_obj );


	boatvelocity = self Vehicle_GetVelocity();

	foreach ( rider in 	level.boatrider )
	{
		rider stop_magic_bullet_shield();
		rider Unlink();

		if ( IsDefined( rider.function_stack ) )
			rider function_stack_clear();
		rider Kill();
	}

//	if ( self Vehicle_GetSpeed() > 50 )
//		self VehPhys_Crash( true );
//	else if ( self Vehicle_GetSpeed() > 30 )
	self delayCall( .75, ::VehPhys_Crash );

//	wait 0.75;

	oldorg = self.origin;
	wait .1;
	linkobj Unlink();

	offset_vec = oldorg - self.origin;
	offset_launchpoint = ( 0, 0, 0 );
	//for spin
	offset_launchpoint = ( offset_vec[ 0 ] * 100, offset_vec[ 1 ] * 100, 0 );

	linkobj PhysicsLaunchServer( linkobj.origin + offset_launchpoint, 8 * boatvelocity + ( 0, 0, 500 ) );

	lastorg = ( 0, 0, 0 );

	while ( lastorg != linkobj.origin )
	{
		lastorg = linkobj.origin;
		wait .05;
	}
}


node_can_reach_spot_infront_of_player( basenode )
{
	//might check basenode moveability
	nodearray = GetNodesInRadius( level.player.origin, 800, 500, 1000, "path" );
	forward = AnglesToForward( level.player.angles );
	foreach ( node in nodearray )
	{
		normal = VectorNormalize( node.origin - level.player.origin );
		dot = VectorDot( forward, normal );
		if ( dot > Cos( 15 ) )
		{
			level.node_to_reach = node;// in a spawn function
			return true;
		}
	}
	return false;
}


find_good_node_for_price_to_spawn_at()
{
	nodearray = GetNodesInRadius( level.player.origin, 230, 100, 1000, "path" );
	forward = AnglesToForward( level.player.angles );
	foreach ( node in nodearray )
	{
		normal = VectorNormalize( node.origin - level.player.origin );
		dot = VectorDot( forward, normal );
		//should spawn on the periphery
		if ( dot < Cos( 45 ) && dot > 0 && node_can_reach_spot_infront_of_player( node ) )
			return node;
	}
}

lower_accuracy_behind_player()
{
	self endon( "death" );
	originalbaseaccuracy = self.baseaccuracy;
	wait .1;// just in case I'm first.
	if ( !isdefined( level.players_boat ) )
		return;// craziness keeps goiing.
	level.players_boat endon( "death" );

	if ( IsDefined( self.ridingVehicle ) && IsSubStr( self.ridingvehicle.classname, "zodiac" ) )
		return;
	if ( IsSubStr( self.classname, "shepherd" ) )
		return;

	while ( 1 )
	{
		while ( boat_in_range_in_front( self ) )
			wait .05;
		self.baseaccuracy = 0;
		self.ignoreSuppression = false;
		while ( ! boat_in_range_in_front( self ) )
			wait .05;
		self.baseaccuracy = originalbaseaccuracy;
	}
}

/*
point_end( shepherd )
{
	Shepherd notify( "point_end" );
	controller = Shepherd getanim( "ending_additive_controller" );
	Shepherd ClearAnim( controller, 0.2 );
	shepherd SetLookAtEntity( level.player );
	//( position, turn acceleration );
}
*/


setup_boat_for_drive()
{
	self Vehicle_TurnEngineOff();
	self maps\_vehicle::godon();
	self MakeUnusable();
	level.players_boat = self;

	level.players_boat StartUsingHeroOnlyLighting();

	self SetModel( "vehicle_zodiac" );

	self waittill( "vehicle_mount", player );


	level.dofDefault[ "nearStart" ] = 10;
	level.dofDefault[ "nearEnd" ] = 20;

//	thread missile_repulser();

	level.price.orgmodel = level.price.model;
	
		
	level.price SetModel( "body_desert_tf141_zodiac" );
	hideTagList = GetWeaponHideTags( level.price.weapon );
	for ( i = 0; i < hideTagList.size; i++ )
		level.price HidePart( hideTagList[ i ], "weapon_m4" );

	self SetModel( "vehicle_zodiac_viewmodel" );

	self Vehicle_TurnEngineOn();

	flag_set( "player_on_boat" );

	thread autosave_by_name_silent( "mount_boat" );

	delayThread( 4, ::add_extra_autosave_check, "boat_check_player_speeding_along", ::autosave_boat_check_player_speeding_along, "players boat not moving fast enough!" );


	level.player ent_flag_clear( "near_death_vision_enabled" );

	thread dialog_boat_nag();

	thread dialog_boat_direction_nag();

	thread raise_attacker_accuracy_on_nearby_boats();

	thread rumble_with_throttle();

	thread flip_when_player_dies();

	thread zodiac_treadfx();

	boatrider = get_boat_rider( "boatrider0" );

	if ( ! boatrider ent_flag_exist( "price_animated_into_boat" ) )
		boatrider thread boatrider_think( self );
	else
	{
		boatrider ent_flag_wait( "price_animated_into_boat" );
		level notify( "stop_animate_price_into_boat" );
		level.price StopAnimScripted();
		level.price thread boatrider_think( level.players_boat );
	}
}

price_ai_mods( price )
{
	price.attackeraccuracy = 0;
	price.baseaccuracy = .1;
	price.ignoreSuppression = true;
	price.dontavoidplayer = true;
	price.takedamage = false;
	price.suppressionwait = 0;
	price.pathrandompercent = 0;
	price.ignoreExplosionEvents = true;
	price disable_surprise();
	price.grenadeawareness = 0;
	price.ignoreme = true;
	price.IgnoreRandomBulletDamage = true;
	price.disableBulletWhizbyReaction = true;
	flag_wait( "player_on_boat" );
	price.baseaccuracy = 25;
}

players_boat()
{

}



change_target_on_vehicle_spawner( boat_targetname, boat_destination_node )
{
	boat = GetEnt( boat_targetname, "targetname" );
	destnode = GetVehicleNode( boat_destination_node, "targetname" );
	boat.target = destnode.targetname;
}

change_target_ent_on_vehicle_spawner( heli_targetname, boat_destination_node )
{
	boat = GetEnt( heli_targetname, "targetname" );
	destnode = GetEnt( boat_destination_node, "targetname" );
	boat.target = destnode.targetname;

	//this stuff should probably be in another function
	boat.origin = destnode.origin;
	boat.angles = destnode.angles;
	boat.speed = destnode.speed;
}

enemy_chase_boat()
{
	level.breadcrumb = [];
	level.enemy_boat = self;
	self endon( "death" );
	self VehPhys_DisableCrashing();
	self.veh_pathtype = "constrained";
	self thread zodiac_monitor_player_trailing_time();

	foreach ( rider in self.riders )
	{
		if ( IsDefined( rider.magic_bullet_shield ) && rider.magic_bullet_shield )
			continue;
		rider thread magic_bullet_shield();
	}

//	self.veh_pathtype = "follow";
	while ( 1 )
	{
		wait .25;
		enemy_chase_boat_breadcrumb();
	}
}

boat_common()
{
	if( ! is_default_start() )
		maps\_friendlyfire::TurnOff();
	boatrider = get_boat_rider( "boatrider0" );
	level.price = boatrider;
	thread price_ai_mods( boatrider );
	thread test_m203();

	kill_ai_in_volume = GetEntArray( "kill_ai_in_volume", "targetname" );
	array_thread( kill_ai_in_volume, ::kill_ai_in_volume );
}

rpg_bridge_guy()
{
	trigger = Spawn( "trigger_radius", self.origin + ( 0, 0, -2000 ), 0, 4500, 2000 );
	trigger waittill( "trigger" );
	level notify( "dialog_rpg_bridge_guy" );
}

rpg_bridge_guy_target()
{
	target_ent = Spawn( "script_origin", level.players_boat.origin );
	self ent_flag_init( "first_player_sighting" );
	self disable_long_death();
	self SetEntityTarget( target_ent );
	self.favoriteenemy = target_ent;
	self.ignoreall = true;
	self.rpg_setup_time = GetTime() + RandomIntRange( 1000, 2000 );// "reaction time so they don't instantly shoot when you round a corner.

	random_vec = flat_origin( randomvectorrange( -64, 64 ) );
	firing_range = 3000;
	while ( IsAlive( self ) )
	{
		velocity_offset = level.players_boat Vehicle_GetVelocity() * 1.4 ;

//		target_ent.origin = level.players_boat.origin +( level.players_boat Vehicle_GetVelocity() * 1.89 );

		forward_origin = level.players_boat.origin + velocity_offset;
		forward_origin = set_z( forward_origin, level.players_boat.origin[ 2 ] + 24 );

//		Line( forward_origin, level.players_boat.origin, (0,1,0) );


		//when the player is headed towards something use the spline direction to influence the shot. otherwise fire away in the direct forward path.
		if ( ! BulletTracePassed( level.player GetEye() + ( 0, 0, 16 ), forward_origin, false, self ) )
		{
			offset = Distance( ( 0, 0, 0 ), velocity_offset );
			target_ent.origin = get_position_from_spline_unlimited( level.player.targ, level.player.progress + offset - level.POS_LOOKAHEAD_DIST, level.player.offset );
			target_ent.origin = set_z( target_ent.origin, level.players_boat.origin[ 2 ] + 24 );
//			Line( target_ent.origin, level.players_boat.origin, (0,0,1) );
			target_ent.origin = ( target_ent.origin + forward_origin ) / 2;
		}
		else
		{
			target_ent.origin = forward_origin;
		}

//		Line( target_ent.origin, level.players_boat.origin, (1,0,0) );
		self OrientMode( "face point", target_ent.origin ) ;

		bullettraced_to_player = false;
		if ( BulletTracePassed( self GetTagOrigin( "tag_flash" ), level.player GetEye(), false, self ) )
		{
			bullettraced_to_player = true;
			if ( ! ent_flag( "first_player_sighting" ) )
				ent_flag_set( "first_player_sighting" );
		}

		if ( ! ent_flag( "first_player_sighting" ) )
			self.rpg_setup_time = GetTime() + RandomIntRange( 1000, 2000 );// "reaction time so they don't instantly shoot when you round a corner.

		if ( GetTime() > self.rpg_setup_time )
			if ( bullettraced_to_player )
				if ( BulletTracePassed( self GetTagOrigin( "tag_flash" ), target_ent.origin + random_vec, false, self ) )
					if ( Distance( self.origin, level.player.origin ) < firing_range )
						if ( GetTime() > level.next_rpg_firetime )
							break;

		wait .05;
	}

	ammo = "rpg_straight_af_chase";
//	if( cointoss() )
//		ammo = "rpg";

	if ( IsDefined( self ) && IsDefined( self GetTagOrigin( "tag_flash" ) ) )// Tried isalive . debugger is broken today = ( .
	{
		rpg_shot = MagicBullet( ammo, self GetTagOrigin( "tag_flash" ), target_ent.origin + random_vec );
		rpg_shot thread kill_rpg_shot_behind_player();
	}
	level.next_rpg_firetime = GetTime() + RandomIntRange( 300, 500 );// stagger time between multiple guys
	target_ent Delete();
}

kill_rpg_shot_behind_player()
{
	level.players_boat endon( "death" );
	self endon( "death" );
	while ( in_front( level.player, self ) )
		wait .05;
	thread play_sound_in_space( "rocket_explode_water" );
	self Delete();
}



set_price_autoswitch_after_caves()
{
	flag_wait( "exit_caves" );
	set_price_auto_switch_pose();
}


teleport_price_on_mount( node )
{
	level endon( "end_teleport_price_on_mount" );
	level.players_boat waittill( "vehicle_mount" );
	level.price teleport_ai_here( node );
}

teleport_ai_here( eNode )
{
	AssertEx( IsAI( self ), "Function teleport_ai can only be called on an AI entity" );
	AssertEx( IsDefined( eNode ), "Need to pass a node entity to function teleport_ai" );
	self ForceTeleport( eNode.origin, eNode.angles );
	self SetGoalPos( self.origin );
}



dialog_boat_battlechatter()
{

	dialog_direction = [];
	dialog_direction = array_add( dialog_direction, "TF_pri_callout_targetclock_" );

	dialog_helicopter_six = [];
	dialog_helicopter_six = array_add( dialog_helicopter_six, "afchase_pri_evasive" );
	dialog_helicopter_six = array_add( dialog_helicopter_six, "afchase_pri_shakeemoff" );
	dialog_helicopter_six = array_add( dialog_helicopter_six, "afchase_pri_miniguns" );

	dialog_helicopter_ahead = [];
	dialog_helicopter_ahead = array_add( dialog_helicopter_ahead, "afchase_pri_dodgeheli" );
	dialog_helicopter_ahead = array_add( dialog_helicopter_ahead, "afchase_pri_gunsspinup" );
	dialog_helicopter_ahead = array_add( dialog_helicopter_ahead, "afchase_pri_steerclear" );

	dialog_rpg_bridge_guy = [];
	dialog_rpg_bridge_guy = array_add( dialog_rpg_bridge_guy, "afchase_pri_rpgsonbridge" );

	dialog = [];
	dialog[ "dialog_direction" ] = 	dialog_direction;
	dialog[ "dialog_helicopter_six" ] = 	dialog_helicopter_six;
	dialog[ "dialog_helicopter_ahead" ] = 	dialog_helicopter_ahead;
	dialog[ "dialog_rpg_bridge_guy" ] = 	dialog_rpg_bridge_guy;

	timeout[ "dialog_direction" ] = .5;
	timeout[ "dialog_helicopter_six" ] = 1;
	timeout[ "dialog_helicopter_ahead" ] = 1;
	timeout[ "dialog_rpg_bridge_guy" ] = .7;

	nagtime[ "dialog_direction" ] = 5500;
	nagtime[ "dialog_helicopter_six" ] = 9300;
	nagtime[ "dialog_helicopter_ahead" ] = 2000;
	nagtime[ "dialog_rpg_bridge_guy" ] = 10000;

	last_nagtime[ "dialog_direction" ] = GetTime();
	last_nagtime[ "dialog_helicopter_six" ] = GetTime();
	last_nagtime[ "dialog_helicopter_ahead" ] = GetTime();
	last_nagtime[ "dialog_rpg_bridge_guy" ] = GetTime();

	unused_dialog = dialog;

	picked = undefined;

	wait 1;// let enemy boat get defined..

	/#
	if ( GetDvarInt( "scr_zodiac_test" ) )
		return;
	#/
	
	level endon( "price_stops_talking_about_helicopters" );

	level.player endon( "death" );
	self endon( "death" );
	flag_wait( "exit_caves" );
	while ( 1 )
	{
		type = level waittill_any_return( "dialog_direction", "dialog_helicopter_six", "dialog_helicopter_ahead", "dialog_rpg_bridge_guy" );
		if ( flag( "price_anim_on_boat" ) )
			continue;
		if ( flag( "rapids_head_bobbing" ) )
			continue;
		picked = random( unused_dialog[ type ] );

		if ( GetTime() - last_nagtime[ type ] < nagtime[ type ] )
			continue;

		last_nagtime[ type ] = GetTime();

		if ( type == "dialog_direction" )
			level.price thread generic_dialogue_queue( picked + level.dialog_dir, timeout[ type ] );
		else
			level.price thread generic_dialogue_queue( picked, timeout[ type ] );


		unused_dialog[ type ] = array_remove( unused_dialog[ type ], picked );
		if ( !unused_dialog[ type ].size )
			unused_dialog[ type ] = dialog[ type ];
		wait .05;
		if ( flag( "player_in_sight_of_boarding" ) )
			return;
	}
}

dialog_boat_nag()
{
	nagtime = 8000;
	next_nag = GetTime() + nagtime;

	dialog = [];
	dialog = array_add( dialog, "afchase_pri_gettingaway" );
	dialog = array_add( dialog, "afchase_pri_gogogo" );
	dialog = array_add( dialog, "afchase_pri_cantlet" );
	dialog = array_add( dialog, "afchase_pri_losinghim" );
	dialog = array_add( dialog, "afchase_pri_drivingtheboat" );
	dialog = array_add( dialog, "afchase_pri_fullpower" );

	unused_dialog = dialog;

	picked = undefined;

	self endon( "death" );
	level.price endon( "death" );
	

	while ( 1 )
	{
		if ( bread_crumb_get_player_trailing_fraction() > .5 && next_nag < GetTime() && ! level.price ent_flag( "transitioning_positions" ) )
		{
			picked = random( unused_dialog );
//			level.price thread radio_dialogue( picked );
			side = level.price.a.boat_pose;
			Assert( IsDefined( side ) && ( side == "left" || side == "right" ) );

			doradio = false;

			if ( level.price.a.lastShootTime > GetTime() - 2000 && ! player_full_heath() )
				doradio = true;
			if ( flag( "rapids_head_bobbing" ) )
			{
				wait .05;
				continue;
			}

			if ( doradio )
				level.price thread generic_dialogue_queue( picked, 1 );
			else
				level.price thread price_anim_single_on_boat( side + "_" + picked );

			unused_dialog = array_remove( unused_dialog, picked );
			next_nag = GetTime() + nagtime;
			if ( !unused_dialog.size )
				unused_dialog = dialog;
		}
		wait .05;
		if ( flag( "stop_boat_dialogue" ) )
			return;
	}
}


dialog_cave()
{
	level.player endon( "death" );
	self waittill( "trigger" );
	level.price generic_dialogue_queue( "afchase_pri_thrucave" );
}



dialog_start()
{
//	thread add_dialogue_line( "Price", "They're just around the corner, come on." );
	level.price thread generic_dialogue_queue( "afchase_pri_aroundcorner" );
	wait 4;
//	thread add_dialogue_line( "Price", "We need to get on that boat. " );
	level.price thread generic_dialogue_queue( "afchase_pri_getonboat" );

	wait 2;
}

dialog_boat_direction_nag()
{
	nagtime = 4000;
	next_nag = GetTime() + nagtime;
	wrong_way_time = 2;
	wrong_way_time_count = 0;

	dialog = [];
	dialog = array_add( dialog, "afchase_pri_wrongway" );
	dialog = array_add( dialog, "afchase_pri_turntoobjective" );
	dialog = array_add( dialog, "afchase_pri_wheregoing" );

	unused_dialog = dialog;

	picked = undefined;

	wait 1;// let enemy boat get defined..

	/#
	if ( GetDvarInt( "scr_zodiac_test" ) )
		return;
	#/

	self endon( "death" );
	level.enemy_boat endon( "death" );
	level.player endon( "death" );
	
	while ( 1 )
	{
		if ( !in_front_by_velocity( level.players_boat, level.enemy_boat ) && next_nag < GetTime() )
			wrong_way_time_count += .05;
		else
			wrong_way_time_count = 0;

		if ( flag( "price_anim_on_boat" ) )
		{
			wait .05;
			continue;
		}

		if ( wrong_way_time_count > wrong_way_time )
		{
			picked = random( unused_dialog );
			level.price thread generic_dialogue_queue( picked );
			unused_dialog = array_remove( unused_dialog, picked );
			next_nag = GetTime() + nagtime;
			if ( !unused_dialog.size )
				unused_dialog = dialog;
		}

		wait .05;
		if ( flag( "stop_boat_dialogue" ) )
			return;
	}
}



animate_price_into_boat()
{
	level endon( "stop_animate_price_into_boat" );
	waittillframeend;// let players boat get spawned and defined
	pathnode = GetNode( self.target, "targetname" );
	node = Spawn( "script_origin", pathnode.origin );
	node.angles = pathnode.angles + ( 0, -90, 0 );
	level.price ent_flag_init( "price_animated_into_boat" );

	//make the scene stick to boat should player start to drive
	node delayCall( 2, ::linkto, level.players_boat );// give it time to settle before linking

	thread teleport_price_on_mount( node );
	node anim_generic_reach( level.price, "price_into_boat" );
	level notify( "end_teleport_price_on_mount" );
	level.price LinkTo( node );

	level.price delayThread( 1.5, ::ent_flag_set, "price_animated_into_boat" );// I timed this as a good cutoff point for when the player jumps in first.
	level.players_boat delayCall( 1, ::JoltBody, level.price.origin, .15 );
	level.players_boat delayThread( 1, ::play_sound_in_space, "water_boat_splash_small", level.players_boat.origin );

	node anim_generic( level.price, "price_into_boat" );
	level.price thread boatrider_think( level.players_boat );
}

search_the_scrash_site()
{
	GetEnt( "damaged_pavelow", "targetname" ) Hide();

	flag_wait( "end_heli_crashed" );
	exploder( "heli_fire" );
	damaged_heli = GetEnt( "damaged_pavelow", "targetname" );
	wait .5;
	damaged_heli Show();
	trigger = Spawn( "trigger_radius", damaged_heli.origin + ( 0, 0, -100 ), 0, 670, 600 );
	trigger waittill( "trigger" );
}



trigger_out_of_caves()
{
	self waittill( "trigger" );
	level.price thread generic_dialogue_queue( "afchase_pri_openareas" );
}

trigger_boat_mount()
{
	self waittill( "trigger" );

	if ( flag( "player_on_boat" ) )
		return;

	origin = level.players_boat GetTagOrigin( "tag_player" );
	angles = level.players_boat GetTagAngles( "tag_player" );
	level.player SwitchToWeapon( "uzi" );
	level.player FreezeControls( true );
	level.player PlayerLinkToBlend( level.players_boat, "tag_player", .35, .2, .1 );
	wait .35;
	level.player FreezeControls( false );
//	level.price ent_flag_wait( "price_animated_into_boat" );
	level.players_boat MakeUsable();
	level.players_boat UseBy( level.player );
	level.player.drivingVehicle = level.players_boat;
}




trigger_price_tells_player_go_right()
{
	self.origin += ( 0, 0, -50 );
	self waittill( "trigger" );
	level.price thread generic_dialogue_queue( "afchase_pri_right" );

}

hint_test()
{
	return player_steadies_boat();
}


trigger_end_caves()
{
	self waittill( "trigger" );
	flag_set( "exit_caves" );
	wait 1.1;

	thread maps\_utility::set_ambient( "af_chase_exit" );
	wait 3;
	SetSavedDvar( "sm_sunSampleSizeNear", "2" );
	if ( IsDefined( level.price ) )
			level.price DontCastShadows();

}

rope_splashers()
{
	self endon( "death" );
	wait .5;
	org_z = self.origin[ 2 ];

	while ( self.origin[ 2 ] == org_z )
		wait .1;

	self Kill();

//this might be cool if I could do client ragdoll..

//self waittill ( "death" );
//self endon ("death");
//
//ent = SpawnStruct();
//ent endon( "complete" );
//ent delayThread( 5, ::send_notify, "complete" );

//  while( self.origin[2] > 48 )
//  	wait .05;
//
//  PlayFX( getfx("body_falls_from_ropes_splash") , set_z( self.origin,48 ) );
// StartRagdoll();
}


trigger_set_max_zodiacs( value )
{
	self waittill( "trigger" );
	level.enemy_snowmobiles_max = value;
}

trigger_rapids()
{
	level.player endon( "death" );
	self waittill( "trigger" );
	flag_set( "rapids_trigger" );
	thread maps\_utility::set_ambient( "af_chase_rapids" );
	level.player.nooffset = true;// makes enemy boats spawn exactly behind the player.

	level.enemy_snowmobiles_max = 1;

	flag_set( "rapids_head_bobbing" );
//	price_anim_single_on_boat( "rapids_in", false );
	level.price generic_dialogue_queue( "afchase_pri_rapidsahead" );
	thread price_anim_loop_on_boat( "rapids_loop", "end_the_rapids_loop" );

	end_price_crazy = GetEnt( "end_price_crazy", "targetname" );
	end_price_crazy waittill( "trigger" );
	flag_clear( "rapids_head_bobbing" );

	level.players_boat notify( "end_the_rapids_loop" );
	level.enemy_snowmobiles_max = 2;

	wait 1;
	set_price_auto_switch_pose();

	// they get really bogged in so reduce them after a bit.
	wait 9;
	level.enemy_snowmobiles_max = 1;
}

trigger_on_river()
{
	self waittill( "trigger" );
	thread maps\_utility::set_ambient( "af_chase_river" );
	flag_set( "on_river" );
}


trigger_open_area()
{
	flag_wait( "exit_caves" );
	level endon ( "stop_deadquote_for_gettingout_of_bounds" );
	level.player endon( "death" );
	nagtime = GetTime() + 30000;
	while ( 1 )
	{
		SetDvar( "ui_deadquote", "" );
		level thread maps\_quotes::setDeadQuote();

		flag_clear( "player_in_open" );
		self waittill( "trigger" );
		while ( level.player IsTouching( self ) )
		{
			if ( GetTime() > nagtime )
			{
				nagtime = GetTime() + RandomFloatRange( 20000, 22000 );

				//Price: Stay clear of open areas as much as possible!
				level.price thread generic_dialogue_queue( "afchase_pri_openareas" );
			}
			flag_set( "player_in_open" );// done every frame to support overlap.
			level notify( "new_quote_string" );
			// Stay clear of open areas as much as possible!
			SetDvar( "ui_deadquote", &"AF_CHASE_MISSION_FAILED_IN_THE_OPEN" );
			wait .05;
		}
	}
}

/*
setDeadQuote()
{
	level endon( "mine death" );

	// kill any deadquotes already running
	level notify( "new_quote_string" );
	level endon( "new_quote_string" );

*/

sentry_technical_think()
{
	wait .5;
	turret = self.mgturret[ 0 ];
	turret SetMode( "manual_ai" );
	turret SetTargetEntity( level.player );

	foreach ( rider in self.riders )
	{
		rider.favoriteenemy = level.player;
		rider.maxsightdistsqrd = 20000 * 20000;
	}
}

sunsample_after_caves()
{
	flag_wait( "exit_caves" );
	SetSavedDvar( "sm_sunSampleSizeNear", "2" );
}


boatsquish()
{
	if ( IsDefined( level.noTankSquish ) )
	{
		AssertEx( level.noTankSquish, "level.noTankSquish must be true or undefined" );
		return;
	}

	if ( IsDefined( level.levelHasVehicles ) && !level.levelHasVehicles )
		return;
	self add_damage_function( ::boatsquish_damage_check );
	self remove_damage_function( maps\_spawner::tanksquish_damage_check );
}

boatsquish_damage_check( amt, who, force, b, c, d, e )
{
	if ( !isdefined( self ) )
	{
		return;
	}
	if ( IsAlive( self ) )
		return;

	if ( !isalive( who ) )
		return;
	if ( !isdefined( who.vehicletype ) )
		return;

	if ( who maps\_vehicle::ishelicopter() )
		return;

	if ( abs( self.origin[ 2 ] - level.players_boat.origin[ 2 ] ) > 64 )
	{
		self Delete();// these guys are getting  hit by the players tall boat collision.. just delete them so they don't fly over.
	}

	self thread boat_squish_ragdoll_or_bust();

	if ( !isdefined( self ) )
	{
		return;
	}
	self remove_damage_function( ::boatsquish_damage_check );

//		self PlaySound( "human_crunch" );
}

boat_squish_ragdoll_or_bust()
{
	make_room_for_priority_squished_guy_corpse();
	timer = GetTime() + 500;
	while ( GetTime() < timer )
	{
		if ( !isdefined( self ) )
			return;
		if ( self IsRagdoll() )
			return;
		self StartRagdoll();
		wait .05;
	}
	self Delete();
}

make_room_for_priority_squished_guy_corpse()
{
	corpses = GetCorpseArray();
	foreach ( corpse in corpses )
		if ( Distance( corpse.origin, level.player GetEye() ) > 600 )
			corpse Delete();

}


explode_barrels_in_radius_think()
{
	assert( isdefined( self.radius ) );

	shootable_stuff = GetEntArray( "explodable_barrel", "targetname" );
	flat_org = flat_origin ( self.origin );
	
	my_barrels = [];
	foreach ( thing in shootable_stuff )
	{
		if( distance( flat_org, flat_origin( thing.origin) ) < self.radius )
			my_barrels[ my_barrels.size ] = thing;
	}

	self waittill ( "trigger" );

	for ( i = 0; i < 10; i++ )
	{
		foreach( barrel in my_barrels )
			barrel notify( "damage", 50, level.player, (0,0,0), barrel.origin, "MOD_EXPLOSIVE" );
		wait .05;
		
	}
}

player_steadies_boat()
{
	return level.player ButtonPressed( "BUTTON_B" ) || 1;
}

remove_global_spawn_funcs()
{
	flag_wait( "water_cliff_jump_splash_sequence" );

	remove_global_spawn_function( "axis", ::lower_accuracy_behind_player );
	remove_global_spawn_function( "axis", ::set_fixed_node_after_seeing_player_spawn_func );
}