2170 lines
61 KiB
Plaintext
2170 lines
61 KiB
Plaintext
// IW5 PC GSC
|
|
// Decompiled by https://github.com/xensik/gsc-tool
|
|
|
|
init()
|
|
{
|
|
var_0 = getentarray( "heli_start", "targetname" );
|
|
var_1 = getentarray( "heli_loop_start", "targetname" );
|
|
|
|
if ( !var_0.size && !var_1.size )
|
|
return;
|
|
|
|
level.heli_types = [];
|
|
precacheitem( "heli_remote_mp" );
|
|
precacheHelicopter( "vehicle_cobra_helicopter_fly_low", "cobra" );
|
|
precacheHelicopter( "vehicle_mi24p_hind_mp", "hind" );
|
|
precachevehicle( "cobra_mp" );
|
|
precacheitem( "cobra_20mm_mp" );
|
|
precacheHelicopter( "vehicle_pavelow", "pavelow" );
|
|
precacheHelicopter( "vehicle_pavelow_opfor", "pavelow" );
|
|
precachevehicle( "pavelow_mp" );
|
|
precacheturret( "pavelow_minigun_mp" );
|
|
precachestring( &"SPLASHES_DESTROYED_PAVELOW" );
|
|
precachestring( &"SPLASHES_DESTROYED_MINIGUNNER" );
|
|
precachestring( &"SPLASHES_DESTROYED_HELICOPTER" );
|
|
level.chopper = undefined;
|
|
level.heli_start_nodes = getentarray( "heli_start", "targetname" );
|
|
level.heli_loop_nodes = getentarray( "heli_loop_start", "targetname" );
|
|
level.heli_leave_nodes = getentarray( "heli_leave", "targetname" );
|
|
level.heli_crash_nodes = getentarray( "heli_crash_start", "targetname" );
|
|
level.heli_missile_rof = 5;
|
|
level.heli_maxhealth = 2000;
|
|
level.heli_debug = 0;
|
|
level.heli_targeting_delay = 0.5;
|
|
level.heli_turretReloadTime = 1.5;
|
|
level.heli_turretClipSize = 40;
|
|
level.heli_visual_range = 3700;
|
|
level.heli_target_spawnprotection = 5;
|
|
level.heli_target_recognition = 0.5;
|
|
level.heli_missile_friendlycare = 256;
|
|
level.heli_missile_target_cone = 0.3;
|
|
level.heli_armor_bulletdamage = 0.3;
|
|
level.heli_attract_strength = 1000;
|
|
level.heli_attract_range = 4096;
|
|
level.heli_angle_offset = 90;
|
|
level.heli_forced_wait = 0;
|
|
level.chopper_fx["explode"]["death"] = [];
|
|
level.chopper_fx["explode"]["large"] = loadfx( "explosions/helicopter_explosion_secondary_small" );
|
|
level.chopper_fx["explode"]["medium"] = loadfx( "explosions/aerial_explosion" );
|
|
level.chopper_fx["smoke"]["trail"] = loadfx( "smoke/smoke_trail_white_heli" );
|
|
level.chopper_fx["fire"]["trail"]["medium"] = loadfx( "fire/fire_smoke_trail_L_emitter" );
|
|
level.chopper_fx["fire"]["trail"]["large"] = loadfx( "fire/fire_smoke_trail_L" );
|
|
level.chopper_fx["damage"]["light_smoke"] = loadfx( "smoke/smoke_trail_white_heli_emitter" );
|
|
level.chopper_fx["damage"]["heavy_smoke"] = loadfx( "smoke/smoke_trail_black_heli_emitter" );
|
|
level.chopper_fx["damage"]["on_fire"] = loadfx( "fire/fire_smoke_trail_L_emitter" );
|
|
level.chopper_fx["light"]["left"] = loadfx( "misc/aircraft_light_wingtip_green" );
|
|
level.chopper_fx["light"]["right"] = loadfx( "misc/aircraft_light_wingtip_red" );
|
|
level.chopper_fx["light"]["belly"] = loadfx( "misc/aircraft_light_red_blink" );
|
|
level.chopper_fx["light"]["tail"] = loadfx( "misc/aircraft_light_white_blink" );
|
|
level.fx_heli_dust = loadfx( "treadfx/heli_dust_default" );
|
|
level.fx_heli_water = loadfx( "treadfx/heli_water" );
|
|
makeHeliType( "cobra", "explosions/helicopter_explosion_cobra_low", ::defaultLightFX );
|
|
addAirExplosion( "cobra", "explosions/aerial_explosion_cobra_low_mp" );
|
|
makeHeliType( "pavelow", "explosions/helicopter_explosion_pavelow", ::pavelowLightFx );
|
|
addAirExplosion( "pavelow", "explosions/aerial_explosion_pavelow_mp" );
|
|
makeHeliType( "mi28", "explosions/helicopter_explosion_mi28_flying", ::defaultLightFX );
|
|
addAirExplosion( "mi28", "explosions/aerial_explosion_mi28_flying_mp" );
|
|
makeHeliType( "hind", "explosions/helicopter_explosion_hind_chernobyl", ::defaultLightFX );
|
|
addAirExplosion( "hind", "explosions/aerial_explosion_hind_chernobyl_mp" );
|
|
makeHeliType( "apache", "explosions/helicopter_explosion_apache", ::defaultLightFX );
|
|
addAirExplosion( "apache", "explosions/aerial_explosion_apache_mp" );
|
|
makeHeliType( "littlebird", "explosions/aerial_explosion_littlebird_mp", ::defaultLightFX );
|
|
addAirExplosion( "littlebird", "explosions/aerial_explosion_littlebird_mp" );
|
|
level.killstreakFuncs["helicopter"] = ::useHelicopter;
|
|
level.killstreakFuncs["helicopter_blackbox"] = ::useHelicopterBlackbox;
|
|
level.killstreakFuncs["helicopter_flares"] = ::useHelicopterFlares;
|
|
level.killstreakFuncs["helicopter_minigun"] = ::useHelicopterMinigun;
|
|
level.killstreakFuncs["helicopter_mk19"] = ::useHelicopterMK19;
|
|
level.heliDialog["tracking"][0] = "ac130_fco_moreenemy";
|
|
level.heliDialog["tracking"][1] = "ac130_fco_getthatguy";
|
|
level.heliDialog["tracking"][2] = "ac130_fco_guyrunnin";
|
|
level.heliDialog["tracking"][3] = "ac130_fco_gotarunner";
|
|
level.heliDialog["tracking"][4] = "ac130_fco_personnelthere";
|
|
level.heliDialog["tracking"][5] = "ac130_fco_rightthere";
|
|
level.heliDialog["tracking"][6] = "ac130_fco_tracking";
|
|
level.heliDialog["locked"][0] = "ac130_fco_lightemup";
|
|
level.heliDialog["locked"][1] = "ac130_fco_takehimout";
|
|
level.heliDialog["locked"][2] = "ac130_fco_nailthoseguys";
|
|
level.lastHeliDialogTime = 0;
|
|
maps\mp\_utility::queueCreate( "helicopter" );
|
|
}
|
|
|
|
makeHeliType( var_0, var_1, var_2 )
|
|
{
|
|
level.chopper_fx["explode"]["death"][var_0] = loadfx( var_1 );
|
|
level.lightFxFunc[var_0] = var_2;
|
|
}
|
|
|
|
addAirExplosion( var_0, var_1 )
|
|
{
|
|
level.chopper_fx["explode"]["air_death"][var_0] = loadfx( var_1 );
|
|
}
|
|
|
|
pavelowLightFx()
|
|
{
|
|
playfxontag( level.chopper_fx["light"]["left"], self, "tag_light_L_wing1" );
|
|
wait 0.05;
|
|
playfxontag( level.chopper_fx["light"]["right"], self, "tag_light_R_wing1" );
|
|
wait 0.05;
|
|
playfxontag( level.chopper_fx["light"]["belly"], self, "tag_light_belly" );
|
|
wait 0.05;
|
|
playfxontag( level.chopper_fx["light"]["tail"], self, "tag_light_tail" );
|
|
wait 0.05;
|
|
playfxontag( level.chopper_fx["light"]["tail"], self, "tag_light_tail2" );
|
|
wait 0.05;
|
|
playfxontag( level.chopper_fx["light"]["belly"], self, "tag_light_cockpit01" );
|
|
}
|
|
|
|
defaultLightFX()
|
|
{
|
|
playfxontag( level.chopper_fx["light"]["left"], self, "tag_light_L_wing" );
|
|
wait 0.05;
|
|
playfxontag( level.chopper_fx["light"]["right"], self, "tag_light_R_wing" );
|
|
wait 0.05;
|
|
playfxontag( level.chopper_fx["light"]["belly"], self, "tag_light_belly" );
|
|
wait 0.05;
|
|
playfxontag( level.chopper_fx["light"]["tail"], self, "tag_light_tail" );
|
|
}
|
|
|
|
useHelicopter( var_0 )
|
|
{
|
|
return tryUseHelicopter( var_0, "helicopter" );
|
|
}
|
|
|
|
useHelicopterBlackbox( var_0 )
|
|
{
|
|
return tryUseHelicopter( var_0, "blackbox" );
|
|
}
|
|
|
|
useHelicopterFlares( var_0 )
|
|
{
|
|
return tryUseHelicopter( var_0, "flares" );
|
|
}
|
|
|
|
useHelicopterMinigun( var_0 )
|
|
{
|
|
if ( isdefined( self.laststand ) && !maps\mp\_utility::_hasPerk( "specialty_finalstand" ) )
|
|
{
|
|
self iprintlnbold( &"MP_UNAVILABLE_IN_LASTSTAND" );
|
|
return 0;
|
|
}
|
|
|
|
return tryUseHelicopter( var_0, "minigun" );
|
|
}
|
|
|
|
useHelicopterMK19( var_0 )
|
|
{
|
|
if ( isdefined( self.laststand ) && !maps\mp\_utility::_hasPerk( "specialty_finalstand" ) )
|
|
{
|
|
self iprintlnbold( &"MP_UNAVILABLE_IN_LASTSTAND" );
|
|
return 0;
|
|
}
|
|
|
|
return tryUseHelicopter( var_0, "mk19" );
|
|
}
|
|
|
|
tryUseHelicopter( lifeId, heliType )
|
|
{
|
|
if ( isdefined( level.civilianJetFlyBy ) )
|
|
{
|
|
self iprintlnbold( &"MP_CIVILIAN_AIR_TRAFFIC" );
|
|
return 0;
|
|
}
|
|
|
|
if ( maps\mp\_utility::isAirDenied() )
|
|
return 0;
|
|
|
|
if ( maps\mp\_utility::isEMPed() )
|
|
return 0;
|
|
|
|
numIncomingVehicles = 1;
|
|
|
|
// Plutonium change: allow queueing of standard helicopter too (was just pave low/"flares")
|
|
if ( ( !isdefined( heliType ) || heliType == "flares" || heliType == "helicopter") && isdefined( level.chopper ) )
|
|
{
|
|
self iprintlnbold( &"MP_HELI_IN_QUEUE" );
|
|
|
|
if ( isdefined( heliType ) && heliType != "helicopter" )
|
|
streakName = "helicopter_" + heliType;
|
|
else
|
|
{
|
|
// the "attack heli" (cobra/hind) is just "helicopter"
|
|
streakName = "helicopter";
|
|
}
|
|
|
|
thread maps\mp\killstreaks\_killstreaks::updateKillstreaks();
|
|
heliEntity = spawn( "script_origin", ( 0, 0, 0 ) );
|
|
heliEntity hide();
|
|
heliEntity thread deleteOnEntNotify( self, "disconnect" );
|
|
heliEntity.player = self;
|
|
heliEntity.lifeId = lifeId;
|
|
heliEntity.heliType = heliType;
|
|
// this will be passed to "usedKillstreak" when they pop it off the queue
|
|
heliEntity.streakName = streakName;
|
|
maps\mp\_utility::queueAdd( "helicopter", heliEntity );
|
|
|
|
// this logic is normally done in _killstreaks::killStreakUseWaiter,
|
|
// but since we're returning false here, it won't be
|
|
if ( !self hasweapon( common_scripts\utility::getLastWeapon() ) )
|
|
lastWeapon = maps\mp\killstreaks\_killstreaks::getFirstPrimaryWeapon();
|
|
else
|
|
lastWeapon = common_scripts\utility::getLastWeapon();
|
|
|
|
ksWeapon = maps\mp\killstreaks\_killstreaks::getKillstreakWeapon( streakName );
|
|
thread maps\mp\killstreaks\_killstreaks::waitTakeKillstreakWeapon( ksWeapon, lastWeapon );
|
|
return 0;
|
|
}
|
|
else if ( isdefined( level.chopper ) )
|
|
{
|
|
self iprintlnbold( &"MP_AIR_SPACE_TOO_CROWDED" );
|
|
return 0;
|
|
}
|
|
else if ( maps\mp\_utility::currentActiveVehicleCount() >= maps\mp\_utility::maxVehiclesAllowed() || level.fauxVehicleCount + numIncomingVehicles >= maps\mp\_utility::maxVehiclesAllowed() )
|
|
{
|
|
self iprintlnbold( &"MP_TOO_MANY_VEHICLES" );
|
|
return 0;
|
|
}
|
|
|
|
numIncomingVehicles = 1;
|
|
|
|
if ( isdefined( heliType ) && heliType == "minigun" )
|
|
{
|
|
maps\mp\_utility::setUsingRemote( "helicopter_" + heliType );
|
|
var_7 = maps\mp\killstreaks\_killstreaks::initRideKillstreak();
|
|
|
|
if ( var_7 != "success" )
|
|
{
|
|
if ( var_7 != "disconnect" )
|
|
maps\mp\_utility::clearUsingRemote();
|
|
|
|
return 0;
|
|
}
|
|
|
|
if ( isdefined( level.chopper ) )
|
|
{
|
|
maps\mp\_utility::clearUsingRemote();
|
|
self iprintlnbold( &"MP_AIR_SPACE_TOO_CROWDED" );
|
|
return 0;
|
|
}
|
|
else if ( maps\mp\_utility::currentActiveVehicleCount() >= maps\mp\_utility::maxVehiclesAllowed() || level.fauxVehicleCount + numIncomingVehicles >= maps\mp\_utility::maxVehiclesAllowed() )
|
|
{
|
|
maps\mp\_utility::clearUsingRemote();
|
|
self iprintlnbold( &"MP_TOO_MANY_VEHICLES" );
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
startHelicopter( lifeId, heliType );
|
|
return 1;
|
|
}
|
|
|
|
deleteOnEntNotify( var_0, var_1 )
|
|
{
|
|
self endon( "death" );
|
|
var_0 waittill( var_1 );
|
|
self delete();
|
|
}
|
|
|
|
startHelicopter( var_0, var_1 )
|
|
{
|
|
maps\mp\_utility::incrementFauxVehicleCount();
|
|
|
|
if ( !isdefined( var_1 ) )
|
|
var_1 = "";
|
|
|
|
switch ( var_1 )
|
|
{
|
|
case "flares":
|
|
thread pavelowMadeSelectionVO();
|
|
var_2 = "helicopter_flares";
|
|
break;
|
|
case "minigun":
|
|
var_2 = "helicopter_minigun";
|
|
break;
|
|
default:
|
|
var_2 = "helicopter";
|
|
break;
|
|
}
|
|
|
|
var_3 = self.pers["team"];
|
|
var_4 = level.heli_start_nodes[randomint( level.heli_start_nodes.size )];
|
|
maps\mp\_matchdata::logKillstreakEvent( var_2, self.origin );
|
|
thread heli_think( var_0, self, var_4, self.pers["team"], var_1 );
|
|
}
|
|
|
|
precacheHelicopter( var_0, var_1 )
|
|
{
|
|
var_2 = loadfx( "explosions/tanker_explosion" );
|
|
precachemodel( var_0 );
|
|
level.heli_types[var_0] = var_1;
|
|
level.cobra_missile_models = [];
|
|
level.cobra_missile_models["cobra_Hellfire"] = "projectile_hellfire_missile";
|
|
precachemodel( level.cobra_missile_models["cobra_Hellfire"] );
|
|
level.heli_sound["allies"]["hit"] = "cobra_helicopter_hit";
|
|
level.heli_sound["allies"]["hitsecondary"] = "cobra_helicopter_secondary_exp";
|
|
level.heli_sound["allies"]["damaged"] = "cobra_helicopter_damaged";
|
|
level.heli_sound["allies"]["spinloop"] = "cobra_helicopter_dying_loop";
|
|
level.heli_sound["allies"]["spinstart"] = "cobra_helicopter_dying_layer";
|
|
level.heli_sound["allies"]["crash"] = "cobra_helicopter_crash";
|
|
level.heli_sound["allies"]["missilefire"] = "weap_cobra_missile_fire";
|
|
level.heli_sound["axis"]["hit"] = "cobra_helicopter_hit";
|
|
level.heli_sound["axis"]["hitsecondary"] = "cobra_helicopter_secondary_exp";
|
|
level.heli_sound["axis"]["damaged"] = "cobra_helicopter_damaged";
|
|
level.heli_sound["axis"]["spinloop"] = "cobra_helicopter_dying_loop";
|
|
level.heli_sound["axis"]["spinstart"] = "cobra_helicopter_dying_layer";
|
|
level.heli_sound["axis"]["crash"] = "cobra_helicopter_crash";
|
|
level.heli_sound["axis"]["missilefire"] = "weap_cobra_missile_fire";
|
|
}
|
|
|
|
spawn_helicopter( var_0, var_1, var_2, var_3, var_4 )
|
|
{
|
|
var_5 = spawnhelicopter( var_0, var_1, var_2, var_3, var_4 );
|
|
|
|
if ( !isdefined( var_5 ) )
|
|
return undefined;
|
|
|
|
var_5.heli_type = level.heli_types[var_4];
|
|
var_5 thread [[ level.lightFxFunc[var_5.heli_type] ]]();
|
|
var_5 addToHeliList();
|
|
var_5.zOffset = ( 0, 0, var_5 gettagorigin( "tag_origin" )[2] - var_5 gettagorigin( "tag_ground" )[2] );
|
|
var_5.attractor = missile_createattractorent( var_5, level.heli_attract_strength , level.heli_attract_range );
|
|
return var_5;
|
|
}
|
|
|
|
heliRide( var_0, var_1 )
|
|
{
|
|
self endon( "disconnect" );
|
|
var_1 endon( "helicopter_done" );
|
|
thread maps\mp\_utility::teamPlayerCardSplash( "used_helicopter_minigun", self );
|
|
self visionsetthermalforplayer( "black_bw", 0 );
|
|
maps\mp\_utility::_giveWeapon( "heli_remote_mp" );
|
|
self switchtoweapon( "heli_remote_mp" );
|
|
self visionsetthermalforplayer( game["thermal_vision"], 6 );
|
|
self thermalvisionon();
|
|
self thermalvisionfofoverlayon();
|
|
thread thermalVision( var_1 );
|
|
|
|
if ( getdvarint( "camera_thirdPerson" ) )
|
|
maps\mp\_utility::setThirdPersonDOF( 0 );
|
|
|
|
var_1 vehicleturretcontrolon( self );
|
|
self playerlinkweaponviewtodelta( var_1, "tag_player", 1.0, 180, 180, 0, 180, 1 );
|
|
var_1.gunner = self;
|
|
self.heliRideLifeId = var_0;
|
|
thread endRideOnHelicopterDone( var_1 );
|
|
thread weaponLockThink( var_1 );
|
|
|
|
for (;;)
|
|
{
|
|
var_1 waittill( "turret_fire" );
|
|
var_1 fireweapon();
|
|
earthquake( 0.2, 1, var_1.origin, 1000 );
|
|
}
|
|
}
|
|
|
|
thermalVision( var_0 )
|
|
{
|
|
var_0 endon( "helicopter_done" );
|
|
|
|
if ( maps\mp\_utility::getIntProperty( "ac130_thermal_enabled", 1 ) == 0 )
|
|
return;
|
|
|
|
var_1 = 0;
|
|
self visionsetthermalforplayer( level.ac130.enhanced_vision, 1 );
|
|
self.lastvisionsetthermal = level.ac130.enhanced_vision;
|
|
self thermalvisionoff();
|
|
self notifyonplayercommand( "switch thermal", "+usereload" );
|
|
self notifyonplayercommand( "switch thermal", "+activate" );
|
|
|
|
for (;;)
|
|
{
|
|
self waittill( "switch thermal" );
|
|
|
|
if ( !var_1 )
|
|
{
|
|
self visionsetthermalforplayer( level.ac130.thermal_vision, 0.62 );
|
|
self.lastvisionsetthermal = level.ac130.thermal_vision;
|
|
self thermalvisionon();
|
|
}
|
|
else
|
|
{
|
|
self visionsetthermalforplayer( level.ac130.enhanced_vision, 0.51 );
|
|
self.lastvisionsetthermal = level.ac130.enhanced_vision;
|
|
self thermalvisionoff();
|
|
}
|
|
|
|
var_1 = !var_1;
|
|
}
|
|
}
|
|
|
|
weaponLockThink( var_0 )
|
|
{
|
|
self endon( "disconnect" );
|
|
var_0 endon( "helicopter_done" );
|
|
|
|
if ( !isdefined( level.heliTargetOrigin ) )
|
|
{
|
|
level.heliTargetOrigin = spawn( "script_origin", ( 0, 0, 0 ) );
|
|
level.heliTargetOrigin hide();
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
var_1 = bullettrace( self geteye(), self geteye() + anglestoforward( self getplayerangles() ) * 100000, 1, self );
|
|
level.heliTargetOrigin.origin = var_1["position"];
|
|
var_2 = [];
|
|
var_3 = [];
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
if ( !isalive( var_5 ) )
|
|
continue;
|
|
|
|
if ( level.teamBased && var_5.team == self.team )
|
|
continue;
|
|
|
|
if ( var_5 == self )
|
|
continue;
|
|
|
|
if ( var_5 maps\mp\_utility::_hasPerk( "specialty_blindeye" ) )
|
|
continue;
|
|
|
|
if ( isdefined( var_5.spawnTime ) && ( gettime() - var_5.spawnTime ) / 1000 <= 5 )
|
|
continue;
|
|
|
|
var_5.remoteHeliLOS = 1;
|
|
|
|
if ( !bullettracepassed( self geteye(), var_5.origin + ( 0, 0, 32 ), 0, var_0 ) )
|
|
{
|
|
var_3[var_3.size] = var_5;
|
|
continue;
|
|
}
|
|
|
|
var_2[var_2.size] = var_5;
|
|
}
|
|
|
|
var_7 = [];
|
|
var_7 = var_2;
|
|
|
|
foreach ( var_9 in var_3 )
|
|
var_2[var_2.size] = var_9;
|
|
|
|
if ( var_7.size != 0 )
|
|
{
|
|
var_11 = sortbydistance( var_7, var_1["position"] );
|
|
|
|
if ( distance( var_11[0].origin, var_1["position"] ) < 384 && var_11[0] damageconetrace( var_1["position"] ) )
|
|
{
|
|
self weaponlockfinalize( var_11[0] );
|
|
heliDialog( "locked" );
|
|
}
|
|
else
|
|
{
|
|
self weaponlockstart( var_11[0] );
|
|
heliDialog( "tracking" );
|
|
}
|
|
}
|
|
else
|
|
self weaponlockfree();
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
heliDialog( var_0 )
|
|
{
|
|
if ( gettime() - level.lastHeliDialogTime < 6000 )
|
|
return;
|
|
|
|
level.lastHeliDialogTime = gettime();
|
|
var_1 = randomint( level.heliDialog[var_0].size );
|
|
var_2 = level.heliDialog[var_0][var_1];
|
|
var_3 = maps\mp\gametypes\_teams::getTeamVoicePrefix( self.team ) + var_2;
|
|
self playlocalsound( var_3 );
|
|
}
|
|
|
|
endRide( var_0 )
|
|
{
|
|
self remotecamerasoundscapeoff();
|
|
self thermalvisionoff();
|
|
self thermalvisionfofoverlayoff();
|
|
self unlink();
|
|
self switchtoweapon( common_scripts\utility::getLastWeapon() );
|
|
maps\mp\_utility::clearUsingRemote();
|
|
|
|
if ( getdvarint( "camera_thirdPerson" ) )
|
|
maps\mp\_utility::setThirdPersonDOF( 1 );
|
|
|
|
self visionsetthermalforplayer( game["thermal_vision"], 0 );
|
|
|
|
if ( isdefined( var_0 ) )
|
|
{
|
|
var_1 = maps\mp\killstreaks\_killstreaks::getKillstreakWeapon( "helicopter_minigun" );
|
|
self takeweapon( var_1 );
|
|
var_0 vehicleturretcontroloff( self );
|
|
}
|
|
|
|
self notify( "heliPlayer_removed" );
|
|
}
|
|
|
|
endRideOnHelicopterDone( var_0 )
|
|
{
|
|
self endon( "disconnect" );
|
|
var_0 waittill( "helicopter_done" );
|
|
endRide( var_0 );
|
|
}
|
|
|
|
getPosNearEnemies()
|
|
{
|
|
var_0 = [];
|
|
|
|
foreach ( var_2 in level.players )
|
|
{
|
|
if ( var_2.team == "spectator" )
|
|
continue;
|
|
|
|
if ( var_2.team == self.team )
|
|
continue;
|
|
|
|
if ( !isalive( var_2 ) )
|
|
continue;
|
|
|
|
if ( !bullettracepassed( var_2.origin, var_2.origin + ( 0, 0, 2048 ), 0, var_2 ) )
|
|
continue;
|
|
|
|
var_2.remoteHeliDist = 0;
|
|
var_0[var_0.size] = var_2;
|
|
}
|
|
|
|
if ( !var_0.size )
|
|
return undefined;
|
|
|
|
for ( var_4 = 0; var_4 < var_0.size; var_4++ )
|
|
{
|
|
for ( var_5 = var_4 + 1; var_5 < var_0.size; var_5++ )
|
|
{
|
|
var_6 = distancesquared( var_0[var_4].origin, var_0[var_5].origin );
|
|
var_0[var_4].remoteHeliDist = var_0[var_4].remoteHeliDist + var_6;
|
|
var_0[var_5].remoteHeliDist = var_0[var_5].remoteHeliDist + var_6;
|
|
}
|
|
}
|
|
|
|
var_7 = var_0[0];
|
|
|
|
foreach ( var_2 in var_0 )
|
|
{
|
|
if ( var_2.remoteHeliDist < var_7.remoteHeliDist )
|
|
var_7 = var_2;
|
|
}
|
|
|
|
return var_7.origin;
|
|
}
|
|
|
|
updateAreaNodes( var_0 )
|
|
{
|
|
var_1 = [];
|
|
|
|
foreach ( var_3 in var_0 )
|
|
{
|
|
var_3.validPlayers = [];
|
|
var_3.nodeScore = 0;
|
|
}
|
|
|
|
foreach ( var_6 in level.players )
|
|
{
|
|
if ( !isalive( var_6 ) )
|
|
continue;
|
|
|
|
if ( var_6.team == self.team )
|
|
continue;
|
|
|
|
foreach ( var_3 in var_0 )
|
|
{
|
|
if ( distancesquared( var_6.origin, var_3.origin ) > 1048576 )
|
|
continue;
|
|
|
|
var_3.validPlayers[var_3.validPlayers.size] = var_6;
|
|
}
|
|
}
|
|
|
|
var_10 = var_0[0];
|
|
|
|
foreach ( var_3 in var_0 )
|
|
{
|
|
var_12 = getent( var_3.target, "targetname" );
|
|
|
|
foreach ( var_6 in var_3.validPlayers )
|
|
{
|
|
var_3.nodeScore = var_3.nodeScore + 1;
|
|
|
|
if ( bullettracepassed( var_6.origin + ( 0, 0, 32 ), var_12.origin, 0, var_6 ) )
|
|
var_3.nodeScore = var_3.nodeScore + 3;
|
|
}
|
|
|
|
if ( var_3.nodeScore > var_10.nodeScore )
|
|
var_10 = var_3;
|
|
}
|
|
|
|
return getent( var_10.target, "targetname" );
|
|
}
|
|
|
|
heli_think( var_0, var_1, var_2, var_3, var_4 )
|
|
{
|
|
var_5 = var_2.origin;
|
|
var_6 = var_2.angles;
|
|
|
|
switch ( var_4 )
|
|
{
|
|
case "minigun":
|
|
var_7 = "cobra_minigun_mp";
|
|
|
|
if ( var_1.team == "allies" )
|
|
var_8 = "vehicle_apache_mp";
|
|
else
|
|
var_8 = "vehicle_mi-28_mp";
|
|
|
|
break;
|
|
case "flares":
|
|
var_7 = "pavelow_mp";
|
|
|
|
if ( var_1.team == "allies" )
|
|
var_8 = "vehicle_pavelow";
|
|
else
|
|
var_8 = "vehicle_pavelow_opfor";
|
|
|
|
break;
|
|
default:
|
|
var_7 = "cobra_mp";
|
|
|
|
if ( var_1.team == "allies" )
|
|
var_8 = "vehicle_cobra_helicopter_fly_low";
|
|
else
|
|
var_8 = "vehicle_mi24p_hind_mp";
|
|
|
|
break;
|
|
}
|
|
|
|
var_9 = spawn_helicopter( var_1, var_5, var_6, var_7, var_8 );
|
|
|
|
if ( !isdefined( var_9 ) )
|
|
return;
|
|
|
|
level.chopper = var_9;
|
|
var_9.heliType = var_4;
|
|
var_9.lifeId = var_0;
|
|
var_9.team = var_3;
|
|
var_9.pers["team"] = var_3;
|
|
var_9.owner = var_1;
|
|
|
|
if ( var_4 == "flares" )
|
|
var_9.maxHealth = level.heli_maxhealth * 2;
|
|
else
|
|
var_9.maxHealth = level.heli_maxhealth;
|
|
|
|
var_9.targeting_delay = level.heli_targeting_delay;
|
|
var_9.primaryTarget = undefined;
|
|
var_9.secondaryTarget = undefined;
|
|
var_9.attacker = undefined;
|
|
var_9.currentstate = "ok";
|
|
var_9.empGrenaded = 0;
|
|
|
|
if ( var_4 == "flares" || var_4 == "minigun" )
|
|
var_9 thread heli_flares_monitor();
|
|
|
|
var_9 thread heli_leave_on_disconnect( var_1 );
|
|
var_9 thread heli_leave_on_changeTeams( var_1 );
|
|
var_9 thread heli_leave_on_gameended( var_1 );
|
|
var_9 thread heli_damage_monitor();
|
|
var_9 thread heli_health();
|
|
var_9 thread heli_existance();
|
|
var_9 endon( "helicopter_done" );
|
|
var_9 endon( "crashing" );
|
|
var_9 endon( "leaving" );
|
|
var_9 endon( "death" );
|
|
|
|
if ( var_4 == "minigun" )
|
|
{
|
|
var_1 thread heliRide( var_0, var_9 );
|
|
var_9 thread heli_leave_on_spawned( var_1 );
|
|
}
|
|
|
|
var_10 = getentarray( "heli_attack_area", "targetname" );
|
|
var_11 = level.heli_loop_nodes[randomint( level.heli_loop_nodes.size )];
|
|
|
|
switch ( var_4 )
|
|
{
|
|
case "minigun":
|
|
var_9 thread heli_targeting();
|
|
var_9 heli_fly_simple_path( var_2 );
|
|
var_9 thread heli_leave_on_timeout( 40.0 );
|
|
|
|
if ( var_10.size )
|
|
var_9 thread heli_fly_well( var_10 );
|
|
else
|
|
var_9 thread heli_fly_loop_path( var_11 );
|
|
|
|
break;
|
|
case "flares":
|
|
var_9 thread makeGunShip();
|
|
thread maps\mp\_utility::teamPlayerCardSplash( "used_helicopter_flares", var_1 );
|
|
var_9 heli_fly_simple_path( var_2 );
|
|
var_9 thread heli_leave_on_timeout( 60.0 );
|
|
var_9 thread heli_fly_loop_path( var_11 );
|
|
break;
|
|
default:
|
|
var_9 thread attack_targets();
|
|
var_9 thread heli_targeting();
|
|
var_9 heli_fly_simple_path( var_2 );
|
|
var_9 thread heli_leave_on_timeout( 60.0 );
|
|
var_9 thread heli_fly_loop_path( var_11 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
makeGunShip()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
wait 0.5;
|
|
var_0 = spawnturret( "misc_turret", self.origin, "pavelow_minigun_mp" );
|
|
var_0.lifeId = self.lifeId;
|
|
var_0 linkto( self, "tag_gunner_left", ( 0, 0, 0 ), ( 0, 0, 0 ) );
|
|
var_0 setmodel( "weapon_minigun" );
|
|
var_0.owner = self.owner;
|
|
var_0.team = self.team;
|
|
var_0 maketurretinoperable();
|
|
var_0.pers["team"] = self.team;
|
|
var_0.killCamEnt = self;
|
|
self.mgTurretLeft = var_0;
|
|
self.mgTurretLeft setdefaultdroppitch( 0 );
|
|
var_0 = spawnturret( "misc_turret", self.origin, "pavelow_minigun_mp" );
|
|
var_0.lifeId = self.lifeId;
|
|
var_0 linkto( self, "tag_gunner_right", ( 0, 0, 0 ), ( 0, 0, 0 ) );
|
|
var_0 setmodel( "weapon_minigun" );
|
|
var_0.owner = self.owner;
|
|
var_0.team = self.team;
|
|
var_0 maketurretinoperable();
|
|
var_0.pers["team"] = self.team;
|
|
var_0.killCamEnt = self;
|
|
self.mgTurretRight = var_0;
|
|
self.mgTurretRight setdefaultdroppitch( 0 );
|
|
|
|
if ( level.teamBased )
|
|
{
|
|
self.mgTurretLeft setturretteam( self.team );
|
|
self.mgTurretRight setturretteam( self.team );
|
|
}
|
|
|
|
self.mgTurretLeft setmode( "auto_nonai" );
|
|
self.mgTurretRight setmode( "auto_nonai" );
|
|
self.mgTurretLeft setsentryowner( self.owner );
|
|
self.mgTurretRight setsentryowner( self.owner );
|
|
self.mgTurretLeft setturretminimapvisible( 0 );
|
|
self.mgTurretRight setturretminimapvisible( 0 );
|
|
self.mgTurretLeft.chopper = self;
|
|
self.mgTurretRight.chopper = self;
|
|
self.mgTurretLeft thread sentry_attackTargets();
|
|
self.mgTurretRight thread sentry_attackTargets();
|
|
thread deleteTurretsWhenDone();
|
|
}
|
|
|
|
deleteTurretsWhenDone()
|
|
{
|
|
self waittill( "helicopter_done" );
|
|
self.mgTurretRight delete();
|
|
self.mgTurretLeft delete();
|
|
}
|
|
|
|
sentry_attackTargets()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
level endon( "game_ended" );
|
|
|
|
for (;;)
|
|
{
|
|
self waittill( "turretstatechange" );
|
|
|
|
if ( self isfiringturret() && !self.chopper.empGrenaded )
|
|
{
|
|
thread sentry_burstFireStart();
|
|
continue;
|
|
}
|
|
|
|
thread sentry_burstFireStop();
|
|
}
|
|
}
|
|
|
|
sentry_burstFireStart()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "stop_shooting" );
|
|
self endon( "leaving" );
|
|
level endon( "game_ended" );
|
|
var_0 = 0.1;
|
|
var_1 = 40;
|
|
var_2 = 80;
|
|
var_3 = 1.0;
|
|
var_4 = 2.0;
|
|
|
|
for (;;)
|
|
{
|
|
var_5 = randomintrange( var_1, var_2 + 1 );
|
|
|
|
for ( var_6 = 0; var_6 < var_5; var_6++ )
|
|
{
|
|
var_7 = self getturrettarget( 0 );
|
|
|
|
if ( isdefined( var_7 ) && ( !isdefined( var_7.spawnTime ) || ( gettime() - var_7.spawnTime ) / 1000 > 5 ) )
|
|
self shootturret();
|
|
|
|
wait(var_0);
|
|
}
|
|
|
|
wait(randomfloatrange( var_3, var_4 ));
|
|
}
|
|
}
|
|
|
|
sentry_burstFireStop()
|
|
{
|
|
self notify( "stop_shooting" );
|
|
}
|
|
|
|
heli_existance()
|
|
{
|
|
var_0 = self getentitynumber();
|
|
common_scripts\utility::waittill_any( "death", "crashing", "leaving" );
|
|
removeFromHeliList( var_0 );
|
|
self notify( "helicopter_done" );
|
|
self notify( "helicopter_removed" );
|
|
var_1 = undefined;
|
|
var_2 = maps\mp\_utility::queueRemoveFirst( "helicopter" );
|
|
|
|
if ( !isdefined( var_2 ) )
|
|
level.chopper = undefined;
|
|
else
|
|
{
|
|
var_1 = var_2.player;
|
|
var_3 = var_2.lifeId;
|
|
var_4 = var_2.streakName;
|
|
var_5 = var_2.heliType;
|
|
var_2 delete();
|
|
|
|
if ( isdefined( var_1 ) && ( var_1.sessionstate == "playing" || var_1.sessionstate == "dead" ) )
|
|
{
|
|
var_1 maps\mp\killstreaks\_killstreaks::usedKillstreak( var_4, 1 );
|
|
var_1 startHelicopter( var_3, var_5 );
|
|
return;
|
|
}
|
|
|
|
level.chopper = undefined;
|
|
}
|
|
}
|
|
|
|
heli_targeting()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
|
|
for (;;)
|
|
{
|
|
var_0 = [];
|
|
self.primaryTarget = undefined;
|
|
self.secondaryTarget = undefined;
|
|
var_1 = level.players;
|
|
|
|
foreach ( var_3 in level.players )
|
|
{
|
|
if ( !canTarget_turret( var_3 ) )
|
|
continue;
|
|
|
|
var_0[var_0.size] = var_3;
|
|
}
|
|
|
|
if ( var_0.size )
|
|
{
|
|
for ( var_5 = getBestPrimaryTarget( var_0 ); !isdefined( var_5 ); var_5 = getBestPrimaryTarget( var_0 ) )
|
|
wait 0.05;
|
|
|
|
self.primaryTarget = var_5;
|
|
self notify( "primary acquired" );
|
|
}
|
|
|
|
if ( isdefined( level.harriers ) )
|
|
{
|
|
foreach ( var_7 in level.harriers )
|
|
{
|
|
if ( !isdefined( var_7 ) )
|
|
continue;
|
|
|
|
if ( level.teamBased && var_7.team != self.team || !level.teamBased && var_7.owner != self.owner )
|
|
{
|
|
self notify( "secondary acquired" );
|
|
self.secondaryTarget = var_7;
|
|
}
|
|
}
|
|
}
|
|
|
|
wait 0.5;
|
|
}
|
|
}
|
|
|
|
canTarget_turret( var_0 )
|
|
{
|
|
var_1 = 1;
|
|
|
|
if ( !isalive( var_0 ) || var_0.sessionstate != "playing" )
|
|
return 0;
|
|
|
|
if ( self.heliType == "remote_mortar" )
|
|
{
|
|
if ( var_0 sightconetrace( self.origin, self ) < 1 )
|
|
return 0;
|
|
}
|
|
else if ( self.heliType != "flares" )
|
|
{
|
|
if ( !self vehicle_canturrettargetpoint( var_0.origin + ( 0, 0, 40 ), 1, self ) )
|
|
return 0;
|
|
}
|
|
|
|
if ( distance( var_0.origin, self.origin ) > level.heli_visual_range )
|
|
return 0;
|
|
|
|
if ( level.teamBased && var_0.pers["team"] == self.team )
|
|
return 0;
|
|
|
|
if ( var_0 == self.owner )
|
|
return 0;
|
|
|
|
if ( isdefined( var_0.spawnTime ) && ( gettime() - var_0.spawnTime ) / 1000 <= 5 )
|
|
return 0;
|
|
|
|
if ( var_0 maps\mp\_utility::_hasPerk( "specialty_blindeye" ) )
|
|
return 0;
|
|
|
|
var_2 = self.origin + ( 0, 0, -160 );
|
|
var_3 = anglestoforward( self.angles );
|
|
var_4 = var_2 + 144 * var_3;
|
|
|
|
if ( var_0 sightconetrace( var_4, self ) < level.heli_target_recognition )
|
|
return 0;
|
|
|
|
return var_1;
|
|
}
|
|
|
|
getBestPrimaryTarget( var_0 )
|
|
{
|
|
foreach ( var_2 in var_0 )
|
|
update_player_threat( var_2 );
|
|
|
|
var_4 = 0;
|
|
var_5 = undefined;
|
|
var_6 = getentarray( "minimap_corner", "targetname" );
|
|
|
|
foreach ( var_2 in var_0 )
|
|
{
|
|
if ( var_6.size == 2 )
|
|
{
|
|
var_8 = var_6[0].origin;
|
|
var_9 = var_6[0].origin;
|
|
|
|
if ( var_6[1].origin[0] > var_9[0] )
|
|
var_9 = ( var_6[1].origin[0], var_9[1], var_9[2] );
|
|
else
|
|
var_8 = ( var_6[1].origin[0], var_8[1], var_8[2] );
|
|
|
|
if ( var_6[1].origin[1] > var_9[1] )
|
|
var_9 = ( var_9[0], var_6[1].origin[1], var_9[2] );
|
|
else
|
|
var_8 = ( var_8[0], var_6[1].origin[1], var_8[2] );
|
|
|
|
if ( var_2.origin[0] < var_8[0] || var_2.origin[0] > var_9[0] || var_2.origin[1] < var_8[1] || var_2.origin[1] > var_9[1] )
|
|
continue;
|
|
}
|
|
|
|
if ( var_2.threatlevel < var_4 )
|
|
continue;
|
|
|
|
var_4 = var_2.threatlevel;
|
|
var_5 = var_2;
|
|
}
|
|
|
|
return var_5;
|
|
}
|
|
|
|
update_player_threat( var_0 )
|
|
{
|
|
var_0.threatlevel = 0;
|
|
var_1 = distance( var_0.origin, self.origin );
|
|
var_0.threatlevel = var_0.threatlevel + ( level.heli_visual_range - var_1 ) / level.heli_visual_range * 100;
|
|
|
|
if ( isdefined( self.attacker ) && var_0 == self.attacker )
|
|
var_0.threatlevel = var_0.threatlevel + 100;
|
|
|
|
var_0.threatlevel = var_0.threatlevel + var_0.score * 4;
|
|
|
|
if ( isdefined( var_0.antithreat ) )
|
|
var_0.threatlevel = var_0.threatlevel - var_0.antithreat;
|
|
|
|
if ( var_0.threatlevel <= 0 )
|
|
var_0.threatlevel = 1;
|
|
}
|
|
|
|
heli_reset()
|
|
{
|
|
self cleartargetyaw();
|
|
self cleargoalyaw();
|
|
self vehicle_setspeed( 60, 25 );
|
|
self setyawspeed( 75, 45, 45 );
|
|
self setmaxpitchroll( 30, 30 );
|
|
self setneargoalnotifydist( 256 );
|
|
self setturningability( 0.9 );
|
|
}
|
|
|
|
addRecentDamage( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self.recentDamageAmount = self.recentDamageAmount + var_0;
|
|
wait 4.0;
|
|
self.recentDamageAmount = self.recentDamageAmount - var_0;
|
|
}
|
|
|
|
heli_damage_monitor()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
self.health = 999999;
|
|
self.damagetaken = 0;
|
|
self.recentDamageAmount = 0;
|
|
|
|
for (;;)
|
|
{
|
|
self waittill( "damage", var_0, var_1, var_2, var_3, var_4, var_5, var_6, var_7, var_8, var_9 );
|
|
|
|
if ( isdefined( var_1.class ) && var_1.class == "worldspawn" )
|
|
continue;
|
|
else if ( var_1 == self )
|
|
continue;
|
|
|
|
if ( !maps\mp\gametypes\_weapons::friendlyFireCheck( self.owner, var_1 ) )
|
|
continue;
|
|
|
|
self.attacker = var_1;
|
|
var_10 = var_0;
|
|
|
|
if ( isplayer( var_1 ) )
|
|
{
|
|
var_1 maps\mp\gametypes\_damagefeedback::updateDamageFeedback( "" );
|
|
|
|
if ( var_4 == "MOD_RIFLE_BULLET" || var_4 == "MOD_PISTOL_BULLET" )
|
|
{
|
|
if ( self.heliType == "flares" )
|
|
var_10 *= level.heli_armor_bulletdamage;
|
|
|
|
if ( var_1 maps\mp\_utility::_hasPerk( "specialty_armorpiercing" ) )
|
|
var_10 += var_0 * level.armorPiercingMod;
|
|
}
|
|
}
|
|
|
|
if ( isdefined( var_1.owner ) && isplayer( var_1.owner ) )
|
|
var_1.owner maps\mp\gametypes\_damagefeedback::updateDamageFeedback( "helicopter" );
|
|
|
|
if ( isdefined( var_9 ) )
|
|
{
|
|
switch ( var_9 )
|
|
{
|
|
case "ac130_105mm_mp":
|
|
case "ac130_40mm_mp":
|
|
case "remotemissile_projectile_mp":
|
|
case "stinger_mp":
|
|
case "javelin_mp":
|
|
case "remote_mortar_missile_mp":
|
|
self.largeProjectileDamage = 1;
|
|
var_10 = self.maxHealth + 1;
|
|
break;
|
|
case "sam_projectile_mp":
|
|
self.largeProjectileDamage = 1;
|
|
|
|
switch ( self.heliType )
|
|
{
|
|
case "osprey_gunner":
|
|
case "flares":
|
|
case "osprey":
|
|
var_10 = self.maxHealth * 0.07;
|
|
break;
|
|
case "helicopter":
|
|
case "littlebird":
|
|
var_10 = self.maxHealth * 0.09;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case "emp_grenade_mp":
|
|
var_10 = 0;
|
|
thread heli_empgrenaded();
|
|
break;
|
|
case "osprey_player_minigun_mp":
|
|
self.largeProjectileDamage = 0;
|
|
var_10 *= 2;
|
|
break;
|
|
}
|
|
|
|
maps\mp\killstreaks\_killstreaks::killstreakhit( var_1, var_9, self );
|
|
}
|
|
|
|
self.damagetaken = self.damagetaken + var_10;
|
|
thread addRecentDamage( var_10 );
|
|
|
|
if ( self.damagetaken >= self.maxHealth )
|
|
{
|
|
if ( level.teamBased && self.team != var_1.team || !level.teamBased )
|
|
{
|
|
var_11 = undefined;
|
|
|
|
if ( isdefined( var_1.owner ) && ( !isdefined( self.owner ) || var_1.owner != self.owner ) )
|
|
var_11 = var_1.owner;
|
|
else if ( !isdefined( var_1.owner ) && var_1.classname == "script_vehicle" )
|
|
return;
|
|
else if ( !isdefined( self.owner ) || var_1 != self.owner )
|
|
var_11 = var_1;
|
|
|
|
if ( isdefined( var_11 ) )
|
|
{
|
|
var_11 notify( "destroyed_helicopter" );
|
|
|
|
switch ( self.heliType )
|
|
{
|
|
case "flares":
|
|
var_11 thread maps\mp\gametypes\_rank::xpEventPopup( &"SPLASHES_DESTROYED_PAVELOW" );
|
|
thread maps\mp\_utility::teamPlayerCardSplash( "callout_destroyed_helicopter_flares", var_11 );
|
|
var_12 = 400;
|
|
break;
|
|
case "minigun":
|
|
var_11 thread maps\mp\gametypes\_rank::xpEventPopup( &"SPLASHES_DESTROYED_MINIGUNNER" );
|
|
thread maps\mp\_utility::teamPlayerCardSplash( "callout_destroyed_helicopter_minigun", var_11 );
|
|
var_12 = 300;
|
|
break;
|
|
case "osprey_gunner":
|
|
case "osprey":
|
|
var_11 thread maps\mp\gametypes\_rank::xpEventPopup( &"SPLASHES_DESTROYED_OSPREY" );
|
|
thread maps\mp\_utility::teamPlayerCardSplash( "callout_destroyed_osprey", var_11 );
|
|
var_12 = 300;
|
|
break;
|
|
case "littlebird":
|
|
var_11 thread maps\mp\gametypes\_rank::xpEventPopup( &"SPLASHES_DESTROYED_LITTLE_BIRD" );
|
|
thread maps\mp\_utility::teamPlayerCardSplash( "callout_destroyed_little_bird", var_11 );
|
|
var_12 = 200;
|
|
default:
|
|
var_11 thread maps\mp\gametypes\_rank::xpEventPopup( &"SPLASHES_DESTROYED_HELICOPTER" );
|
|
thread maps\mp\_utility::teamPlayerCardSplash( "callout_destroyed_helicopter", var_11 );
|
|
var_12 = 200;
|
|
break;
|
|
}
|
|
|
|
var_11 thread maps\mp\gametypes\_rank::giveRankXP( "kill", var_12, var_9, var_4 );
|
|
thread maps\mp\gametypes\_missions::vehicleKilled( self.owner, self, undefined, var_11, var_0, var_4, var_9 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
heli_empgrenaded()
|
|
{
|
|
self notify( "heli_EMPGrenaded" );
|
|
self endon( "heli_EMPGrenaded" );
|
|
self endon( "death" );
|
|
self endon( "leaving" );
|
|
self endon( "crashing" );
|
|
self.owner endon( "disconnect" );
|
|
level endon( "game_ended" );
|
|
self.empGrenaded = 1;
|
|
|
|
if ( isdefined( self.mgTurretLeft ) )
|
|
self.mgTurretLeft notify( "stop_shooting" );
|
|
|
|
if ( isdefined( self.mgTurretRight ) )
|
|
self.mgTurretRight notify( "stop_shooting" );
|
|
|
|
wait 3.5;
|
|
self.empGrenaded = 0;
|
|
|
|
if ( isdefined( self.mgTurretLeft ) )
|
|
self.mgTurretLeft notify( "turretstatechange" );
|
|
|
|
if ( isdefined( self.mgTurretRight ) )
|
|
self.mgTurretRight notify( "turretstatechange" );
|
|
}
|
|
|
|
heli_health()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "leaving" );
|
|
self endon( "crashing" );
|
|
self.currentstate = "ok";
|
|
self.laststate = "ok";
|
|
self setdamagestate( 3 );
|
|
var_0 = 3;
|
|
self setdamagestate( var_0 );
|
|
|
|
for (;;)
|
|
{
|
|
if ( self.damagetaken >= self.maxHealth * 0.33 && var_0 == 3 )
|
|
{
|
|
var_0 = 2;
|
|
self setdamagestate( var_0 );
|
|
self.currentstate = "light smoke";
|
|
playfxontag( level.chopper_fx["damage"]["light_smoke"], self, "tag_engine_left" );
|
|
}
|
|
else if ( self.damagetaken >= self.maxHealth * 0.66 && var_0 == 2 )
|
|
{
|
|
var_0 = 1;
|
|
self setdamagestate( var_0 );
|
|
self.currentstate = "heavy smoke";
|
|
stopfxontag( level.chopper_fx["damage"]["light_smoke"], self, "tag_engine_left" );
|
|
playfxontag( level.chopper_fx["damage"]["heavy_smoke"], self, "tag_engine_left" );
|
|
}
|
|
else if ( self.damagetaken > self.maxHealth )
|
|
{
|
|
var_0 = 0;
|
|
self setdamagestate( var_0 );
|
|
stopfxontag( level.chopper_fx["damage"]["heavy_smoke"], self, "tag_engine_left" );
|
|
|
|
if ( isdefined( self.largeProjectileDamage ) && self.largeProjectileDamage )
|
|
thread heli_explode( 1 );
|
|
else
|
|
{
|
|
playfxontag( level.chopper_fx["damage"]["on_fire"], self, "tag_engine_left" );
|
|
thread heli_crash();
|
|
}
|
|
}
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
heli_crash()
|
|
{
|
|
self notify( "crashing" );
|
|
var_0 = level.heli_crash_nodes[randomint( level.heli_crash_nodes.size )];
|
|
thread heli_spin( 180 );
|
|
thread heli_secondary_explosions();
|
|
heli_fly_simple_path( var_0 );
|
|
thread heli_explode();
|
|
}
|
|
|
|
heli_secondary_explosions()
|
|
{
|
|
playfxontag( level.chopper_fx["explode"]["large"], self, "tag_engine_left" );
|
|
self playsound( level.heli_sound[self.team]["hitsecondary"] );
|
|
wait 3.0;
|
|
|
|
if ( !isdefined( self ) )
|
|
return;
|
|
|
|
playfxontag( level.chopper_fx["explode"]["large"], self, "tag_engine_left" );
|
|
self playsound( level.heli_sound[self.team]["hitsecondary"] );
|
|
}
|
|
|
|
heli_spin( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self playsound( level.heli_sound[self.team]["hit"] );
|
|
thread spinSoundShortly();
|
|
self setyawspeed( var_0, var_0, var_0 );
|
|
|
|
while ( isdefined( self ) )
|
|
{
|
|
self settargetyaw( self.angles[1] + var_0 * 0.9 );
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
spinSoundShortly()
|
|
{
|
|
self endon( "death" );
|
|
wait 0.25;
|
|
self stoploopsound();
|
|
wait 0.05;
|
|
self playloopsound( level.heli_sound[self.team]["spinloop"] );
|
|
wait 0.05;
|
|
self playloopsound( level.heli_sound[self.team]["spinstart"] );
|
|
}
|
|
|
|
heli_explode( var_0 )
|
|
{
|
|
self notify( "death" );
|
|
|
|
if ( isdefined( var_0 ) && isdefined( level.chopper_fx["explode"]["air_death"][self.heli_type] ) )
|
|
{
|
|
var_1 = self gettagangles( "tag_deathfx" );
|
|
playfx( level.chopper_fx["explode"]["air_death"][self.heli_type], self gettagorigin( "tag_deathfx" ), anglestoforward( var_1 ), anglestoup( var_1 ) );
|
|
}
|
|
else
|
|
{
|
|
var_2 = self.origin;
|
|
var_3 = self.origin + ( 0, 0, 1 ) - self.origin;
|
|
playfx( level.chopper_fx["explode"]["death"][self.heli_type], var_2, var_3 );
|
|
}
|
|
|
|
self playsound( level.heli_sound[self.team]["crash"] );
|
|
wait 0.05;
|
|
|
|
if ( isdefined( self.killCamEnt ) )
|
|
self.killCamEnt delete();
|
|
|
|
maps\mp\_utility::decrementFauxVehicleCount();
|
|
self delete();
|
|
}
|
|
|
|
fire_missile( var_0, var_1, var_2 )
|
|
{
|
|
if ( !isdefined( var_1 ) )
|
|
var_1 = 1;
|
|
|
|
var_3 = undefined;
|
|
var_4 = undefined;
|
|
var_5 = "cobra_20mm_mp";
|
|
var_6 = [];
|
|
|
|
switch ( var_0 )
|
|
{
|
|
case "ffar":
|
|
var_3 = "harrier_FFAR_mp";
|
|
var_6[0] = "tag_store_r_2";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
var_4 = weaponfiretime( var_3 );
|
|
self setvehweapon( var_3 );
|
|
var_7 = -1;
|
|
|
|
for ( var_8 = 0; var_8 < var_1; var_8++ )
|
|
{
|
|
var_7++;
|
|
|
|
if ( var_7 >= var_6.size )
|
|
var_7 = 0;
|
|
|
|
self setvehweapon( "harrier_FFAR_mp" );
|
|
|
|
if ( isdefined( var_2 ) )
|
|
{
|
|
var_9 = self fireweapon( var_6[var_7], var_2 );
|
|
var_9 missile_setflightmodedirect();
|
|
var_9 missile_settargetent( var_2 );
|
|
}
|
|
else
|
|
{
|
|
var_9 = self fireweapon( var_6[var_7] );
|
|
var_9 missile_setflightmodedirect();
|
|
var_9 missile_settargetent( var_2 );
|
|
}
|
|
|
|
if ( var_8 < var_1 - 1 )
|
|
wait(var_4);
|
|
}
|
|
}
|
|
|
|
check_owner()
|
|
{
|
|
if ( !isdefined( self.owner ) || !isdefined( self.owner.pers["team"] ) || self.owner.pers["team"] != self.team )
|
|
{
|
|
thread heli_leave();
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
heli_leave_on_disconnect( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
var_0 waittill( "disconnect" );
|
|
thread heli_leave();
|
|
}
|
|
|
|
heli_leave_on_changeTeams( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
var_0 common_scripts\utility::waittill_any( "joined_team", "joined_spectators" );
|
|
thread heli_leave();
|
|
}
|
|
|
|
heli_leave_on_spawned( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
var_0 waittill( "spawned" );
|
|
thread heli_leave();
|
|
}
|
|
|
|
heli_leave_on_gameended( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
level waittill( "game_ended" );
|
|
thread heli_leave();
|
|
}
|
|
|
|
heli_leave_on_timeout( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
maps\mp\gametypes\_hostmigration::waitLongDurationWithHostMigrationPause( var_0 );
|
|
thread heli_leave();
|
|
}
|
|
|
|
attack_targets()
|
|
{
|
|
thread attack_primary();
|
|
thread attack_secondary();
|
|
}
|
|
|
|
attack_secondary()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
|
|
for (;;)
|
|
{
|
|
if ( isdefined( self.secondaryTarget ) )
|
|
{
|
|
self.secondaryTarget.antithreat = undefined;
|
|
self.missileTarget = self.secondaryTarget;
|
|
var_0 = 0;
|
|
|
|
while ( isdefined( self.missileTarget ) && isalive( self.missileTarget ) )
|
|
{
|
|
if ( missile_target_sight_check( self.missileTarget ) )
|
|
thread missile_support( self.missileTarget, level.heli_missile_rof );
|
|
else
|
|
break;
|
|
|
|
self waittill( "missile ready" );
|
|
|
|
if ( !isdefined( self.secondaryTarget ) || isdefined( self.secondaryTarget ) && self.missileTarget != self.secondaryTarget )
|
|
break;
|
|
}
|
|
|
|
if ( isdefined( self.missileTarget ) )
|
|
self.missileTarget.antithreat = undefined;
|
|
}
|
|
|
|
self waittill( "secondary acquired" );
|
|
check_owner();
|
|
}
|
|
}
|
|
|
|
missile_target_sight_check( var_0 )
|
|
{
|
|
var_1 = vectornormalize( var_0.origin - self.origin );
|
|
var_2 = anglestoforward( self.angles );
|
|
var_3 = vectornormalize( var_2 );
|
|
var_4 = vectordot( var_1, var_3 );
|
|
|
|
if ( var_4 >= level.heli_missile_target_cone )
|
|
{
|
|
debug_print3d_simple( "Missile sight: " + var_4, self, ( 0, 0, -40 ), 40 );
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
missile_support( var_0, var_1 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
|
|
if ( isdefined( var_0 ) )
|
|
{
|
|
if ( level.teamBased )
|
|
{
|
|
if ( isdefined( var_0.owner ) && var_0.team != self.team )
|
|
{
|
|
fire_missile( "ffar", 1, var_0 );
|
|
self notify( "missile fired" );
|
|
}
|
|
}
|
|
else if ( isdefined( var_0.owner ) && var_0.owner != self.owner )
|
|
{
|
|
fire_missile( "ffar", 1, var_0 );
|
|
self notify( "missile fired" );
|
|
}
|
|
}
|
|
|
|
wait(var_1);
|
|
self notify( "missile ready" );
|
|
return;
|
|
}
|
|
|
|
attack_primary()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
|
|
for (;;)
|
|
{
|
|
wait 0.05;
|
|
|
|
if ( !isalive( self.primaryTarget ) )
|
|
continue;
|
|
|
|
var_0 = self.primaryTarget;
|
|
var_0.antithreat = 0;
|
|
|
|
if ( randomint( 5 ) < 3 )
|
|
var_1 = var_0.angles[1] + randomfloatrange( -30, 30 );
|
|
else
|
|
var_1 = randomint( 360 );
|
|
|
|
var_2 = 96;
|
|
var_3 = cos( var_1 ) * var_2;
|
|
var_4 = sin( var_1 ) * var_2;
|
|
self setturrettargetent( var_0, ( var_3, var_4, 40 ) );
|
|
waitOnTargetOrDeath( var_0, 3.0 );
|
|
|
|
if ( !isalive( var_0 ) || !self vehicle_canturrettargetpoint( var_0.origin + ( 0, 0, 40 ) ) )
|
|
continue;
|
|
|
|
var_5 = weaponfiretime( "cobra_20mm_mp" );
|
|
var_6 = 1;
|
|
var_7 = 0;
|
|
self playloopsound( "weap_cobra_20mm_fire_npc" );
|
|
|
|
for ( var_8 = 0; var_8 < level.heli_turretClipSize; var_8++ )
|
|
{
|
|
if ( self.empGrenaded )
|
|
break;
|
|
|
|
self setvehweapon( "cobra_20mm_mp" );
|
|
self fireweapon( "tag_flash" );
|
|
|
|
if ( var_8 < level.heli_turretClipSize - 1 )
|
|
wait(var_5);
|
|
|
|
if ( !isdefined( var_0 ) )
|
|
break;
|
|
|
|
if ( self vehicle_canturrettargetpoint( var_0.origin + ( 0, 0, 40 ), 1, self ) )
|
|
{
|
|
var_6 = max( var_6 - 0.05, 0 );
|
|
var_7 = 0;
|
|
}
|
|
else
|
|
var_7++;
|
|
|
|
if ( var_7 > 10 )
|
|
break;
|
|
|
|
var_9 = ( var_3 * var_6 + randomfloatrange( -6, 6 ), var_4 * var_6 + randomfloatrange( -6, 6 ), 40 + randomfloatrange( -6, 6 ) );
|
|
self setturrettargetent( var_0, var_9 );
|
|
}
|
|
|
|
self stoploopsound();
|
|
|
|
if ( isalive( var_0 ) )
|
|
var_0.antithreat = var_0.antithreat + 100;
|
|
|
|
wait(randomfloatrange( 0.5, 2.0 ));
|
|
}
|
|
}
|
|
|
|
waitOnTargetOrDeath( var_0, var_1 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "helicopter_done" );
|
|
var_0 endon( "death" );
|
|
var_0 endon( "disconnect" );
|
|
common_scripts\utility::waittill_notify_or_timeout( "turret_on_target", var_1 );
|
|
}
|
|
|
|
fireMissile( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
|
|
if ( !isdefined( var_0 ) )
|
|
return;
|
|
|
|
if ( distance2d( self.origin, var_0.origin ) < 512 )
|
|
return;
|
|
|
|
self setvehweapon( "harrier_FFAR_mp" );
|
|
var_1 = self fireweapon( "tag_flash", var_0 );
|
|
var_1 missile_setflightmodedirect();
|
|
var_1 missile_settargetent( var_0 );
|
|
}
|
|
|
|
getOriginOffsets( var_0 )
|
|
{
|
|
var_1 = self.origin;
|
|
var_2 = var_0.origin;
|
|
var_3 = 0;
|
|
var_4 = 40;
|
|
var_5 = ( 0, 0, -196 );
|
|
|
|
for ( var_6 = bullettrace( var_1 + var_5, var_2 + var_5, 0, self ); distancesquared( var_6["position"], var_2 + var_5 ) > 10 && var_3 < var_4; var_6 = bullettrace( var_1 + var_5, var_2 + var_5, 0, self ) )
|
|
{
|
|
if ( var_1[2] < var_2[2] )
|
|
var_1 += ( 0, 0, 128 );
|
|
else if ( var_1[2] > var_2[2] )
|
|
var_2 += ( 0, 0, 128 );
|
|
else
|
|
{
|
|
var_1 += ( 0, 0, 128 );
|
|
var_2 += ( 0, 0, 128 );
|
|
}
|
|
|
|
var_3++;
|
|
}
|
|
|
|
var_7 = [];
|
|
var_7["start"] = var_1;
|
|
var_7["end"] = var_2;
|
|
return var_7;
|
|
}
|
|
|
|
travelToNode( var_0 )
|
|
{
|
|
var_1 = getOriginOffsets( var_0 );
|
|
|
|
if ( var_1["start"] != self.origin )
|
|
{
|
|
if ( isdefined( var_0.script_airspeed ) && isdefined( var_0.script_accel ) )
|
|
{
|
|
var_2 = var_0.script_airspeed;
|
|
var_3 = var_0.script_accel;
|
|
}
|
|
else
|
|
{
|
|
var_2 = 30 + randomint( 20 );
|
|
var_3 = 15 + randomint( 15 );
|
|
}
|
|
|
|
self vehicle_setspeed( var_2, var_3 );
|
|
self setvehgoalpos( var_1["start"] + ( 0, 0, 30 ), 0 );
|
|
self setgoalyaw( var_0.angles[1] + level.heli_angle_offset );
|
|
self waittill( "goal" );
|
|
}
|
|
|
|
if ( var_1["end"] != var_0.origin )
|
|
{
|
|
if ( isdefined( var_0.script_airspeed ) && isdefined( var_0.script_accel ) )
|
|
{
|
|
var_2 = var_0.script_airspeed;
|
|
var_3 = var_0.script_accel;
|
|
}
|
|
else
|
|
{
|
|
var_2 = 30 + randomint( 20 );
|
|
var_3 = 15 + randomint( 15 );
|
|
}
|
|
|
|
self vehicle_setspeed( var_2, var_3 );
|
|
self setvehgoalpos( var_1["end"] + ( 0, 0, 30 ), 0 );
|
|
self setgoalyaw( var_0.angles[1] + level.heli_angle_offset );
|
|
self waittill( "goal" );
|
|
}
|
|
}
|
|
|
|
heli_fly_simple_path( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "leaving" );
|
|
self notify( "flying" );
|
|
self endon( "flying" );
|
|
heli_reset();
|
|
|
|
for ( var_1 = var_0; isdefined( var_1.target ); var_1 = var_2 )
|
|
{
|
|
var_2 = getent( var_1.target, "targetname" );
|
|
|
|
if ( isdefined( var_1.script_airspeed ) && isdefined( var_1.script_accel ) )
|
|
{
|
|
var_3 = var_1.script_airspeed;
|
|
var_4 = var_1.script_accel;
|
|
}
|
|
else
|
|
{
|
|
var_3 = 30 + randomint( 20 );
|
|
var_4 = 15 + randomint( 15 );
|
|
}
|
|
|
|
self vehicle_setspeed( var_3, var_4 );
|
|
|
|
if ( !isdefined( var_2.target ) )
|
|
{
|
|
self setvehgoalpos( var_2.origin + self.zOffset, 1 );
|
|
self waittill( "near_goal" );
|
|
continue;
|
|
}
|
|
|
|
self setvehgoalpos( var_2.origin + self.zOffset, 0 );
|
|
self waittill( "near_goal" );
|
|
self setgoalyaw( var_2.angles[1] );
|
|
self waittillmatch( "goal" );
|
|
}
|
|
}
|
|
|
|
heli_fly_loop_path( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
self notify( "flying" );
|
|
self endon( "flying" );
|
|
heli_reset();
|
|
thread heli_loop_speed_control( var_0 );
|
|
|
|
for ( var_1 = var_0; isdefined( var_1.target ); var_1 = var_2 )
|
|
{
|
|
var_2 = getent( var_1.target, "targetname" );
|
|
|
|
if ( isdefined( var_1.script_airspeed ) && isdefined( var_1.script_accel ) )
|
|
{
|
|
self.desired_speed = var_1.script_airspeed;
|
|
self.desired_accel = var_1.script_accel;
|
|
}
|
|
else
|
|
{
|
|
self.desired_speed = 30 + randomint( 20 );
|
|
self.desired_accel = 15 + randomint( 15 );
|
|
}
|
|
|
|
if ( self.heliType == "flares" )
|
|
{
|
|
self.desired_speed = self.desired_speed * 0.5;
|
|
self.desired_accel = self.desired_accel * 0.5;
|
|
}
|
|
|
|
if ( isdefined( var_2.script_delay ) && isdefined( self.primaryTarget ) && !heli_is_threatened() )
|
|
{
|
|
self setvehgoalpos( var_2.origin + self.zOffset, 1 );
|
|
self waittill( "near_goal" );
|
|
wait(var_2.script_delay);
|
|
continue;
|
|
}
|
|
|
|
self setvehgoalpos( var_2.origin + self.zOffset, 0 );
|
|
self waittill( "near_goal" );
|
|
self setgoalyaw( var_2.angles[1] );
|
|
self waittillmatch( "goal" );
|
|
}
|
|
}
|
|
|
|
heli_loop_speed_control( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
|
|
if ( isdefined( var_0.script_airspeed ) && isdefined( var_0.script_accel ) )
|
|
{
|
|
self.desired_speed = var_0.script_airspeed;
|
|
self.desired_accel = var_0.script_accel;
|
|
}
|
|
else
|
|
{
|
|
self.desired_speed = 30 + randomint( 20 );
|
|
self.desired_accel = 15 + randomint( 15 );
|
|
}
|
|
|
|
var_1 = 0;
|
|
var_2 = 0;
|
|
|
|
for (;;)
|
|
{
|
|
var_3 = self.desired_speed;
|
|
var_4 = self.desired_accel;
|
|
|
|
if ( self.heliType != "flares" && isdefined( self.primaryTarget ) && !heli_is_threatened() )
|
|
var_3 *= 0.25;
|
|
|
|
if ( var_1 != var_3 || var_2 != var_4 )
|
|
{
|
|
self vehicle_setspeed( var_3, var_4 );
|
|
var_1 = var_3;
|
|
var_2 = var_4;
|
|
}
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
heli_is_threatened()
|
|
{
|
|
if ( self.recentDamageAmount > 50 )
|
|
return 1;
|
|
|
|
if ( self.currentstate == "heavy smoke" )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
heli_fly_well( var_0 )
|
|
{
|
|
self notify( "flying" );
|
|
self endon( "flying" );
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
|
|
for (;;)
|
|
{
|
|
var_1 = get_best_area_attack_node( var_0 );
|
|
travelToNode( var_1 );
|
|
|
|
if ( isdefined( var_1.script_airspeed ) && isdefined( var_1.script_accel ) )
|
|
{
|
|
var_2 = var_1.script_airspeed;
|
|
var_3 = var_1.script_accel;
|
|
}
|
|
else
|
|
{
|
|
var_2 = 30 + randomint( 20 );
|
|
var_3 = 15 + randomint( 15 );
|
|
}
|
|
|
|
self vehicle_setspeed( var_2, var_3 );
|
|
self setvehgoalpos( var_1.origin + self.zOffset, 1 );
|
|
self setgoalyaw( var_1.angles[1] + level.heli_angle_offset );
|
|
|
|
if ( level.heli_forced_wait != 0 )
|
|
{
|
|
self waittill( "near_goal" );
|
|
wait(level.heli_forced_wait);
|
|
continue;
|
|
}
|
|
|
|
if ( !isdefined( var_1.script_delay ) )
|
|
{
|
|
self waittill( "near_goal" );
|
|
wait(5 + randomint( 5 ));
|
|
continue;
|
|
}
|
|
|
|
self waittillmatch( "goal" );
|
|
wait(var_1.script_delay);
|
|
}
|
|
}
|
|
|
|
get_best_area_attack_node( var_0 )
|
|
{
|
|
return updateAreaNodes( var_0 );
|
|
}
|
|
|
|
heli_leave( var_0 )
|
|
{
|
|
self notify( "leaving" );
|
|
|
|
if ( isdefined( self.heliType ) && self.heliType == "osprey" && isdefined( self.pathGoal ) )
|
|
{
|
|
self setvehgoalpos( self.pathGoal, 1 );
|
|
common_scripts\utility::waittill_any_timeout( 5, "goal" );
|
|
}
|
|
|
|
if ( !isdefined( var_0 ) )
|
|
{
|
|
var_1 = level.heli_leave_nodes[randomint( level.heli_leave_nodes.size )];
|
|
var_0 = var_1.origin;
|
|
}
|
|
|
|
var_2 = spawn( "script_origin", var_0 );
|
|
|
|
if ( isdefined( var_2 ) )
|
|
{
|
|
self setlookatent( var_2 );
|
|
var_2 thread wait_and_delete( 3.0 );
|
|
}
|
|
|
|
heli_reset();
|
|
self vehicle_setspeed( 100, 45 );
|
|
self setvehgoalpos( var_0, 1 );
|
|
self waittillmatch( "goal" );
|
|
self notify( "death" );
|
|
wait 0.05;
|
|
|
|
if ( isdefined( self.killCamEnt ) )
|
|
self.killCamEnt delete();
|
|
|
|
maps\mp\_utility::decrementFauxVehicleCount();
|
|
self delete();
|
|
}
|
|
|
|
wait_and_delete( var_0 )
|
|
{
|
|
self endon( "death" );
|
|
level endon( "game_ended" );
|
|
wait(var_0);
|
|
self delete();
|
|
}
|
|
|
|
debug_print3d( var_0, var_1, var_2, var_3, var_4 )
|
|
{
|
|
if ( isdefined( level.heli_debug ) && level.heli_debug == 1.0 )
|
|
thread draw_text( var_0, var_1, var_2, var_3, var_4 );
|
|
}
|
|
|
|
debug_print3d_simple( var_0, var_1, var_2, var_3 )
|
|
{
|
|
if ( isdefined( level.heli_debug ) && level.heli_debug == 1.0 )
|
|
{
|
|
if ( isdefined( var_3 ) )
|
|
thread draw_text( var_0, ( 0.8, 0.8, 0.8 ), var_1, var_2, var_3 );
|
|
else
|
|
thread draw_text( var_0, ( 0.8, 0.8, 0.8 ), var_1, var_2, 0 );
|
|
}
|
|
}
|
|
|
|
debug_line( var_0, var_1, var_2, var_3 )
|
|
{
|
|
if ( isdefined( level.heli_debug ) && level.heli_debug == 1.0 && !isdefined( var_3 ) )
|
|
thread draw_line( var_0, var_1, var_2 );
|
|
else if ( isdefined( level.heli_debug ) && level.heli_debug == 1.0 )
|
|
thread draw_line( var_0, var_1, var_2, var_3 );
|
|
}
|
|
|
|
draw_text( var_0, var_1, var_2, var_3, var_4 )
|
|
{
|
|
if ( var_4 == 0 )
|
|
{
|
|
while ( isdefined( var_2 ) )
|
|
wait 0.05;
|
|
}
|
|
else
|
|
{
|
|
for ( var_5 = 0; var_5 < var_4; var_5++ )
|
|
{
|
|
if ( !isdefined( var_2 ) )
|
|
break;
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
}
|
|
|
|
draw_line( var_0, var_1, var_2, var_3 )
|
|
{
|
|
if ( isdefined( var_3 ) )
|
|
{
|
|
for ( var_4 = 0; var_4 < var_3; var_4++ )
|
|
wait 0.05;
|
|
}
|
|
else
|
|
{
|
|
for (;;)
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
addToHeliList()
|
|
{
|
|
level.helis[self getentitynumber()] = self;
|
|
}
|
|
|
|
removeFromHeliList( var_0 )
|
|
{
|
|
level.helis[var_0] = undefined;
|
|
}
|
|
|
|
addToLittleBirdList()
|
|
{
|
|
level.littleBirds[self getentitynumber()] = self;
|
|
}
|
|
|
|
removeFromLittleBirdListOnDeath()
|
|
{
|
|
var_0 = self getentitynumber();
|
|
self waittill( "death" );
|
|
level.littleBirds[var_0] = undefined;
|
|
}
|
|
|
|
exceededMaxLittlebirds( var_0 )
|
|
{
|
|
if ( level.littleBirds.size >= 4 || level.littleBirds.size >= 2 && var_0 == "littlebird_flock" )
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
playFlareFx()
|
|
{
|
|
for ( var_0 = 0; var_0 < 10; var_0++ )
|
|
{
|
|
if ( !isdefined( self ) )
|
|
return;
|
|
|
|
playfxontag( level._effect["ac130_flare"], self, "TAG_FLARE" );
|
|
wait 0.15;
|
|
}
|
|
}
|
|
|
|
deployFlares()
|
|
{
|
|
var_0 = spawn( "script_origin", self.origin + ( 0, 0, -256 ) );
|
|
var_0.angles = self.angles;
|
|
var_0 movegravity( ( 0, 0, -1 ), 5.0 );
|
|
var_0 thread deleteAfterTime( 5.0 );
|
|
return var_0;
|
|
}
|
|
|
|
heli_flares_monitor()
|
|
{
|
|
switch ( self.heliType )
|
|
{
|
|
case "osprey_gunner":
|
|
case "osprey":
|
|
self.numFlares = 2;
|
|
break;
|
|
default:
|
|
self.numFlares = 1;
|
|
break;
|
|
}
|
|
|
|
thread handleIncomingSAM();
|
|
thread handleIncomingStinger();
|
|
}
|
|
|
|
handleIncomingStinger( var_0 )
|
|
{
|
|
level endon( "game_ended" );
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
self endon( "helicopter_done" );
|
|
|
|
for (;;)
|
|
{
|
|
level waittill( "stinger_fired", var_1, var_2, var_3 );
|
|
|
|
if ( !isdefined( var_3 ) || var_3 != self )
|
|
continue;
|
|
|
|
if ( isdefined( var_0 ) )
|
|
{
|
|
var_2 thread [[ var_0 ]]( var_1, var_1.team, var_3 );
|
|
continue;
|
|
}
|
|
|
|
var_2 thread watchStingerProximity( var_1, var_1.team, var_3 );
|
|
}
|
|
}
|
|
|
|
watchStingerProximity( var_0, var_1, var_2 )
|
|
{
|
|
self endon( "death" );
|
|
|
|
for (;;)
|
|
{
|
|
if ( !isdefined( var_2 ) )
|
|
break;
|
|
|
|
var_3 = var_2 getpointinbounds( 0, 0, 0 );
|
|
var_4 = distance( self.origin, var_3 );
|
|
|
|
if ( var_4 < 4000 && var_2.numFlares > 0 )
|
|
{
|
|
var_2.numFlares--;
|
|
var_2 thread playFlareFx();
|
|
var_5 = var_2 deployFlares();
|
|
self missile_settargetent( var_5 );
|
|
return;
|
|
}
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
handleIncomingSAM( var_0 )
|
|
{
|
|
level endon( "game_ended" );
|
|
self endon( "death" );
|
|
self endon( "crashing" );
|
|
self endon( "leaving" );
|
|
self endon( "helicopter_done" );
|
|
|
|
for (;;)
|
|
{
|
|
level waittill( "sam_fired", var_1, var_2, var_3 );
|
|
|
|
if ( !isdefined( var_3 ) || var_3 != self )
|
|
continue;
|
|
|
|
if ( isdefined( var_0 ) )
|
|
{
|
|
level thread [[ var_0 ]]( var_1, var_1.team, var_3, var_2 );
|
|
continue;
|
|
}
|
|
|
|
level thread watchSAMProximity( var_1, var_1.team, var_3, var_2 );
|
|
}
|
|
}
|
|
|
|
watchSAMProximity( var_0, var_1, var_2, var_3 )
|
|
{
|
|
level endon( "game_ended" );
|
|
var_2 endon( "death" );
|
|
|
|
for (;;)
|
|
{
|
|
var_4 = var_2 getpointinbounds( 0, 0, 0 );
|
|
var_5 = [];
|
|
|
|
for ( var_6 = 0; var_6 < var_3.size; var_6++ )
|
|
{
|
|
if ( isdefined( var_3[var_6] ) )
|
|
var_5[var_6] = distance( var_3[var_6].origin, var_4 );
|
|
}
|
|
|
|
for ( var_6 = 0; var_6 < var_5.size; var_6++ )
|
|
{
|
|
if ( isdefined( var_5[var_6] ) )
|
|
{
|
|
if ( var_5[var_6] < 4000 && var_2.numFlares > 0 )
|
|
{
|
|
var_2.numFlares--;
|
|
var_2 thread playFlareFx();
|
|
var_7 = var_2 deployFlares();
|
|
|
|
for ( var_8 = 0; var_8 < var_3.size; var_8++ )
|
|
{
|
|
if ( isdefined( var_3[var_8] ) )
|
|
var_3[var_8] missile_settargetent( var_7 );
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
deleteAfterTime( var_0 )
|
|
{
|
|
wait(var_0);
|
|
self delete();
|
|
}
|
|
|
|
pavelowMadeSelectionVO()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "disconnect" );
|
|
self playlocalsound( game["voice"][self.team] + "KS_hqr_pavelow" );
|
|
wait 3.5;
|
|
self playlocalsound( game["voice"][self.team] + "KS_pvl_inbound" );
|
|
}
|