mirror of
https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git
synced 2025-06-10 10:47:58 -05:00
2050 lines
50 KiB
Plaintext
2050 lines
50 KiB
Plaintext
#include maps/mp/gametypes/_hud;
|
|
#include maps/mp/gametypes/_hostmigration;
|
|
#include maps/mp/gametypes/_globallogic_audio;
|
|
#include maps/mp/gametypes/_globallogic_utils;
|
|
#include maps/mp/gametypes/_weapons;
|
|
#include maps/mp/gametypes/_globallogic_score;
|
|
#include maps/mp/gametypes/_class;
|
|
#include maps/mp/killstreaks/_killstreaks;
|
|
#include maps/mp/gametypes/_hud_message;
|
|
#include maps/mp/killstreaks/_dogs;
|
|
#include maps/mp/killstreaks/_airsupport;
|
|
#include common_scripts/utility;
|
|
#include maps/mp/gametypes/_hud_util;
|
|
#include maps/mp/_utility;
|
|
|
|
init()
|
|
{
|
|
precachestring( &"MP_KILLSTREAK_N" );
|
|
if ( getDvar( "scr_allow_killstreak_building" ) == "" )
|
|
{
|
|
setdvar( "scr_allow_killstreak_building", "0" );
|
|
}
|
|
level.killstreaks = [];
|
|
level.killstreakweapons = [];
|
|
level.menureferenceforkillstreak = [];
|
|
level.numkillstreakreservedobjectives = 0;
|
|
level.killstreakcounter = 0;
|
|
if ( !isDefined( level.roundstartkillstreakdelay ) )
|
|
{
|
|
level.roundstartkillstreakdelay = 0;
|
|
}
|
|
level.killstreak_timers = [];
|
|
_a31 = level.teams;
|
|
_k31 = getFirstArrayKey( _a31 );
|
|
while ( isDefined( _k31 ) )
|
|
{
|
|
team = _a31[ _k31 ];
|
|
level.killstreak_timers[ team ] = [];
|
|
_k31 = getNextArrayKey( _a31, _k31 );
|
|
}
|
|
level.iskillstreakweapon = ::iskillstreakweapon;
|
|
maps/mp/killstreaks/_supplydrop::init();
|
|
maps/mp/killstreaks/_ai_tank::init();
|
|
maps/mp/killstreaks/_airsupport::initairsupport();
|
|
maps/mp/killstreaks/_dogs::initkillstreak();
|
|
maps/mp/killstreaks/_radar::init();
|
|
maps/mp/killstreaks/_emp::init();
|
|
maps/mp/killstreaks/_helicopter::init();
|
|
maps/mp/killstreaks/_helicopter_guard::init();
|
|
maps/mp/killstreaks/_helicopter_gunner::init();
|
|
maps/mp/killstreaks/_killstreakrules::init();
|
|
maps/mp/killstreaks/_killstreak_weapons::init();
|
|
maps/mp/killstreaks/_missile_drone::init();
|
|
maps/mp/killstreaks/_missile_swarm::init();
|
|
maps/mp/killstreaks/_planemortar::init();
|
|
maps/mp/killstreaks/_rcbomb::init();
|
|
maps/mp/killstreaks/_remote_weapons::init();
|
|
maps/mp/killstreaks/_remotemissile::init();
|
|
maps/mp/killstreaks/_remotemortar::init();
|
|
maps/mp/killstreaks/_qrdrone::init();
|
|
maps/mp/killstreaks/_spyplane::init();
|
|
maps/mp/killstreaks/_straferun::init();
|
|
maps/mp/killstreaks/_turret_killstreak::init();
|
|
level thread onplayerconnect();
|
|
/#
|
|
level thread killstreak_debug_think();
|
|
#/
|
|
}
|
|
|
|
registerkillstreak( killstreaktype, killstreakweapon, killstreakmenuname, killstreakusagekey, killstreakusefunction, killstreakdelaystreak, weaponholdallowed, killstreakstatsname )
|
|
{
|
|
/#
|
|
assert( isDefined( killstreaktype ), "Can not register a killstreak without a valid type name." );
|
|
#/
|
|
/#
|
|
assert( !isDefined( level.killstreaks[ killstreaktype ] ), "Killstreak " + killstreaktype + " already registered" );
|
|
#/
|
|
/#
|
|
assert( isDefined( killstreakusefunction ), "No use function defined for killstreak " + killstreaktype );
|
|
#/
|
|
level.killstreaks[ killstreaktype ] = spawnstruct();
|
|
level.killstreaks[ killstreaktype ].killstreaklevel = int( tablelookup( "mp/statstable.csv", 4, killstreakmenuname, 5 ) );
|
|
level.killstreaks[ killstreaktype ].momentumcost = int( tablelookup( "mp/statstable.csv", 4, killstreakmenuname, 16 ) );
|
|
level.killstreaks[ killstreaktype ].iconmaterial = tablelookup( "mp/statstable.csv", 4, killstreakmenuname, 6 );
|
|
level.killstreaks[ killstreaktype ].quantity = int( tablelookup( "mp/statstable.csv", 4, killstreakmenuname, 5 ) );
|
|
level.killstreaks[ killstreaktype ].usagekey = killstreakusagekey;
|
|
level.killstreaks[ killstreaktype ].usefunction = killstreakusefunction;
|
|
level.killstreaks[ killstreaktype ].menuname = killstreakmenuname;
|
|
level.killstreaks[ killstreaktype ].delaystreak = killstreakdelaystreak;
|
|
level.killstreaks[ killstreaktype ].allowassists = 0;
|
|
level.killstreaks[ killstreaktype ].overrideentitycameraindemo = 0;
|
|
level.killstreaks[ killstreaktype ].teamkillpenaltyscale = 1;
|
|
if ( isDefined( killstreakweapon ) )
|
|
{
|
|
/#
|
|
assert( !isDefined( level.killstreakweapons[ killstreakweapon ] ), "Can not have a weapon associated with multiple killstreaks." );
|
|
#/
|
|
precacheitem( killstreakweapon );
|
|
level.killstreaks[ killstreaktype ].weapon = killstreakweapon;
|
|
level.killstreakweapons[ killstreakweapon ] = killstreaktype;
|
|
}
|
|
if ( !isDefined( weaponholdallowed ) )
|
|
{
|
|
weaponholdallowed = 0;
|
|
}
|
|
if ( isDefined( killstreakstatsname ) )
|
|
{
|
|
level.killstreaks[ killstreaktype ].killstreakstatsname = killstreakstatsname;
|
|
}
|
|
level.killstreaks[ killstreaktype ].weaponholdallowed = weaponholdallowed;
|
|
level.menureferenceforkillstreak[ killstreakmenuname ] = killstreaktype;
|
|
}
|
|
|
|
registerkillstreakstrings( killstreaktype, receivedtext, notusabletext, inboundtext, inboundnearplayertext )
|
|
{
|
|
/#
|
|
assert( isDefined( killstreaktype ), "Can not register a killstreak without a valid type name." );
|
|
#/
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ] ), "Killstreak needs to be registered before calling registerKillstreakStrings." );
|
|
#/
|
|
level.killstreaks[ killstreaktype ].receivedtext = receivedtext;
|
|
level.killstreaks[ killstreaktype ].notavailabletext = notusabletext;
|
|
level.killstreaks[ killstreaktype ].inboundtext = inboundtext;
|
|
level.killstreaks[ killstreaktype ].inboundnearplayertext = inboundnearplayertext;
|
|
if ( isDefined( level.killstreaks[ killstreaktype ].receivedtext ) )
|
|
{
|
|
precachestring( level.killstreaks[ killstreaktype ].receivedtext );
|
|
}
|
|
if ( isDefined( level.killstreaks[ killstreaktype ].notavailabletext ) )
|
|
{
|
|
precachestring( level.killstreaks[ killstreaktype ].notavailabletext );
|
|
}
|
|
if ( isDefined( level.killstreaks[ killstreaktype ].inboundtext ) )
|
|
{
|
|
precachestring( level.killstreaks[ killstreaktype ].inboundtext );
|
|
}
|
|
if ( isDefined( level.killstreaks[ killstreaktype ].inboundnearplayertext ) )
|
|
{
|
|
precachestring( level.killstreaks[ killstreaktype ].inboundnearplayertext );
|
|
}
|
|
}
|
|
|
|
registerkillstreakdialog( killstreaktype, receiveddialog, friendlystartdialog, friendlyenddialog, enemystartdialog, enemyenddialog, dialog )
|
|
{
|
|
/#
|
|
assert( isDefined( killstreaktype ), "Can not register a killstreak without a valid type name." );
|
|
#/
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ] ), "Killstreak needs to be registered before calling registerKillstreakDialog." );
|
|
#/
|
|
precachestring( istring( receiveddialog ) );
|
|
level.killstreaks[ killstreaktype ].informdialog = receiveddialog;
|
|
game[ "dialog" ][ killstreaktype + "_start" ] = friendlystartdialog;
|
|
game[ "dialog" ][ killstreaktype + "_end" ] = friendlyenddialog;
|
|
game[ "dialog" ][ killstreaktype + "_enemy_start" ] = enemystartdialog;
|
|
game[ "dialog" ][ killstreaktype + "_enemy_end" ] = enemyenddialog;
|
|
game[ "dialog" ][ killstreaktype ] = dialog;
|
|
}
|
|
|
|
registerkillstreakaltweapon( killstreaktype, weapon )
|
|
{
|
|
/#
|
|
assert( isDefined( killstreaktype ), "Can not register a killstreak without a valid type name." );
|
|
#/
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ] ), "Killstreak needs to be registered before calling registerKillstreakAltWeapon." );
|
|
#/
|
|
if ( level.killstreaks[ killstreaktype ].weapon == weapon )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( level.killstreaks[ killstreaktype ].altweapons ) )
|
|
{
|
|
level.killstreaks[ killstreaktype ].altweapons = [];
|
|
}
|
|
if ( !isDefined( level.killstreakweapons[ weapon ] ) )
|
|
{
|
|
level.killstreakweapons[ weapon ] = killstreaktype;
|
|
}
|
|
level.killstreaks[ killstreaktype ].altweapons[ level.killstreaks[ killstreaktype ].altweapons.size ] = weapon;
|
|
}
|
|
|
|
registerkillstreakremoteoverrideweapon( killstreaktype, weapon )
|
|
{
|
|
/#
|
|
assert( isDefined( killstreaktype ), "Can not register a killstreak without a valid type name." );
|
|
#/
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ] ), "Killstreak needs to be registered before calling registerKillstreakAltWeapon." );
|
|
#/
|
|
if ( level.killstreaks[ killstreaktype ].weapon == weapon )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( level.killstreaks[ killstreaktype ].remoteoverrideweapons ) )
|
|
{
|
|
level.killstreaks[ killstreaktype ].remoteoverrideweapons = [];
|
|
}
|
|
if ( !isDefined( level.killstreakweapons[ weapon ] ) )
|
|
{
|
|
level.killstreakweapons[ weapon ] = killstreaktype;
|
|
}
|
|
level.killstreaks[ killstreaktype ].remoteoverrideweapons[ level.killstreaks[ killstreaktype ].remoteoverrideweapons.size ] = weapon;
|
|
}
|
|
|
|
iskillstreakremoteoverrideweapon( killstreaktype, weapon )
|
|
{
|
|
while ( isDefined( level.killstreaks[ killstreaktype ].remoteoverrideweapons ) )
|
|
{
|
|
i = 0;
|
|
while ( i < level.killstreaks[ killstreaktype ].remoteoverrideweapons.size )
|
|
{
|
|
if ( level.killstreaks[ killstreaktype ].remoteoverrideweapons[ i ] == weapon )
|
|
{
|
|
return 1;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
registerkillstreakdevdvar( killstreaktype, dvar )
|
|
{
|
|
/#
|
|
assert( isDefined( killstreaktype ), "Can not register a killstreak without a valid type name." );
|
|
#/
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ] ), "Killstreak needs to be registered before calling registerKillstreakDevDvar." );
|
|
#/
|
|
level.killstreaks[ killstreaktype ].devdvar = dvar;
|
|
}
|
|
|
|
allowkillstreakassists( killstreaktype, allow )
|
|
{
|
|
level.killstreaks[ killstreaktype ].allowassists = allow;
|
|
}
|
|
|
|
setkillstreakteamkillpenaltyscale( killstreaktype, scale )
|
|
{
|
|
level.killstreaks[ killstreaktype ].teamkillpenaltyscale = scale;
|
|
}
|
|
|
|
overrideentitycameraindemo( killstreaktype, value )
|
|
{
|
|
level.killstreaks[ killstreaktype ].overrideentitycameraindemo = value;
|
|
}
|
|
|
|
iskillstreakavailable( killstreak )
|
|
{
|
|
if ( isDefined( level.menureferenceforkillstreak[ killstreak ] ) )
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
getkillstreakbymenuname( killstreak )
|
|
{
|
|
return level.menureferenceforkillstreak[ killstreak ];
|
|
}
|
|
|
|
getkillstreakmenuname( killstreaktype )
|
|
{
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ] ) );
|
|
#/
|
|
return level.killstreaks[ killstreaktype ].menuname;
|
|
}
|
|
|
|
drawline( start, end, timeslice, color )
|
|
{
|
|
/#
|
|
drawtime = int( timeslice * 20 );
|
|
time = 0;
|
|
while ( time < drawtime )
|
|
{
|
|
line( start, end, ( 1, 0, 0 ), 0, 1 );
|
|
wait 0,05;
|
|
time++;
|
|
#/
|
|
}
|
|
}
|
|
|
|
getkillstreaklevel( index, killstreak )
|
|
{
|
|
killstreaklevel = level.killstreaks[ getkillstreakbymenuname( killstreak ) ].killstreaklevel;
|
|
if ( getDvarInt( #"826EB3B9" ) == 2 )
|
|
{
|
|
if ( isDefined( self.killstreak[ index ] ) && killstreak == self.killstreak[ index ] )
|
|
{
|
|
killsrequired = getDvarInt( 2404036340 + index + 1 + "_kills" );
|
|
if ( killsrequired )
|
|
{
|
|
killstreaklevel = getDvarInt( 2404036340 + index + 1 + "_kills" );
|
|
}
|
|
}
|
|
}
|
|
return killstreaklevel;
|
|
}
|
|
|
|
givekillstreakifstreakcountmatches( index, killstreak, streakcount )
|
|
{
|
|
pixbeginevent( "giveKillstreakIfStreakCountMatches" );
|
|
/#
|
|
if ( !isDefined( killstreak ) )
|
|
{
|
|
println( "Killstreak Undefined.\n" );
|
|
}
|
|
if ( isDefined( killstreak ) )
|
|
{
|
|
println( "Killstreak listed as." + killstreak + "\n" );
|
|
}
|
|
if ( !iskillstreakavailable( killstreak ) )
|
|
{
|
|
println( "Killstreak Not Available.\n" );
|
|
#/
|
|
}
|
|
if ( self.pers[ "killstreaksEarnedThisKillstreak" ] > index && isroundbased() )
|
|
{
|
|
hasalreadyearnedkillstreak = 1;
|
|
}
|
|
else
|
|
{
|
|
hasalreadyearnedkillstreak = 0;
|
|
}
|
|
if ( isDefined( killstreak ) && iskillstreakavailable( killstreak ) && !hasalreadyearnedkillstreak )
|
|
{
|
|
killstreaklevel = getkillstreaklevel( index, killstreak );
|
|
if ( self hasperk( "specialty_killstreak" ) )
|
|
{
|
|
reduction = getDvarInt( "perk_killstreakReduction" );
|
|
killstreaklevel -= reduction;
|
|
if ( killstreaklevel <= 0 )
|
|
{
|
|
killstreaklevel = 1;
|
|
}
|
|
}
|
|
if ( killstreaklevel == streakcount )
|
|
{
|
|
self givekillstreak( getkillstreakbymenuname( killstreak ), streakcount );
|
|
self.pers[ "killstreaksEarnedThisKillstreak" ] = index + 1;
|
|
pixendevent();
|
|
return 1;
|
|
}
|
|
}
|
|
pixendevent();
|
|
return 0;
|
|
}
|
|
|
|
givekillstreakforstreak()
|
|
{
|
|
if ( !iskillstreaksenabled() )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( self.pers[ "totalKillstreakCount" ] ) )
|
|
{
|
|
self.pers[ "totalKillstreakCount" ] = 0;
|
|
}
|
|
given = 0;
|
|
i = 0;
|
|
while ( i < self.killstreak.size )
|
|
{
|
|
given |= givekillstreakifstreakcountmatches( i, self.killstreak[ i ], self.pers[ "cur_kill_streak" ] );
|
|
i++;
|
|
}
|
|
}
|
|
|
|
isonakillstreak()
|
|
{
|
|
onkillstreak = 0;
|
|
if ( !isDefined( self.pers[ "kill_streak_before_death" ] ) )
|
|
{
|
|
self.pers[ "kill_streak_before_death" ] = 0;
|
|
}
|
|
streakplusone = self.pers[ "kill_streak_before_death" ] + 1;
|
|
if ( self.pers[ "kill_streak_before_death" ] >= 5 )
|
|
{
|
|
onkillstreak = 1;
|
|
}
|
|
return onkillstreak;
|
|
}
|
|
|
|
doesstreakcountmatch( killstreak, streakcount )
|
|
{
|
|
if ( isDefined( killstreak ) && iskillstreakavailable( killstreak ) )
|
|
{
|
|
killstreaklevel = level.killstreaks[ getkillstreakbymenuname( killstreak ) ].killstreaklevel;
|
|
if ( killstreaklevel == streakcount )
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
streaknotify( streakval )
|
|
{
|
|
self endon( "disconnect" );
|
|
self waittill( "playerKilledChallengesProcessed" );
|
|
wait 0,05;
|
|
notifydata = spawnstruct();
|
|
notifydata.titlelabel = &"MP_KILLSTREAK_N";
|
|
notifydata.titletext = streakval;
|
|
notifydata.iconheight = 32;
|
|
self maps/mp/gametypes/_hud_message::notifymessage( notifydata );
|
|
}
|
|
|
|
givekillstreak( killstreaktype, streak, suppressnotification, noxp )
|
|
{
|
|
pixbeginevent( "giveKillstreak" );
|
|
self endon( "disconnect" );
|
|
level endon( "game_ended" );
|
|
had_to_delay = 0;
|
|
killstreakgiven = 0;
|
|
if ( isDefined( noxp ) )
|
|
{
|
|
if ( self givekillstreakinternal( killstreaktype, undefined, noxp ) )
|
|
{
|
|
killstreakgiven = 1;
|
|
self addkillstreaktoqueue( level.killstreaks[ killstreaktype ].menuname, streak, killstreaktype, noxp );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( self givekillstreakinternal( killstreaktype, noxp ) )
|
|
{
|
|
killstreakgiven = 1;
|
|
self addkillstreaktoqueue( level.killstreaks[ killstreaktype ].menuname, streak, killstreaktype, noxp );
|
|
}
|
|
}
|
|
pixendevent();
|
|
}
|
|
|
|
removeoldestkillstreak()
|
|
{
|
|
if ( isDefined( self.pers[ "killstreaks" ][ 0 ] ) )
|
|
{
|
|
currentweapon = self getcurrentweapon();
|
|
if ( currentweapon == self.pers[ "killstreaks" ][ 0 ] )
|
|
{
|
|
primaries = self getweaponslistprimaries();
|
|
if ( primaries.size > 0 )
|
|
{
|
|
self switchtoweapon( primaries[ 0 ] );
|
|
}
|
|
}
|
|
self notify( "oldest_killstreak_removed" );
|
|
self maps/mp/killstreaks/_killstreaks::removeusedkillstreak( self.pers[ "killstreaks" ][ 0 ], self.pers[ "killstreak_unique_id" ][ 0 ] );
|
|
}
|
|
}
|
|
|
|
givekillstreakinternal( killstreaktype, do_not_update_death_count, noxp )
|
|
{
|
|
if ( level.gameended )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !iskillstreaksenabled() )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !isDefined( level.killstreaks[ killstreaktype ] ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !isDefined( self.pers[ "killstreaks" ] ) )
|
|
{
|
|
self.pers[ "killstreaks" ] = [];
|
|
}
|
|
if ( !isDefined( self.pers[ "killstreak_has_been_used" ] ) )
|
|
{
|
|
self.pers[ "killstreak_has_been_used" ] = [];
|
|
}
|
|
if ( !isDefined( self.pers[ "killstreak_unique_id" ] ) )
|
|
{
|
|
self.pers[ "killstreak_unique_id" ] = [];
|
|
}
|
|
self.pers[ "killstreaks" ][ self.pers[ "killstreaks" ].size ] = killstreaktype;
|
|
self.pers[ "killstreak_unique_id" ][ self.pers[ "killstreak_unique_id" ].size ] = level.killstreakcounter;
|
|
level.killstreakcounter++;
|
|
if ( self.pers[ "killstreaks" ].size > level.maxinventoryscorestreaks )
|
|
{
|
|
self removeoldestkillstreak();
|
|
}
|
|
if ( isDefined( noxp ) )
|
|
{
|
|
self.pers[ "killstreak_has_been_used" ][ self.pers[ "killstreak_has_been_used" ].size ] = noxp;
|
|
}
|
|
else
|
|
{
|
|
self.pers[ "killstreak_has_been_used" ][ self.pers[ "killstreak_has_been_used" ].size ] = 0;
|
|
}
|
|
weapon = getkillstreakweapon( killstreaktype );
|
|
ammocount = givekillstreakweapon( weapon, 1 );
|
|
self.pers[ "killstreak_ammo_count" ][ self.pers[ "killstreak_ammo_count" ].size ] = ammocount;
|
|
return 1;
|
|
}
|
|
|
|
addkillstreaktoqueue( menuname, streakcount, hardpointtype, nonotify )
|
|
{
|
|
killstreaktablenumber = level.killstreakindices[ menuname ];
|
|
if ( !isDefined( killstreaktablenumber ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( isDefined( nonotify ) && nonotify )
|
|
{
|
|
return;
|
|
}
|
|
informdialog = getkillstreakinformdialog( hardpointtype );
|
|
self playkillstreakreadydialog( hardpointtype );
|
|
self luinotifyevent( &"killstreak_received", 2, killstreaktablenumber, istring( informdialog ) );
|
|
self luinotifyeventtospectators( &"killstreak_received", 2, killstreaktablenumber, istring( informdialog ) );
|
|
}
|
|
|
|
haskillstreakequipped()
|
|
{
|
|
currentweapon = self getcurrentweapon();
|
|
keys = getarraykeys( level.killstreaks );
|
|
i = 0;
|
|
while ( i < keys.size )
|
|
{
|
|
if ( level.killstreaks[ keys[ i ] ].weapon == currentweapon )
|
|
{
|
|
return 1;
|
|
}
|
|
i++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
getkillstreakfromweapon( weapon )
|
|
{
|
|
keys = getarraykeys( level.killstreaks );
|
|
i = 0;
|
|
while ( i < keys.size )
|
|
{
|
|
if ( level.killstreaks[ keys[ i ] ].weapon == weapon )
|
|
{
|
|
return keys[ i ];
|
|
}
|
|
while ( isDefined( level.killstreaks[ keys[ i ] ].altweapons ) )
|
|
{
|
|
_a558 = level.killstreaks[ keys[ i ] ].altweapons;
|
|
_k558 = getFirstArrayKey( _a558 );
|
|
while ( isDefined( _k558 ) )
|
|
{
|
|
altweapon = _a558[ _k558 ];
|
|
if ( altweapon == weapon )
|
|
{
|
|
return keys[ i ];
|
|
}
|
|
_k558 = getNextArrayKey( _a558, _k558 );
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
givekillstreakweapon( weapon, isinventory, usestoredammo )
|
|
{
|
|
currentweapon = self getcurrentweapon();
|
|
while ( !isDefined( level.usingmomentum ) || !level.usingmomentum )
|
|
{
|
|
weaponslist = self getweaponslist();
|
|
idx = 0;
|
|
while ( idx < weaponslist.size )
|
|
{
|
|
carriedweapon = weaponslist[ idx ];
|
|
if ( currentweapon == carriedweapon )
|
|
{
|
|
idx++;
|
|
continue;
|
|
}
|
|
else if ( currentweapon == "none" )
|
|
{
|
|
idx++;
|
|
continue;
|
|
}
|
|
else switch( carriedweapon )
|
|
{
|
|
case "m32_mp":
|
|
case "minigun_mp":
|
|
idx++;
|
|
continue;
|
|
}
|
|
if ( iskillstreakweapon( carriedweapon ) )
|
|
{
|
|
self takeweapon( carriedweapon );
|
|
}
|
|
idx++;
|
|
}
|
|
}
|
|
if ( currentweapon != weapon && self hasweapon( weapon ) == 0 )
|
|
{
|
|
self takeweapon( weapon );
|
|
self giveweapon( weapon );
|
|
}
|
|
if ( isDefined( level.usingmomentum ) && level.usingmomentum )
|
|
{
|
|
self setinventoryweapon( weapon );
|
|
if ( maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( weapon ) )
|
|
{
|
|
if ( !isDefined( self.pers[ "held_killstreak_ammo_count" ][ weapon ] ) )
|
|
{
|
|
self.pers[ "held_killstreak_ammo_count" ][ weapon ] = 0;
|
|
}
|
|
if ( !isDefined( self.pers[ "held_killstreak_clip_count" ][ weapon ] ) )
|
|
{
|
|
self.pers[ "held_killstreak_clip_count" ][ weapon ] = weaponclipsize( weapon );
|
|
}
|
|
if ( !isDefined( self.pers[ "killstreak_quantity" ][ weapon ] ) )
|
|
{
|
|
self.pers[ "killstreak_quantity" ][ weapon ] = 0;
|
|
}
|
|
if ( currentweapon == weapon && !maps/mp/killstreaks/_killstreak_weapons::isheldinventorykillstreakweapon( weapon ) )
|
|
{
|
|
return weaponmaxammo( weapon );
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( usestoredammo ) && usestoredammo && self.pers[ "killstreak_ammo_count" ][ self.pers[ "killstreak_ammo_count" ].size - 1 ] > 0 )
|
|
{
|
|
switch( weapon )
|
|
{
|
|
case "inventory_minigun_mp":
|
|
if ( isDefined( self.minigunactive ) && self.minigunactive )
|
|
{
|
|
return self.pers[ "held_killstreak_ammo_count" ][ weapon ];
|
|
}
|
|
case "inventory_m32_mp":
|
|
if ( isDefined( self.m32active ) && self.m32active )
|
|
{
|
|
return self.pers[ "held_killstreak_ammo_count" ][ weapon ];
|
|
}
|
|
default:
|
|
}
|
|
self.pers[ "held_killstreak_ammo_count" ][ weapon ] = self.pers[ "killstreak_ammo_count" ][ self.pers[ "killstreak_ammo_count" ].size - 1 ];
|
|
self maps/mp/gametypes/_class::setweaponammooverall( weapon, self.pers[ "killstreak_ammo_count" ][ self.pers[ "killstreak_ammo_count" ].size - 1 ] );
|
|
}
|
|
else self.pers[ "held_killstreak_ammo_count" ][ weapon ] = weaponmaxammo( weapon );
|
|
self.pers[ "held_killstreak_clip_count" ][ weapon ] = weaponclipsize( weapon );
|
|
self maps/mp/gametypes/_class::setweaponammooverall( weapon, self.pers[ "held_killstreak_ammo_count" ][ weapon ] );
|
|
}
|
|
return self.pers[ "held_killstreak_ammo_count" ][ weapon ];
|
|
}
|
|
else
|
|
{
|
|
if ( weapon != "inventory_ai_tank_drop_mp" && weapon != "inventory_supplydrop_mp" && weapon != "inventory_minigun_drop_mp" || weapon == "inventory_m32_drop_mp" && weapon == "inventory_missile_drone_mp" )
|
|
{
|
|
delta = 1;
|
|
}
|
|
else
|
|
{
|
|
delta = 0;
|
|
}
|
|
return changekillstreakquantity( weapon, delta );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self setactionslot( 4, "weapon", weapon );
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
activatenextkillstreak( do_not_update_death_count )
|
|
{
|
|
if ( level.gameended )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( level.usingmomentum ) && level.usingmomentum )
|
|
{
|
|
self setinventoryweapon( "" );
|
|
}
|
|
else
|
|
{
|
|
self setactionslot( 4, "" );
|
|
}
|
|
if ( !isDefined( self.pers[ "killstreaks" ] ) || self.pers[ "killstreaks" ].size == 0 )
|
|
{
|
|
return 0;
|
|
}
|
|
killstreaktype = self.pers[ "killstreaks" ][ self.pers[ "killstreaks" ].size - 1 ];
|
|
if ( !isDefined( level.killstreaks[ killstreaktype ] ) )
|
|
{
|
|
return 0;
|
|
}
|
|
weapon = level.killstreaks[ killstreaktype ].weapon;
|
|
wait 0,05;
|
|
ammocount = givekillstreakweapon( weapon, 0, 1 );
|
|
if ( maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( weapon ) )
|
|
{
|
|
self setweaponammoclip( weapon, self.pers[ "held_killstreak_clip_count" ][ weapon ] );
|
|
self setweaponammostock( weapon, ammocount - self.pers[ "held_killstreak_clip_count" ][ weapon ] );
|
|
}
|
|
if ( !isDefined( do_not_update_death_count ) || do_not_update_death_count != 0 )
|
|
{
|
|
self.pers[ "killstreakItemDeathCount" + killstreaktype ] = self.deathcount;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
takekillstreak( killstreaktype )
|
|
{
|
|
if ( level.gameended )
|
|
{
|
|
return;
|
|
}
|
|
if ( !iskillstreaksenabled() )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( self.selectinglocation ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !isDefined( level.killstreaks[ killstreaktype ] ) )
|
|
{
|
|
return 0;
|
|
}
|
|
self takeweapon( killstreaktype );
|
|
self setactionslot( 4, "" );
|
|
self.pers[ "killstreakItemDeathCount" + killstreaktype ] = 0;
|
|
return 1;
|
|
}
|
|
|
|
giveownedkillstreak()
|
|
{
|
|
if ( isDefined( self.pers[ "killstreaks" ] ) && self.pers[ "killstreaks" ].size > 0 )
|
|
{
|
|
self activatenextkillstreak( 0 );
|
|
}
|
|
}
|
|
|
|
switchtolastnonkillstreakweapon()
|
|
{
|
|
if ( isDefined( self.laststand ) && self.laststand && isDefined( self.laststandpistol ) && self hasweapon( self.laststandpistol ) )
|
|
{
|
|
self switchtoweapon( self.laststandpistol );
|
|
}
|
|
else
|
|
{
|
|
if ( self hasweapon( self.lastnonkillstreakweapon ) )
|
|
{
|
|
self switchtoweapon( self.lastnonkillstreakweapon );
|
|
}
|
|
else if ( self hasweapon( self.lastdroppableweapon ) )
|
|
{
|
|
self switchtoweapon( self.lastdroppableweapon );
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
changeweaponafterkillstreak( killstreak, takeweapon )
|
|
{
|
|
self endon( "disconnect" );
|
|
self endon( "death" );
|
|
killstreak_weapon = getkillstreakweapon( killstreak );
|
|
currentweapon = self getcurrentweapon();
|
|
result = self switchtolastnonkillstreakweapon();
|
|
}
|
|
|
|
changekillstreakquantity( killstreakweapon, delta )
|
|
{
|
|
quantity = self.pers[ "killstreak_quantity" ][ killstreakweapon ];
|
|
if ( !isDefined( quantity ) )
|
|
{
|
|
quantity = 0;
|
|
}
|
|
previousquantity = quantity;
|
|
if ( delta < 0 )
|
|
{
|
|
/#
|
|
assert( quantity > 0 );
|
|
#/
|
|
}
|
|
quantity += delta;
|
|
if ( quantity > level.scorestreaksmaxstacking )
|
|
{
|
|
quantity = level.scorestreaksmaxstacking;
|
|
}
|
|
if ( self hasweapon( killstreakweapon ) == 0 )
|
|
{
|
|
self takeweapon( killstreakweapon );
|
|
self giveweapon( killstreakweapon );
|
|
self seteverhadweaponall( 1 );
|
|
}
|
|
self.pers[ "killstreak_quantity" ][ killstreakweapon ] = quantity;
|
|
self setweaponammoclip( killstreakweapon, quantity );
|
|
return quantity;
|
|
}
|
|
|
|
haskillstreakinclass( killstreakmenuname )
|
|
{
|
|
_a819 = self.killstreak;
|
|
_k819 = getFirstArrayKey( _a819 );
|
|
while ( isDefined( _k819 ) )
|
|
{
|
|
equippedkillstreak = _a819[ _k819 ];
|
|
if ( equippedkillstreak == killstreakmenuname )
|
|
{
|
|
return 1;
|
|
}
|
|
_k819 = getNextArrayKey( _a819, _k819 );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
removekillstreakwhendone( killstreak, haskillstreakbeenused, isfrominventory )
|
|
{
|
|
self endon( "disconnect" );
|
|
self waittill( "killstreak_done", successful, killstreaktype );
|
|
if ( successful )
|
|
{
|
|
logstring( "killstreak: " + getkillstreakmenuname( killstreak ) );
|
|
killstreak_weapon = getkillstreakweapon( killstreak );
|
|
recordstreakindex = undefined;
|
|
if ( isDefined( level.killstreaks[ killstreak ].menuname ) )
|
|
{
|
|
recordstreakindex = level.killstreakindices[ level.killstreaks[ killstreak ].menuname ];
|
|
if ( isDefined( recordstreakindex ) )
|
|
{
|
|
self recordkillstreakevent( recordstreakindex );
|
|
}
|
|
}
|
|
if ( isDefined( level.usingscorestreaks ) && level.usingscorestreaks )
|
|
{
|
|
if ( isDefined( isfrominventory ) && isfrominventory )
|
|
{
|
|
removeusedkillstreak( killstreak );
|
|
if ( self getinventoryweapon() == killstreak_weapon )
|
|
{
|
|
self setinventoryweapon( "" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self changekillstreakquantity( killstreak_weapon, -1 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( level.usingmomentum ) && level.usingmomentum )
|
|
{
|
|
if ( isDefined( isfrominventory ) && isfrominventory && self getinventoryweapon() == killstreak_weapon )
|
|
{
|
|
removeusedkillstreak( killstreak );
|
|
self setinventoryweapon( "" );
|
|
}
|
|
else
|
|
{
|
|
maps/mp/gametypes/_globallogic_score::_setplayermomentum( self, self.momentum - level.killstreaks[ killstreaktype ].momentumcost );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
removeusedkillstreak( killstreak );
|
|
}
|
|
}
|
|
if ( !isDefined( level.usingmomentum ) || !level.usingmomentum )
|
|
{
|
|
self setactionslot( 4, "" );
|
|
}
|
|
success = 1;
|
|
}
|
|
waittillframeend;
|
|
currentweapon = self getcurrentweapon();
|
|
if ( maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( killstreaktype ) && currentweapon == killstreaktype )
|
|
{
|
|
return;
|
|
}
|
|
if ( successful || !self haskillstreakinclass( getkillstreakmenuname( killstreak ) ) && isDefined( isfrominventory ) && isfrominventory )
|
|
{
|
|
changeweaponafterkillstreak( killstreak, 1 );
|
|
}
|
|
else
|
|
{
|
|
killstreakforcurrentweapon = getkillstreakfromweapon( currentweapon );
|
|
if ( maps/mp/killstreaks/_killstreak_weapons::isgameplayweapon( currentweapon ) )
|
|
{
|
|
if ( is_true( self.isplanting ) || is_true( self.isdefusing ) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
if ( !successful || !isDefined( killstreakforcurrentweapon ) && killstreakforcurrentweapon == killstreak )
|
|
{
|
|
changeweaponafterkillstreak( killstreak, 0 );
|
|
}
|
|
}
|
|
if ( isDefined( level.usingmomentum ) || !level.usingmomentum && isDefined( isfrominventory ) && isfrominventory )
|
|
{
|
|
if ( successful )
|
|
{
|
|
activatenextkillstreak();
|
|
}
|
|
}
|
|
}
|
|
|
|
usekillstreak( killstreak, isfrominventory )
|
|
{
|
|
haskillstreakbeenused = getiftopkillstreakhasbeenused();
|
|
if ( isDefined( self.selectinglocation ) )
|
|
{
|
|
return;
|
|
}
|
|
self thread removekillstreakwhendone( killstreak, haskillstreakbeenused, isfrominventory );
|
|
self thread triggerkillstreak( killstreak, isfrominventory );
|
|
}
|
|
|
|
removeusedkillstreak( killstreak, killstreakid )
|
|
{
|
|
killstreakindex = undefined;
|
|
i = self.pers[ "killstreaks" ].size - 1;
|
|
while ( i >= 0 )
|
|
{
|
|
if ( self.pers[ "killstreaks" ][ i ] == killstreak )
|
|
{
|
|
if ( isDefined( killstreakid ) && self.pers[ "killstreak_unique_id" ][ i ] != killstreakid )
|
|
{
|
|
i--;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
killstreakindex = i;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
i--;
|
|
|
|
}
|
|
}
|
|
if ( !isDefined( killstreakindex ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( !self haskillstreakinclass( getkillstreakmenuname( killstreak ) ) )
|
|
{
|
|
self thread takeweaponafteruse( killstreak );
|
|
}
|
|
arraysize = self.pers[ "killstreaks" ].size;
|
|
i = killstreakindex;
|
|
while ( i < ( arraysize - 1 ) )
|
|
{
|
|
self.pers[ "killstreaks" ][ i ] = self.pers[ "killstreaks" ][ i + 1 ];
|
|
self.pers[ "killstreak_has_been_used" ][ i ] = self.pers[ "killstreak_has_been_used" ][ i + 1 ];
|
|
self.pers[ "killstreak_unique_id" ][ i ] = self.pers[ "killstreak_unique_id" ][ i + 1 ];
|
|
self.pers[ "killstreak_ammo_count" ][ i ] = self.pers[ "killstreak_ammo_count" ][ i + 1 ];
|
|
i++;
|
|
}
|
|
}
|
|
|
|
takeweaponafteruse( killstreak )
|
|
{
|
|
self endon( "disconnect" );
|
|
self endon( "death" );
|
|
self endon( "joined_team" );
|
|
self endon( "joined_spectators" );
|
|
self waittill( "weapon_change" );
|
|
inventoryweapon = self getinventoryweapon();
|
|
if ( inventoryweapon != killstreak )
|
|
{
|
|
self takeweapon( killstreak );
|
|
}
|
|
}
|
|
|
|
gettopkillstreak()
|
|
{
|
|
if ( self.pers[ "killstreaks" ].size == 0 )
|
|
{
|
|
return undefined;
|
|
}
|
|
return self.pers[ "killstreaks" ][ self.pers[ "killstreaks" ].size - 1 ];
|
|
}
|
|
|
|
getiftopkillstreakhasbeenused()
|
|
{
|
|
if ( !isDefined( level.usingmomentum ) || !level.usingmomentum )
|
|
{
|
|
if ( self.pers[ "killstreak_has_been_used" ].size == 0 )
|
|
{
|
|
return undefined;
|
|
}
|
|
return self.pers[ "killstreak_has_been_used" ][ self.pers[ "killstreak_has_been_used" ].size - 1 ];
|
|
}
|
|
}
|
|
|
|
gettopkillstreakuniqueid()
|
|
{
|
|
if ( self.pers[ "killstreak_unique_id" ].size == 0 )
|
|
{
|
|
return undefined;
|
|
}
|
|
return self.pers[ "killstreak_unique_id" ][ self.pers[ "killstreak_unique_id" ].size - 1 ];
|
|
}
|
|
|
|
getkillstreakindexbyid( killstreakid )
|
|
{
|
|
index = self.pers[ "killstreak_unique_id" ].size - 1;
|
|
while ( index >= 0 )
|
|
{
|
|
if ( self.pers[ "killstreak_unique_id" ][ index ] == killstreakid )
|
|
{
|
|
return index;
|
|
}
|
|
index--;
|
|
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
getkillstreakweapon( killstreak )
|
|
{
|
|
if ( !isDefined( killstreak ) )
|
|
{
|
|
return "none";
|
|
}
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreak ] ) );
|
|
#/
|
|
return level.killstreaks[ killstreak ].weapon;
|
|
}
|
|
|
|
getkillstreakmomentumcost( killstreak )
|
|
{
|
|
if ( !isDefined( level.usingmomentum ) || !level.usingmomentum )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !isDefined( killstreak ) )
|
|
{
|
|
return 0;
|
|
}
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreak ] ) );
|
|
#/
|
|
return level.killstreaks[ killstreak ].momentumcost;
|
|
}
|
|
|
|
getkillstreakforweapon( weapon )
|
|
{
|
|
return level.killstreakweapons[ weapon ];
|
|
}
|
|
|
|
iskillstreakweapon( weapon )
|
|
{
|
|
if ( isweaponassociatedwithkillstreak( weapon ) )
|
|
{
|
|
return 1;
|
|
}
|
|
switch( weapon )
|
|
{
|
|
case "briefcase_bomb_defuse_mp":
|
|
case "briefcase_bomb_mp":
|
|
case "none":
|
|
case "scavenger_item_mp":
|
|
case "vcs_controller_mp":
|
|
return 0;
|
|
}
|
|
if ( isweaponspecificuse( weapon ) )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
iskillstreakweaponassistallowed( weapon )
|
|
{
|
|
killstreak = getkillstreakforweapon( weapon );
|
|
if ( !isDefined( killstreak ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( level.killstreaks[ killstreak ].allowassists )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
getkillstreakteamkillpenaltyscale( weapon )
|
|
{
|
|
killstreak = getkillstreakforweapon( weapon );
|
|
if ( !isDefined( killstreak ) )
|
|
{
|
|
return 1;
|
|
}
|
|
return level.killstreaks[ killstreak ].teamkillpenaltyscale;
|
|
}
|
|
|
|
shouldoverrideentitycameraindemo( player, weapon )
|
|
{
|
|
killstreak = getkillstreakforweapon( weapon );
|
|
if ( !isDefined( killstreak ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( level.killstreaks[ killstreak ].overrideentitycameraindemo )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( isDefined( player.remoteweapon ) && isDefined( player.remoteweapon.controlled ) && player.remoteweapon.controlled )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
trackweaponusage()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "disconnect" );
|
|
self.lastnonkillstreakweapon = self getcurrentweapon();
|
|
lastvalidpimary = self getcurrentweapon();
|
|
if ( self.lastnonkillstreakweapon == "none" )
|
|
{
|
|
weapons = self getweaponslistprimaries();
|
|
if ( weapons.size > 0 )
|
|
{
|
|
self.lastnonkillstreakweapon = weapons[ 0 ];
|
|
}
|
|
else
|
|
{
|
|
self.lastnonkillstreakweapon = "knife_mp";
|
|
}
|
|
}
|
|
/#
|
|
assert( self.lastnonkillstreakweapon != "none" );
|
|
#/
|
|
for ( ;; )
|
|
{
|
|
currentweapon = self getcurrentweapon();
|
|
self waittill( "weapon_change", weapon );
|
|
if ( maps/mp/gametypes/_weapons::isprimaryweapon( weapon ) )
|
|
{
|
|
lastvalidpimary = weapon;
|
|
}
|
|
if ( weapon == self.lastnonkillstreakweapon )
|
|
{
|
|
continue;
|
|
}
|
|
else switch( weapon )
|
|
{
|
|
case "knife_mp":
|
|
case "none":
|
|
continue;
|
|
}
|
|
if ( maps/mp/killstreaks/_killstreak_weapons::isgameplayweapon( weapon ) )
|
|
{
|
|
continue;
|
|
}
|
|
else name = getkillstreakforweapon( weapon );
|
|
if ( isDefined( name ) && !maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( weapon ) )
|
|
{
|
|
killstreak = level.killstreaks[ name ];
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if ( currentweapon != "none" && isweaponequipment( currentweapon ) && maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( self.lastnonkillstreakweapon ) )
|
|
{
|
|
self.lastnonkillstreakweapon = lastvalidpimary;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( isweaponequipment( weapon ) )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
self.lastnonkillstreakweapon = weapon;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
killstreakwaiter()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "disconnect" );
|
|
level endon( "game_ended" );
|
|
self thread trackweaponusage();
|
|
self giveownedkillstreak();
|
|
for ( ;; )
|
|
{
|
|
self waittill( "weapon_change", weapon );
|
|
if ( !iskillstreakweapon( weapon ) )
|
|
{
|
|
continue;
|
|
}
|
|
else killstreak = getkillstreakforweapon( weapon );
|
|
if ( !isDefined( level.usingmomentum ) || !level.usingmomentum )
|
|
{
|
|
killstreak = gettopkillstreak();
|
|
if ( weapon != getkillstreakweapon( killstreak ) )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else if ( iskillstreakremoteoverrideweapon( killstreak, weapon ) )
|
|
{
|
|
continue;
|
|
}
|
|
else if ( !self inventorybuttonpressed() )
|
|
{
|
|
inventorybuttonpressed = isDefined( self.pers[ "isBot" ] );
|
|
}
|
|
waittillframeend;
|
|
if ( isDefined( self.usingkillstreakheldweapon ) && self.usingkillstreakheldweapon && maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( killstreak ) )
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
isfrominventory = undefined;
|
|
if ( isDefined( level.usingscorestreaks ) && level.usingscorestreaks )
|
|
{
|
|
if ( weapon == self getinventoryweapon() && inventorybuttonpressed )
|
|
{
|
|
isfrominventory = 1;
|
|
}
|
|
else
|
|
{
|
|
if ( self getammocount( weapon ) <= 0 && weapon != "killstreak_ai_tank_mp" )
|
|
{
|
|
self switchtolastnonkillstreakweapon();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
}
|
|
else if ( isDefined( level.usingmomentum ) && level.usingmomentum )
|
|
{
|
|
if ( weapon == self getinventoryweapon() && inventorybuttonpressed )
|
|
{
|
|
isfrominventory = 1;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( self.momentum < level.killstreaks[ killstreak ].momentumcost )
|
|
{
|
|
self switchtolastnonkillstreakweapon();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
thread usekillstreak( killstreak, isfrominventory );
|
|
if ( isDefined( self.selectinglocation ) && getDvarInt( #"027EB3EF" ) == 0 )
|
|
{
|
|
event = self waittill_any_return( "cancel_location", "game_ended", "used", "weapon_change" );
|
|
if ( event == "cancel_location" || event == "weapon_change" )
|
|
{
|
|
wait 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
shoulddelaykillstreak( killstreaktype )
|
|
{
|
|
if ( !isDefined( level.starttime ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( level.roundstartkillstreakdelay < ( ( getTime() - level.starttime - level.discardtime ) / 1000 ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !isdelayablekillstreak( killstreaktype ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( killstreaktype ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isfirstround() || isoneround() )
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
isdelayablekillstreak( killstreaktype )
|
|
{
|
|
if ( isDefined( level.killstreaks[ killstreaktype ] ) && isDefined( level.killstreaks[ killstreaktype ].delaystreak ) && level.killstreaks[ killstreaktype ].delaystreak )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
getxpamountforkillstreak( killstreaktype )
|
|
{
|
|
xpamount = 0;
|
|
switch( level.killstreaks[ killstreaktype ].killstreaklevel )
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
xpamount = 100;
|
|
break;
|
|
case 5:
|
|
xpamount = 150;
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
xpamount = 200;
|
|
break;
|
|
case 8:
|
|
xpamount = 250;
|
|
break;
|
|
case 9:
|
|
xpamount = 300;
|
|
break;
|
|
case 10:
|
|
case 11:
|
|
xpamount = 350;
|
|
break;
|
|
case 12:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
xpamount = 500;
|
|
break;
|
|
}
|
|
return xpamount;
|
|
}
|
|
|
|
triggerkillstreak( killstreaktype, isfrominventory )
|
|
{
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ].usefunction ), "No use function defined for killstreak " + killstreaktype );
|
|
#/
|
|
self.usingkillstreakfrominventory = isfrominventory;
|
|
if ( level.infinalkillcam )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( shoulddelaykillstreak( killstreaktype ) )
|
|
{
|
|
timeleft = int( level.roundstartkillstreakdelay - ( maps/mp/gametypes/_globallogic_utils::gettimepassed() / 1000 ) );
|
|
if ( !timeleft )
|
|
{
|
|
timeleft = 1;
|
|
}
|
|
self iprintlnbold( &"MP_UNAVAILABLE_FOR_N", " " + timeleft + " ", &"EXE_SECONDS" );
|
|
}
|
|
else
|
|
{
|
|
if ( [[ level.killstreaks[ killstreaktype ].usefunction ]]( killstreaktype ) )
|
|
{
|
|
if ( isDefined( self ) )
|
|
{
|
|
if ( !isDefined( self.pers[ level.killstreaks[ killstreaktype ].usagekey ] ) )
|
|
{
|
|
self.pers[ level.killstreaks[ killstreaktype ].usagekey ] = 0;
|
|
}
|
|
self.pers[ level.killstreaks[ killstreaktype ].usagekey ]++;
|
|
self notify( "killstreak_used" );
|
|
self notify( "killstreak_done" );
|
|
}
|
|
self.usingkillstreakfrominventory = undefined;
|
|
return 1;
|
|
}
|
|
}
|
|
self.usingkillstreakfrominventory = undefined;
|
|
if ( isDefined( self ) )
|
|
{
|
|
self notify( "killstreak_done" );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
addtokillstreakcount( weapon )
|
|
{
|
|
if ( !isDefined( self.pers[ "totalKillstreakCount" ] ) )
|
|
{
|
|
self.pers[ "totalKillstreakCount" ] = 0;
|
|
}
|
|
self.pers[ "totalKillstreakCount" ]++;
|
|
}
|
|
|
|
isweaponassociatedwithkillstreak( weapon )
|
|
{
|
|
return isDefined( level.killstreakweapons[ weapon ] );
|
|
}
|
|
|
|
getfirstvalidkillstreakaltweapon( killstreaktype )
|
|
{
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ] ), "Killstreak not registered." );
|
|
#/
|
|
while ( isDefined( level.killstreaks[ killstreaktype ].altweapons ) )
|
|
{
|
|
i = 0;
|
|
while ( i < level.killstreaks[ killstreaktype ].altweapons.size )
|
|
{
|
|
if ( isDefined( level.killstreaks[ killstreaktype ].altweapons[ i ] ) )
|
|
{
|
|
return level.killstreaks[ killstreaktype ].altweapons[ i ];
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
return "none";
|
|
}
|
|
|
|
shouldgivekillstreak( weapon )
|
|
{
|
|
killstreakbuilding = getDvarInt( "scr_allow_killstreak_building" );
|
|
if ( killstreakbuilding == 0 )
|
|
{
|
|
if ( isweaponassociatedwithkillstreak( weapon ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
pointisindangerarea( point, targetpos, radius )
|
|
{
|
|
return distance2d( point, targetpos ) <= ( radius * 1,25 );
|
|
}
|
|
|
|
printkillstreakstarttext( killstreaktype, owner, team, targetpos, dangerradius )
|
|
{
|
|
if ( !isDefined( level.killstreaks[ killstreaktype ] ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( level.teambased )
|
|
{
|
|
players = level.players;
|
|
while ( !level.hardcoremode && isDefined( level.killstreaks[ killstreaktype ].inboundnearplayertext ) )
|
|
{
|
|
i = 0;
|
|
while ( i < players.size )
|
|
{
|
|
if ( isalive( players[ i ] ) && isDefined( players[ i ].pers[ "team" ] ) && players[ i ].pers[ "team" ] == team )
|
|
{
|
|
if ( pointisindangerarea( players[ i ].origin, targetpos, dangerradius ) )
|
|
{
|
|
players[ i ] iprintlnbold( level.killstreaks[ killstreaktype ].inboundnearplayertext );
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
while ( isDefined( level.killstreaks[ killstreaktype ] ) )
|
|
{
|
|
i = 0;
|
|
while ( i < level.players.size )
|
|
{
|
|
player = level.players[ i ];
|
|
playerteam = player.pers[ "team" ];
|
|
if ( isDefined( playerteam ) )
|
|
{
|
|
if ( playerteam == team )
|
|
{
|
|
player iprintln( level.killstreaks[ killstreaktype ].inboundtext, owner );
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
else if ( !level.hardcoremode && isDefined( level.killstreaks[ killstreaktype ].inboundnearplayertext ) )
|
|
{
|
|
if ( pointisindangerarea( owner.origin, targetpos, dangerradius ) )
|
|
{
|
|
owner iprintlnbold( level.killstreaks[ killstreaktype ].inboundnearplayertext );
|
|
}
|
|
}
|
|
}
|
|
|
|
playkillstreakstartdialog( killstreaktype, team, playnonteambasedenemysounds )
|
|
{
|
|
if ( !isDefined( level.killstreaks[ killstreaktype ] ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( killstreaktype == "radar_mp" && level.teambased )
|
|
{
|
|
if ( ( getTime() - level.radartimers[ team ] ) > 30000 )
|
|
{
|
|
maps/mp/gametypes/_globallogic_audio::leaderdialog( killstreaktype + "_start", team );
|
|
maps/mp/gametypes/_globallogic_audio::leaderdialogforotherteams( killstreaktype + "_enemy_start", team );
|
|
level.radartimers[ team ] = getTime();
|
|
}
|
|
else
|
|
{
|
|
self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( killstreaktype + "_start" );
|
|
}
|
|
return;
|
|
}
|
|
if ( level.teambased )
|
|
{
|
|
maps/mp/gametypes/_globallogic_audio::leaderdialog( killstreaktype + "_start", team );
|
|
maps/mp/gametypes/_globallogic_audio::leaderdialogforotherteams( killstreaktype + "_enemy_start", team );
|
|
}
|
|
else
|
|
{
|
|
self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( killstreaktype + "_start" );
|
|
selfarray = [];
|
|
selfarray[ 0 ] = self;
|
|
maps/mp/gametypes/_globallogic_audio::leaderdialog( killstreaktype + "_enemy_start", undefined, undefined, selfarray );
|
|
}
|
|
}
|
|
|
|
playkillstreakreadydialog( killstreaktype )
|
|
{
|
|
if ( !isDefined( level.gameended ) || !level.gameended )
|
|
{
|
|
self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( killstreaktype );
|
|
}
|
|
}
|
|
|
|
getkillstreakinformdialog( killstreaktype )
|
|
{
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ].informdialog ) );
|
|
#/
|
|
if ( isDefined( level.killstreaks[ killstreaktype ].informdialog ) )
|
|
{
|
|
return level.killstreaks[ killstreaktype ].informdialog;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
playkillstreakenddialog( killstreaktype, team )
|
|
{
|
|
if ( !isDefined( level.killstreaks[ killstreaktype ] ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( level.teambased )
|
|
{
|
|
maps/mp/gametypes/_globallogic_audio::leaderdialog( killstreaktype + "_end", team );
|
|
maps/mp/gametypes/_globallogic_audio::leaderdialogforotherteams( killstreaktype + "_enemy_end", team );
|
|
}
|
|
else
|
|
{
|
|
self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( killstreaktype + "_end" );
|
|
}
|
|
}
|
|
|
|
getkillstreakusagebykillstreak( killstreaktype )
|
|
{
|
|
/#
|
|
assert( isDefined( level.killstreaks[ killstreaktype ] ), "Killstreak needs to be registered before calling getKillstreakUsage." );
|
|
#/
|
|
return getkillstreakusage( level.killstreaks[ killstreaktype ].usagekey );
|
|
}
|
|
|
|
getkillstreakusage( usagekey )
|
|
{
|
|
if ( !isDefined( self.pers[ usagekey ] ) )
|
|
{
|
|
return 0;
|
|
}
|
|
return self.pers[ usagekey ];
|
|
}
|
|
|
|
onplayerconnect()
|
|
{
|
|
for ( ;; )
|
|
{
|
|
level waittill( "connecting", player );
|
|
player thread onplayerspawned();
|
|
player thread onjoinedteam();
|
|
}
|
|
}
|
|
|
|
onplayerspawned()
|
|
{
|
|
self endon( "disconnect" );
|
|
for ( ;; )
|
|
{
|
|
self waittill( "spawned_player" );
|
|
pixbeginevent( "_killstreaks.gsc/onPlayerSpawned" );
|
|
giveownedkillstreak();
|
|
if ( !isDefined( self.pers[ "killstreaks" ] ) )
|
|
{
|
|
self.pers[ "killstreaks" ] = [];
|
|
}
|
|
if ( !isDefined( self.pers[ "killstreak_has_been_used" ] ) )
|
|
{
|
|
self.pers[ "killstreak_has_been_used" ] = [];
|
|
}
|
|
if ( !isDefined( self.pers[ "killstreak_unique_id" ] ) )
|
|
{
|
|
self.pers[ "killstreak_unique_id" ] = [];
|
|
}
|
|
if ( !isDefined( self.pers[ "killstreak_ammo_count" ] ) )
|
|
{
|
|
self.pers[ "killstreak_ammo_count" ] = [];
|
|
}
|
|
size = self.pers[ "killstreaks" ].size;
|
|
if ( size > 0 )
|
|
{
|
|
playkillstreakreadydialog( self.pers[ "killstreaks" ][ size - 1 ] );
|
|
}
|
|
pixendevent();
|
|
}
|
|
}
|
|
|
|
onjoinedteam()
|
|
{
|
|
self endon( "disconnect" );
|
|
for ( ;; )
|
|
{
|
|
self waittill( "joined_team" );
|
|
self setinventoryweapon( "" );
|
|
self.pers[ "cur_kill_streak" ] = 0;
|
|
self.pers[ "cur_total_kill_streak" ] = 0;
|
|
self setplayercurrentstreak( 0 );
|
|
self.pers[ "totalKillstreakCount" ] = 0;
|
|
self.pers[ "killstreaks" ] = [];
|
|
self.pers[ "killstreak_has_been_used" ] = [];
|
|
self.pers[ "killstreak_unique_id" ] = [];
|
|
self.pers[ "killstreak_ammo_count" ] = [];
|
|
if ( isDefined( level.usingscorestreaks ) && level.usingscorestreaks )
|
|
{
|
|
self.pers[ "killstreak_quantity" ] = [];
|
|
self.pers[ "held_killstreak_ammo_count" ] = [];
|
|
self.pers[ "held_killstreak_clip_count" ] = [];
|
|
}
|
|
}
|
|
}
|
|
|
|
createkillstreaktimerforteam( killstreaktype, xposition, team )
|
|
{
|
|
/#
|
|
assert( isDefined( level.killstreak_timers[ team ] ) );
|
|
#/
|
|
killstreaktimer = spawnstruct();
|
|
killstreaktimer.team = team;
|
|
killstreaktimer.icon = createservericon( level.killstreaks[ killstreaktype ].iconmaterial, 36, 36, team );
|
|
killstreaktimer.icon.horzalign = "user_left";
|
|
killstreaktimer.icon.vertalign = "user_top";
|
|
killstreaktimer.icon.x = xposition + 15;
|
|
killstreaktimer.icon.y = 100;
|
|
killstreaktimer.icon.alpha = 0;
|
|
killstreaktimer.killstreaktype = killstreaktype;
|
|
level.killstreak_timers[ team ][ level.killstreak_timers[ team ].size ] = killstreaktimer;
|
|
}
|
|
|
|
createkillstreaktimer( killstreaktype )
|
|
{
|
|
if ( killstreaktype == "radar_mp" )
|
|
{
|
|
xposition = 0;
|
|
}
|
|
else if ( killstreaktype == "counteruav_mp" )
|
|
{
|
|
xposition = 20;
|
|
}
|
|
else if ( killstreaktype == "missile_swarm_mp" )
|
|
{
|
|
xposition = 40;
|
|
}
|
|
else if ( killstreaktype == "emp_mp" )
|
|
{
|
|
xposition = 60;
|
|
}
|
|
else if ( killstreaktype == "radardirection_mp" )
|
|
{
|
|
xposition = 80;
|
|
}
|
|
else
|
|
{
|
|
xposition = 0;
|
|
}
|
|
_a1692 = level.teams;
|
|
_k1692 = getFirstArrayKey( _a1692 );
|
|
while ( isDefined( _k1692 ) )
|
|
{
|
|
team = _a1692[ _k1692 ];
|
|
createkillstreaktimerforteam( killstreaktype, xposition, team );
|
|
_k1692 = getNextArrayKey( _a1692, _k1692 );
|
|
}
|
|
}
|
|
|
|
destroykillstreaktimers()
|
|
{
|
|
level notify( "endKillstreakTimers" );
|
|
if ( isDefined( level.killstreak_timers ) )
|
|
{
|
|
_a1705 = level.teams;
|
|
_k1705 = getFirstArrayKey( _a1705 );
|
|
while ( isDefined( _k1705 ) )
|
|
{
|
|
team = _a1705[ _k1705 ];
|
|
_a1707 = level.killstreak_timers[ team ];
|
|
_k1707 = getFirstArrayKey( _a1707 );
|
|
while ( isDefined( _k1707 ) )
|
|
{
|
|
killstreaktimer = _a1707[ _k1707 ];
|
|
killstreaktimer.icon destroyelem();
|
|
_k1707 = getNextArrayKey( _a1707, _k1707 );
|
|
}
|
|
_k1705 = getNextArrayKey( _a1705, _k1705 );
|
|
}
|
|
level.killstreak_timers = undefined;
|
|
}
|
|
}
|
|
|
|
getkillstreaktimerforkillstreak( team, killstreaktype, duration )
|
|
{
|
|
endtime = getTime() + ( duration * 1000 );
|
|
numkillstreaktimers = level.killstreak_timers[ team ].size;
|
|
killstreakslot = undefined;
|
|
targetindex = 0;
|
|
i = 0;
|
|
while ( i < numkillstreaktimers )
|
|
{
|
|
killstreaktimer = level.killstreak_timers[ team ][ i ];
|
|
if ( isDefined( killstreaktimer.killstreaktype ) && killstreaktimer.killstreaktype == killstreaktype )
|
|
{
|
|
killstreakslot = i;
|
|
break;
|
|
}
|
|
else if ( !isDefined( killstreaktimer.killstreaktype ) && !isDefined( killstreakslot ) )
|
|
{
|
|
killstreakslot = i;
|
|
}
|
|
i++;
|
|
}
|
|
if ( isDefined( killstreakslot ) )
|
|
{
|
|
killstreaktimer = level.killstreak_timers[ team ][ killstreakslot ];
|
|
killstreaktimer.endtime = endtime;
|
|
killstreaktimer.icon.alpha = 1;
|
|
return killstreaktimer;
|
|
}
|
|
}
|
|
|
|
freekillstreaktimer( killstreaktimer )
|
|
{
|
|
killstreaktimer.icon.alpha = 0,2;
|
|
killstreaktimer.endtime = undefined;
|
|
}
|
|
|
|
killstreaktimer( killstreaktype, team, duration )
|
|
{
|
|
level endon( "endKillstreakTimers" );
|
|
if ( level.gameended )
|
|
{
|
|
return;
|
|
}
|
|
killstreaktimer = getkillstreaktimerforkillstreak( team, killstreaktype, duration );
|
|
if ( !isDefined( killstreaktimer ) )
|
|
{
|
|
return;
|
|
}
|
|
eventname = ( team + "_" ) + killstreaktype;
|
|
level notify( eventname );
|
|
level endon( eventname );
|
|
blinkingduration = 5;
|
|
while ( duration > 0 )
|
|
{
|
|
wait ( duration - blinkingduration );
|
|
while ( blinkingduration > 0 )
|
|
{
|
|
killstreaktimer.icon fadeovertime( 0,5 );
|
|
killstreaktimer.icon.alpha = 1;
|
|
wait 0,5;
|
|
killstreaktimer.icon fadeovertime( 0,5 );
|
|
killstreaktimer.icon.alpha = 0;
|
|
wait 0,5;
|
|
blinkingduration -= 1;
|
|
}
|
|
}
|
|
freekillstreaktimer( killstreaktimer );
|
|
}
|
|
|
|
setkillstreaktimer( killstreaktype, team, duration )
|
|
{
|
|
thread killstreaktimer( killstreaktype, team, duration );
|
|
}
|
|
|
|
initridekillstreak( streak )
|
|
{
|
|
self disableusability();
|
|
result = self initridekillstreak_internal( streak );
|
|
if ( isDefined( self ) )
|
|
{
|
|
self enableusability();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
watchforemoveremoteweapon()
|
|
{
|
|
self endon( "endWatchFoRemoveRemoteWeapon" );
|
|
for ( ;; )
|
|
{
|
|
self waittill( "remove_remote_weapon" );
|
|
self maps/mp/killstreaks/_killstreaks::switchtolastnonkillstreakweapon();
|
|
self enableusability();
|
|
}
|
|
}
|
|
|
|
initridekillstreak_internal( streak )
|
|
{
|
|
if ( isDefined( streak ) && streak != "qrdrone" && streak != "killstreak_remote_turret_mp" || streak == "killstreak_ai_tank_mp" && streak == "qrdrone_mp" )
|
|
{
|
|
laptopwait = "timeout";
|
|
}
|
|
else
|
|
{
|
|
laptopwait = self waittill_any_timeout( 0,6, "disconnect", "death", "weapon_switch_started" );
|
|
}
|
|
maps/mp/gametypes/_hostmigration::waittillhostmigrationdone();
|
|
if ( laptopwait == "weapon_switch_started" )
|
|
{
|
|
return "fail";
|
|
}
|
|
if ( !isalive( self ) )
|
|
{
|
|
return "fail";
|
|
}
|
|
if ( laptopwait == "disconnect" || laptopwait == "death" )
|
|
{
|
|
if ( laptopwait == "disconnect" )
|
|
{
|
|
return "disconnect";
|
|
}
|
|
if ( self.team == "spectator" )
|
|
{
|
|
return "fail";
|
|
}
|
|
return "success";
|
|
}
|
|
if ( self isempjammed() )
|
|
{
|
|
return "fail";
|
|
}
|
|
if ( self isinteractingwithobject() )
|
|
{
|
|
return "fail";
|
|
}
|
|
self thread maps/mp/gametypes/_hud::fadetoblackforxsec( 0, 0,2, 0,4, 0,25 );
|
|
self thread watchforemoveremoteweapon();
|
|
blackoutwait = self waittill_any_timeout( 0,6, "disconnect", "death" );
|
|
self notify( "endWatchFoRemoveRemoteWeapon" );
|
|
maps/mp/gametypes/_hostmigration::waittillhostmigrationdone();
|
|
if ( blackoutwait != "disconnect" )
|
|
{
|
|
self thread clearrideintro( 1 );
|
|
if ( self.team == "spectator" )
|
|
{
|
|
return "fail";
|
|
}
|
|
}
|
|
if ( self isonladder() )
|
|
{
|
|
return "fail";
|
|
}
|
|
if ( !isalive( self ) )
|
|
{
|
|
return "fail";
|
|
}
|
|
if ( self isempjammed() )
|
|
{
|
|
return "fail";
|
|
}
|
|
if ( self isinteractingwithobject() )
|
|
{
|
|
return "fail";
|
|
}
|
|
if ( blackoutwait == "disconnect" )
|
|
{
|
|
return "disconnect";
|
|
}
|
|
else
|
|
{
|
|
return "success";
|
|
}
|
|
}
|
|
|
|
clearrideintro( delay )
|
|
{
|
|
self endon( "disconnect" );
|
|
if ( isDefined( delay ) )
|
|
{
|
|
wait delay;
|
|
}
|
|
self thread maps/mp/gametypes/_hud::fadetoblackforxsec( 0, 0, 0, 0 );
|
|
}
|
|
|
|
killstreak_debug_think()
|
|
{
|
|
/#
|
|
setdvar( "debug_killstreak", "" );
|
|
for ( ;; )
|
|
{
|
|
cmd = getDvar( "debug_killstreak" );
|
|
switch( cmd )
|
|
{
|
|
case "data_dump":
|
|
killstreak_data_dump();
|
|
break;
|
|
}
|
|
if ( cmd != "" )
|
|
{
|
|
setdvar( "debug_killstreak", "" );
|
|
}
|
|
wait 0,5;
|
|
#/
|
|
}
|
|
}
|
|
|
|
killstreak_data_dump()
|
|
{
|
|
/#
|
|
iprintln( "Killstreak Data Sent to Console" );
|
|
println( "##### Killstreak Data #####" );
|
|
println( "killstreak,killstreaklevel,weapon,altweapon1,altweapon2,altweapon3,altweapon4,type1,type2,type3,type4" );
|
|
keys = getarraykeys( level.killstreaks );
|
|
i = 0;
|
|
while ( i < keys.size )
|
|
{
|
|
data = level.killstreaks[ keys[ i ] ];
|
|
type_data = level.killstreaktype[ keys[ i ] ];
|
|
print( keys[ i ] + "," );
|
|
print( data.killstreaklevel + "," );
|
|
print( data.weapon + "," );
|
|
alt = 0;
|
|
while ( isDefined( data.altweapons ) )
|
|
{
|
|
assert( data.altweapons.size <= 4 );
|
|
alt = 0;
|
|
while ( alt < data.altweapons.size )
|
|
{
|
|
print( data.altweapons[ alt ] + "," );
|
|
alt++;
|
|
}
|
|
}
|
|
while ( alt < 4 )
|
|
{
|
|
print( "," );
|
|
alt++;
|
|
}
|
|
type = 0;
|
|
while ( isDefined( type_data ) )
|
|
{
|
|
assert( type_data.size < 4 );
|
|
type_keys = getarraykeys( type_data );
|
|
while ( type < type_keys.size )
|
|
{
|
|
if ( type_data[ type_keys[ type ] ] == 1 )
|
|
{
|
|
print( type_keys[ type ] + "," );
|
|
}
|
|
type++;
|
|
}
|
|
}
|
|
while ( type < 4 )
|
|
{
|
|
print( "," );
|
|
type++;
|
|
}
|
|
println( "" );
|
|
i++;
|
|
}
|
|
println( "##### End Killstreak Data #####" );
|
|
#/
|
|
}
|
|
|
|
isinteractingwithobject()
|
|
{
|
|
if ( self iscarryingturret() )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( is_true( self.isplanting ) )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( is_true( self.isdefusing ) )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
clearusingremote()
|
|
{
|
|
if ( !isDefined( self ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( isDefined( self.carryicon ) )
|
|
{
|
|
self.carryicon.alpha = 1;
|
|
}
|
|
self.usingremote = undefined;
|
|
self enableoffhandweapons();
|
|
curweapon = self getcurrentweapon();
|
|
if ( isalive( self ) )
|
|
{
|
|
if ( curweapon == "none" || maps/mp/killstreaks/_killstreaks::iskillstreakweapon( curweapon ) )
|
|
{
|
|
last_weapon = self getlastweapon();
|
|
if ( isDefined( last_weapon ) )
|
|
{
|
|
self switchtoweapon( last_weapon );
|
|
}
|
|
}
|
|
}
|
|
self freezecontrolswrapper( 0 );
|
|
self notify( "stopped_using_remote" );
|
|
}
|