_airsupport.gsc

Go to the documentation of this file.

#using scripts\codescripts\struct;
 
#using scripts\shared\challenges_shared;
#using scripts\shared\damagefeedback_shared;
#using scripts\shared\math_shared;
#using scripts\shared\util_shared;
#using scripts\shared\weapons\_weaponobjects;
#using scripts\shared\weapons\_weapons;
 
#insert scripts\shared\shared.gsh;
 
#using scripts\mp\_util;
 
#namespace airsupport;
 
// some common functions between all the air kill streaks
 
function ‪init()
{   
    if ( !isdefined( level.airsupportHeightScale ) ) 
        level.airsupportHeightScale = 1;
    
    level.airsupportHeightScale = GetDvarInt( "scr_airsupportHeightScale", level.airsupportHeightScale );   
 
    level.noFlyZones = [];
    level.noFlyZones = GetEntArray("no_fly_zone","targetname");
 
    airsupport_heights = ‪struct::get_array("air_support_height","targetname");
    
    /#
    if ( airsupport_heights.size > 1 )
    {
        ‪util::error( "Found more then one 'air_support_height' structs in the map" );
    }
    #/
    
    airsupport_heights = GetEntArray("air_support_height","targetname");
    
    /#
    if ( airsupport_heights.size > 0 )
    {
        ‪util::error( "Found an entity in the map with an 'air_support_height' targetname.  There should be only structs." );
    }
    #/
 
    heli_height_meshes = GetEntArray("heli_height_lock","classname");   
 
    /#
    if ( heli_height_meshes.size > 1 )
    {
        ‪util::error( "Found more then one 'heli_height_lock' classname in the map" );
    }
    #/
        
    ‪InitRotatingRig();
}
 
function ‪finishHardpointLocationUsage( location, usedCallback )
{
    self notify( "used" );
    ‪WAIT_SERVER_FRAME;
    
    if( isdefined( usedCallback ) )
    {
        return self [[usedCallback]]( location );
    }
    
    return true;
}
 
function ‪finishDualHardpointLocationUsage( locationStart, locationEnd, usedCallback )
{
    self notify( "used" );
    ‪WAIT_SERVER_FRAME;
    return self [[usedCallback]]( locationStart, locationEnd );
}
 
function ‪endSelectionOnGameEnd()
{
    self endon( "death" );
    self endon( "disconnect" );
    self endon( "cancel_location" );
    self endon( "used" );
    self endon( "host_migration_begin" );
 
    level waittill( "game_ended" );
    self notify( "game_ended" );
}
 
function ‪endSelectionOnHostMigration()
{
    self endon( "death" );
    self endon( "disconnect" );
    self endon( "cancel_location" );
    self endon( "used" );
    self endon( "game_ended" );
 
    level waittill( "host_migration_begin" );
    self notify( "cancel_location" );
}
 
function ‪endSelectionThink()
{
    assert( IsPlayer( self ) );
    assert( IsAlive( self ) );
    assert( isdefined( self.selectingLocation ) );
    assert( self.selectingLocation == true );
    
    self thread ‪endSelectionOnGameEnd();
    self thread ‪endSelectionOnHostMigration();
    
    event = self ‪util::waittill_any_return( "death", "disconnect", "cancel_location", "game_ended", "used", "weapon_change", "emp_jammed" );
 
    if ( event != "disconnect" )
    {
        self.selectingLocation = undefined;
        self thread ‪clearUpLocationSelection();
    }
 
    if ( event != "used" )
    {
        // wake threads waiting for locations
        self notify( "confirm_location", undefined, undefined );
    }
}
 
function ‪clearUpLocationSelection()
{
    event = self ‪util::waittill_any_return( "death", "disconnect", "game_ended", "used", "weapon_change", "emp_jammed", "weapon_change_complete" );
 
    if ( event != "disconnect" )
    {
        self endLocationSelection();
    }
}
 
function ‪stopLoopSoundAfterTime( time )
{
    self endon ( "death" );
    wait ( time );
    
    self stoploopsound( 2 );  
}
 
function ‪calculateFallTime( flyHeight )
{
    // this is the value that code uses 
    gravity = GetDvarint( "bg_gravity" );
 
    time = sqrt( (2 * flyHeight) / gravity );
    
    return time;
}
 
function ‪calculateReleaseTime( flyTime, flyHeight, flySpeed, bombSpeedScale )
{
    falltime = ‪calculateFallTime( flyHeight );
 
    // bomb horizontal velocity is not the same as the plane speed so we need to take this
    // into account when calculating the bomb time
    bomb_x = (flySpeed * bombSpeedScale) * falltime;
    release_time = bomb_x / flySpeed;
    
    return ( (flyTime * 0.5) - release_time);
}
 
function ‪getMinimumFlyHeight()
{   
    airsupport_height = ‪struct::get( "air_support_height", "targetname");
    if ( isdefined(airsupport_height) )
    {
        planeFlyHeight = airsupport_height.origin[2];
    }
    else
    {
/#
        PrintLn("WARNING:  Missing air_support_height entity in the map.  Using default height.");
#/
        // original system
        planeFlyHeight = 850;
    
        if ( isdefined( level.airsupportHeightScale ) )
        {
            level.airsupportHeightScale = GetDvarInt( "scr_airsupportHeightScale", level.airsupportHeightScale );   
            planeFlyHeight *= GetDvarInt( "scr_airsupportHeightScale", level.airsupportHeightScale );   
        }
        
        if ( isdefined( level.forceAirsupportMapHeight ) )
        {
            planeFlyHeight += level.forceAirsupportMapHeight;
        }   
    }
    
    return planeFlyHeight;
}
 
function ‪callStrike( flightPlan )
{   
    level.bomberDamagedEnts = [];
    level.bomberDamagedEntsCount = 0;
    level.bomberDamagedEntsIndex = 0;
    
    assert( flightPlan.distance != 0, "callStrike can not be passed a zero fly distance");
    
    planeHalfDistance = flightPlan.distance / 2;
 
    path = ‪getStrikePath( flightPlan.target, flightPlan.height, planeHalfDistance );
    startPoint = path["start"];
    endPoint = path["end"];
    flightPlan.height = path["height"];
    direction = path["direction"];
 
    // Make the plane fly by
    d = length( startPoint - endPoint );
    flyTime = ( d / flightPlan.speed );
    
    bombTime = ‪calculateReleaseTime( flyTime, flightPlan.height, flightPlan.speed, flightPlan.bombSpeedScale);
    
    if (bombTime < 0)
    {
        bombTime = 0;
    }
 
    assert( flyTime > bombTime );
    
    flightPlan.owner endon("disconnect");
    
    requiredDeathCount = flightPlan.owner.deathCount;
    
    side = VectorCross( anglestoforward( direction ), (0,0,1) );
    plane_seperation = 25;
    side_offset = VectorScale( side, plane_seperation );
 
    level thread ‪planeStrike( flightPlan.owner, requiredDeathCount, startPoint, endPoint, bombTime, flyTime, flightPlan.speed, flightPlan.bombSpeedScale, direction, flightPlan.planeSpawnCallback );
    wait( flightPlan.planeSpacing );
    level thread ‪planeStrike( flightPlan.owner, requiredDeathCount, startPoint+side_offset, endPoint+side_offset, bombTime, flyTime, flightPlan.speed, flightPlan.bombSpeedScale, direction, flightPlan.planeSpawnCallback );
    wait( flightPlan.planeSpacing );
    
    side_offset = VectorScale( side, -1 * plane_seperation );
 
    level thread ‪planeStrike( flightPlan.owner, requiredDeathCount, startPoint+side_offset, endPoint+side_offset, bombTime, flyTime, flightPlan.speed, flightPlan.bombSpeedScale, direction, flightPlan.planeSpawnCallback );
}
 
 
function ‪planeStrike( owner, requiredDeathCount, pathStart, pathEnd, bombTime, flyTime, flyspeed, bombSpeedScale, direction, planeSpawnedFunction )
{
    // plane spawning randomness = up to 125 units, biased towards 0
    // radius of bomb damage is 512
 
    if ( !isdefined( owner ) ) 
        return;
    
//  bomb_x = (flySpeed * bombSpeedScale) * bombTime;
//  origin = VectorScale(pathEnd - pathStart, 0.5) + pathStart;
//  plane = spawnplane( owner, "script_model", origin );
 
    // Spawn the planes
    plane = spawnplane( owner, "script_model", pathStart );
    plane.angles = direction;
 
    plane moveTo( pathEnd, flyTime, 0, 0 );
    
    thread ‪debug_plane_line( flyTime, flyspeed, pathStart, pathEnd );
    
    if ( isdefined(planeSpawnedFunction) )
    {
        plane [[planeSpawnedFunction]]( owner, requiredDeathCount, pathStart, pathEnd, bombTime, bombSpeedScale, flyTime, flyspeed );
    }
    
    // Delete the plane after its flyby
    wait flyTime;
    plane notify( "delete" );
    plane delete();
}
 
// TARGETING 
 
function ‪determineGroundPoint( player, position )
{
    ground = (position[0], position[1], player.origin[2]);
    
    ‪trace = bullettrace(ground  + (0,0,10000), ground, false, undefined );
    return ‪trace["position"];
}
 
function ‪determineTargetPoint( player, position )
{
    point = ‪determineGroundPoint( player, position );
    
    return ‪clampTarget( point );
}
 
function ‪getMinTargetHeight()
{
    return level.spawnMins[2] - 500;
}
 
function ‪getMaxTargetHeight()
{
    return level.spawnMaxs[2] + 500;
}
 
function ‪clampTarget( target )
{
    min = ‪getMinTargetHeight();
    max = ‪getMaxTargetHeight();
    
    if ( target[2] < min )
        target[2] = min;
 
    if ( target[2] > max )
        target[2] = max;
        
    return target;
}
 
 
// NO FLY ZONE 
 
function ‪_insideCylinder( point, base, radius, height )
{
    // only going to test if the point is above the height
    // if the point is below the cylinder going to treat it
    // as being inside
    if ( isdefined( height ) )
    {
        if ( point[2] > base[2] + height )
            return false;
    }
        
    dist = Distance2D( point,   base );
    
    if ( dist < radius )
        return true;
        
    return false;
}
 
function ‪_insideNoFlyZoneByIndex( point, index, disregardHeight )
{
    height = level.noFlyZones[index].height;
    
    if ( isdefined(disregardHeight ) )
        height = undefined;
        
    return ‪_insideCylinder( point, level.noFLyZones[index].origin, level.noFlyZones[index].radius, height );
}
 
// if not in a no fly zone then it just returns the height of the point passed in
function ‪getNoFlyZoneHeight( point )
{
    height = point[2];
    origin = undefined;
    
    for ( i = 0; i < level.noFlyZones.size; i++ )
    {
        if ( ‪_insideNoFlyZoneByIndex( point, i ) )
        {
            if ( height < level.noFlyZones[i].height )
            {
                height = level.noFlyZones[i].height;
                origin = level.noFlyZones[i].origin;
            }
        }
    }
    
    if ( !isdefined( origin ) )
        return point[2];
         
    return origin[2] + height;
}
 
function ‪insideNoFlyZones( point, disregardHeight )
{
    noFlyZones = [];
    
    for ( i = 0; i < level.noFlyZones.size; i++ )
    {
        if ( ‪_insideNoFlyZoneByIndex( point, i, disregardHeight ) )
        {
            noFlyZones[noFlyZones.size] = i;
        }
    }
    
    return noFlyZones;
}
 
 
function ‪crossesNoFlyZone( start, ‪end )
{
    for ( i = 0; i < level.noFlyZones.size; i++ )
    {
        point = ‪math::closest_point_on_line( level.noFlyZones[i].origin + (0,0,(0.5 * level.noFlyZones[i].height)), start, ‪end );
        dist = Distance2D( point, level.noFlyZones[i].origin );
    
        if ( point[2] > ( level.noFlyZones[i].origin[2] + level.noFlyZones[i].height ) )
            continue;
            
        if ( dist  < level.noFlyZones[i].radius )
        {
            return i;
        }
    }
    
    return undefined;
}
 
function ‪crossesNoFlyZones( start, ‪end )
{
    zones = [];
    for ( i = 0; i < level.noFlyZones.size; i++ )
    {
        point = ‪math::closest_point_on_line( level.noFlyZones[i].origin, start, ‪end );
        dist = Distance2D( point,   level.noFlyZones[i].origin );
    
        if ( point[2] > ( level.noFlyZones[i].origin[2] + level.noFlyZones[i].height ) )
            continue;
            
        if ( dist < level.noFlyZones[i].radius )
        {
            zones[zones.size] = i;
        }
    }
    
    return zones;
}
 
function ‪getNoFlyZoneHeightCrossed( start, ‪end, minHeight )
{
    height = minHeight;
    for ( i = 0; i < level.noFlyZones.size; i++ )
    {
        point = ‪math::closest_point_on_line( level.noFlyZones[i].origin, start, ‪end );
        dist = Distance2D( point, level.noFlyZones[i].origin );
    
        if ( dist < level.noFlyZones[i].radius )
        {
            if ( height < level.noFlyZones[i].height )
                height = level.noFlyZones[i].height;
        }
    }
    
    return height;
}
 
function ‪_shouldIgnoreNoFlyZone( noFlyZone, noFlyZones )
{
    if ( !isdefined( noFlyZone ) )
        return true;
        
    for ( i = 0; i < noFlyZones.size; i ++ )
    {
        if ( isdefined( noFlyZones[i] ) && noFlyZones[i] == noFlyZone )
            return true;
    }
        
    return false;
}
 
function ‪_shouldIgnoreStartGoalNoFlyZone( noFlyZone, startNoFlyZones, goalNoFlyZones )
{
    if ( !isdefined( noFlyZone ) )
        return true;
        
    if ( ‪_shouldIgnoreNoFlyZone( noFlyZone, startNoFlyZones ) )
        return true;
        
    if ( ‪_shouldIgnoreNoFlyZone( noFlyZone, goalNoFlyZones ) )
        return true;
        
    return false;
}
 
 
function ‪getHeliPath( start, goal )
{
    startNoFlyZones = ‪insideNoFlyZones( start, true );
    
    thread ‪debug_line( start, goal, (1,1,1) );
 
    goalNoFlyZones = ‪insideNoFlyZones( goal );
    
    // if the end point is in a no fly zone then raise the height to the top of the zone
    if ( goalNoFlyZones.size )
    {
        goal = ( goal[0], goal[1], ‪getNoFlyZoneHeight( goal ) );
    }
    
    goal_points = ‪calculatePath(start, goal, startNoFlyZones, goalNoFlyZones );
    
    if ( !isdefined( goal_points ) )
        return undefined;
        
    Assert(goal_points.size >= 1 );
    
    return goal_points;
}
 
function ‪followPath( path,  doneNotify, stopAtGoal )
{
    for ( i = 0; i < (path.size - 1); i++ )
    {
        self SetVehGoalPos( path[i], false );
        
        thread ‪debug_line( self.origin, path[i], (1,1,0) );
        self waittill("goal" );     
    }
        
    self SetVehGoalPos( path[path.size - 1], stopAtGoal );
    thread ‪debug_line( self.origin, path[i], (1,1,0) );
    
    self waittill("goal" );
    
    if ( isdefined( doneNotify ) )
    {
        self notify(doneNotify);
    }
}
 
function ‪setGoalPosition( goal, doneNotify, stopAtGoal ) 
{
    if ( !isdefined( stopAtGoal ) )
        stopAtGoal = true;
        
    // should test the start to see if it is inside of a no fly zone
    // and try and make the vehicle leave the no fly zone in as short of
    // a path possible while still moving intelligently
    start = self.origin;
    
    goal_points = ‪getHeliPath(start, goal );
    
    if ( !isdefined(goal_points) )
    {
        goal_points = [];
        goal_points[0] = goal;
    }
    
    ‪followPath( goal_points, doneNotify, stopAtGoal );
}
 
function ‪clearPath( start, ‪end, startNoFlyZone, goalNoFlyZone )
{
    noFlyZones = ‪crossesNoFlyZones( start, ‪end );
    
    for ( i = 0 ; i < noFlyZones.size; i++ )
    {
        if ( !‪_shouldIgnoreStartGoalNoFlyZone( noFlyZones[i], startNoFlyZone, goalNoFlyZone) )
        {
            return false;
        }
    }
    
    return true;
}
 
function ‪append_array( dst, src )
{
    for ( i= 0; i < src.size; i++ )
    {
        dst[ dst.size ]= src[ i ];
    }
}
 
function ‪calculatePath_r( start, ‪end, points, startNoFlyZones, goalNoFlyZones, depth )
{
    depth--;
    
    if ( depth <= 0 )
    {
        points[points.size] = ‪end;
        return points;
    }
    
    noFlyZones = ‪crossesNoFlyZones( start, ‪end );
    
    for ( i = 0; i < noFlyZones.size; i++ )
    {
        noFlyZone = noFlyZones[i];
        
        // simple path right now
        // probably need to modify this so it tests the new lines found
        if ( !‪_shouldIgnoreStartGoalNoFlyZone( noFlyZone, startNoFlyZones, goalNoFlyZones) )
        {
            return undefined;
        }
    }
    
    points[points.size] = ‪end;
 
    return points;
}
 
function ‪calculatePath( start, ‪end, startNoFlyZones, goalNoFlyZones )
{
    points = [];
    
//  PrintLn( "starting path calc: " + start + " " + end );
//  points[0] = start;
    
    points = ‪calculatePath_r( start, ‪end, points, startNoFlyZones, goalNoFlyZones, 3 );
    
    if ( !isdefined(points) )
        return undefined;
    
    Assert( points.size >= 1 );
    
    
    ‪debug_sphere( points[points.size - 1], 10, (1,0,0), 1, 1000 );
    
    point = start;
    
//  PrintLn( "Path Calculated: " + points.size );
    for ( i = 0 ; i < points.size; i++ )
    {
        thread ‪debug_line( point, points[i], (0,1,0) );
        ‪debug_sphere( points[i], 10, (0,0,1), 1, 1000 );
        point = points[i];
    }
    return points;
}
 
function ‪_getStrikePathStartAndEnd( goal, yaw, halfDistance )
{
    direction = (0,yaw,0);
    
    startPoint = goal + VectorScale( anglestoforward( direction ), -1 * halfDistance );
    endPoint = goal + VectorScale( anglestoforward( direction ), halfDistance );
    
    noFlyZone = ‪crossesNoFlyZone( startPoint, endPoint );
    
    path = [];
    
    if ( isdefined( noFlyZone ) )
    {
        path["noFlyZone"] = noFlyZone;
        
        startPoint = ( startPoint[0], startPoint[1], level.noFlyZones[noFlyZone].origin[2] + level.noFlyZones[noFlyZone].height ); 
        endPoint = ( endPoint[0], endPoint[1], startPoint[2] );
    }
    else
    {
        path["noFlyZone"] = undefined;
    }
    
    path["start"] = startPoint;
    path["end"] = endPoint;
    path["direction"] = direction;
    
    return path;
}
 
function ‪getStrikePath( target, height, halfDistance, yaw )
{
    noFlyZoneHeight = ‪getNoFlyZoneHeight( target );
    
    worldHeight = target[2] + height;
    
    if ( noFlyZoneHeight > worldHeight )
    {
        worldHeight = noFlyZoneHeight;
    }
    
    goal = ( target[0], target[1], worldHeight );
 
    path = [];
    
    if ( !isdefined( yaw ) || yaw != "random" )
    {
        // try a few times to find a path that is not through a no fly zone
        for ( i = 0; i < 3; i++ )
        {
            path = ‪_getStrikePathStartAndEnd( goal, randomint( 360 ), halfDistance );
    
            if ( !isdefined( path["noFlyZone"] ) )
            {
                break;
            }
        }
    }
    else
    {
            path = ‪_getStrikePathStartAndEnd( goal, yaw, halfDistance );
    }
    
    path["height"] = worldHeight - target[2];
    return path;
}
 
function ‪doGlassDamage(pos, radius, max, min, mod)
{
    wait(RandomFloatRange(0.05, 0.15));
    glassRadiusDamage( pos, radius, max, min, mod );
}
 
function ‪entLOSRadiusDamage( ent, pos, radius, max, min, owner, eInflictor )
{
    dist = distance(pos, ent.damageCenter);
    
    if ( ent.isPlayer || ent.isActor )
    {
        assumed_ceiling_height = 800;  // check for very high ceilings
        eye_position = ent.entity GetEye();
        head_height = eye_position[2];
        debug_display_time = 40 * 100;
 
        // check if there is a path to this entity above his feet. if not, they're probably indoors
        ‪trace = ‪weapons::damage_trace( ent.entity.origin, ent.entity.origin + (0,0,assumed_ceiling_height), 0, undefined );
        indoors = (‪trace["fraction"] != 1);
            
        if ( indoors )
        {
            // the follow check will still fail indoors if the bomb is detonated above the player
            // and the ceiling is under 130 units.  This second check will have line of site to 
            // the "ceiling height" point.  I dont want to change it at this point.
            
            test_point = ‪trace["position"];
            ‪debug_star(test_point, (0,1,0), debug_display_time);
            
            ‪trace = ‪weapons::damage_trace( (test_point[0],test_point[1],head_height) , (pos[0],pos[1], head_height), 0, undefined );
            indoors = (‪trace["fraction"] != 1);
            
            if ( indoors )
            {
                ‪debug_star((pos[0],pos[1], head_height), (0,1,0), debug_display_time);
                // give them a distance advantage for being indoors.
                dist *= 4;
                if ( dist > radius )
                    return false;
            }
            else
            {
                ‪debug_star((pos[0],pos[1], head_height), (1,0,0), debug_display_time);
                ‪trace = ‪weapons::damage_trace( (pos[0],pos[1], head_height), pos, 0, undefined );
                indoors = (‪trace["fraction"] != 1);
                if ( indoors )
                {
                    ‪debug_star(pos, (0,1,0), debug_display_time);
                    // give them a distance advantage for being indoors.
                    dist *= 4;
                    if ( dist > radius )
                        return false;
                }
                else
                {
                    ‪debug_star(pos, (1,0,0), debug_display_time);
                }
            }
        }
        else
        {
            ‪debug_star(ent.entity.origin + (0,0,assumed_ceiling_height), (1,0,0), debug_display_time );
        }
    }
 
    ent.damage = int(max + (min-max)*dist/radius);
    ent.pos = pos;
    ent.damageOwner = owner;
    ent.eInflictor = eInflictor;
    
    return true;
}
 
function ‪GetMapCenter()
{
    minimapOrigins = getEntArray( "minimap_corner", "targetname" );
    if( miniMapOrigins.size )
    {
        return ‪math::find_box_center( miniMapOrigins[0].origin, miniMapOrigins[1].origin );
    }
    
    return ( 0, 0, 0 );
}
 
function ‪GetRandomMapPoint( x_offset, y_offset, map_x_percentage, map_y_percentage )
{
    minimapOrigins = getEntArray( "minimap_corner", "targetname" );
    if( miniMapOrigins.size )
    {
        rand_x = 0;
        rand_y = 0;
        
        if( miniMapOrigins[0].origin[0] < miniMapOrigins[1].origin[0] )
        {
            rand_x = RandomFloatRange( miniMapOrigins[0].origin[0] * map_x_percentage, miniMapOrigins[1].origin[0] * map_x_percentage );
            rand_y = RandomFloatRange( miniMapOrigins[0].origin[1] * map_y_percentage, miniMapOrigins[1].origin[1] * map_y_percentage );
        }
        else
        {
            rand_x = RandomFloatRange( miniMapOrigins[1].origin[0] * map_x_percentage, miniMapOrigins[0].origin[0] * map_x_percentage );
            rand_y = RandomFloatRange( miniMapOrigins[1].origin[1] * map_y_percentage, miniMapOrigins[0].origin[1] * map_y_percentage );
        }
 
        return ( x_offset + rand_x, y_offset + rand_y, 0 );
    }
    
    return ( x_offset, y_offset, 0 );
}
 
function ‪GetMaxMapWidth()
{
    minimapOrigins = getEntArray( "minimap_corner", "targetname" );
    if( miniMapOrigins.size )
    {
        x = abs( miniMapOrigins[0].origin[0] - miniMapOrigins[1].origin[0] );
        y = abs( miniMapOrigins[0].origin[1] - miniMapOrigins[1].origin[1] );
        
        return max( x, y );
    }
    
    return 0;
}
 
function ‪InitRotatingRig()
{
    level.airsupport_rotator = ‪spawn( "script_model", ‪GetMapCenter() +  ( ‪VAL( level.rotator_x_offset, 0 ), ‪VAL( level.rotator_y_offset, 0 ), 1200 ) );
    level.airsupport_rotator setModel( "tag_origin" );
    level.airsupport_rotator.angles = ( 0, 115, 0 );
    level.airsupport_rotator hide();
    level.airsupport_rotator thread ‪RotateRig();
    level.airsupport_rotator thread ‪SwayRig();
}
 
function ‪RotateRig()
{
    for (;;)
    {
        self rotateyaw( -360, 60 );
        wait ( 60 );
    }
}
 
function ‪SwayRig()
{
    centerOrigin = self.origin;
    
    for (;;)
    {
        z = randomIntRange( -200, -100 );
        
        time = randomIntRange( 3, 6 );
        self moveto( centerOrigin + (0,0,z), time, 1, 1 );
        wait ( time );
        
        z = randomIntRange( 100, 200 );
        
        time = randomIntRange( 3, 6 );
        self moveto( centerOrigin + (0,0,z), time, 1, 1 );
        wait ( time );
    }
}
 
function ‪StopRotation( time )
{
    self endon( "death" );
    wait( time );
    self StopLoopSound();
}
 
function ‪FlattenYaw( goal )
{
    self endon( "death" );
    
    ‪increment = 3;
    if ( self.angles[1] > goal )
    {
        ‪increment = ‪increment * -1;
    }
    while( abs( self.angles[1] - goal ) > 3 )
    {
        self.angles = (self.angles[0], self.angles[1] + ‪increment, self.angles[2] );
        ‪WAIT_SERVER_FRAME;
    }
}
 
function ‪FlattenRoll()
{
    self endon( "death" );
    
    while (self.angles[2] < 0)
    {
        self.angles = (self.angles[0], self.angles[1], self.angles[2] + 2.5 );
        ‪WAIT_SERVER_FRAME;
    }
}
 
function ‪Leave( duration )
{   
    self unlink();
 
    self thread ‪StopRotation( 1 );
    
    tries = 10;
    yaw = 0;
    while( tries > 0 )
    {
        exitVector = ( anglestoforward( self.angles + ( 0, yaw, 0 ) ) * 20000 );
        exitPoint = ( self.origin[0] + exitVector[0], self.origin[1] + exitVector[1], self.origin[2] - 2500);
        exitPoint = self.origin + exitVector;
        
        nfz = ‪airsupport::crossesNoFlyZone (self.origin, exitPoint);
        if( isdefined(nfz))
        {
            if ( tries != 1 )
            {
                if ( tries % 2 == 1)
                {
                    yaw = yaw * -1;
                }
                else
                {
                    yaw = yaw + 10;
                    yaw = yaw * -1;
                }
            }
            tries--;
        }
        else
        {
            tries = 0;  
        }
    }
 
    self thread ‪FlattenYaw( self.angles[1] + yaw );
    if (self.angles[2] != 0)
    {
        self thread ‪FlattenRoll();
    }
    
    if ( IsVehicle( self ) )
    {
        self SetSpeed( ( ( Length( exitVector ) / duration ) / ‪MPH_TO_INCHES_PER_SEC ), 60 );
        self SetVehGoalPos( exitPoint, false, false );
    }
    else
    {
        self moveto( exitPoint, duration, 0, 0 );
    }
    self notify ( "leaving");
}
 
 
function ‪GetRandomHelicopterStartOrigin()
{
    dist = -1 * GetDvarInt( "scr_supplydropIncomingDistance", 10000 );
    pathRandomness = 100;
    direction = ( 0, RandomIntRange( -2, 3 ), 0 );
    
    start_origin = ( AnglesToForward( direction ) * dist );
    start_origin += ( ( randomfloat( 2 ) - 1 ) * pathRandomness, ( randomfloat( 2 ) - 1 ) * pathRandomness, 0 );
 
/#
    if ( GetDvarInt( "scr_noflyzones_debug", 0 ) ) 
    {
        if ( level.noFlyZones.size )
        {
            index = RandomIntRange( 0, level.noFlyZones.size );
            delta = level.noFlyZones[ index ].origin;
            delta = ( delta[0] + RandomInt( 10 ), delta[ 1 ] + RandomInt( 10 ), 0 );
            delta = VectorNormalize( delta );
            start_origin = ( delta * dist );
        }
    }
#/
    return start_origin;
}
 
 
// debug
 
function ‪debug_no_fly_zones()
{
    /#
    for ( i = 0; i < level.noFlyZones.size; i++ )
    {
        ‪debug_airsupport_cylinder( level.noFlyZones[i].origin, level.noFlyZones[i].radius, level.noFlyZones[i].height, (1,1,1), undefined, 5000 );
    }
    #/
}
 
function ‪debug_plane_line( flyTime, flyspeed,pathStart, pathEnd )
{
    thread ‪debug_line( pathStart, pathEnd, (1,1,1) );
    
    delta = VectorNormalize(pathEnd - pathStart);
    
    for ( i = 0; i < flyTime; i++ )
    {
        thread ‪debug_star( pathStart + VectorScale(delta, i * flyspeed), (1,0,0) );
    }
}
 
function ‪debug_draw_bomb_explosion(prevpos)
{
    self notify("draw_explosion");
    ‪WAIT_SERVER_FRAME;
    self endon("draw_explosion");
    
    self waittill("projectile_impact", weapon, position );
    
    thread ‪debug_line( prevpos, position, (.5,1,0) );
    thread ‪debug_star( position, (1,0,0) );
}
 
function ‪debug_draw_bomb_path( projectile, color, time )
{
/#
    self endon("death");
    level.airsupport_debug = GetDvarInt( "scr_airsupport_debug", 0 );               // debug mode, draws debugging info on screen
    
    if ( !isdefined( color ) )
    {
        color = (.5,1,0);
    }
    
    if ( isdefined( level.airsupport_debug ) && level.airsupport_debug == 1.0 )
    {
        prevpos = self.origin;
        while(isdefined ( self.origin ) )
        {       
            thread ‪debug_line( prevpos, self.origin, color, time );
            prevpos = self.origin;
            
            if ( isdefined(projectile) && projectile )
            {
                thread ‪debug_draw_bomb_explosion( prevpos );
            }
            
            wait .2;
        }
    }
#/
}
 
function ‪debug_print3d_simple( message, ent, offset, frames )
{
    /#
    level.airsupport_debug = GetDvarInt( "scr_airsupport_debug", 0 );               // debug mode, draws debugging info on screen
    
    if ( isdefined( level.airsupport_debug ) && level.airsupport_debug == 1.0 )
    {
        if( isdefined( frames ) )
            thread ‪draw_text( message, ( 0.8, 0.8, 0.8 ), ent, offset, frames );
        else
            thread ‪draw_text( message, ( 0.8, 0.8, 0.8 ), ent, offset, 0 );
    }
    #/
}
 
function ‪draw_text( msg, color, ent, offset, frames )
{
    /#
    if( frames == 0 )
    {
        while ( isdefined( ent ) && isdefined( ent.origin ) )
        {
            print3d( ent.origin+offset, msg , color, 0.5, 4 );
            ‪WAIT_SERVER_FRAME;
        }
    }
    else
    {
        for( i=0; i < frames; i++ )
        {
            if( !isdefined( ent ) )
                break;
            print3d( ent.origin+offset, msg , color, 0.5, 4 );
            ‪WAIT_SERVER_FRAME;
        }
    }
    #/
}
 
 
function ‪debug_print3d( message, color, ent, origin_offset, frames )
{
/#
    level.airsupport_debug = GetDvarInt( "scr_airsupport_debug", 0 );               // debug mode, draws debugging info on screen
    
    if ( isdefined( level.airsupport_debug ) && level.airsupport_debug == 1.0 )
        self thread ‪draw_text( message, color, ent, origin_offset, frames );
#/
}
 
 
function ‪debug_line( from, to, color, time, depthTest )
{
/#
    level.airsupport_debug = GetDvarInt( "scr_airsupport_debug", 0 );               // debug mode, draws debugging info on screen
    
    if ( isdefined( level.airsupport_debug ) && level.airsupport_debug == 1.0 )
    {
        if ( DistanceSquared( from, to )  < 0.01 )
            return;
        
        if ( !isdefined(time) )
        {
            time = 1000;
        }
        if ( !isdefined(depthTest) )
        {
            depthTest = true;
        }
        Line( from, to, color, 1, depthTest, time);
    }
#/
 
}
 
function ‪debug_star( origin, color, time )
{
/#
    level.airsupport_debug = GetDvarInt( "scr_airsupport_debug", 0 );               // debug mode, draws debugging info on screen
    
    if ( isdefined( level.airsupport_debug ) && level.airsupport_debug == 1.0 )
    {
        if ( !isdefined(time) )
        {
            time = 1000;
        }
        if ( !isdefined(color) )
        {
            color = (1,1,1);
        }
        debugstar(  origin, time, color );
    }
#/
}
 
function ‪debug_circle( origin, radius, color, time )
{
/#
    level.airsupport_debug = GetDvarInt( "scr_airsupport_debug", 0 );               // debug mode, draws debugging info on screen
    
    if ( isdefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
    {
        if ( !isdefined(time) )
        {
            time = 1000;
        }
        if ( !isdefined(color) )
        {
            color = (1,1,1);
        }
        circle( origin, radius, color, true, true, time );
    }
#/
}
 
function ‪debug_sphere( origin, radius, color, alpha, time )
{
/#
    level.airsupport_debug = GetDvarInt( "scr_airsupport_debug", 0 );               // debug mode, draws debugging info on screen
    
    if ( isdefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
    {
        if ( !isdefined(time) )
        {
            time = 1000;
        }
        if ( !isdefined(color) )
        {
            color = (1,1,1);
        }
        
        sides = Int(10 * ( 1 + Int(radius / 100) ));
        sphere( origin, radius, color, alpha, true, sides, time );
    }
#/
}
 
function ‪debug_airsupport_cylinder( origin, radius, height, color, mustRenderHeight, time )
{
/#
    level.airsupport_debug = GetDvarInt( "scr_airsupport_debug", 0 );               // debug mode, draws debugging info on screen
    
    if ( isdefined( level.airsupport_debug ) && level.airsupport_debug == 1 )
    {
        ‪debug_cylinder( origin, radius, height, color, mustRenderHeight, time );
    }
#/
}
 
function ‪debug_cylinder( origin, radius, height, color, mustRenderHeight, time )
{
/#
    
    subdivision = 600;
    
    {
        if ( !isdefined(time) )
        {
            time = 1000;
        }
        if ( !isdefined(color) )
        {
            color = (1,1,1);
        }
        
        count = (height/subdivision);
        
        for ( i = 0; i < count; i++ )
        {
            point = origin + ( 0, 0, i * subdivision );
            circle( point, radius, color, true, true, time );
        }
        
        if( isdefined( mustRenderHeight ) )
        {
            point = origin + ( 0, 0, mustRenderHeight );
            circle( point, radius, color, true, true, time );
        }
    }
#/
}
function ‪getPointOnLine( startPoint, endPoint, ratio )
{
    nextPoint = ( startPoint[0] + ( ( endPoint[0] - startPoint[0] ) * ratio ) , 
                  startPoint[1] + ( ( endPoint[1] - startPoint[1] ) * ratio ) ,
                  startPoint[2] + ( ( endPoint[2] - startPoint[2] ) * ratio ) );
 
    return nextPoint;
}
 
function ‪canTargetPlayerWithSpecialty()
{
    if ( self HasPerk( "specialty_nottargetedbyairsupport" ) || 
    (   isdefined( self.specialty_nottargetedbyairsupport ) && self.specialty_nottargetedbyairsupport ) )
    {
        if ( !isdefined( self.notTargettedAI_underMinSpeedTimer ) || self.notTargettedAI_underMinSpeedTimer < GetDvarInt( "perk_nottargetedbyai_graceperiod" ) )
            return false;
    }
    return true;
}
 
 
function ‪monitorSpeed( spawnProtectionTime )
{
    self endon( "death" );
    self endon( "disconnect" );
    
    if ( self HasPerk( "specialty_nottargetedbyairsupport" ) == false )
    {
        return;
    }
 
    GetDvarString( "perk_nottargetted_graceperiod" );
    ‪gracePeriod = GetDvarInt( "perk_nottargetedbyai_graceperiod" );
    minspeed = GetDvarInt( "perk_nottargetedbyai_min_speed" );
    minspeedSq = minspeed * minspeed;
    waitPeriod = 0.25;
    waitPeriodMilliseconds = waitPeriod * 1000;
    if ( minspeedSq == 0 ) // will never fail min speed check below so early out.  
        return;
    
    self.notTargettedAI_underMinSpeedTimer = 0;
    
    if ( isdefined ( spawnProtectionTime ) )
    {
        wait( spawnProtectionTime );
    }
    
    while(1)
    {
        velocity = self GetVelocity();
        
        speedsq = lengthsquared( velocity );
        
        if ( speedSq < minspeedSq )
        {
            self.notTargettedAI_underMinSpeedTimer += waitPeriodMilliseconds;
        }
        else
        {
            self.notTargettedAI_underMinSpeedTimer = 0;
        }
        
        wait( waitPeriod );
    }
}
 
function ‪clearmonitoredspeed()
{
    if ( isdefined ( self.notTargettedAI_underMinSpeedTimer ) ) 
        self.notTargettedAI_underMinSpeedTimer = 0;
}