mirror of
https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git
synced 2025-06-10 18:57:58 -05:00
761 lines
20 KiB
Plaintext
761 lines
20 KiB
Plaintext
#include maps/mp/killstreaks/_dogs;
|
|
#include maps/mp/_challenges;
|
|
#include maps/mp/_scoreevents;
|
|
#include maps/mp/killstreaks/_killstreakrules;
|
|
#include maps/mp/killstreaks/_airsupport;
|
|
#include maps/mp/killstreaks/_killstreaks;
|
|
#include common_scripts/utility;
|
|
#include maps/mp/_utility;
|
|
|
|
init()
|
|
{
|
|
level.missile_swarm_max = 6;
|
|
level.missile_swarm_flyheight = 3000;
|
|
level.missile_swarm_flydist = 5000;
|
|
set_dvar_float_if_unset( "scr_missile_swarm_lifetime", 40 );
|
|
precacheitem( "missile_swarm_projectile_mp" );
|
|
level.swarm_fx[ "swarm" ] = loadfx( "weapon/harpy_swarm/fx_hrpy_swrm_os_circle_neg_x" );
|
|
level.swarm_fx[ "swarm_tail" ] = loadfx( "weapon/harpy_swarm/fx_hrpy_swrm_exhaust_trail_close" );
|
|
level.missiledronesoundstart = "mpl_hk_scan";
|
|
registerkillstreak( "missile_swarm_mp", "missile_swarm_mp", "killstreak_missile_swarm", "missile_swarm_used", ::swarm_killstreak, 1 );
|
|
registerkillstreakaltweapon( "missile_swarm_mp", "missile_swarm_projectile_mp" );
|
|
registerkillstreakstrings( "missile_swarm_mp", &"KILLSTREAK_EARNED_MISSILE_SWARM", &"KILLSTREAK_MISSILE_SWARM_NOT_AVAILABLE", &"KILLSTREAK_MISSILE_SWARM_INBOUND" );
|
|
registerkillstreakdialog( "missile_swarm_mp", "mpl_killstreak_missile_swarm", "kls_swarm_used", "", "kls_swarm_enemy", "", "kls_swarm_ready" );
|
|
registerkillstreakdevdvar( "missile_swarm_mp", "scr_givemissileswarm" );
|
|
setkillstreakteamkillpenaltyscale( "missile_swarm_mp", 0 );
|
|
maps/mp/killstreaks/_killstreaks::createkillstreaktimer( "missile_swarm_mp" );
|
|
registerclientfield( "world", "missile_swarm", 1, 2, "int" );
|
|
/#
|
|
set_dvar_int_if_unset( "scr_missile_swarm_cam", 0 );
|
|
#/
|
|
}
|
|
|
|
swarm_killstreak( hardpointtype )
|
|
{
|
|
/#
|
|
assert( hardpointtype == "missile_swarm_mp" );
|
|
#/
|
|
level.missile_swarm_origin = level.mapcenter + ( 0, 0, level.missile_swarm_flyheight );
|
|
if ( level.script == "mp_drone" )
|
|
{
|
|
level.missile_swarm_origin += ( -5000, 0, 2000 );
|
|
}
|
|
if ( level.script == "mp_la" )
|
|
{
|
|
level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 2000 );
|
|
}
|
|
if ( level.script == "mp_turbine" )
|
|
{
|
|
level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 1500 );
|
|
}
|
|
if ( level.script == "mp_downhill" )
|
|
{
|
|
level.missile_swarm_origin += ( 4000, 0, 1000 );
|
|
}
|
|
if ( level.script == "mp_hydro" )
|
|
{
|
|
level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 5000 );
|
|
}
|
|
if ( level.script == "mp_magma" )
|
|
{
|
|
level.missile_swarm_origin += ( 0, -6000, 3000 );
|
|
}
|
|
if ( level.script == "mp_uplink" )
|
|
{
|
|
level.missile_swarm_origin += ( -6000, 0, 2000 );
|
|
}
|
|
if ( level.script == "mp_bridge" )
|
|
{
|
|
level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 2000 );
|
|
}
|
|
if ( level.script == "mp_paintball" )
|
|
{
|
|
level.missile_swarm_origin += vectorScale( ( 0, 0, 1 ), 1000 );
|
|
}
|
|
if ( level.script == "mp_dig" )
|
|
{
|
|
level.missile_swarm_origin += ( -2000, -2000, 1000 );
|
|
}
|
|
killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( "missile_swarm_mp", self.team, 0, 1 );
|
|
if ( killstreak_id == -1 )
|
|
{
|
|
return 0;
|
|
}
|
|
level thread swarm_killstreak_start( self, killstreak_id );
|
|
return 1;
|
|
}
|
|
|
|
swarm_killstreak_start( owner, killstreak_id )
|
|
{
|
|
level endon( "swarm_end" );
|
|
missiles = getentarray( "swarm_missile", "targetname" );
|
|
_a102 = missiles;
|
|
_k102 = getFirstArrayKey( _a102 );
|
|
while ( isDefined( _k102 ) )
|
|
{
|
|
missile = _a102[ _k102 ];
|
|
if ( isDefined( missile ) )
|
|
{
|
|
missile detonate();
|
|
wait 0,1;
|
|
}
|
|
_k102 = getNextArrayKey( _a102, _k102 );
|
|
}
|
|
while ( isDefined( level.missile_swarm_fx ) )
|
|
{
|
|
i = 0;
|
|
while ( i < level.missile_swarm_fx.size )
|
|
{
|
|
if ( isDefined( level.missile_swarm_fx[ i ] ) )
|
|
{
|
|
level.missile_swarm_fx[ i ] delete();
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
level.missile_swarm_fx = undefined;
|
|
level.missile_swarm_team = owner.team;
|
|
level.missile_swarm_owner = owner;
|
|
owner maps/mp/killstreaks/_killstreaks::playkillstreakstartdialog( "missile_swarm_mp", owner.pers[ "team" ] );
|
|
level create_player_targeting_array( owner, owner.team );
|
|
level.globalkillstreakscalled++;
|
|
owner addweaponstat( "missile_swarm_mp", "used", 1 );
|
|
level thread swarm_killstreak_abort( owner, killstreak_id );
|
|
level thread swarm_killstreak_watch_for_emp( owner, killstreak_id );
|
|
level thread swarm_killstreak_fx();
|
|
wait 2;
|
|
level thread swarm_think( owner, killstreak_id );
|
|
}
|
|
|
|
swarm_killstreak_end( owner, detonate, killstreak_id )
|
|
{
|
|
level notify( "swarm_end" );
|
|
if ( isDefined( detonate ) && detonate )
|
|
{
|
|
level setclientfield( "missile_swarm", 2 );
|
|
}
|
|
else
|
|
{
|
|
level setclientfield( "missile_swarm", 0 );
|
|
}
|
|
missiles = getentarray( "swarm_missile", "targetname" );
|
|
if ( is_true( detonate ) )
|
|
{
|
|
i = 0;
|
|
while ( i < level.missile_swarm_fx.size )
|
|
{
|
|
if ( isDefined( level.missile_swarm_fx[ i ] ) )
|
|
{
|
|
level.missile_swarm_fx[ i ] delete();
|
|
}
|
|
i++;
|
|
}
|
|
_a160 = missiles;
|
|
_k160 = getFirstArrayKey( _a160 );
|
|
while ( isDefined( _k160 ) )
|
|
{
|
|
missile = _a160[ _k160 ];
|
|
if ( isDefined( missile ) )
|
|
{
|
|
missile detonate();
|
|
wait 0,1;
|
|
}
|
|
_k160 = getNextArrayKey( _a160, _k160 );
|
|
}
|
|
}
|
|
else _a171 = missiles;
|
|
_k171 = getFirstArrayKey( _a171 );
|
|
while ( isDefined( _k171 ) )
|
|
{
|
|
missile = _a171[ _k171 ];
|
|
if ( isDefined( missile ) )
|
|
{
|
|
yaw = randomintrange( 0, 360 );
|
|
angles = ( 0, yaw, 0 );
|
|
forward = anglesToForward( angles );
|
|
if ( isDefined( missile.goal ) )
|
|
{
|
|
missile.goal.origin = missile.origin + ( forward * level.missile_swarm_flydist * 1000 );
|
|
}
|
|
}
|
|
_k171 = getNextArrayKey( _a171, _k171 );
|
|
}
|
|
wait 1;
|
|
level.missile_swarm_sound stoploopsound( 2 );
|
|
wait 2;
|
|
level.missile_swarm_sound delete();
|
|
recordstreakindex = level.killstreakindices[ level.killstreaks[ "missile_swarm_mp" ].menuname ];
|
|
if ( isDefined( recordstreakindex ) )
|
|
{
|
|
owner recordkillstreakendevent( recordstreakindex );
|
|
}
|
|
maps/mp/killstreaks/_killstreakrules::killstreakstop( "missile_swarm_mp", level.missile_swarm_team, killstreak_id );
|
|
level.missile_swarm_owner = undefined;
|
|
wait 4;
|
|
missiles = getentarray( "swarm_missile", "targetname" );
|
|
_a205 = missiles;
|
|
_k205 = getFirstArrayKey( _a205 );
|
|
while ( isDefined( _k205 ) )
|
|
{
|
|
missile = _a205[ _k205 ];
|
|
if ( isDefined( missile ) )
|
|
{
|
|
missile delete();
|
|
wait 0,1;
|
|
}
|
|
_k205 = getNextArrayKey( _a205, _k205 );
|
|
}
|
|
wait 6;
|
|
i = 0;
|
|
while ( i < level.missile_swarm_fx.size )
|
|
{
|
|
if ( isDefined( level.missile_swarm_fx[ i ] ) )
|
|
{
|
|
level.missile_swarm_fx[ i ] delete();
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
swarm_killstreak_abort( owner, killstreak_id )
|
|
{
|
|
level endon( "swarm_end" );
|
|
owner waittill_any( "disconnect", "joined_team", "joined_spectators", "emp_jammed" );
|
|
level thread swarm_killstreak_end( owner, 1, killstreak_id );
|
|
}
|
|
|
|
swarm_killstreak_watch_for_emp( owner, killstreak_id )
|
|
{
|
|
level endon( "swarm_end" );
|
|
owner waittill( "emp_destroyed_missile_swarm", attacker );
|
|
maps/mp/_scoreevents::processscoreevent( "destroyed_missile_swarm", attacker, owner, "emp_mp" );
|
|
attacker maps/mp/_challenges::addflyswatterstat( "emp_mp" );
|
|
level thread swarm_killstreak_end( owner, 1, killstreak_id );
|
|
}
|
|
|
|
swarm_killstreak_fx()
|
|
{
|
|
level endon( "swarm_end" );
|
|
level.missile_swarm_fx = [];
|
|
yaw = randomint( 360 );
|
|
level.missile_swarm_fx[ 0 ] = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_fx[ 0 ] setmodel( "tag_origin" );
|
|
level.missile_swarm_fx[ 0 ].angles = ( -90, yaw, 0 );
|
|
level.missile_swarm_fx[ 1 ] = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_fx[ 1 ] setmodel( "tag_origin" );
|
|
level.missile_swarm_fx[ 1 ].angles = ( -90, yaw, 0 );
|
|
level.missile_swarm_fx[ 2 ] = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_fx[ 2 ] setmodel( "tag_origin" );
|
|
level.missile_swarm_fx[ 2 ].angles = ( -90, yaw, 0 );
|
|
level.missile_swarm_fx[ 3 ] = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_fx[ 3 ] setmodel( "tag_origin" );
|
|
level.missile_swarm_fx[ 3 ].angles = ( -90, yaw, 0 );
|
|
level.missile_swarm_fx[ 4 ] = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_fx[ 4 ] setmodel( "tag_origin" );
|
|
level.missile_swarm_fx[ 4 ].angles = ( -90, yaw, 0 );
|
|
level.missile_swarm_fx[ 5 ] = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_fx[ 5 ] setmodel( "tag_origin" );
|
|
level.missile_swarm_fx[ 5 ].angles = ( -90, yaw, 0 );
|
|
level.missile_swarm_fx[ 6 ] = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_fx[ 6 ] setmodel( "tag_origin" );
|
|
level.missile_swarm_fx[ 6 ].angles = ( -90, yaw, 0 );
|
|
level.missile_swarm_sound = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_sound setmodel( "tag_origin" );
|
|
level.missile_swarm_sound.angles = ( 0, 0, 1 );
|
|
wait 0,1;
|
|
playfxontag( level.swarm_fx[ "swarm" ], level.missile_swarm_fx[ 0 ], "tag_origin" );
|
|
wait 2;
|
|
level.missile_swarm_sound playloopsound( "veh_harpy_drone_swarm_lp", 3 );
|
|
level setclientfield( "missile_swarm", 1 );
|
|
current = 1;
|
|
while ( 1 )
|
|
{
|
|
if ( !isDefined( level.missile_swarm_fx[ current ] ) )
|
|
{
|
|
level.missile_swarm_fx[ current ] = spawn( "script_model", level.missile_swarm_origin );
|
|
level.missile_swarm_fx[ current ] setmodel( "tag_origin" );
|
|
}
|
|
yaw = randomint( 360 );
|
|
if ( isDefined( level.missile_swarm_fx[ current ] ) )
|
|
{
|
|
level.missile_swarm_fx[ current ].angles = ( -90, yaw, 0 );
|
|
}
|
|
wait 0,1;
|
|
if ( isDefined( level.missile_swarm_fx[ current ] ) )
|
|
{
|
|
playfxontag( level.swarm_fx[ "swarm" ], level.missile_swarm_fx[ current ], "tag_origin" );
|
|
}
|
|
current = ( current + 1 ) % 7;
|
|
wait 1,9;
|
|
}
|
|
}
|
|
|
|
swarm_think( owner, killstreak_id )
|
|
{
|
|
level endon( "swarm_end" );
|
|
lifetime = getDvarFloat( #"4FEEA279" );
|
|
end_time = getTime() + ( lifetime * 1000 );
|
|
level.missile_swarm_count = 0;
|
|
while ( getTime() < end_time )
|
|
{
|
|
/#
|
|
assert( level.missile_swarm_count >= 0 );
|
|
#/
|
|
while ( level.missile_swarm_count >= level.missile_swarm_max )
|
|
{
|
|
wait 0,5;
|
|
}
|
|
count = 1;
|
|
level.missile_swarm_count += count;
|
|
i = 0;
|
|
while ( i < count )
|
|
{
|
|
self thread projectile_spawn( owner );
|
|
i++;
|
|
}
|
|
wait ( ( level.missile_swarm_count / level.missile_swarm_max ) + 0,4 );
|
|
}
|
|
level thread swarm_killstreak_end( owner, undefined, killstreak_id );
|
|
}
|
|
|
|
projectile_cam( player )
|
|
{
|
|
/#
|
|
player.swarm_cam = 1;
|
|
wait 0,05;
|
|
forward = anglesToForward( self.angles );
|
|
cam = spawn( "script_model", ( self.origin + vectorScale( ( 0, 0, 1 ), 300 ) ) + ( forward * -200 ) );
|
|
cam setmodel( "tag_origin" );
|
|
cam linkto( self );
|
|
player camerasetposition( cam );
|
|
player camerasetlookat( self );
|
|
player cameraactivate( 1 );
|
|
self waittill( "death" );
|
|
wait 1;
|
|
player cameraactivate( 0 );
|
|
cam delete();
|
|
player.swarm_cam = 0;
|
|
#/
|
|
}
|
|
|
|
projectile_goal_move()
|
|
{
|
|
self endon( "death" );
|
|
for ( ;; )
|
|
{
|
|
wait 0,25;
|
|
while ( distancesquared( self.origin, self.goal.origin ) < 65536 )
|
|
{
|
|
if ( distancesquared( self.origin, level.missile_swarm_origin ) > ( level.missile_swarm_flydist * level.missile_swarm_flydist ) )
|
|
{
|
|
self.goal.origin = level.missile_swarm_origin;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
enemy = projectile_find_random_player( self.owner, self.team );
|
|
if ( isDefined( enemy ) )
|
|
{
|
|
self.goal.origin = enemy.origin + ( 0, 0, self.origin[ 2 ] );
|
|
}
|
|
else
|
|
{
|
|
pitch = randomintrange( -45, 45 );
|
|
yaw = randomintrange( 0, 360 );
|
|
angles = ( 0, yaw, 0 );
|
|
forward = anglesToForward( angles );
|
|
self.goal.origin = self.origin + ( forward * level.missile_swarm_flydist );
|
|
}
|
|
nfz = crossesnoflyzone( self.origin, self.goal.origin );
|
|
tries = 20;
|
|
while ( isDefined( nfz ) && tries > 0 )
|
|
{
|
|
tries--;
|
|
|
|
pitch = randomintrange( -45, 45 );
|
|
yaw = randomintrange( 0, 360 );
|
|
angles = ( 0, yaw, 0 );
|
|
forward = anglesToForward( angles );
|
|
self.goal.origin = self.origin + ( forward * level.missile_swarm_flydist );
|
|
nfz = crossesnoflyzone( self.origin, self.goal.origin );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
projectile_target_search( acceptskyexposure, acquiretime, allowplayeroffset )
|
|
{
|
|
self endon( "death" );
|
|
wait acquiretime;
|
|
for ( ;; )
|
|
{
|
|
wait randomfloatrange( 0,5, 1 );
|
|
target = self projectile_find_target( acceptskyexposure );
|
|
if ( isDefined( target ) )
|
|
{
|
|
self.swarm_target = target[ "entity" ];
|
|
target[ "entity" ].swarm = self;
|
|
if ( allowplayeroffset )
|
|
{
|
|
self missile_settarget( target[ "entity" ], target[ "offset" ] );
|
|
self missile_dronesetvisible( 1 );
|
|
}
|
|
else
|
|
{
|
|
self missile_settarget( target[ "entity" ] );
|
|
self missile_dronesetvisible( 1 );
|
|
}
|
|
self playsound( "veh_harpy_drone_swarm_incomming" );
|
|
if ( !isDefined( target[ "entity" ].swarmsound ) || target[ "entity" ].swarmsound == 0 )
|
|
{
|
|
self thread target_sounds( target[ "entity" ] );
|
|
}
|
|
target[ "entity" ] waittill_any( "death", "disconnect", "joined_team" );
|
|
self missile_settarget( self.goal );
|
|
self missile_dronesetvisible( 0 );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
target_sounds( targetent )
|
|
{
|
|
targetent endon( "death" );
|
|
targetent endon( "disconnect" );
|
|
targetent endon( "joined_team" );
|
|
self endon( "death" );
|
|
dist = 3000;
|
|
if ( isDefined( self.warningsounddist ) )
|
|
{
|
|
dist = self.warningsounddist;
|
|
}
|
|
while ( distancesquared( self.origin, targetent.origin ) > ( dist * dist ) )
|
|
{
|
|
wait 0,05;
|
|
}
|
|
if ( isDefined( targetent.swarmsound ) && targetent.swarmsound == 1 )
|
|
{
|
|
return;
|
|
}
|
|
targetent.swarmsound = 1;
|
|
self thread reset_sound_blocker( targetent );
|
|
self thread target_stop_sounds( targetent );
|
|
if ( isplayer( targetent ) )
|
|
{
|
|
targetent playlocalsound( level.missiledronesoundstart );
|
|
}
|
|
self playsound( level.missiledronesoundstart );
|
|
}
|
|
|
|
target_stop_sounds( targetent )
|
|
{
|
|
targetent waittill_any( "disconnect", "death", "joined_team" );
|
|
if ( isDefined( targetent ) && isplayer( targetent ) )
|
|
{
|
|
targetent stoplocalsound( level.missiledronesoundstart );
|
|
}
|
|
}
|
|
|
|
reset_sound_blocker( target )
|
|
{
|
|
wait 2;
|
|
if ( isDefined( target ) )
|
|
{
|
|
target.swarmsound = 0;
|
|
}
|
|
}
|
|
|
|
projectile_spawn( owner )
|
|
{
|
|
level endon( "swarm_end" );
|
|
upvector = ( 0, 0, randomintrange( level.missile_swarm_flyheight - 1500, level.missile_swarm_flyheight - 1000 ) );
|
|
yaw = randomintrange( 0, 360 );
|
|
angles = ( 0, yaw, 0 );
|
|
forward = anglesToForward( angles );
|
|
origin = ( level.mapcenter + upvector ) + ( forward * level.missile_swarm_flydist * -1 );
|
|
target = ( level.mapcenter + upvector ) + ( forward * level.missile_swarm_flydist );
|
|
enemy = projectile_find_random_player( owner, owner.team );
|
|
if ( isDefined( enemy ) )
|
|
{
|
|
target = enemy.origin + upvector;
|
|
}
|
|
projectile = projectile_spawn_utility( owner, target, origin, "missile_swarm_projectile_mp", "swarm_missile", 1 );
|
|
projectile thread projectile_abort_think();
|
|
projectile thread projectile_target_search( cointoss(), 1, 1 );
|
|
projectile thread projectile_death_think();
|
|
projectile thread projectile_goal_move();
|
|
wait 0,1;
|
|
if ( isDefined( projectile ) )
|
|
{
|
|
projectile setclientfield( "missile_drone_projectile_animate", 1 );
|
|
}
|
|
}
|
|
|
|
projectile_spawn_utility( owner, target, origin, weapon, targetname, movegoal )
|
|
{
|
|
goal = spawn( "script_model", target );
|
|
goal setmodel( "tag_origin" );
|
|
p = magicbullet( weapon, origin, target, owner, goal );
|
|
p.owner = owner;
|
|
p.team = owner.team;
|
|
p.goal = goal;
|
|
p.targetname = "swarm_missile";
|
|
/#
|
|
if ( !is_true( owner.swarm_cam ) && getDvarInt( #"492656A6" ) == 1 )
|
|
{
|
|
p thread projectile_cam( owner );
|
|
#/
|
|
}
|
|
return p;
|
|
}
|
|
|
|
projectile_death_think()
|
|
{
|
|
self waittill( "death" );
|
|
level.missile_swarm_count--;
|
|
|
|
self.goal delete();
|
|
}
|
|
|
|
projectile_abort_think()
|
|
{
|
|
self endon( "death" );
|
|
self.owner waittill_any( "disconnect", "joined_team" );
|
|
self detonate();
|
|
}
|
|
|
|
projectile_find_target( acceptskyexposure )
|
|
{
|
|
ks = projectile_find_target_killstreak( acceptskyexposure );
|
|
player = projectile_find_target_player( acceptskyexposure );
|
|
if ( isDefined( ks ) && !isDefined( player ) )
|
|
{
|
|
return ks;
|
|
}
|
|
else
|
|
{
|
|
if ( !isDefined( ks ) && isDefined( player ) )
|
|
{
|
|
return player;
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( ks ) && isDefined( player ) )
|
|
{
|
|
if ( cointoss() )
|
|
{
|
|
return ks;
|
|
}
|
|
return player;
|
|
}
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
projectile_find_target_killstreak( acceptskyexposure )
|
|
{
|
|
ks = [];
|
|
ks[ "offset" ] = vectorScale( ( 0, 0, 1 ), 10 );
|
|
targets = target_getarray();
|
|
rcbombs = getentarray( "rcbomb", "targetname" );
|
|
satellites = getentarray( "satellite", "targetname" );
|
|
dogs = maps/mp/killstreaks/_dogs::dog_manager_get_dogs();
|
|
targets = arraycombine( targets, rcbombs, 1, 0 );
|
|
targets = arraycombine( targets, satellites, 1, 0 );
|
|
targets = arraycombine( targets, dogs, 1, 0 );
|
|
if ( targets.size <= 0 )
|
|
{
|
|
return undefined;
|
|
}
|
|
targets = arraysort( targets, self.origin );
|
|
_a634 = targets;
|
|
_k634 = getFirstArrayKey( _a634 );
|
|
while ( isDefined( _k634 ) )
|
|
{
|
|
target = _a634[ _k634 ];
|
|
if ( isDefined( target.owner ) && target.owner == self.owner )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( target.script_owner ) && target.script_owner == self.owner )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( level.teambased && isDefined( target.team ) )
|
|
{
|
|
if ( target.team == self.team )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if ( level.teambased && isDefined( target.aiteam ) )
|
|
{
|
|
if ( target.aiteam == self.team )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( bullettracepassed( self.origin, target.origin, 0, target ) )
|
|
{
|
|
ks[ "entity" ] = target;
|
|
return ks;
|
|
}
|
|
if ( acceptskyexposure && cointoss() )
|
|
{
|
|
end = target.origin + vectorScale( ( 0, 0, 1 ), 2048 );
|
|
if ( bullettracepassed( target.origin, end, 0, target ) )
|
|
{
|
|
ks[ "entity" ] = target;
|
|
return ks;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_k634 = getNextArrayKey( _a634, _k634 );
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
projectile_find_target_player( acceptexposedtosky )
|
|
{
|
|
target = [];
|
|
players = get_players();
|
|
players = arraysort( players, self.origin );
|
|
_a692 = players;
|
|
_k692 = getFirstArrayKey( _a692 );
|
|
while ( isDefined( _k692 ) )
|
|
{
|
|
player = _a692[ _k692 ];
|
|
if ( !player_valid_target( player, self.team, self.owner ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if ( bullettracepassed( self.origin, player.origin, 0, player ) )
|
|
{
|
|
target[ "entity" ] = player;
|
|
target[ "offset" ] = ( 0, 0, 1 );
|
|
return target;
|
|
}
|
|
if ( bullettracepassed( self.origin, player geteye(), 0, player ) )
|
|
{
|
|
target[ "entity" ] = player;
|
|
target[ "offset" ] = vectorScale( ( 0, 0, 1 ), 50 );
|
|
return target;
|
|
}
|
|
if ( acceptexposedtosky && cointoss() )
|
|
{
|
|
end = player.origin + vectorScale( ( 0, 0, 1 ), 2048 );
|
|
if ( bullettracepassed( player.origin, end, 0, player ) )
|
|
{
|
|
target[ "entity" ] = player;
|
|
target[ "offset" ] = vectorScale( ( 0, 0, 1 ), 30 );
|
|
return target;
|
|
}
|
|
}
|
|
}
|
|
_k692 = getNextArrayKey( _a692, _k692 );
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
create_player_targeting_array( owner, team )
|
|
{
|
|
level.playertargetedtimes = [];
|
|
players = get_players();
|
|
_a739 = players;
|
|
_k739 = getFirstArrayKey( _a739 );
|
|
while ( isDefined( _k739 ) )
|
|
{
|
|
player = _a739[ _k739 ];
|
|
if ( !player_valid_target( player, team, owner ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
level.playertargetedtimes[ player.clientid ] = 0;
|
|
}
|
|
_k739 = getNextArrayKey( _a739, _k739 );
|
|
}
|
|
}
|
|
|
|
projectile_find_random_player( owner, team )
|
|
{
|
|
players = get_players();
|
|
lowest = 10000;
|
|
_a757 = players;
|
|
_k757 = getFirstArrayKey( _a757 );
|
|
while ( isDefined( _k757 ) )
|
|
{
|
|
player = _a757[ _k757 ];
|
|
if ( !player_valid_target( player, team, owner ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if ( !isDefined( level.playertargetedtimes[ player.clientid ] ) )
|
|
{
|
|
level.playertargetedtimes[ player.clientid ] = 0;
|
|
}
|
|
if ( level.playertargetedtimes[ player.clientid ] < lowest || level.playertargetedtimes[ player.clientid ] == lowest && randomint( 100 ) > 50 )
|
|
{
|
|
target = player;
|
|
lowest = level.playertargetedtimes[ player.clientid ];
|
|
}
|
|
}
|
|
_k757 = getNextArrayKey( _a757, _k757 );
|
|
}
|
|
if ( isDefined( target ) )
|
|
{
|
|
level.playertargetedtimes[ target.clientid ] += 1;
|
|
return target;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
player_valid_target( player, team, owner )
|
|
{
|
|
if ( player.sessionstate != "playing" )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !isalive( player ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( player == owner )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( level.teambased )
|
|
{
|
|
if ( team == player.team )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
if ( player cantargetplayerwithspecialty() == 0 )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( player.lastspawntime ) && ( getTime() - player.lastspawntime ) < 3000 )
|
|
{
|
|
return 0;
|
|
}
|
|
/#
|
|
if ( player isinmovemode( "ufo", "noclip" ) )
|
|
{
|
|
return 0;
|
|
#/
|
|
}
|
|
return 1;
|
|
}
|