#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\bots\_bots;
#include maps\mp\bots\_bots_util;
#include maps\mp\bots\_bots_ks;

remote_vehicle_setup()
{
	while(!IsDefined(level.bot_variables_initialized))
		wait(0.05);
	
	if ( IsDefined(level.bot_initialized_remote_vehicles) )
		return;
	
	level.bot_ks_heli_offset["heli_pilot"] = (0,0,350);
	level.bot_ks_heli_offset["heli_sniper"] = (0,0,228);
	
	level.bot_ks_funcs["isUsing"]["odin_assault"] = ::isUsingRemote;
	level.bot_ks_funcs["isUsing"]["odin_support"] = ::isUsingRemote;
	level.bot_ks_funcs["isUsing"]["heli_pilot"] = ::isUsingRemote;
	level.bot_ks_funcs["isUsing"]["heli_sniper"] = maps\mp\killstreaks\_killstreaks::isUsingHeliSniper;
	level.bot_ks_funcs["isUsing"]["switchblade_cluster"] = ::isUsingRemote;
	level.bot_ks_funcs["isUsing"]["vanguard"] = ::isUsingVanguard;
	level.bot_ks_funcs["waittill_initial_goal"]["heli_pilot"] = ::heli_pilot_waittill_initial_goal;
	level.bot_ks_funcs["waittill_initial_goal"]["heli_sniper"] = ::heli_sniper_waittill_initial_goal;
	level.bot_ks_funcs["control_aiming"]["heli_pilot"] = ::heli_pilot_control_heli_aiming;
	level.bot_ks_funcs["control_aiming"]["heli_sniper"] = ::empty_init_func;
	level.bot_ks_funcs["control_aiming"]["vanguard"] = ::vanguard_control_aiming;
	level.bot_ks_funcs["control_other"]["heli_pilot"] = ::heli_pilot_monitor_flares;
	level.bot_ks_funcs["heli_pick_node"]["heli_pilot"] = ::heli_pilot_pick_node;
	level.bot_ks_funcs["heli_pick_node"]["heli_sniper"] = ::heli_sniper_pick_node;
	level.bot_ks_funcs["heli_pick_node"]["vanguard"] = ::vanguard_pick_node;
	level.bot_ks_funcs["heli_node_get_origin"]["heli_pilot"] = ::heli_get_node_origin;
	level.bot_ks_funcs["heli_node_get_origin"]["heli_sniper"] = ::heli_get_node_origin;
	level.bot_ks_funcs["heli_node_get_origin"]["vanguard"] = ::vanguard_get_node_origin;
	level.bot_ks_funcs["odin_perform_action"]["odin_assault"] = ::odin_assault_perform_action;
	level.bot_ks_funcs["odin_perform_action"]["odin_support"] = ::odin_support_perform_action;
	level.bot_ks_funcs["odin_get_target"]["odin_assault"] = ::odin_assault_get_target;
	level.bot_ks_funcs["odin_get_target"]["odin_support"] = ::odin_support_get_target;
	
	all_heli_nodes = GetStructArray("so_chopper_boss_path_struct","script_noteworthy");
	level.bot_heli_nodes = [];
	foreach ( heli_node in all_heli_nodes )
	{
		// Start nodes (which don't have a script_linkname) aren't used by bots so don't validate them
		if ( IsDefined(heli_node.script_linkname) )
			level.bot_heli_nodes = array_add(level.bot_heli_nodes,heli_node);
	}
	
	level.bot_heli_pilot_traceOffset = getHeliPilotTraceOffset();
	/#
	thread bot_validate_heli_nodes( level.bot_heli_nodes );
	#/
	
	foreach( node in level.bot_heli_nodes )
	{
		node.vanguard_origin = node.origin;
		
		test_point = node.origin + (0,0,50);		// catch nodes that are *just* under the trigger but the vanguard would touch the trigger at those nodes
		node.valid_for_vanguard = true;
		while( !origin_is_valid_for_vanguard(test_point) && test_point[2] > (node.origin[2] - 1000) )
		{
			test_point = test_point - (0,0,25);
		}
		
		if ( test_point[2] <= (node.origin[2] - 1000) )
			node.valid_for_vanguard = false;
		
		test_point = test_point - (0,0,50);
		node.vanguard_origin = test_point;
	}

	bot_vehicle_node_highest_height_value = -99999999;
	foreach( node in level.bot_heli_nodes )
	{
		bot_vehicle_node_highest_height_value = max(bot_vehicle_node_highest_height_value,node.origin[2]);
	}
	level.bot_vanguard_height_trace_size = (bot_vehicle_node_highest_height_value - level.bot_map_min_z) + 100;
		
	level.odin_large_rod_radius = GetWeaponExplosionRadius("odin_projectile_large_rod_mp");
	level.odin_small_rod_radius = GetWeaponExplosionRadius("odin_projectile_small_rod_mp");
	level.vanguard_missile_radius = GetWeaponExplosionRadius("remote_tank_projectile_mp");
	level.heli_pilot_missile_radius = GetDvarFloat( "bg_bulletExplRadius" );
	
	while ( !isDefined( level.odin_marking_flash_radius_max ) || !isDefined( level.odin_marking_flash_radius_min ) )
		wait( 0.05 );
	
	level.odin_flash_radius = (level.odin_marking_flash_radius_max + level.odin_marking_flash_radius_min) / 2;
	
	level.outside_zones = [];
	if ( IsDefined(level.teleportGetActivePathnodeZonesFunc) )
	{
		all_zones = [[level.teleportGetActivePathnodeZonesFunc]]();
	}
	else
	{
		all_zones = [];
		for ( i = 0; i < level.zoneCount; i++ )
			all_zones[all_zones.size] = i;
	}

	foreach( z in all_zones )
	{
		if ( BotZoneGetIndoorPercent( z ) < 0.25 )
			level.outside_zones = array_add(level.outside_zones, z);
	}
	
	// After calculating a move target, move for this amount of time.  Lower number means the bot is more reactive.
	level.bot_odin_time_to_move["recruit"] = 1.0;
	level.bot_odin_time_to_move["regular"] = 0.70;
	level.bot_odin_time_to_move["hardened"] = 0.40;
	level.bot_odin_time_to_move["veteran"] = 0.05;
	
	level.bot_initialized_remote_vehicles = true;
}

/#
bot_validate_heli_nodes( nodes )
{
	wait(5.0);
	bot_waittill_bots_enabled( true );
	
	// If bots are being used, validate that the heli mesh has been set up correctly
	
	// First test that there are enough valid heli nodes in the map
	AssertEx(nodes.size > 2, "Level needs more than 2 heli nodes");
	
	heli_pilot_mesh_offset = getHeliPilotMeshOffset();
	bot_heli_pilot_trace_offset = level.bot_heli_pilot_traceOffset;
	
	// Next test that the node exists above/below the heli mesh
	foreach ( heli_node in nodes )
	{
		traceStart = ( heli_node.origin ) + ( heli_pilot_mesh_offset + bot_heli_pilot_trace_offset );
		traceEnd = ( heli_node.origin ) + ( heli_pilot_mesh_offset - bot_heli_pilot_trace_offset );
		traceResult = BulletTrace( traceStart, traceEnd, false, undefined, false, false, true );
		AssertEx( IsDefined( traceResult["entity"] ), "Unable to find heli mesh above or below heli_node at " + heli_node.origin );
		wait(0.05);
	}
	
	thread bot_draw_debug_heli_nodes( nodes );
}

bot_draw_debug_heli_nodes( nodes )
{
	self notify("bot_draw_debug_heli_nodes");
	self endon("bot_draw_debug_heli_nodes");
	level endon("teleport_to_zone");
	
	while(1)
	{
		draw_debug_heli_nodes = GetDvar("bot_DrawDebugSpecial") == "heli_nodes";
		draw_debug_heli_nodes_with_vanguard_info = GetDvar("bot_DrawDebugSpecial") == "heli_nodes_vanguard_info";
		if ( draw_debug_heli_nodes || draw_debug_heli_nodes_with_vanguard_info )
		{
			current_nodes = nodes;
			for ( i = 0; i < current_nodes.size; i++ )
			{
				// Normal node/link color is teal, but if it is red that means the vanguard can't use it
				node_color = (0,1,1);
				if ( draw_debug_heli_nodes_with_vanguard_info )
				{
					if ( !current_nodes[i].valid_for_vanguard )
					{
						node_color = (1,0,0);
					}
					else if ( !bot_vectors_are_equal( current_nodes[i].origin, current_nodes[i].vanguard_origin ) )
					{
						node_color = (1,0,0);
						line( current_nodes[i].origin, current_nodes[i].vanguard_origin, (1,0,0), 1.0, true );
						bot_draw_cylinder(current_nodes[i].vanguard_origin - (0,0,5), 10, 12, 0.05, undefined, (0,1,1), true, 4);
					}
				}
				
				bot_draw_cylinder(current_nodes[i].origin - (0,0,5), 10, 12, 0.05, undefined, node_color, true, 4);
				
				foreach( neighbor_node in current_nodes[i].neighbors )
				{
					if ( IsDefined(neighbor_node.script_linkname) && array_contains( current_nodes, neighbor_node ) )
					{
						// Neighbor node is valid and has not been visited yet, so draw a line to it
						link_color = (0,1,1);
						if ( draw_debug_heli_nodes_with_vanguard_info )
						{
							if ( current_nodes[i].valid_for_vanguard && neighbor_node.valid_for_vanguard )
							{
								if ( !bot_vectors_are_equal( current_nodes[i].origin, current_nodes[i].vanguard_origin ) ||
								    !bot_vectors_are_equal( neighbor_node.origin, neighbor_node.vanguard_origin ) )
								{
									// Draw a teal line between the actual valid vanguard node positions
									line( current_nodes[i].vanguard_origin, neighbor_node.vanguard_origin, link_color, 1.0, true );
									link_color = (1,0,0);
								}
							}
							else
							{
								link_color = (1,0,0);
							}
						}
						line( current_nodes[i].origin, neighbor_node.origin, link_color, 1.0, true );
					}
				}
				
				// Once we've gone through all the neighbor nodes, remove this node from the list (so we don't get double lines)
				current_nodes[i] = current_nodes[current_nodes.size-1];
				current_nodes[current_nodes.size-1] = undefined;
				i--;
			}
		}
		
		wait(0.05);
	}
}
#/

//========================================================
//				bot_killstreak_remote_control
//========================================================
bot_killstreak_remote_control( killstreak_info, killstreaks_array, canUseFunc, controlFunc, prefer_place_outside )
{
	// let control thread decide if we can use this killstreak now or not
	if ( !IsDefined( controlFunc ) )
		return false;
	
	// Get to a place to hide around me first
	needs_new_hide_goal = true;
	needs_to_reach_hide_goal = true;
	hideNode = undefined;
	if ( IsDefined(self.node_ambushing_from) )
	{
		script_goal_radius = self BotGetScriptGoalRadius();
		
		dist_sq_to_camp_goal = DistanceSquared( self.origin, self.node_ambushing_from.origin );
		if ( dist_sq_to_camp_goal < squared(script_goal_radius) )
		{
			needs_new_hide_goal = false;
			needs_to_reach_hide_goal = false;
		}
		else if ( dist_sq_to_camp_goal < squared(200) )
		{
			needs_new_hide_goal = false;
		}
	}
	
	is_vanguard_in_inside_map = (killstreak_info.streakName == "vanguard" && is_indoor_map());
	if ( is_vanguard_in_inside_map || needs_new_hide_goal )
	{
		nodesAroundMe = GetNodesInRadius( self.origin, 500, 0, 512 );
		if ( IsDefined( nodesAroundMe ) && nodesAroundMe.size > 0 )
		{
			if ( IsDefined(prefer_place_outside) && prefer_place_outside )
			{
				nodesAroundMeOld = nodesAroundMe;
				nodesAroundMe = [];
				foreach( node in nodesAroundMeOld )
				{
					if ( NodeExposedToSky(node) )
					{
						linked_nodes = GetLinkedNodes( node );
						num_linked_nodes_exposed = 0;
						foreach( linked_node in linked_nodes )
						{
							if ( NodeExposedToSky(linked_node) )
								num_linked_nodes_exposed++;
						}
						
						if ( num_linked_nodes_exposed / linked_nodes.size > 0.5 )
							nodesAroundMe = array_add(nodesAroundMe,node);
					}
				}
			}
			
			if ( is_vanguard_in_inside_map )
			{
				nodes = self BotNodeScoreMultiple( nodesAroundMe, "node_exposed" );
				foreach( node in nodes )
				{
					if ( BulletTracePassed(node.origin + (0,0,30), node.origin + (0,0,400), false, self ) )
					{
						hideNode = node;
						break;
					}
					
					wait(0.05);		// Wait a frame between traces
				}
			}
			else if ( nodesAroundMe.size > 0 )
			{
				hideNode = self BotNodePick( nodesAroundMe, min(3,nodesAroundMe.size), "node_hide" );
			}
			
			if ( !IsDefined(hideNode) )
				return false;
			self BotSetScriptGoalNode( hideNode, "tactical" );
		}
	}
	
	if ( needs_to_reach_hide_goal )
	{
		result = self bot_waittill_goal_or_fail();
		if ( result != "goal" )
		{
			self try_clear_hide_goal(hideNode);
			return true;
		}
	}
	
	if ( IsDefined( canUseFunc ) && !self [[canUseFunc]]() )
	{
		self try_clear_hide_goal(hideNode);
		return false;
	}

	if ( !self bot_allowed_to_use_killstreaks() )
	{
		// This may have become false during the wait, like an enemy appeared while we pathed to hiding spot
		self try_clear_hide_goal(hideNode);
		return true;
	}
	
	if ( !IsDefined(hideNode) )
	{
		if ( self GetStance() == "prone" )
			self BotSetStance("prone");
		else if ( self GetStance() == "crouch" )
			self BotSetStance("crouch");
	}
	else if ( self BotGetDifficultySetting("strategyLevel") > 0 )
	{
		if ( RandomInt(100) > 50 )
			self BotSetStance("prone");
		else
			self BotSetStance("crouch");
	}
	
	bot_switch_to_killstreak_weapon( killstreak_info, killstreaks_array, killstreak_info.weapon );
	
	self.vehicle_controlling = undefined;
	self thread [[controlFunc]]();
	self thread bot_end_control_on_respawn();
	self thread bot_end_control_watcher(hideNode);
	self waittill("control_func_done");

	return true;
}

bot_end_control_on_respawn()
{
	self endon( "disconnect" );
	self endon( "control_func_done" );
	level endon( "game_ended" );

	self waittill ("spawned_player");
	self notify( "control_func_done" );
}

bot_end_control_watcher(hideNode)
{
	self endon("disconnect");
	self waittill("control_func_done");
	
	self try_clear_hide_goal(hideNode);
	self BotSetStance("none");
	self BotSetScriptMove( 0, 0 );	// clear any script move leftover from controlling the vehicle
	self BotSetFlag("disable_movement",false);
	self BotSetFlag("disable_rotation",false);
	self.vehicle_controlling = undefined;
}

try_clear_hide_goal(hideNode)
{
	if ( IsDefined(hideNode) && self BotHasScriptGoal() && IsDefined( self BotGetScriptGoalNode() ) && self BotGetScriptGoalNode() == hideNode )
		self BotClearScriptGoal();
}

bot_end_control_on_vehicle_death( vehicle )
{
	vehicle waittill("death");
	self notify("control_func_done");
}

bot_waittill_using_vehicle( type )
{
	time_started = GetTime();
	while( !self [[level.bot_ks_funcs["isUsing"][type]]]() )
	{
		wait(0.05);
		if ( GetTime() - time_started > 5000 )
			return false;
	}
	
	return true;
}

// ******************************************************************************************
// *********************************** Switchblade Cluster **********************************
// ******************************************************************************************

bot_control_switchblade_cluster()
{
	self endon( "spawned_player" );
	self endon( "disconnect" );
	self endon( "control_func_done" );
	level endon( "game_ended" );
	
	self childthread handle_disable_rotation();
	
	// First wait until bot is in the heli (or he times out)
	result = self bot_waittill_using_vehicle( "switchblade_cluster" );
	if ( !result )
		self notify("control_func_done");
	
	self thread switchblade_handle_awareness();	// The red boxes allow very easy enemy sight, so articially speed up the process
	
	current_rocket = find_cluster_rocket_for_bot(self);
	wait(0.1); // give time for the visionset to change, else the bot will be piloting the missile while the screen is still black
	
	self.oldmaxsightdistsqrd = self.maxsightdistsqrd;
	self.maxsightdistsqrd = 16000 * 16000;
	self thread watch_end_switchblade();
	
	current_random_zone_target = undefined;
	num_mini_missiles_fired = 0;
	next_missile_time = 0;
	mini_missiles = [];
	next_mini_missile_target = undefined;
	has_boosted = false;
	last_predict_enemy_time = 0;
	target_loc = undefined;
	locked_target = undefined;
	lock_movement_permanently = false;
	map_is_mostly_indoor = is_indoor_map();
	
	while ( self [[level.bot_ks_funcs["isUsing"]["switchblade_cluster"]]]() && IsDefined(current_rocket) )
	{
		foreach ( rocket in level.rockets )
		{
			if ( IsDefined(rocket) && rocket.owner == self && rocket.weapon_name == "switch_blade_child_mp" )
			{
				should_add = true;
				foreach( missile_struct in mini_missiles )
				{
					if ( missile_struct.rocket == rocket )
						should_add = false;
				}
				
				if ( should_add )
				{
					new_missile_struct = SpawnStruct();
					new_missile_struct.rocket = rocket;
					new_missile_struct.target = next_mini_missile_target;
					next_mini_missile_target = undefined;
					mini_missiles = array_add(mini_missiles,new_missile_struct);
				}
			}
		}
		
		for ( i = 0; i < mini_missiles.size; i++ )
		{
			missile_struct = mini_missiles[i];
			if ( IsDefined(missile_struct) && IsDefined(missile_struct.rocket) && !array_contains(level.rockets, missile_struct.rocket) )
			{
				mini_missiles[i] = mini_missiles[mini_missiles.size-1];
				mini_missiles[mini_missiles.size-1] = undefined;
				i--;
			}
		}
		
		if ( lock_movement_permanently )
		{
			wait(0.05);
			continue;
		}
		
		best_target = undefined;
		if ( IsDefined(locked_target) )
		{
			best_target = locked_target;
			if ( !IsAlive(locked_target) || !self BotCanSeeEntity(best_target) )
			{
				if ( !IsAlive(locked_target) )
					lock_movement_permanently = true;
				wait(0.05);
				continue;
			}
		}
		
		visible_enemies = [];
		if ( !IsDefined(best_target) )
		{
			enemies = bot_killstreak_get_all_outside_enemies( false );
			current_missile_targets = [];
			foreach( missile_struct in mini_missiles )
			{
				if ( IsDefined(missile_struct.target) )
					current_missile_targets = array_add(current_missile_targets, missile_struct.target);
			}
			enemies = array_remove_array(enemies,current_missile_targets);
			foreach ( enemy in enemies )
			{
				if ( enemy _hasPerk( "specialty_noplayertarget" ) )
					continue;
				
				if ( self BotCanSeeEntity(enemy) || (map_is_mostly_indoor && within_fov( self GetEye(), current_rocket.angles, enemy.origin, self BotGetFovDot() )) )
				{
					if ( !self bot_body_is_dead() && DistanceSquared(enemy.origin,self.origin) < 200*200 )
						continue;
					
					visible_enemies = array_add(visible_enemies,enemy);
					if ( !IsDefined(best_target) )
					{
						best_target = enemy;
					}
					else
					{
						rocket_to_best_target = VectorNormalize(best_target.origin - current_rocket.origin);
						rocket_to_enemy = VectorNormalize(enemy.origin - current_rocket.origin);
						rocket_orientation = AnglesToForward(current_rocket.angles);
						
						dot_to_best_target = VectorDot( rocket_to_best_target, rocket_orientation );
						dot_to_enemy = VectorDot( rocket_to_enemy, rocket_orientation );
						
						if ( dot_to_enemy > dot_to_best_target )
							best_target = enemy;
					}
				}
			}
		}
		
		if ( IsDefined(best_target) )
		{
			current_random_zone_target = undefined;
			dist_above_target = current_rocket.origin[2] - best_target.origin[2];
			
			bot_difficulty = self BotGetDifficulty();
			if ( bot_difficulty == "recruit" )
			{
				target_loc = best_target.origin;
			}
			else
			{
				if ( dist_above_target < 5000 )
				{
					target_loc = best_target.origin;
				}
				else if ( Length(best_target GetEntityVelocity()) < 25 )
				{
					target_loc = best_target.origin;
				}
				else if ( GetTime() - last_predict_enemy_time > 500 )
				{
					last_predict_enemy_time = GetTime();
					predict_ahead_time = 3.0;
					if ( bot_difficulty == "regular" )
						predict_ahead_time = 1.0;
					target_loc = GetPredictedEntityPosition( best_target, predict_ahead_time );
				}
			}
			
			// find rocket target point (point on ground in center of screen)
			desired_angles = missile_get_desired_angles_to_target( current_rocket, target_loc );
			
			// Missile can move target 200 units per frame
			dist_current_to_desired = missile_get_distance_to_target(current_rocket, target_loc);
			if ( dist_current_to_desired < 30 )
				speed = 0.00;
			else if ( dist_current_to_desired < 100 )
				speed = 0.15;
			else if ( dist_current_to_desired < 200 )
				speed = 0.30;
			else if ( dist_current_to_desired < 400 )
				speed = 0.60;
			else
				speed = 1.0;
			
			if ( has_boosted )
				speed = min(speed * 3, 1.0);
			
			if ( speed > 0 )
			{
				self BotSetScriptMove( desired_angles[1], 0.05, speed, true, true );
			}
			else if ( GetTime() > next_missile_time )
			{
				if ( num_mini_missiles_fired < 2 )
				{
					self BotPressButton("attack");
					num_mini_missiles_fired++;
					next_missile_time = GetTime() + 200;
					if ( (bot_difficulty == "regular" && num_mini_missiles_fired == 2 ) || bot_difficulty == "hardened" || bot_difficulty == "veteran" )
					{
						// If this is the first missile fired and there's only one visible enemy on screen, then the next missile should fire at him as well
						// otherwise the next missile should find a different target
						should_stay_on_target = (num_mini_missiles_fired == 1) && (visible_enemies.size == 1);
						if ( !should_stay_on_target )
						{
							next_mini_missile_target = best_target;
							next_missile_time += 800;
						}
					}
				}
				else if ( !has_boosted && (dist_above_target < 5000 || bot_difficulty == "recruit") )
				{
					has_boosted = true;
					self BotPressButton("attack");
					if ( bot_difficulty == "recruit" )
						locked_target = best_target;
				}
			}
		}
		else
		{
			if ( !IsDefined(current_random_zone_target) )
				current_random_zone_target = Random(level.outside_zones);
			
			zone_origin = GetZoneNodeForIndex(current_random_zone_target).origin;
			if ( missile_get_distance_to_target(current_rocket, zone_origin) < 200 )
			{
				current_random_zone_target = Random(level.outside_zones);
				zone_origin = GetZoneNodeForIndex(current_random_zone_target).origin;
			}
			
			desired_angles = missile_get_desired_angles_to_target( current_rocket, zone_origin );
			self BotSetScriptMove( desired_angles[1], 0.05, 0.75, true, true );
		}
		
		wait(0.05);
	}
	
	self notify("control_func_done");
}

missile_get_desired_angles_to_target( missile, target_origin )
{
	current_target = missile_find_ground_target( missile, target_origin[2] );
	missile_target_to_desired_target = VectorNormalize( target_origin - current_target );
	return VectorToAngles(missile_target_to_desired_target);
}

missile_get_distance_to_target( missile, target_origin )
{
	current_target = missile_find_ground_target( missile, target_origin[2] );
	return Distance(current_target, target_origin);
}

handle_disable_rotation()
{
	self BotSetFlag("disable_rotation",true);
	self BotSetFlag("disable_movement",true);
	
	find_cluster_rocket_for_bot(self);
	
	self BotSetFlag("disable_rotation",false);
	self BotSetFlag("disable_movement",false);
}

switchblade_handle_awareness()
{
	self endon("disconnect");
	self BotSetAwareness(2.5);
	
	self waittill("control_func_done");
	
	self BotSetAwareness(1.0);
}

missile_find_ground_target( missile, desired_target_height )
{
	// Finds the point along the rocket's vector at the height of the target
	// i.e. this is the current target that would be hit if the rocket did not move
	
	missile_dir = AnglesToForward( missile.angles );
	vec_to_ground_size = ( desired_target_height - missile.origin[2] ) / missile_dir[2];
	
	pt_on_ground = missile.origin + missile_dir * vec_to_ground_size;
	
	return pt_on_ground;
}

watch_end_switchblade()
{
	self endon("disconnect");
	self waittill("control_func_done");
	
	self.maxsightdistsqrd = self.oldmaxsightdistsqrd;
}

find_cluster_rocket_for_bot( bot )
{
	while(1)
	{
		foreach ( rocket in level.rockets )
		{
			if ( IsDefined(rocket) && rocket.owner == bot )
				return rocket;
		}
		
		wait(0.05);
	}
}

// ******************************************************************************************
// **************************************** Vanguard ****************************************
// ******************************************************************************************

vanguard_allowed()
{
	if ( !self aerial_vehicle_allowed() )
		return false;
	
	if ( maps\mp\killstreaks\_vanguard::exceededMaxVanguards( self.team ) || (level.littleBirds.size >= 4) )
		return false;
	
	if ( isKillstreakBlockedForBots( "vanguard" ) )
		return false;
	
	return true;
}

bot_killstreak_vanguard_start( killstreak_info, killstreaks_array, canUseFunc, controlFunc )
{
	bot_killstreak_remote_control( killstreak_info, killstreaks_array, canUseFunc, controlFunc, true );
}

isUsingVanguard()
{
	return ( self isUsingRemote() && self.usingRemote == "vanguard" && IsDefined(self.remoteUAV) );
}

SCR_CONST_vanguard_desired_path_height = 64;

bot_control_vanguard()
{
	self endon( "spawned_player" );
	self endon( "disconnect" );
	self endon( "control_func_done" );
	level endon( "game_ended" );
	
	// First wait until bot is in the vanguard (or he times out)
	result = self bot_waittill_using_vehicle("vanguard");
	if ( !result )
		self notify("control_func_done");
	
	self.vehicle_controlling = self.remoteUAV;
	self childthread bot_end_control_on_vehicle_death( self.vehicle_controlling );
/#
	self childthread vanguard_assert_on_range( self.vehicle_controlling );
#/
	self.vehicle_controlling endon("death");
	wait(0.5);	// Wait for the fade-in from black
	
/#		
	if ( !self.vehicle_controlling maps\mp\killstreaks\_vanguard::vanguard_in_range() )
	{
		AssertMsg( "Vanguard at location " + self.vehicle_controlling.origin + " spawned in an invalid area for the Vanguard.  Spawned by bot at location " + self.origin );
		self BotPressButton("use", 4.0);	// cancel vanguard
		wait(4.0);	// No need to return, will be handled by the vehicle dying
	}
#/	
	
	// Next, get the vanguard outside
	total_time_waited = 0;
	try_to_get_outside = !self.vehicle_controlling vanguard_is_outside();
	outside_target = undefined;
	attempts_to_find_outside_target = 0;
	map_is_mostly_indoor = is_indoor_map();
	while ( try_to_get_outside && !map_is_mostly_indoor )
	{
		nodes = GetNodesInRadiusSorted( self.vehicle_controlling.origin, 1024, 64, 512, "path" );
		if ( IsDefined(outside_target) )
			nodes = array_remove(nodes, outside_target);		// Second attempt, so remove the first node (since it failed to find a path to it)
		foreach( potential_target in nodes )
		{
			if ( node_is_valid_outside_for_vanguard( potential_target ) )
			{
				outside_target = potential_target;
				break;
			}
			
			wait(0.05);
			total_time_waited += 0.05;
		}
		
		if ( total_time_waited < 1.0 )
			wait( 1.0 - total_time_waited );		// Allow time for visionset change
		
		if ( !IsDefined(outside_target) )
		{
			AssertMsg("Bot tried to use Vanguard from location " + self.origin + " but couldn't find an outside node within a 1024 unit radius");
			self BotPressButton("use", 4.0);	// cancel vanguard
			wait(4.0);	// No need to return, will be handled by the vehicle dying
		}
		
		path = bot_queued_process( "GetNodesOnPathVanguard", ::func_get_nodes_on_path, self.vehicle_controlling.origin, outside_target.origin );
		
		if ( !IsDefined(path) )
		{
			if ( attempts_to_find_outside_target == 0 )
			{
				attempts_to_find_outside_target++;
				wait(0.05);
				continue;
			}
			else
			{
				//AssertMsg( "Vanguard at location " + self.vehicle_controlling.origin + " could not calculate a path to an outside target at " + outside_target.origin );
				self BotPressButton("use", 4.0);	// cancel vanguard
				wait(4.0);	// No need to return, will be handled by the vehicle dying
			}
		}
		
		for( i=0; i<path.size; i++ )
		{
			next_node = path[i];
			
			if ( i == 0 && DistanceSquared(self.origin, next_node.origin) < 40*40 )
			{
				// Initial node is directly under the bot's body, so just skip it
				continue;
			}
			
			dist_wanted = 32;
			if ( i == path.size - 1 )
				dist_wanted = 16;
			
			last_pos = self.vehicle_controlling.origin;
			next_stuck_check_time = GetTime() + 2500;
			while( Distance2DSquared( next_node.origin, self.vehicle_controlling.origin ) > dist_wanted * dist_wanted )
			{
				if ( self.vehicle_controlling vanguard_is_outside() )
				{
					// Already made it outside before we reached the end of the path
					i = path.size;
					break;
				}
				
				if ( GetTime() > next_stuck_check_time )
				{
					next_stuck_check_time = GetTime() + 2500;
					
					dist_to_last_pos = DistanceSquared(self.vehicle_controlling.origin, last_pos );
					if ( dist_to_last_pos < 1.0 )
					{
						// Stuck, so try to just skip to the next node
						i++;
						break;
					}
					
					last_pos = self.vehicle_controlling.origin;
				}
				
				dir_to_next_node = VectorNormalize(next_node.origin - self.vehicle_controlling.origin);
				self BotSetScriptMove( VectorToAngles(dir_to_next_node)[1], 0.20 );
				self BotLookAtPoint(next_node.origin, 0.20, "script_forced" );
				
				desired_height = next_node.origin[2] + SCR_CONST_vanguard_desired_path_height;
				height_difference = desired_height - self.vehicle_controlling.origin[2];
				if ( height_difference > 10 )
					self BotPressButton("lethal");
				else if ( height_difference < -10 )
					self BotPressButton("tactical");
/#				
				if ( GetDvarInt("ai_showpaths") == 1 )
				{
					line(self.vehicle_controlling.origin, path[i].origin + (0,0,SCR_CONST_vanguard_desired_path_height), (0,0,1), 1.0, false, 4);
					for( j=i; j<path.size-1; j++ )
					{
						line(path[j].origin + (0,0,SCR_CONST_vanguard_desired_path_height), path[j+1].origin + (0,0,SCR_CONST_vanguard_desired_path_height), (0,0,1), 1.0, false, 4);
					}
				}
#/				
				wait(0.05);
			}
		}
		
		try_to_get_outside = false;
		if ( !self.vehicle_controlling vanguard_is_outside() )
			try_to_get_outside = true;
	}
	
	self BotSetScriptMove( 0, 0 );
	self BotLookAtPoint( undefined );
	
	// Start looking around for targets while ascending
	self childthread [[level.bot_ks_funcs["control_aiming"]["vanguard"]]]();
	
	// Now that the vanguard is outside, ascend to the correct height
	last_height = self.vehicle_controlling.origin[2];
	sideways_dir = undefined;
	next_sideways_check = GetTime() + 2000;
	possible_directions = [];
	possible_directions[0] = (1,0,0);
	possible_directions[1] = (-1,0,0);
	possible_directions[2] = (0,1,0);
	possible_directions[3] = (0,-1,0);
	possible_directions[4] = (1,1,0);
	possible_directions[5] = (1,-1,0);
	possible_directions[6] = (-1,1,0);
	possible_directions[7] = (-1,-1,0);
	closest_heli_node = find_closest_heli_node_2D( self.vehicle_controlling.origin, "vanguard" );
	while( (closest_heli_node.vanguard_origin[2] - self.vehicle_controlling.origin[2]) > 20 )
	{
		if ( !self.vehicle_controlling maps\mp\killstreaks\_vanguard::vanguard_in_range() )
			break;
		
		if ( GetTime() > next_sideways_check )
		{
			next_sideways_check = GetTime() + 2000;
			if ( IsDefined(sideways_dir) )
			{
				sideways_dir = undefined;
			}
			else
			{
				height_difference = self.vehicle_controlling.origin[2] - last_height;
				if ( height_difference < 20 && !map_is_mostly_indoor )
				{
					// Stuck, so try to move sideways
					directions = array_randomize(possible_directions);
					foreach( direction in directions )
					{
						if ( pos_passes_sky_trace( self.vehicle_controlling.origin + direction * 64 ) )
						{
							if ( !BulletTracePassed( self.vehicle_controlling.origin, self.vehicle_controlling.origin + direction * 64, false, self.vehicle_controlling ) )
							{
								wait(0.05);
								continue;
							}
							
							sideways_dir = direction;
							break;
						}
						wait(0.05);
					}
				}
			}
			
			last_height = self.vehicle_controlling.origin[2];
		}
		
		if ( IsDefined(sideways_dir) )
		{
/#
			if ( GetDvarInt("ai_showpaths") == 1 )
				line( self.vehicle_controlling.origin, self.vehicle_controlling.origin + sideways_dir * 64, (0,1,0), 1.0, true );
#/
			self BotSetScriptMove( VectorToAngles(sideways_dir)[1], 0.05 );
			if ( cointoss() )
				self BotPressButton("tactical");
		}
		else
		{
			self BotPressButton("lethal");
		}
		wait(0.05);
	}
	
	wait(1.0);	// wait for vertical movement to finish
	while( !self.vehicle_controlling maps\mp\killstreaks\_vanguard::vanguard_in_range() )
	{
		self BotPressButton("tactical");
		wait(0.1);
	}
	wait(1.0);	// wait for vertical movement to finish
	
	self BotSetFlag("disable_movement",false);
	self bot_control_heli_main_move_loop( "vanguard", false );
	
	self notify("control_func_done");
}

/#
vanguard_assert_on_range( vehicle )
{
	vehicle waittill("death", reason);
	if ( IsDefined(reason) )
	{
		AssertEx( reason != "range_death", "Bot drove vanguard out of range in " + getdvar("mapname") );
	}
}
#/

pos_is_valid_outside_for_vanguard( pos )
{
	nearest_node = GetClosestNodeInSight( pos );
	if ( IsDefined(nearest_node) )
		return node_is_valid_outside_for_vanguard(nearest_node);
	
	return false;
}

node_is_valid_outside_for_vanguard( node )
{
	if ( NodeExposedToSky(node) )
		return pos_passes_sky_trace(node.origin);
	
	return false;
}

pos_passes_sky_trace( pos )
{
	// Trace directly up to determine sky
	start = pos;
	end = pos + (0,0,level.bot_vanguard_height_trace_size);
	
	// If end is up inside the no-fly zone, move the trace end down until its in a safe spot
	while( !origin_is_valid_for_vanguard(end) && end[2] > start[2] )
	{
		end = end - (0,0,50);
	}
	
	if ( end[2] <= start[2] )
		return false;
	
	result = BulletTracePassed( start, end, false, undefined );
	//if ( result )
	//	line(start,end,(0,1,0),1.0,true,99999999);
	return result;
}

SCR_CONST_VANGUARD_RADIUS = 18.0;

vanguard_is_outside() // self == vanguard
{
	nearest_node = GetClosestNodeInSight( self.origin );
	if ( IsDefined(nearest_node) && !NodeExposedToSky(nearest_node) )
		return false;
	
	wait(0.05);
	if ( !pos_passes_sky_trace( self.origin + (SCR_CONST_VANGUARD_RADIUS,0,25) ) )	// offset a bit up so it doesn't collide with the vanguard model
		return false;
	
	wait(0.05);
	if ( !pos_passes_sky_trace( self.origin + (-1*SCR_CONST_VANGUARD_RADIUS,0,25) ) )	// offset a bit up so it doesn't collide with the vanguard model
		return false;
	
	wait(0.05);
	if ( !pos_passes_sky_trace( self.origin + (0,SCR_CONST_VANGUARD_RADIUS,25) ) )	// offset a bit up so it doesn't collide with the vanguard model
		return false;
	
	wait(0.05);
	if ( !pos_passes_sky_trace( self.origin + (0,-1*SCR_CONST_VANGUARD_RADIUS,25) ) )	// offset a bit up so it doesn't collide with the vanguard model
		return false;
	
	return true;
}

vanguard_control_aiming()
{
	self notify("vanguard_control_aiming");
	self endon("vanguard_control_aiming");
	
	target_loc = undefined;
	next_random_node_time = 0;
	last_time_fired = GetTime();
	last_predict_enemy_time = 0;
	last_enemy_predicted = undefined;
	time_following_red_boxes = 0;
	while( self [[level.bot_ks_funcs["isUsing"]["vanguard"]]]() )
	{
		enemy_chosen = undefined;
		eye_pos = self GetEye();
		eye_angles = self GetPlayerAngles();
		bot_fov = self BotGetFovDot();
		
		if ( IsAlive(self.enemy) && self BotCanSeeEntity(self.enemy) )
		{
			should_target_enemy = true;
			enemy_chosen = self.enemy;
			time_following_red_boxes = 0;
		}
		else if ( time_following_red_boxes < 10.0 )
		{
			foreach( character in level.characters )
			{
				if ( character == self || !IsAlive(character) )
					continue;
				
				if ( character _hasPerk( "specialty_noplayertarget" ) )
					continue;
				
				if ( !IsDefined( character.team ) )
					continue;
				
				if ( !level.teamBased || ( self.team != character.team ) )
				{
					if ( within_fov( eye_pos, eye_angles, character.origin, bot_fov ) )
					{
						time_following_red_boxes += 0.05;	// After 5 seconds of following boxes, give up and search randomly around the map
						if ( IsDefined(enemy_chosen) )
						{
							dist_vanguard_to_enemy_chosen_sq = DistanceSquared(self.vehicle_controlling.origin, enemy_chosen.origin);
							dist_vanguard_to_this_character = DistanceSquared(self.vehicle_controlling.origin, character.origin);
							if ( dist_vanguard_to_this_character < dist_vanguard_to_enemy_chosen_sq )
								enemy_chosen = character;
						}
						else
						{
							enemy_chosen = character;
						}
					}
				}
			}
		}
		
		if ( IsDefined(enemy_chosen) )
		{
			if ( (IsAI(enemy_chosen) || IsPlayer(enemy_chosen)) && Length(enemy_chosen GetEntityVelocity()) < 25 )
			{
				target_loc = enemy_chosen.origin;
			}
			else if ( GetTime() - last_predict_enemy_time < 500 )
			{
				if ( last_enemy_predicted != enemy_chosen )
					target_loc = enemy_chosen.origin;
			}
			else if ( GetTime() - last_predict_enemy_time > 500 )
			{
				last_predict_enemy_time = GetTime();
				target_loc = GetPredictedEntityPosition( enemy_chosen, 3.0 );
				last_enemy_predicted = enemy_chosen;
			}
			
			allowable_dist = 165;
			if ( GetTime() - last_time_fired > 10000 )
				allowable_dist = 200;
			
			if ( DistanceSquared(self.vehicle_controlling.attackArrow.origin,target_loc) < level.vanguard_missile_radius * level.vanguard_missile_radius )
			{
				if ( self bot_body_is_dead() || DistanceSquared( self.vehicle_controlling.attackArrow.origin, self.origin ) > level.vanguard_missile_radius * level.vanguard_missile_radius )
				{
					last_time_fired = GetTime();
					self BotPressButton("attack");
				}
			}
			
			//bot_draw_cylinder(target_loc, 10, 10, 0.05, undefined, (0,1,0), false, 4);
			//line( enemy_chosen.origin, target_loc, (0,1,0), 1, false );
		}
		else if ( GetTime() > next_random_node_time )
		{
			next_random_node_time = GetTime() + RandomIntRange(1000,2000);
			target_loc = get_random_outside_target();
			self.next_goal_time = GetTime();
		}
		
		if ( Length(target_loc) == 0 )
			target_loc = (0,0,10);
		self BotLookAtPoint( target_loc, 0.2, "script_forced");		
		wait(0.05);
	}
}

vanguard_pick_node( current_node )
{
	current_node.bot_visited_times[self.entity_number]++;
	current_node_origin = [[level.bot_ks_funcs["heli_node_get_origin"]["vanguard"]]](current_node);
	
	best_nodes = bot_vanguard_find_unvisited_nodes( current_node );
	
	best_nodes_old = best_nodes;
	best_nodes = [];
	foreach( node in best_nodes_old )
	{
		if ( node.valid_for_vanguard )
		{
			if ( current_node.origin[2] != current_node.vanguard_origin[2] || node.origin[2] != node.vanguard_origin[2] )
			{
				node_origin = [[level.bot_ks_funcs["heli_node_get_origin"]["vanguard"]]](node);
				
				hitPos = PlayerPhysicsTrace( current_node_origin, node_origin );
				if ( DistanceSquared( hitPos, node_origin ) < 1 )
					best_nodes = array_add(best_nodes, node);

				wait(0.05);
			}
			else
			{
				best_nodes = array_add(best_nodes, node);
			}
		}
	}
	
	if ( best_nodes.size == 0 && best_nodes_old.size > 0 )
	{
		// All of the least-visited nodes that we found were not valid destinations
		// So we need to mark each node as visited, otherwise the bot will just keep attempting to pick this same set over and over again and will never move
		foreach ( node in best_nodes_old )
			node.bot_visited_times[self.entity_number]++;
	}
	
	return heli_pick_node_furthest_from_center( best_nodes, "vanguard" );
}

bot_vanguard_find_unvisited_nodes(current_node)
{
	lowest_visted_num = 99;
	best_nodes = [];
	foreach( node in current_node.neighbors )
	{
		// node.neighbors contains any nodes that this node links to, or that link to it.  So it may contain start nodes that we need to ignore
		if ( IsDefined(node.script_linkname) && node.valid_for_vanguard )
		{
			times_visited_this_node = node.bot_visited_times[self.entity_number];
			if ( times_visited_this_node < lowest_visted_num )
			{
				best_nodes = [];
				best_nodes[0] = node;
				lowest_visted_num = times_visited_this_node;
			}
			else if ( times_visited_this_node == lowest_visted_num )
			{
				best_nodes[best_nodes.size] = node;
			}
		}
	}
	
	return best_nodes;
}

vanguard_get_node_origin( node )
{
	return node.vanguard_origin;
}

origin_is_valid_for_vanguard( origin )
{
	test_script_origin = spawn_tag_origin();
	test_script_origin.origin = origin;
	result = test_script_origin maps\mp\killstreaks\_vanguard::vanguard_in_range();
	test_script_origin delete();
	return result;
}

// ******************************************************************************************
// *************************************** Heli Sniper **************************************
// ******************************************************************************************

heli_sniper_allowed()
{
	if ( !self aerial_vehicle_allowed() )
		return false;
	
	if ( maps\mp\killstreaks\_heliSniper::exceededMaxHeliSnipers() )
		return false;
	
	return true;
}

heli_sniper_waittill_initial_goal()
{
	self.vehicle_controlling waittill( "near_goal" );	
}

bot_control_heli_sniper()
{
	self thread heli_sniper_clear_script_goal_on_ride();
	
	bot_control_heli("heli_sniper");
}

heli_sniper_clear_script_goal_on_ride()
{
	self endon( "spawned_player" );
	self endon( "disconnect" );
	self endon( "control_func_done" );
	level endon( "game_ended" );
	
	while( !(self maps\mp\killstreaks\_killstreaks::isUsingHeliSniper() && self IsLinked()) )
	{
		wait(0.05);
	}
	
	self BotClearScriptGoal();		// Clear goal because we are going to be picked up in the heli
}

heli_sniper_pick_node( current_node )
{
	current_node.bot_visited_times[self.entity_number]++;
	
	best_nodes = bot_heli_find_unvisited_nodes( current_node );
	
	return heli_pick_node_furthest_from_center( best_nodes, "heli_sniper" );
}

// ******************************************************************************************
// *************************************** Heli Pilot ***************************************
// ******************************************************************************************

heli_pilot_allowed()
{
	if ( !self aerial_vehicle_allowed() )
		return false;
	
	if ( maps\mp\killstreaks\_helicopter_pilot::exceededMaxHeliPilots( self.team ) )
		return false;
	
	return true;
}

heli_pilot_waittill_initial_goal()
{
	self.vehicle_controlling waittill( "goal_reached" );
}

bot_control_heli_pilot()
{
	bot_control_heli("heli_pilot");
}

heli_pilot_pick_node( current_node )
{
	current_node.bot_visited_times[self.entity_number]++;
	
	best_nodes = bot_heli_find_unvisited_nodes( current_node );
	
	node_picked = Random(best_nodes);
	return node_picked;
}

heli_pilot_monitor_flares()
{
	self notify("heli_pilot_monitor_flares");
	self endon("heli_pilot_monitor_flares");
	
	missiles_checked = [];
	while( self [[level.bot_ks_funcs["isUsing"]["heli_pilot"]]]() )
	{
		self.vehicle_controlling waittill("targeted_by_incoming_missile", missiles);
		
		if ( !maps\mp\killstreaks\_flares::flares_areAvailable( self.vehicle_controlling ) )
			break;
		
		all_missiles_have_been_checked = true;
		foreach( missile in missiles )
		{
			if ( IsDefined(missile) && !array_contains(missiles_checked, missile) )
				all_missiles_have_been_checked = false;
		}
		
		if ( !all_missiles_have_been_checked )
		{
			chance_to_use_flare = Clamp(0.34 * self BotGetDifficultySetting("strategyLevel"), 0.0, 1.0);
			if ( RandomFloat(1.0) < chance_to_use_flare )
				self notify("manual_flare_popped");
			
			missiles_checked = array_combine( missiles_checked, missiles );
			missiles_checked = array_removeUndefined(missiles_checked);
			
			wait(3.0);		// Wait a bit to avoid popping both flares at once when it wouldn't be necessary
		}
	}
}

heli_pilot_control_heli_aiming()
{
	self notify("heli_pilot_control_heli_aiming");
	self endon("heli_pilot_control_heli_aiming");
	
	last_enemy_loc = undefined;
	last_enemy_seen = undefined;
	target_loc = undefined;
	next_random_node_time = 0;
	last_inaccuracy_check = 0;
	inaccuracy_vector = undefined;
	bot_inaccuracy = (self BotGetDifficultySetting("minInaccuracy") + self BotGetDifficultySetting("maxInaccuracy")) / 2;
	time_following_outlines = 0;
	while( self [[level.bot_ks_funcs["isUsing"]["heli_pilot"]]]() )
	{
		should_aim_at_enemy = false;
		should_fire_at_enemy = false;
		
		if ( IsDefined(last_enemy_seen) && last_enemy_seen.health <= 0 && GetTime() - last_enemy_seen.deathtime < 2000 )
		{
			// Enemy just died, so force aim and fire at the last recorded position
			should_aim_at_enemy = true;
			should_fire_at_enemy = true;
		}
		else if ( IsAlive(self.enemy) && ( self BotCanSeeEntity(self.enemy) || (GetTime() - self LastKnownTime(self.enemy)) <= 300 ) )	
		{
			// Enemy is either on screen or visible due to outline, etc
			should_aim_at_enemy = true;
			last_enemy_seen = self.enemy;
			last_enemy_loc = self.enemy.origin;
			
			if ( self BotCanSeeEntity(self.enemy) )
			{
				// Enemy is onscreen (i.e. direct line of sight)
				time_following_outlines = 0;
				should_fire_at_enemy = true;
				last_time_actually_saw_enemy = GetTime();
			}
			else
			{
				time_following_outlines += 0.05;
				
				if ( time_following_outlines > 5.0 )
				{
					// If we keep seeing enemies as outlines but they're never actually visible, then eventually stop following them and look around randomly
					should_aim_at_enemy = false;
				}
			}
		}
		
		if ( should_aim_at_enemy )
		{
			target_loc = last_enemy_loc - (0,0,50); // heli tends to aim a bit high, so lower the target location a bit
			
			if ( should_fire_at_enemy && ( self bot_body_is_dead() || DistanceSquared( target_loc, self.origin ) > level.heli_pilot_missile_radius * level.heli_pilot_missile_radius ) )
				self BotPressButton("attack");
			
			if ( GetTime() > last_inaccuracy_check + 500 )
			{
				random_x = RandomFloatRange(-1 * bot_inaccuracy/2, bot_inaccuracy/2);
				random_y = RandomFloatRange(-1 * bot_inaccuracy/2, bot_inaccuracy/2);
				random_z = RandomFloatRange(-1 * bot_inaccuracy/2, bot_inaccuracy/2);
				inaccuracy_vector = (150*random_x, 150*random_y, 150*random_z);
				last_inaccuracy_check = GetTime();
			}
			target_loc = target_loc + inaccuracy_vector;
			
			heli_eye_pos = self.vehicle_controlling GetTagOrigin("tag_player");
			heli_eye_to_enemy_norm = VectorNormalize(target_loc - heli_eye_pos);
			player_angles = AnglesToForward(self GetPlayerAngles());
			dot = VectorDot( heli_eye_to_enemy_norm, player_angles );
			if ( dot > 0.5 )
				self BotPressButton("ads",0.1);
		}
		else if ( GetTime() > next_random_node_time )
		{
			next_random_node_time = GetTime() + RandomIntRange(1000,2000);
			target_loc = get_random_outside_target();
			self.next_goal_time = GetTime();
		}
		
		// Make sure bot isn't breaking the 15 degree pitch limit (since nothing internally limits him)
		heli_to_lookat = target_loc - self.vehicle_controlling.origin;
		dist_heli_to_lookat = Length(heli_to_lookat);
		heli_to_lookat_angles = VectorToAngles( heli_to_lookat );
		
		vehicle_pitch = AngleClamp( self.vehicle_controlling.angles[0] );
		heli_lookat_pitch = AngleClamp( heli_to_lookat_angles[0] );
		
		dist = int(vehicle_pitch - heli_lookat_pitch) % 360;
		if ( dist > 180 )
			dist = 360 - dist;
		else if ( dist < -180 )
			dist = -360 + dist;
		
		if ( dist > 15 )
			heli_lookat_pitch = vehicle_pitch - 15;
		else if ( dist < -15 )
			heli_lookat_pitch = vehicle_pitch + 15;
		
		heli_to_lookat_angles = (heli_lookat_pitch,heli_to_lookat_angles[1],heli_to_lookat_angles[2]);
		heli_to_lookat = AnglesToForward(heli_to_lookat_angles);
		target_loc = self.vehicle_controlling.origin + heli_to_lookat * dist_heli_to_lookat;
		
		if ( Length(target_loc) == 0 )
			target_loc = (0,0,10);
		self BotLookAtPoint( target_loc, 0.2, "script_forced");		
		wait(0.05);
	}
}

// ******************************************************************************************
// ************************************** Odin Assault **************************************
// ******************************************************************************************

bot_control_odin_assault()
{
	bot_control_odin("odin_assault");
}

odin_assault_perform_action()
{
	if ( self bot_odin_try_spawn_juggernaut() )
		return true;
	
	if ( self bot_odin_try_rods() )
		return true;
	
	if ( self bot_odin_try_airdrop() )
		return true;
	
	return false;
}

odin_assault_get_target()
{
	// Assault Odin doesn't specifically try to find places to drop a care package,
	// but he can still drop it if he happens across a good location while following targets
	return self bot_odin_find_target_for_rods();
}

bot_odin_find_target_for_rods()
{
	player_to_ignore = undefined;
	if ( IsDefined(self.last_large_rod_target) && GetTime() - self.last_large_rod_time < 5000 )
	{
		// Just shot a large rod at this guy, don't continue following him since he's probably dead
		player_to_ignore = self.last_large_rod_target;
	}

	return bot_odin_get_closest_visible_outside_player( "enemy", true, player_to_ignore );
}

bot_odin_try_rods()
{
	rod_to_fire = bot_odin_should_fire_rod_at_marker();
	if ( rod_to_fire == "large" )
	{
		self notify("large_rod_action");
		return true;
	}
	
	if ( rod_to_fire == "small" )
	{
		self notify("small_rod_action");
		return true;
	}
	
	return false;
}

bot_odin_should_fire_rod_at_marker()
{
	large_rod_available = GetTime() >= self.odin.odin_LargeRodUseTime;
	small_rod_available = GetTime() >= self.odin.odin_SmallRodUseTime;
	
	if ( large_rod_available || small_rod_available )
	{
		outside_enemies = bot_odin_get_visible_outside_players( "enemy", false );
		dist_enemy_to_marker_sq = [];
		dist_body_to_marker_sq = DistanceSquared(self.origin, self.odin.targeting_marker.origin);
		
		for ( i = 0; i < outside_enemies.size; i++ )
		{
			enemy_target_point = self bot_odin_get_player_target_point(outside_enemies[i]);
			dist_enemy_to_marker_sq[i] = DistanceSquared(self.odin.targeting_marker.origin, enemy_target_point);
		}
		
		if ( large_rod_available )
		{
			if ( !self bot_body_is_dead() && dist_body_to_marker_sq < level.odin_large_rod_radius * level.odin_large_rod_radius )
				return "none";
			
			for ( i = 0; i < outside_enemies.size; i++ )
			{
				if ( dist_enemy_to_marker_sq[i] < squared(level.odin_large_rod_radius) )
				{
					self.last_large_rod_target = outside_enemies[i];
					self.last_large_rod_time = GetTime();
					return "large";
				}
			}
		}
		
		if ( small_rod_available )
		{
			if ( !self bot_body_is_dead() && dist_body_to_marker_sq < level.odin_small_rod_radius * level.odin_small_rod_radius )
				return "none";
			
			for ( i = 0; i < outside_enemies.size; i++ )
			{
				if ( dist_enemy_to_marker_sq[i] < squared(level.odin_small_rod_radius) )
				{
					if ( IsDefined(self.last_large_rod_target) && self.last_large_rod_target == outside_enemies[i] && GetTime() - self.last_large_rod_time < 5000 )
					{
						// Just shot a large rod at this guy, don't waste a small on him as well
						continue;
					}

					return "small";
				}
			}
		}
	}
	
	return "none";
}

// ******************************************************************************************
// ************************************** Odin Support **************************************
// ******************************************************************************************

bot_control_odin_support()
{
	bot_control_odin("odin_support");
}

odin_support_perform_action()
{
	if ( self bot_odin_try_spawn_juggernaut() )
		return true;
	
	if ( self bot_odin_try_airdrop() )
		return true;
	
	if ( self bot_odin_try_smoke() )
		return true;
	
	if ( self bot_odin_try_flash() )
		return true;
	
	return false;
}

bot_odin_try_flash()
{
	if ( self bot_odin_should_fire_flash_at_marker() )
	{
		self notify("marking_action");
		return true;
	}

	return false;
}

bot_odin_should_fire_flash_at_marker()
{
	if ( GetTime() < self.odin.odin_markingUseTime )
		return false;
	
	outside_enemies = bot_odin_get_visible_outside_players( "enemy", false );
	dist_enemy_to_marker_sq = [];
	
	for ( i = 0; i < outside_enemies.size; i++ )
	{
		enemy_target_point = self bot_odin_get_player_target_point(outside_enemies[i]);
		dist_enemy_to_marker_sq[i] = DistanceSquared(self.odin.targeting_marker.origin, enemy_target_point);
		
		if ( dist_enemy_to_marker_sq[i] < squared(level.odin_flash_radius/2) )
			return true;
	}
	
	return false;
}

bot_odin_try_smoke()
{
	if ( self bot_odin_should_drop_smoke_at_marker() )
	{
		self notify("smoke_action");
		return true;
	}
	
	return false;
}

bot_odin_should_drop_smoke_at_marker()
{
	if ( GetTime() < self.odin.odin_smokeUseTime )
		return false;
	
	high_priority_locations = self bot_odin_get_high_priority_smoke_locations();
	foreach( location in high_priority_locations )
	{
		if ( DistanceSquared(location,self.odin.targeting_marker.origin) < 50 * 50 )
			return true;
	}
	
	// try to drop smoke randomly in an enemy zone
	marker_zone = undefined;
	if ( IsDefined(self.odin.targeting_marker.nearest_node) ) 
		marker_zone = GetNodeZone(self.odin.targeting_marker.nearest_node);
	
	if ( !IsDefined(marker_zone) )
		return false;
	
	zone_enemies = self bot_killstreak_get_zone_enemies_outside( true );
	num_enemies_in_zone = zone_enemies[marker_zone].size;
	if ( num_enemies_in_zone >= 2 )
		return true;
	
	return false;
}

bot_odin_get_high_priority_smoke_locations()
{
	desired_locations = [];
	if ( GetTime() < self.odin.odin_smokeUseTime )
		return desired_locations;
	
	// First, try to drop smoke on a care package to help my team in capturing it
	foreach( package in level.carePackages )
	{
		if ( crate_landed_and_on_path_grid(package) )
		{
			excluders[0] = self;
			players_sorted = get_array_of_closest( package.origin, level.players, excluders );
			if ( players_sorted.size > 0 && players_sorted[0].team == self.team )
			{
				// Closest player to the crate is on my team, so place the smoke there to help him out
				desired_locations = array_add(desired_locations, package.origin);
			}
		}
	}
	
	// Second, try to drop smoke on a player on my team who is capturing something (dom flag, etc)
	outside_allies = bot_odin_get_visible_outside_players( "ally", false );
	foreach( ally in outside_allies )
	{
		if ( IsAI(ally) && ally bot_is_capturing() )
		{
			desired_locations = array_add(desired_locations, ally.origin);
		}
	}
	
	return desired_locations;
}

odin_support_get_target()
{
	high_priority_smoke_locs = self bot_odin_get_high_priority_smoke_locations();
	if ( high_priority_smoke_locs.size > 0 )
		return high_priority_smoke_locs[0];
	
	return bot_odin_get_closest_visible_outside_player( "enemy", true );
}

// ******************************************************************************************
// *************************************** Odin Shared **************************************
// ******************************************************************************************

monitor_odin_marker()
{
	while(1)
	{
		self.odin.targeting_marker.nearest_node = GetClosestNodeInSight( self.odin.targeting_marker.origin );
		
		if ( bot_point_is_on_pathgrid( self.odin.targeting_marker.origin, 200 ) )
			self.odin.targeting_marker.nearest_point_on_pathgrid = self.odin.targeting_marker.origin;
		else
			self.odin.targeting_marker.nearest_point_on_pathgrid = undefined;
		
		wait(0.25);
	}
}

bot_control_odin(type)
{
	self endon( "spawned_player" );
	self endon( "disconnect" );
	self endon( "control_func_done" );
	level endon( "game_ended" );
	
	// First wait until bot is in the Odin (or he times out)
	result = self bot_waittill_using_vehicle( type );
	if ( !result )
		self notify("control_func_done");
	
	self.vehicle_controlling = self.odin;
	self childthread bot_end_control_on_vehicle_death( self.odin );
	self.odin endon("death");
	
	wait(1.4);	// There's an additional 1.4 second (or so) wait until a human player can see from the Odin's eyes
	
	self BotSetAwareness(0.7);		// Harder to see enemies since you're so high up
	self thread bot_end_odin_watcher();
	self.odin_predicted_loc_for_player = [];
	self.odin_predicted_loc_time_for_player = [];
	self.odin_last_predict_position_time = 0;
	current_random_zone_target = undefined;
	next_move_time = 0;
	move_loc = undefined;
	self childthread monitor_odin_marker();
	last_marker_loc = self.odin.targeting_marker.origin;
	last_marker_check = GetTime();
	while ( self [[level.bot_ks_funcs["isUsing"][type]]]() )
	{
		performed_action = self [[level.bot_ks_funcs["odin_perform_action"][type]]]();
		
		if ( GetTime() > last_marker_check + 2000 )
		{
			last_marker_check = GetTime();
			marker_moved = Distance(last_marker_loc, self.odin.targeting_marker.origin);
			last_marker_loc = self.odin.targeting_marker.origin;
			
			if ( marker_moved < 100 )
			{
				// stuck, find a new destination
				move_loc = undefined;
				current_random_zone_target = undefined;
			}
		}
		
		if ( GetTime() > next_move_time || !IsDefined(move_loc) )
		{
			time_to_move = level.bot_odin_time_to_move[self BotGetDifficulty()];
			next_move_time = GetTime() + time_to_move * 1000;
			
			// Current location isn't good, so decide where to move
			desired_target = self [[level.bot_ks_funcs["odin_get_target"][type]]]();
			if ( IsDefined(desired_target) )
			{
				current_random_zone_target = undefined;
				if ( IsPlayer(desired_target) )
					move_loc = self bot_odin_get_player_target_point(desired_target);
				else
					move_loc = desired_target;
			}
			else
			{
				if ( !IsDefined(current_random_zone_target) )
					current_random_zone_target = Random(level.outside_zones);
				
				zone_origin = GetZoneNodeForIndex(current_random_zone_target).origin;
				if ( Distance2DSquared( self.odin.targeting_marker.origin, zone_origin ) < 100 * 100 )
				{
					current_random_zone_target = Random(level.outside_zones);
					zone_origin = GetZoneNodeForIndex(current_random_zone_target).origin;
					last_marker_check = GetTime();
				}
				
				move_loc = zone_origin;
			}
			
			//bot_draw_cylinder(move_loc, 10, 10, time_to_move, undefined, (0,1,0), false, 4);
			//if ( IsDefined(desired_target) && IsPlayer(desired_target) )
			//	line( desired_target.origin, move_loc, (0,1,0), 1, false, INT(time_to_move / 0.05) );
		}
		
		//line(move_loc, self.odin.targeting_marker.origin, (0,0,1), 1.0, false );
		
		marker_to_move_loc = move_loc - self.odin.targeting_marker.origin;
		if ( LengthSquared(marker_to_move_loc) > 100 )
		{
			marker_to_move_loc_angles = VectorToAngles( marker_to_move_loc );
			self BotSetScriptMove( marker_to_move_loc_angles[1], 0.05 );
			self BotLookAtPoint( move_loc, 0.1, "script_forced");	
		}
		else
		{
			last_marker_check = GetTime();
		}
		
		wait(0.05);
	}
	
	self notify("control_func_done");
}

bot_end_odin_watcher(hideNode)
{
	self endon("disconnect");
	self waittill("control_func_done");
	
	self.odin_predicted_loc_for_player = undefined;
	self.odin_predicted_loc_time_for_player = undefined;
	self.odin_last_predict_position_time = undefined;
	self BotSetAwareness(1.0);
}

SCR_CONST_PLAYER_PREDICT_UPDATE_TIME = 400;

bot_odin_get_player_target_point( player )
{
	if ( level.teamBased && self.team == player.team )
	{
		// This is an ally, no need to predict future position
		return player.origin;
	}
	else
	{
		if ( Length(player GetEntityVelocity()) < 25 )
			return player.origin;
		
		player_ent_num = player GetEntityNumber();
		if ( !IsDefined(self.odin_predicted_loc_time_for_player[player_ent_num]) )
			self.odin_predicted_loc_time_for_player[player_ent_num] = 0;
		
		cur_time = GetTime();
		time_since_predicted = cur_time - self.odin_predicted_loc_time_for_player[player_ent_num];
		
		if ( time_since_predicted <= SCR_CONST_PLAYER_PREDICT_UPDATE_TIME )
		{
			// If we can see that the prediction is totally wrong, then ignore it
			player_velocity = VectorNormalize(player GetEntityVelocity());
			player_to_predicted_loc = VectorNormalize(self.odin_predicted_loc_for_player[player_ent_num] - player.origin);
			if ( VectorDot(player_velocity,player_to_predicted_loc) < -0.5 )
				return player.origin;
		}
				
		if ( time_since_predicted > SCR_CONST_PLAYER_PREDICT_UPDATE_TIME )
		{
			if ( cur_time == self.odin_last_predict_position_time )
			{
				// Already predicted one player's position this frame, so don't predict again
				// If the stored data on this guy is too old just return his position
				if ( time_since_predicted > 1000 )
					return player.origin;
			}
			else
			{
				self.odin_predicted_loc_for_player[player_ent_num] = GetPredictedEntityPosition( player, 1.5 );
				self.odin_predicted_loc_time_for_player[player_ent_num] = cur_time;
				self.odin_last_predict_position_time = cur_time;
			}
		}
		
		return self.odin_predicted_loc_for_player[player_ent_num];
	}
}

bot_odin_get_closest_visible_outside_player( type, only_players, player_to_ignore )
{
	visible_players = self bot_odin_get_visible_outside_players( type, only_players );
	
	if ( IsDefined(player_to_ignore) )
		visible_players = array_remove( visible_players, player_to_ignore );
	
	if ( visible_players.size > 0 )
	{
		visible_players_sorted = get_array_of_closest( self.odin.targeting_marker.origin, visible_players );
		return visible_players_sorted[0];
	}
	
	return undefined;
}

bot_odin_try_spawn_juggernaut()
{
	if ( GetTime() >= self.odin.odin_juggernautUseTime )
	{
		if ( !IsDefined(self.odin.targeting_marker.nearest_node) )
			return false;
		
		node_for_juggernaut = maps\mp\killstreaks\_odin::getJuggStartingPathNode( self.odin.targeting_marker.origin );
		if ( IsDefined(node_for_juggernaut) )
		{
			self notify("juggernaut_action");
			return true;
		}
	}
	
	return false;
}

bot_odin_find_target_for_airdrop()
{
	return bot_odin_get_closest_visible_outside_player( "ally", false);
}

bot_odin_try_airdrop()
{
	if ( self bot_odin_should_airdrop_at_marker() )
	{
		self notify("airdrop_action");
		self notify("juggernaut_action");	// Move Juggernaut to guard care package
		return true;
	}
	
	return false;
}

bot_odin_should_airdrop_at_marker()
{
	if ( GetTime() < self.odin.odin_airdropUseTime )
		return false;
	
	if ( !IsDefined(self.odin.targeting_marker.nearest_node) )
		return false;
	
	if ( bot_odin_get_num_valid_care_packages() > 2 )
	{
		// Too many care packages already - don't want to overwhelm my team and risk one of them falling into the wrong hands
		return false;
	}
	
	if ( !IsDefined(self.odin.targeting_marker.nearest_point_on_pathgrid) )
	{
		// Marker is off the path grid, so don't drop a crate since it would be unreachable
		return false;
	}

	marker_zone = GetNodeZone(self.odin.targeting_marker.nearest_node);
	if ( !IsDefined(marker_zone) )
		return false;
	
	zone_allies = self bot_killstreak_get_zone_allies_outside( true );
	num_allies_in_zone = zone_allies[marker_zone].size;
	
	zone_enemies = self bot_killstreak_get_zone_enemies_outside( true );
	num_enemies_in_zone = zone_enemies[marker_zone].size;
	
	if ( num_allies_in_zone == 0 )
	{
		// Don't use airdrop in a zone with zero allies
		return false;
	}
	
	if ( num_enemies_in_zone == 0 )
	{
		// Zone has at least one ally and no enemies, so allow airdrop if there are no close visible enemies (on the border of another zone for example)
		enemy_nearby_marker = false;
		visible_enemies = self bot_odin_get_visible_outside_players( "enemy", true );
		foreach ( enemy in visible_enemies )
		{
			if ( DistanceSquared(enemy.origin, self.odin.targeting_marker.origin) < 120 * 120 )
				enemy_nearby_marker = true;
		}
		
		if ( !enemy_nearby_marker )
			return true;
	}
	
	if ( num_allies_in_zone - num_enemies_in_zone >= 2 )
	{
		// Zone has allies and enemies in it, so allow airdrop if allies in the current zone outnumber enemies by 2 or more
		
		// But make sure that there's an ally significantly closer than an enemy
		allies_sorted = get_array_of_closest( self.odin.targeting_marker.origin, zone_allies[marker_zone] );
		enemies_sorted = get_array_of_closest( self.odin.targeting_marker.origin, zone_enemies[marker_zone] );
		
		closest_ally_dist = Distance( self.odin.targeting_marker.origin, allies_sorted[0].origin );
		closest_enemy_dist = Distance( self.odin.targeting_marker.origin, enemies_sorted[0].origin );
		
		if ( closest_ally_dist + 120 < closest_enemy_dist )
			return true;
	}
	
	return false;
}

bot_odin_get_num_valid_care_packages()
{
	count = 0;
	foreach( package in level.carePackages )
	{
		if ( IsDefined(package) && crate_landed_and_on_path_grid(package) )
			count++;
	}
	
	return count;
}

bot_odin_get_visible_outside_players( type, only_players, only_check_fov )
{
	outside_players = self bot_killstreak_get_outside_players( self.team, type, only_players );
	
	fov_dot_base = self BotGetFovDot();
	visible_outside_players = [];
	foreach ( player in outside_players )
	{
		check_sight = false;
		fov_dot = fov_dot_base;
		if ( type == "enemy" )
		{
			if ( maps\mp\killstreaks\_odin::enemyNotAffectedByOdinOutline(player) )
				check_sight = true;
			else
				fov_dot *= 0.9;	// Can see enemy outline through the UI blackness on the left/right edges of the screen, so increase the FOV
		}
		
		if ( within_fov( self.vehicle_controlling.origin, self GetPlayerAngles(), player.origin, fov_dot ) )
		{
			if ( !check_sight || self BotCanSeeEntity(player) )
				visible_outside_players = array_add( visible_outside_players, player );
		}
	}
	
	return visible_outside_players;
}

// ******************************************************************************************
// ************************************ Shared Functions ************************************
// ******************************************************************************************

is_indoor_map()
{
	return (level.script == "mp_sovereign");
}

bot_body_is_dead()
{
	return (IsDefined(self.fauxDead) && self.fauxDead);
}

heli_pick_node_furthest_from_center( nodes, type )
{
	farthest_node = undefined;
	farthest_node_dist_sq = 0;
	foreach( node in nodes )
	{
		dist_to_center_sq = DistanceSquared( level.bot_map_center, [[level.bot_ks_funcs["heli_node_get_origin"][type]]](node) );
		if ( dist_to_center_sq > farthest_node_dist_sq )
		{
			farthest_node_dist_sq = dist_to_center_sq;
			farthest_node = node;
		}
	}
	
	if ( IsDefined(farthest_node) )
		return farthest_node;
	else
		return Random(nodes);
}

heli_get_node_origin( node )
{
	return node.origin;
}

find_closest_heli_node_2D( origin, type )
{
	closest_node_2D = undefined;
	closest_node_2D_dist = 99999999;
	foreach( node in level.bot_heli_nodes )
	{
		dist_2D_sq = Distance2DSquared( origin, [[level.bot_ks_funcs["heli_node_get_origin"][type]]](node) );
		if ( dist_2D_sq < closest_node_2D_dist )
		{
			closest_node_2D = node;
			closest_node_2D_dist = dist_2D_sq;
		}
	}
	
	return closest_node_2D;
}

bot_killstreak_get_zone_allies_outside( only_players )
{
	outside_allies = self bot_killstreak_get_all_outside_allies( only_players );
	zone_allies = [];
	
	for ( i=0; i<level.zoneCount; i++ )
		zone_allies[i] = [];
	
	foreach ( ally in outside_allies )
	{
		nearest_node = ally GetNearestNode();
		zone = GetNodeZone(nearest_node);
		if ( IsDefined(zone) )
			zone_allies[zone] = array_add( zone_allies[zone], ally );
	}
	
	return zone_allies;
}

bot_killstreak_get_zone_enemies_outside( only_players )
{
	outside_enemies = self bot_killstreak_get_all_outside_enemies( only_players );
	zone_enemies = [];
	
	for ( i=0; i<level.zoneCount; i++ )
		zone_enemies[i] = [];
	
	foreach ( enemy in outside_enemies )
	{
		nearest_node = enemy GetNearestNode();
		zone = GetNodeZone(nearest_node);
		zone_enemies[zone] = array_add( zone_enemies[zone], enemy );
	}
	
	return zone_enemies;
}

bot_killstreak_get_all_outside_enemies( only_players )
{
	return self bot_killstreak_get_outside_players( self.team, "enemy", only_players );
}

bot_killstreak_get_all_outside_allies( only_players )
{
	return self bot_killstreak_get_outside_players( self.team, "ally", only_players );
}

bot_killstreak_get_outside_players( team, type, only_players )
{
	outside_players = [];
	all_players = level.participants;
	if ( IsDefined(only_players) && only_players )
		all_players = level.players;
	
	foreach( player in all_players )
	{
		if ( player == self || !IsAlive(player) )
			continue;
		
		// should really have the same check as AI_IsAlliedSentient in code
		is_valid_player = false;
		if ( type == "ally" )
			is_valid_player = level.teamBased && ( team == player.team );
		else if ( type == "enemy" )
			is_valid_player = !level.teamBased || ( team != player.team );
		
		if ( is_valid_player )
		{
			nearest_node_player = player GetNearestNode();
			if ( IsDefined( nearest_node_player ) && NodeExposedToSky( nearest_node_player ) )
				outside_players = array_add(outside_players, player);
		}
	}
	
	outside_players = array_remove(outside_players,self);
	return outside_players;
}

bot_heli_find_unvisited_nodes(current_node)
{
	lowest_visted_num = 99;
	best_nodes = [];
	foreach( node in current_node.neighbors )
	{
		// node.neighbors contains any nodes that this node links to, or that link to it.  So it may contain start nodes that we need to ignore
		if ( IsDefined(node.script_linkname) )
		{
			times_visited_this_node = node.bot_visited_times[self.entity_number];
			if ( times_visited_this_node < lowest_visted_num )
			{
				best_nodes = [];
				best_nodes[0] = node;
				lowest_visted_num = times_visited_this_node;
			}
			else if ( times_visited_this_node == lowest_visted_num )
			{
				best_nodes[best_nodes.size] = node;
			}
		}
	}
	
	return best_nodes;
}

bot_control_heli( type )
{
	self endon( "spawned_player" );
	self endon( "disconnect" );
	self endon( "control_func_done" );
	level endon( "game_ended" );
	
	// First wait until bot is in the heli (or he times out)
	result = self bot_waittill_using_vehicle( type );
	if ( !result )
		self notify("control_func_done");
	
	foreach ( bird in level.littleBirds )
	{
		if ( bird.owner == self )
			self.vehicle_controlling = bird;
	}
	Assert(IsDefined(self.vehicle_controlling));
	
	self childthread bot_end_control_on_vehicle_death( self.vehicle_controlling );
	self.vehicle_controlling endon("death");
	
	if ( IsDefined(level.bot_ks_funcs["control_other"][type]) )
		self childthread [[level.bot_ks_funcs["control_other"][type]]]();
	
	// Next wait until the heli reaches its target
	self [[level.bot_ks_funcs["waittill_initial_goal"][type]]]();
	
	self childthread [[level.bot_ks_funcs["control_aiming"][type]]]();
	
	self bot_control_heli_main_move_loop( type, true );
	
	self notify("control_func_done");
}

SCR_CONST_BOT_HELI_ON_MESH_GOAL_DIST = 100;		// Vehicle that rides on the mesh will consider itself "at goal" within this distance
SCR_CONST_BOT_HELI_OFF_MESH_GOAL_DIST = 30; 	// Vehicle that doesn't ride on the mesh will consider itself "at goal" within this distance
SCR_CONST_BOT_HELI_SLOWDOWN_RANGE = 3;			// At this scalar of GOAL_DIST, the vehicle will start to slow down

bot_get_heli_goal_dist_sq( rides_on_mesh )
{
	if ( rides_on_mesh )
		return squared(SCR_CONST_BOT_HELI_ON_MESH_GOAL_DIST);
	else
		return squared(SCR_CONST_BOT_HELI_OFF_MESH_GOAL_DIST);
}

bot_get_heli_slowdown_dist_sq( rides_on_mesh )
{
	if ( rides_on_mesh )
		return squared(SCR_CONST_BOT_HELI_ON_MESH_GOAL_DIST * SCR_CONST_BOT_HELI_SLOWDOWN_RANGE);
	else
		return squared(SCR_CONST_BOT_HELI_OFF_MESH_GOAL_DIST * SCR_CONST_BOT_HELI_SLOWDOWN_RANGE);
}

SCR_CONST_BOT_VANGUARD_STUCK_TIME = 3.0;

bot_control_heli_main_move_loop( type, rides_on_mesh )
{
	foreach (node in level.bot_heli_nodes)
		node.bot_visited_times[self.entity_number] = 0;
	current_node = find_closest_heli_node_2D( self.vehicle_controlling.origin, type );

	current_target = undefined;
	self.next_goal_time = 0;
	state = "needs_new_goal";
	dist_to_goal_sq = undefined;
	last_vehicle_origin = self.vehicle_controlling.origin;
	time_till_next_stuck_check = SCR_CONST_BOT_VANGUARD_STUCK_TIME;
	wait_time = 0.05;
	while ( self [[level.bot_ks_funcs["isUsing"][type]]]() )
	{
		if ( GetTime() > self.next_goal_time && state == "needs_new_goal" )
		{
			// Pick a new node that is linked to the current one
			prev_node = current_node;
			current_node = [[level.bot_ks_funcs["heli_pick_node"][type]]](current_node);
			current_target = undefined;
			if ( IsDefined(current_node) )
			{
				current_node_origin = [[level.bot_ks_funcs["heli_node_get_origin"][type]]](current_node);
				
				if ( rides_on_mesh )
				{
					// Find the "ground" position under the node (i.e. the position of the vehicle clip)
					traceStart = ( current_node.origin ) + ( getHeliPilotMeshOffset() + level.bot_heli_pilot_traceOffset );
					traceEnd = ( current_node.origin ) + ( getHeliPilotMeshOffset() - level.bot_heli_pilot_traceOffset );
					traceResult = BulletTrace( traceStart, traceEnd, false, undefined, false, false, true );
					AssertEx( IsDefined( traceResult["entity"] ), "Unable to find heli mesh above or below heli_node at " + current_node_origin );
					current_target = ( traceResult[ "position" ] - getHeliPilotMeshOffset() ) + level.bot_ks_heli_offset[type];
				}
				else
				{
					current_target = current_node_origin;
				}
			}
			
			if ( IsDefined(current_target) )
			{
				self BotSetFlag("disable_movement",false);
				state = "waiting_till_goal";
				time_till_next_stuck_check = SCR_CONST_BOT_VANGUARD_STUCK_TIME;
				last_vehicle_origin = self.vehicle_controlling.origin;
			}
			else
			{
				current_node = prev_node;
				self.next_goal_time = GetTime() + 2000;
			}
		}
		else if ( state == "waiting_till_goal" )
		{
			if ( !rides_on_mesh )
			{
				// Need to manually adjust height
				height_difference = current_target[2] - self.vehicle_controlling.origin[2];
				if ( height_difference > 10 )
					self BotPressButton("lethal");
				else if ( height_difference < -10 )
					self BotPressButton("tactical");
			}
			
			heli_to_current_target = (current_target - self.vehicle_controlling.origin);
			if ( rides_on_mesh )
				dist_to_goal_sq = Length2DSquared(heli_to_current_target);
			else
				dist_to_goal_sq = LengthSquared(heli_to_current_target);
			
			if ( dist_to_goal_sq < bot_get_heli_goal_dist_sq( rides_on_mesh ) )
			{
				self BotSetScriptMove( 0, 0 );	// clear the script move
				self BotSetFlag("disable_movement",true);
				if ( self BotGetDifficulty() == "recruit" )
					self.next_goal_time = GetTime() + RandomIntRange(5000,7000);
				else
					self.next_goal_time = GetTime() + RandomIntRange(3000,5000);
				state = "needs_new_goal";
			}
			else
			{
				heli_to_current_target = (current_target - self.vehicle_controlling.origin);
				heli_to_current_target_angles = VectorToAngles( heli_to_current_target );
				stick_speed = ter_op( dist_to_goal_sq < bot_get_heli_slowdown_dist_sq( rides_on_mesh ), 0.5, 1.0 );
				self BotSetScriptMove( heli_to_current_target_angles[1], wait_time, stick_speed );
				time_till_next_stuck_check -= wait_time;
				
				if ( time_till_next_stuck_check <= 0.0 )
				{
					if ( DistanceSquared(self.vehicle_controlling.origin, last_vehicle_origin) < 15*15 )
					{
						// Stuck, so mark the node as "visited" and try a new destination
						current_node.bot_visited_times[self.entity_number]++;
						state = "needs_new_goal";
					}
					
					last_vehicle_origin = self.vehicle_controlling.origin;
					time_till_next_stuck_check = SCR_CONST_BOT_VANGUARD_STUCK_TIME;
				}
			}
		}
/#		
		if ( GetDvarInt("ai_showpaths") == 1 )
		{
			if ( IsDefined(current_target) )
				Line( self.vehicle_controlling.origin, current_target, (0,0,1), 1.0, false );
		}
#/		
		wait(wait_time);
	}
}

get_random_outside_target()
{
	possible_zones = [];
	foreach ( z in level.outside_zones )
	{
		enemies_in_zone = BotZoneGetCount( z, self.team, "enemy_predict" );
		if ( enemies_in_zone > 0 )
			possible_zones = array_add(possible_zones,z);
	}
	
	target_loc = undefined;
	if ( possible_zones.size > 0 )
	{
		random_zone = Random(possible_zones);
		random_node = Random(GetZoneNodes( random_zone ));
		target_loc = random_node.origin;
	}
	else
	{
		if ( IsDefined(level.teleportGetActiveNodesFunc) )
			all_nodes = [[level.teleportGetActiveNodesFunc]]();
		else
			all_nodes = GetAllNodes();
		num_picked = 0;
		while( num_picked < 10 )
		{
			num_picked++;
			node_picked = all_nodes[RandomInt(all_nodes.size)];
			target_loc = node_picked.origin;
			if ( NodeExposedToSky(node_picked) && Distance2DSquared(node_picked.origin, self.vehicle_controlling.origin) > 250*250 )
				break;
		}
	}
	
	return target_loc;
}