INSANEMODE/Recompilable-gscs-for-BO2-zombies-and-multiplayer
1
0
Fork 0
mirror of https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git synced 2025-06-08 01:47:50 -05:00
Code Issues Releases Wiki Activity

Removed 18 Player Fixes, moved to its own repository.

Browse Source
This commit is contained in:
JezuzLizard 2021-07-30 08:06:46 -07:00
parent 0f172f59d2
commit cf8d60b2d0
21 changed files with 0 additions and 27708 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

442
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/_visionset_mgr.gsc
View File

@ -1,442 +0,0 @@
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( level.createfx_enabled )
{
return;
}
level.vsmgr_initializing = 1;
level.vsmgr_default_info_name = "none";
level.vsmgr = [];
level thread register_type( "visionset" );
level thread register_type( "overlay" );
onfinalizeinitialization_callback( ::finalize_clientfields );
level thread monitor();
level thread onplayerconnect();
}
vsmgr_register_info( type, name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread )
{
if ( level.createfx_enabled )
{
return;
}
lower_name = tolower( name );
validate_info( type, lower_name, priority );
add_sorted_name_key( type, lower_name );
add_sorted_priority_key( type, lower_name, priority );
level.vsmgr[ type ].info[ lower_name ] = spawnstruct();
level.vsmgr[ type ].info[ lower_name ] add_info( type, lower_name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread );
if ( level.vsmgr[ type ].highest_version < version )
{
level.vsmgr[ type ].highest_version = version;
}
}
vsmgr_activate( type, name, player, opt_param_1, opt_param_2 )
{
if ( level.vsmgr[ type ].info[ name ].state.activate_per_player )
{
activate_per_player( type, name, player, opt_param_1, opt_param_2 );
return;
}
state = level.vsmgr[ type ].info[ name ].state;
if ( state.ref_count_lerp_thread )
{
state.ref_count++;
if ( state.ref_count > 1 )
{
return;
}
}
if ( isDefined( state.lerp_thread ) )
{
state thread lerp_thread_wrapper( state.lerp_thread, opt_param_1, opt_param_2 );
}
else
{
players = getplayers();
for( player_index = 0; player_index < players.size; player_index++ )
{
state vsmgr_set_state_active( players[ player_index ], 1 );
}
}
}
vsmgr_deactivate( type, name, player )
{
if ( level.vsmgr[ type ].info[ name ].state.activate_per_player )
{
deactivate_per_player( type, name, player );
return;
}
state = level.vsmgr[ type ].info[ name ].state;
if ( state.ref_count_lerp_thread )
{
state.ref_count--;
if ( state.ref_count > 0 )
{
return;
}
}
state notify( "deactivate" );
players = getplayers();
for( player_index = 0; player_index < players.size; player_index++ )
{
state vsmgr_set_state_inactive( players[ player_index ] );
}
}
vsmgr_set_state_active( player, lerp )
{
player_entnum = player getentitynumber();
if ( !isDefined( self.players[ player_entnum ] ) )
{
return;
}
self.players[ player_entnum ].active = 1;
self.players[ player_entnum ].lerp = lerp;
}
vsmgr_set_state_inactive( player )
{
player_entnum = player getentitynumber();
if ( !isDefined( self.players[ player_entnum ] ) )
{
return;
}
self.players[ player_entnum ].active = 0;
self.players[ player_entnum ].lerp = 0;
}
vsmgr_timeout_lerp_thread( timeout, opt_param_2 )
{
players = getplayers();
for( player_index = 0; player_index < players.size; player_index++ )
{
self vsmgr_set_state_active( players[ player_index ], 1 );
}
wait timeout;
vsmgr_deactivate( self.type, self.name );
}
vsmgr_timeout_lerp_thread_per_player( player, timeout, opt_param_2 )
{
self vsmgr_set_state_active( player, 1 );
wait timeout;
deactivate_per_player( self.type, self.name, player );
}
vsmgr_duration_lerp_thread( duration, max_duration )
{
start_time = getTime();
end_time = start_time + int( duration * 1000 );
if ( isDefined( max_duration ) )
{
start_time = end_time - int( max_duration * 1000 );
}
while ( 1 )
{
lerp = calc_remaining_duration_lerp( start_time, end_time );
if ( lerp <= 0 )
{
break;
}
players = getplayers();
for( player_index = 0; player_index < players.size; player_index++ )
{
self vsmgr_set_state_active( players[ player_index ], lerp );
}
wait 0.05;
}
vsmgr_deactivate( self.type, self.name );
}
vsmgr_duration_lerp_thread_per_player( player, duration, max_duration )
{
start_time = getTime();
end_time = start_time + int( duration * 1000 );
if ( isDefined( max_duration ) )
{
start_time = end_time - int( max_duration * 1000 );
}
while ( 1 )
{
lerp = calc_remaining_duration_lerp( start_time, end_time );
if ( lerp <= 0 )
{
break;
}
self vsmgr_set_state_active( player, lerp );
wait 0.05;
}
deactivate_per_player( self.type, self.name, player );
}
register_type( type )
{
level.vsmgr[ type ] = spawnstruct();
level.vsmgr[ type ].type = type;
level.vsmgr[ type ].in_use = 0;
level.vsmgr[ type ].highest_version = 0;
level.vsmgr[ type ].cf_slot_name = type + "_slot";
level.vsmgr[ type ].cf_lerp_name = type + "_lerp";
level.vsmgr[ type ].info = [];
level.vsmgr[ type ].sorted_name_keys = [];
level.vsmgr[ type ].sorted_prio_keys = [];
vsmgr_register_info( type, level.vsmgr_default_info_name, 1, 0, 1, 0, undefined );
}
finalize_clientfields()
{
typekeys = getarraykeys( level.vsmgr );
for ( type_index = 0; type_index < typeKeys.size; type_index++ )
{
level.vsmgr[ typekeys[ type_index ] ] thread finalize_type_clientfields();
}
level.vsmgr_initializing = 0;
}
finalize_type_clientfields()
{
if ( self.info.size <= 1 )
{
return;
}
self.in_use = 1;
self.cf_slot_bit_count = getminbitcountfornum( self.info.size - 1 );
self.cf_lerp_bit_count = self.info[ self.sorted_name_keys[ 0 ] ].lerp_bit_count;
for ( i = 0; i < self.sorted_name_keys.size; i++ )
{
self.info[ self.sorted_name_keys[ i ] ].slot_index = i;
if ( self.info[ self.sorted_name_keys[ i ] ].lerp_bit_count > self.cf_lerp_bit_count )
{
self.cf_lerp_bit_count = self.info[ self.sorted_name_keys[ i ] ].lerp_bit_count;
}
}
registerclientfield( "toplayer", self.cf_slot_name, self.highest_version, self.cf_slot_bit_count, "int" );
if ( self.cf_lerp_bit_count > 1 )
{
registerclientfield( "toplayer", self.cf_lerp_name, self.highest_version, self.cf_lerp_bit_count, "float" );
}
}
validate_info( type, name, priority )
{
keys = getarraykeys( level.vsmgr );
for ( i = 0; i < keys.size; i++ )
{
if ( type == keys[ i ] )
{
break;
}
}
}
add_sorted_name_key( type, name )
{
for ( i = 0; i < level.vsmgr[type].sorted_name_keys.size; i++ )
{
if ( name < level.vsmgr[ type ].sorted_name_keys[ i ] )
{
break;
}
}
arrayinsert( level.vsmgr[ type ].sorted_name_keys, name, i );
}
add_sorted_priority_key( type, name, priority )
{
for ( i = 0; i < level.vsmgr[type].sorted_prio_keys.size; i++ )
{
if ( priority > level.vsmgr[ type ].info[ level.vsmgr[ type ].sorted_prio_keys[ i ] ].priority )
{
break;
}
}
arrayinsert( level.vsmgr[ type ].sorted_prio_keys, name, i );
}
add_info( type, name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread )
{
self.type = type;
self.name = name;
self.version = version;
self.priority = priority;
self.lerp_step_count = lerp_step_count;
self.lerp_bit_count = getminbitcountfornum( lerp_step_count );
if ( !isDefined( ref_count_lerp_thread ) )
{
ref_count_lerp_thread = 0;
}
self.state = spawnstruct();
self.state.type = type;
self.state.name = name;
self.state.activate_per_player = activate_per_player;
self.state.lerp_thread = lerp_thread;
self.state.ref_count_lerp_thread = ref_count_lerp_thread;
self.state.players = [];
if ( ref_count_lerp_thread && !activate_per_player )
{
self.state.ref_count = 0;
}
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connected", player );
player thread on_player_connect();
}
}
on_player_connect()
{
self._player_entnum = self getentitynumber();
typekeys = getarraykeys( level.vsmgr );
for ( type_index = 0; type_index < typeKeys.size; type_index++ )
{
type = typekeys[ type_index ];
if ( !level.vsmgr[ type ].in_use )
{
type_index++;
}
else
{
for ( name_index = 0; name_index < level.vsmgr[type].sorted_name_keys.size; name_index++ )
{
name_key = level.vsmgr[ type ].sorted_name_keys[ name_index ];
level.vsmgr[ type ].info[ name_key ].state.players[ self._player_entnum ] = spawnstruct();
level.vsmgr[ type ].info[ name_key ].state.players[ self._player_entnum ].active = 0;
level.vsmgr[ type ].info[ name_key ].state.players[ self._player_entnum ].lerp = 0;
if ( level.vsmgr[ type ].info[ name_key ].state.ref_count_lerp_thread && level.vsmgr[ type ].info[ name_key ].state.activate_per_player )
{
level.vsmgr[ type ].info[ name_key ].state.players[ self._player_entnum ].ref_count = 0;
}
}
level.vsmgr[ type ].info[ level.vsmgr_default_info_name ].state vsmgr_set_state_active( self, 1 );
}
}
}
monitor()
{
while ( level.vsmgr_initializing )
{
wait 0.05;
}
typekeys = getarraykeys( level.vsmgr );
while ( 1 )
{
wait 0.05;
waittillframeend;
players = get_players();
for ( type_index = 0; type_index < typeKeys.size; type_index++ )
{
type = typekeys[ type_index ];
if ( !level.vsmgr[ type ].in_use )
{
type_index++;
}
else
{
for ( player_index = 0; player_index < players.size; player_index++ )
{
update_clientfields( players[ player_index ], level.vsmgr[ type ] );
}
}
}
}
}
get_first_active_name( type_struct )
{
size = type_struct.sorted_prio_keys.size;
for ( prio_index = 0; prio_index < size; prio_index++ )
{
prio_key = type_struct.sorted_prio_keys[ prio_index ];
if ( type_struct.info[ prio_key ].state.players[ self._player_entnum ].active )
{
return prio_key;
}
}
return level.vsmgr_default_info_name;
}
update_clientfields( player, type_struct )
{
name = player get_first_active_name( type_struct );
player setclientfieldtoplayer( type_struct.cf_slot_name, type_struct.info[ name ].slot_index );
if ( type_struct.cf_lerp_bit_count > 1 )
{
player setclientfieldtoplayer( type_struct.cf_lerp_name, type_struct.info[ name ].state.players[ player._player_entnum ].lerp );
}
}
lerp_thread_wrapper( func, opt_param_1, opt_param_2 )
{
self notify( "deactivate" );
self endon( "deactivate" );
self [[ func ]]( opt_param_1, opt_param_2 );
}
lerp_thread_per_player_wrapper( func, player, opt_param_1, opt_param_2 )
{
player_entnum = player getentitynumber();
self notify( "deactivate" );
self endon( "deactivate" );
self.players[ player_entnum ] notify( "deactivate" );
self.players[ player_entnum ] endon( "deactivate" );
player endon( "disconnect" );
self [[ func ]]( player, opt_param_1, opt_param_2 );
}
activate_per_player( type, name, player, opt_param_1, opt_param_2 )
{
player_entnum = player getentitynumber();
state = level.vsmgr[ type ].info[ name ].state;
if ( state.ref_count_lerp_thread )
{
state.players[ player_entnum ].ref_count++;
if ( state.players[ player_entnum ].ref_count > 1 )
{
return;
}
}
if ( isDefined( state.lerp_thread ) )
{
state thread lerp_thread_per_player_wrapper( state.lerp_thread, player, opt_param_1, opt_param_2 );
}
else
{
state vsmgr_set_state_active( player, 1 );
}
}
deactivate_per_player( type, name, player )
{
player_entnum = player getentitynumber();
state = level.vsmgr[ type ].info[ name ].state;
if ( state.ref_count_lerp_thread )
{
state.players[ player_entnum ].ref_count--;
if ( state.players[ player_entnum ].ref_count > 0 )
{
return;
}
}
state vsmgr_set_state_inactive( player );
state notify( "deactivate" );
}
calc_remaining_duration_lerp( start_time, end_time )
{
now = getTime();
frac = float( end_time - now ) / float( end_time - start_time );
return clamp( frac, 0, 1 );
}

2741
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/gametypes_zm/_globallogic.gsc
View File

File diff suppressed because it is too large Load Diff

1950
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/gametypes_zm/_weapons.gsc
View File

File diff suppressed because it is too large Load Diff

1997
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/gametypes_zm/_zm_gametype.gsc
View File

File diff suppressed because it is too large Load Diff

3146
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_buildables.gsc
View File

File diff suppressed because it is too large Load Diff

805
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_chugabud.gsc
View File

@ -1,805 +0,0 @@
#include maps/mp/_visionset_mgr;
#include maps/mp/zombies/_zm;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_weap_cymbal_monkey;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_clone;
#include maps/mp/zombies/_zm_chugabud;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
#include maps/mp/zombies/_zm_perks;
init() //checked matches cerberus output
{
level.chugabud_laststand_func = ::chugabud_laststand;
level thread chugabud_hostmigration();
level._effect[ "chugabud_revive_fx" ] = loadfx( "weapon/quantum_bomb/fx_player_position_effect" );
level._effect[ "chugabud_bleedout_fx" ] = loadfx( "weapon/quantum_bomb/fx_player_position_effect" );
add_custom_limited_weapon_check( ::is_weapon_available_in_chugabud_corpse );
}
chugabug_precache() //checked matches cerberus output
{
}
chugabud_player_init() //checked matches cerberus output
{
}
chugabud_laststand() //checked changed to match cerberus output
{
self endon( "player_suicide" );
self endon( "disconnect" );
self endon( "chugabud_bleedout" );
self maps/mp/zombies/_zm_laststand::increment_downed_stat();
self.ignore_insta_kill = 1;
self.health = self.maxhealth;
self maps/mp/zombies/_zm_chugabud::chugabud_save_loadout();
self maps/mp/zombies/_zm_chugabud::chugabud_fake_death();
wait 3;
if ( is_true( self.insta_killed ) || isDefined( self.disable_chugabud_corpse ) )
{
create_corpse = 0;
}
else
{
create_corpse = 1;
}
if ( create_corpse == 1 )
{
if ( isDefined( level._chugabug_reject_corpse_override_func ) )
{
reject_corpse = self [[ level._chugabug_reject_corpse_override_func ]]( self.origin );
if ( reject_corpse )
{
create_corpse = 0;
}
}
}
if ( create_corpse == 1 )
{
self thread activate_chugabud_effects_and_audio();
corpse = self chugabud_spawn_corpse();
corpse thread chugabud_corpse_revive_icon( self );
self.e_chugabud_corpse = corpse;
corpse thread chugabud_corpse_cleanup_on_spectator( self );
if ( isDefined( level.whos_who_client_setup ) )
{
corpse setclientfield( "clientfield_whos_who_clone_glow_shader", 1 );
}
}
self chugabud_fake_revive();
wait 0.1;
self.ignore_insta_kill = undefined;
self.disable_chugabud_corpse = undefined;
if ( create_corpse == 0 )
{
self notify( "chugabud_effects_cleanup" );
return;
}
bleedout_time = getDvarFloat( "player_lastStandBleedoutTime" );
self thread chugabud_bleed_timeout( bleedout_time, corpse );
self thread chugabud_handle_multiple_instances( corpse );
corpse waittill( "player_revived", e_reviver );
if ( isDefined( e_reviver ) && e_reviver == self )
{
self notify( "whos_who_self_revive" );
}
self perk_abort_drinking( 0.1 );
self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "health_reboot", 1, 0 );
self setorigin( corpse.origin );
self setplayerangles( corpse.angles );
if ( self player_is_in_laststand() )
{
self thread chugabud_laststand_cleanup( corpse, "player_revived" );
self enableweaponcycling();
self enableoffhandweapons();
self auto_revive( self, 1 );
return;
}
self chugabud_laststand_cleanup( corpse, undefined );
}
chugabud_laststand_cleanup( corpse, str_notify ) //checked matches cerberus output
{
if ( isDefined( str_notify ) )
{
self waittill( str_notify );
}
self chugabud_give_loadout();
self chugabud_corpse_cleanup( corpse, 1 );
}
chugabud_bleed_timeout( delay, corpse ) //checked changed to match cerberus output
{
self endon( "player_suicide" );
self endon( "disconnect" );
corpse endon( "death" );
wait delay;
if ( isDefined( corpse.revivetrigger ) )
{
while ( corpse.revivetrigger.beingrevived )
{
wait 0.01;
}
}
if ( isDefined( self.loadout.perks ) && flag( "solo_game" ) )
{
for ( i = 0; i < self.loadout.perks.size; i++ )
{
perk = self.loadout.perks[ i ];
if ( perk == "specialty_quickrevive" )
{
arrayremovevalue( self.loadout.perks, self.loadout.perks[ i ] );
corpse notify( "player_revived" );
return;
}
}
}
self chugabud_corpse_cleanup( corpse, 0 );
}
chugabud_corpse_cleanup( corpse, was_revived ) //checked matches cerberus output
{
self notify( "chugabud_effects_cleanup" );
if ( was_revived )
{
playsoundatposition( "evt_ww_appear", corpse.origin );
playfx( level._effect[ "chugabud_revive_fx" ], corpse.origin );
}
else
{
playsoundatposition( "evt_ww_disappear", corpse.origin );
playfx( level._effect[ "chugabud_bleedout_fx" ], corpse.origin );
self notify( "chugabud_bleedout" );
}
if ( isDefined( corpse.revivetrigger ) )
{
corpse notify( "stop_revive_trigger" );
corpse.revivetrigger delete();
corpse.revivetrigger = undefined;
}
if ( isDefined( corpse.revive_hud_elem ) )
{
corpse.revive_hud_elem destroy();
corpse.revive_hud_elem = undefined;
}
self.loadout = undefined;
wait 0.1;
corpse delete();
self.e_chugabud_corpse = undefined;
}
chugabud_handle_multiple_instances( corpse ) //checked matches cerberus output
{
corpse endon( "death" );
self waittill( "perk_chugabud_activated" );
self chugabud_corpse_cleanup( corpse, 0 );
}
chugabud_spawn_corpse() //checked matches cerberus output
{
corpse = maps/mp/zombies/_zm_clone::spawn_player_clone( self, self.origin, undefined, self.whos_who_shader );
corpse.angles = self.angles;
corpse maps/mp/zombies/_zm_clone::clone_give_weapon( "m1911_zm" );
corpse maps/mp/zombies/_zm_clone::clone_animate( "laststand" );
corpse.revive_hud = self chugabud_revive_hud_create();
corpse thread maps/mp/zombies/_zm_laststand::revive_trigger_spawn();
return corpse;
}
chugabud_revive_hud_create() //checked matches cerberus output
{
self.revive_hud = newclienthudelem( self );
self.revive_hud.alignx = "center";
self.revive_hud.aligny = "middle";
self.revive_hud.horzalign = "center";
self.revive_hud.vertalign = "bottom";
self.revive_hud.y = -50;
self.revive_hud.foreground = 1;
self.revive_hud.font = "default";
self.revive_hud.fontscale = 1.5;
self.revive_hud.alpha = 0;
self.revive_hud.color = ( 1, 1, 1 );
self.revive_hud settext( "" );
return self.revive_hud;
}
chugabud_save_loadout() //checked changed to match cerberus output
{
primaries = self getweaponslistprimaries();
currentweapon = self getcurrentweapon();
self.loadout = spawnstruct();
self.loadout.player = self;
self.loadout.weapons = [];
self.loadout.score = self.score;
self.loadout.current_weapon = -1;
index = 0;
foreach ( weapon in primaries )
{
logline1 = "weapon: " + weapon + "\n";
logprint( logline1 );
self.loadout.weapons[ index ] = maps/mp/zombies/_zm_weapons::get_player_weapondata( self, weapon );
if ( weapon == currentweapon || self.loadout.weapons[ index ][ "alt_name" ] == currentweapon )
{
self.loadout.current_weapon = index;
}
index++;
}
self.loadout.equipment = self get_player_equipment();
if ( isDefined( self.loadout.equipment ) )
{
self equipment_take( self.loadout.equipment );
}
self.loadout save_weapons_for_chugabud( self );
if ( self hasweapon( "claymore_zm" ) )
{
self.loadout.hasclaymore = 1;
self.loadout.claymoreclip = self getweaponammoclip( "claymore_zm" );
}
self.loadout.perks = chugabud_save_perks( self );
self chugabud_save_grenades();
if ( maps/mp/zombies/_zm_weap_cymbal_monkey::cymbal_monkey_exists() )
{
self.loadout.zombie_cymbal_monkey_count = self getweaponammoclip( "cymbal_monkey_zm" );
}
}
chugabud_save_grenades() //checked matches cerberus output
{
if ( self hasweapon( "emp_grenade_zm" ) )
{
self.loadout.hasemp = 1;
self.loadout.empclip = self getweaponammoclip( "emp_grenade_zm" );
}
lethal_grenade = self get_player_lethal_grenade();
if ( self hasweapon( lethal_grenade ) )
{
self.loadout.lethal_grenade = lethal_grenade;
self.loadout.lethal_grenade_count = self getweaponammoclip( lethal_grenade );
}
else
{
self.loadout.lethal_grenade = undefined;
}
}
chugabud_give_loadout() //checked partially changed to match cerberus output continues in for loops bad see the github for more info
{
self takeallweapons();
loadout = self.loadout;
primaries = self getweaponslistprimaries();
if ( loadout.weapons.size > 1 || primaries.size > 1 )
{
foreach ( weapon in primaries )
{
self takeweapon( weapon );
}
}
i = 0;
while ( i < loadout.weapons.size )
{
logline1 = "loadout.weapons[ " + i + " ][ name ] " + loadout.weapons[ i ][ "name" ] + "\n";
logprint( logline1 );
if ( !isDefined( loadout.weapons[ i ] ) )
{
i++;
continue;
}
if ( loadout.weapons[ i ][ "name" ] == "none" )
{
i++;
continue;
}
self maps/mp/zombies/_zm_weapons::weapondata_give( loadout.weapons[ i ] );
i++;
}
if ( loadout.current_weapon >= 0 && isDefined( loadout.weapons[ loadout.current_weapon ][ "name" ] ) )
{
self switchtoweapon( loadout.weapons[ loadout.current_weapon ][ "name" ] );
}
self giveweapon( "knife_zm" );
self maps/mp/zombies/_zm_equipment::equipment_give( self.loadout.equipment );
loadout restore_weapons_for_chugabud( self );
self chugabud_restore_claymore();
self.score = loadout.score;
self.pers[ "score" ] = loadout.score;
perk_array = maps/mp/zombies/_zm_perks::get_perk_array( 1 );
for ( i = 0; i < perk_array.size; i++ )
{
perk = perk_array[ i ];
self unsetperk( perk );
self.num_perks--;
self set_perk_clientfield( perk, 0 );
}
if ( isDefined( loadout.perks ) && loadout.perks.size > 0 )
{
i = 0;
while ( i < loadout.perks.size )
{
if ( self hasperk( loadout.perks[ i ] ) )
{
i++;
continue;
}
if ( loadout.perks[ i ] == "specialty_quickrevive" && flag( "solo_game" ) )
{
level.solo_game_free_player_quickrevive = 1;
}
if ( loadout.perks[ i ] == "specialty_finalstand" )
{
i++;
continue;
}
maps/mp/zombies/_zm_perks::give_perk( loadout.perks[ i ] );
i++;
}
}
self chugabud_restore_grenades();
if ( maps/mp/zombies/_zm_weap_cymbal_monkey::cymbal_monkey_exists() )
{
if ( loadout.zombie_cymbal_monkey_count )
{
self maps/mp/zombies/_zm_weap_cymbal_monkey::player_give_cymbal_monkey();
self setweaponammoclip( "cymbal_monkey_zm", loadout.zombie_cymbal_monkey_count );
}
}
}
chugabud_restore_grenades() //checked matches cerberus output
{
if ( is_true( self.loadout.hasemp ) )
{
self giveweapon( "emp_grenade_zm" );
self setweaponammoclip( "emp_grenade_zm", self.loadout.empclip );
}
if ( isDefined( self.loadout.lethal_grenade ) )
{
self giveweapon( self.loadout.lethal_grenade );
self setweaponammoclip( self.loadout.lethal_grenade, self.loadout.lethal_grenade_count );
}
}
chugabud_restore_claymore() //checked matches cerberus output
{
if ( is_true( self.loadout.hasclaymore ) && !self hasweapon( "claymore_zm" ) )
{
self giveweapon( "claymore_zm" );
self set_player_placeable_mine( "claymore_zm" );
self setactionslot( 4, "weapon", "claymore_zm" );
self setweaponammoclip( "claymore_zm", self.loadout.claymoreclip );
}
}
chugabud_fake_death() //checked matches cerberus output
{
level notify( "fake_death" );
self notify( "fake_death" );
self takeallweapons();
self allowstand( 0 );
self allowcrouch( 0 );
self allowprone( 1 );
self.ignoreme = 1;
self enableinvulnerability();
wait 0.1;
self freezecontrols( 1 );
wait 0.9;
}
chugabud_fake_revive() //checked matches cerberus output
{
level notify( "fake_revive" );
self notify( "fake_revive" );
playsoundatposition( "evt_ww_disappear", self.origin );
playfx( level._effect[ "chugabud_revive_fx" ], self.origin );
spawnpoint = chugabud_get_spawnpoint();
if ( isDefined( level._chugabud_post_respawn_override_func ) )
{
self [[ level._chugabud_post_respawn_override_func ]]( spawnpoint.origin );
}
if ( isDefined( level.chugabud_force_corpse_position ) )
{
if ( isDefined( self.e_chugabud_corpse ) )
{
self.e_chugabud_corpse forceteleport( level.chugabud_force_corpse_position );
}
level.chugabud_force_corpse_position = undefined;
}
if ( isDefined( level.chugabud_force_player_position ) )
{
spawnpoint.origin = level.chugabud_force_player_position;
level.chugabud_force_player_position = undefined;
}
self setorigin( spawnpoint.origin );
self setplayerangles( spawnpoint.angles );
playsoundatposition( "evt_ww_appear", spawnpoint.origin );
playfx( level._effect[ "chugabud_revive_fx" ], spawnpoint.origin );
self allowstand( 1 );
self allowcrouch( 1 );
self allowprone( 1 );
self.ignoreme = 0;
self setstance( "stand" );
self freezecontrols( 0 );
self giveweapon( "knife_zm" );
self give_start_weapon( 1 );
self.score = self.loadout.score;
self.pers[ "score" ] = self.loadout.score;
self giveweapon( "frag_grenade_zm" );
self setweaponammoclip( "frag_grenade_zm", 2 );
self chugabud_restore_claymore();
wait 1;
self disableinvulnerability();
}
chugabud_get_spawnpoint() //checked partially changed to match cerberus output nested foreach is probably bad
{
spawnpoint = undefined;
if ( get_chugabug_spawn_point_from_nodes( self.origin, 500, 700, 64, 1 ) )
{
spawnpoint = level.chugabud_spawn_struct;
}
if ( !isDefined( spawnpoint ) )
{
if ( get_chugabug_spawn_point_from_nodes( self.origin, 100, 400, 64, 1 ) )
{
spawnpoint = level.chugabud_spawn_struct;
}
}
if ( !isDefined( spawnpoint ) )
{
if ( get_chugabug_spawn_point_from_nodes( self.origin, 50, 400, 256, 0 ) )
{
spawnpoint = level.chugabud_spawn_struct;
}
}
if ( !isDefined( spawnpoint ) )
{
spawnpoint = maps/mp/zombies/_zm::check_for_valid_spawn_near_team( self, 1 );
}
if ( !isDefined( spawnpoint ) )
{
match_string = "";
location = level.scr_zm_map_start_location;
if ( (location == "default" || location == "" ) && isdefined( level.default_start_location ) )
{
location = level.default_start_location;
}
match_string = level.scr_zm_ui_gametype + "_" + location;
spawnpoints = [];
structs = getstructarray( "initial_spawn", "script_noteworthy" );
if ( isdefined( structs ) )
{
foreach ( struct in structs )
{
if ( isdefined( struct.script_string ) )
{
tokens = strtok( struct.script_string, " " );
i = 0;
while ( i < tokens.size )
{
if ( tokens[ i ] == match_string )
{
spawnpoints[ spawnpoints.size ] = struct;
}
i++;
}
}
}
}
if ( !isDefined( spawnpoints ) || spawnpoints.size == 0 )
{
spawnpoints = getstructarray( "initial_spawn_points", "targetname" );
}
/*
/#
assert( isDefined( spawnpoints ), "Could not find initial spawn points!" );
#/
*/
spawnpoint = maps/mp/zombies/_zm::getfreespawnpoint( spawnpoints, self );
}
return spawnpoint;
}
get_chugabug_spawn_point_from_nodes( v_origin, min_radius, max_radius, max_height, ignore_targetted_nodes ) //checked partially changed to match cerberus output changed at own discretion
{
if ( !isDefined( level.chugabud_spawn_struct ) )
{
level.chugabud_spawn_struct = spawnstruct();
}
found_node = undefined;
a_nodes = getnodesinradiussorted( v_origin, max_radius, min_radius, max_height, "pathnodes" );
if ( isDefined( a_nodes ) && a_nodes.size > 0 )
{
a_player_volumes = getentarray( "player_volume", "script_noteworthy" );
index = a_nodes.size - 1;
i = index;
while ( i >= 0 )
{
n_node = a_nodes[ i ];
if ( ignore_targetted_nodes == 1 )
{
if ( isDefined( n_node.target ) )
{
i--;
continue;
}
}
if ( !positionwouldtelefrag( n_node.origin ) )
{
if ( maps/mp/zombies/_zm_utility::check_point_in_enabled_zone( n_node.origin, 1, a_player_volumes ) )
{
v_start = ( n_node.origin[ 0 ], n_node.origin[ 1 ], n_node.origin[ 2 ] + 30 );
v_end = ( n_node.origin[ 0 ], n_node.origin[ 1 ], n_node.origin[ 2 ] - 30 );
trace = bullettrace( v_start, v_end, 0, undefined );
if ( trace[ "fraction" ] < 1 )
{
override_abort = 0;
if ( isDefined( level._chugabud_reject_node_override_func ) )
{
override_abort = [[ level._chugabud_reject_node_override_func ]]( v_origin, n_node );
}
if ( !override_abort )
{
found_node = n_node;
break;
}
}
}
}
i--;
}
}
if ( isDefined( found_node ) )
{
level.chugabud_spawn_struct.origin = found_node.origin;
v_dir = vectornormalize( v_origin - level.chugabud_spawn_struct.origin );
level.chugabud_spawn_struct.angles = vectorToAngles( v_dir );
return 1;
}
return 0;
}
force_corpse_respawn_position( forced_corpse_position ) //checked matches cerberus output
{
level.chugabud_force_corpse_position = forced_corpse_position;
}
force_player_respawn_position( forced_player_position ) //checked matches cerberus output
{
level.chugabud_force_player_position = forced_player_position;
}
save_weapons_for_chugabud( player ) //checked changed to match cerberus output
{
self.chugabud_melee_weapons = [];
for ( i = 0; i < level._melee_weapons.size; i++ )
{
self save_weapon_for_chugabud( player, level._melee_weapons[ i ].weapon_name );
}
}
save_weapon_for_chugabud( player, weapon_name ) //checked matches cerberus output
{
if ( player hasweapon( weapon_name ) )
{
self.chugabud_melee_weapons[ weapon_name ] = 1;
}
}
restore_weapons_for_chugabud( player ) //checked changed to match cerberus output
{
for ( i = 0; i < level._melee_weapons.size; i++ )
{
self restore_weapon_for_chugabud( player, level._melee_weapons[ i ].weapon_name );
}
self.chugabud_melee_weapons = undefined;
}
restore_weapon_for_chugabud( player, weapon_name ) //checked changed to match cerberus output
{
if ( !isDefined( weapon_name ) || !isDefined( self.chugabud_melee_weapons ) || !isDefined( self.chugabud_melee_weapons[ weapon_name ] ) )
{
return;
}
if ( is_true( self.chugabud_melee_weapons[ weapon_name ] ) )
{
player giveweapon( weapon_name );
player set_player_melee_weapon( weapon_name );
self.chugabud_melee_weapons[ weapon_name ] = 0;
}
}
chugabud_save_perks( ent ) //checked changed to match cerberus output
{
perk_array = ent get_perk_array( 1 );
foreach ( perk in perk_array )
{
ent unsetperk( perk );
}
return perk_array;
}
playchugabudtimeraudio() //checked matches cerberus output
{
self endon( "chugabud_grabbed" );
self endon( "chugabud_timedout" );
player = self.player;
self thread playchugabudtimerout( player );
while ( 1 )
{
player playsoundtoplayer( "zmb_chugabud_timer_count", player );
wait 1;
}
}
playchugabudtimerout( player ) //checked matches cerberus output
{
self endon( "chugabud_grabbed" );
self waittill( "chugabud_timedout" );
player playsoundtoplayer( "zmb_chugabud_timer_out", player );
}
chugabud_hostmigration() //checked changed to match cerberus output
{
level endon( "end_game" );
level notify( "chugabud_hostmigration" );
level endon( "chugabud_hostmigration" );
while ( 1 )
{
level waittill( "host_migration_end" );
chugabuds = getentarray( "player_chugabud_model", "script_noteworthy" );
foreach ( model in chugabuds )
{
playfxontag( level._effect[ "powerup_on" ], model, "tag_origin" );
}
}
}
player_revived_cleanup_chugabud_corpse() //checked matches cerberus output
{
}
player_has_chugabud_corpse() //checked matches cerberus output
{
if ( isDefined( self.e_chugabud_corpse ) )
{
return 1;
}
return 0;
}
is_weapon_available_in_chugabud_corpse( weapon, player_to_check ) //checked partially changed to match cerberus output
{
count = 0;
upgradedweapon = weapon;
if ( isDefined( level.zombie_weapons[ weapon ] ) && isDefined( level.zombie_weapons[ weapon ].upgrade_name ) )
{
upgradedweapon = level.zombie_weapons[ weapon ].upgrade_name;
}
players = getplayers();
if ( isDefined( players ) )
{
player_index = 0;
while ( player_index < players.size )
{
player = players[ player_index ];
if ( isDefined( player_to_check ) && player != player_to_check )
{
player_index++;
continue;
}
if ( player player_has_chugabud_corpse() )
{
if ( isDefined( player.loadout ) && isDefined( player.loadout.weapons ) )
{
for ( i = 0; i < player.loadout.weapons.size; i++ )
{
chugabud_weapon = player.loadout.weapons[ i ];
if ( isDefined( chugabud_weapon ) && chugabud_weapon[ "name" ] == weapon || chugabud_weapon[ "name" ] == upgradedweapon )
{
count++;
}
}
}
}
player_index++;
}
}
return count;
}
chugabud_corpse_cleanup_on_spectator( player ) //checked changed to match cerberus output
{
self endon( "death" );
player endon( "disconnect" );
while ( 1 )
{
if ( player.sessionstate == "spectator" )
{
break;
}
wait 0.01;
}
player chugabud_corpse_cleanup( self, 0 );
}
chugabud_corpse_revive_icon( player ) //checked changed to match cerberus output
{
self endon( "death" );
height_offset = 30;
index = player.clientid;
hud_elem = newhudelem();
self.revive_hud_elem = hud_elem;
hud_elem.x = self.origin[ 0 ];
hud_elem.y = self.origin[ 1 ];
hud_elem.z = self.origin[ 2 ] + height_offset;
hud_elem.alpha = 1;
hud_elem.archived = 1;
hud_elem setshader( "waypoint_revive", 5, 5 );
hud_elem setwaypoint( 1 );
hud_elem.hidewheninmenu = 1;
hud_elem.immunetodemogamehudsettings = 1;
while ( 1 )
{
if ( !isDefined( self.revive_hud_elem ) )
{
break;
}
hud_elem.x = self.origin[ 0 ];
hud_elem.y = self.origin[ 1 ];
hud_elem.z = self.origin[ 2 ] + height_offset;
wait 0.01;
}
}
activate_chugabud_effects_and_audio() //checked matches cerberus output
{
if ( isDefined( level.whos_who_client_setup ) )
{
if ( !isDefined( self.whos_who_effects_active ) )
{
if ( isDefined( level.chugabud_shellshock ) )
{
self shellshock( "whoswho", 60 );
}
if ( isDefined( level.vsmgr_prio_visionset_zm_whos_who ) )
{
maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_whos_who", self );
}
self setclientfieldtoplayer( "clientfield_whos_who_audio", 1 );
self setclientfieldtoplayer( "clientfield_whos_who_filter", 1 );
self.whos_who_effects_active = 1;
self thread deactivate_chugabud_effects_and_audio();
}
}
}
deactivate_chugabud_effects_and_audio() //checked matches cerberus output
{
self waittill_any( "death", "chugabud_effects_cleanup" );
if ( isDefined( level.whos_who_client_setup ) )
{
if ( isDefined( self.whos_who_effects_active ) && self.whos_who_effects_active == 1 )
{
if ( isDefined( level.chugabud_shellshock ) )
{
self stopshellshock();
}
if ( isDefined( level.vsmgr_prio_visionset_zm_whos_who ) )
{
maps/mp/_visionset_mgr::vsmgr_deactivate( "visionset", "zm_whos_who", self );
}
self setclientfieldtoplayer( "clientfield_whos_who_audio", 0 );
self setclientfieldtoplayer( "clientfield_whos_who_filter", 0 );
}
self.whos_who_effects_active = undefined;
}
}

1905
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_equipment.gsc
View File

File diff suppressed because it is too large Load Diff

3780
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_perks.gsc
View File

File diff suppressed because it is too large Load Diff

604
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_power.gsc
View File

@ -1,604 +0,0 @@
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/_demo;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( !isDefined( level.powered_items ) )
{
level.powered_items = [];
}
if ( !isDefined( level.local_power ) )
{
level.local_power = [];
}
thread standard_powered_items();
}
watch_global_power()
{
while ( 1 )
{
flag_wait( "power_on" );
level thread set_global_power( 1 );
flag_waitopen( "power_on" );
level thread set_global_power( 0 );
}
}
standard_powered_items()
{
flag_wait( "start_zombie_round_logic" );
vending_triggers = getentarray( "zombie_vending", "targetname" );
i = 0;
while ( i < vending_triggers.size)
{
if ( vending_triggers[ i ].script_noteworthy == "specialty_weapupgrade" )
{
i++;
continue;
}
powered_on = maps/mp/zombies/_zm_perks::get_perk_machine_start_state( vending_triggers[ i ].script_noteworthy );
add_powered_item( ::perk_power_on, ::perk_power_off, ::perk_range, ::cost_low_if_local, 0, powered_on, vending_triggers[ i ] );
i++;
}
pack_a_punch = getentarray( "specialty_weapupgrade", "script_noteworthy" );
foreach ( trigger in pack_a_punch )
{
powered_on = maps/mp/zombies/_zm_perks::get_perk_machine_start_state( trigger.script_noteworthy );
trigger.powered = add_powered_item( ::pap_power_on, ::pap_power_off, ::pap_range, ::cost_low_if_local, 0, powered_on, trigger );
}
zombie_doors = getentarray( "zombie_door", "targetname" );
foreach ( door in zombie_doors )
{
if ( isDefined( door.script_noteworthy ) && door.script_noteworthy == "electric_door" )
{
add_powered_item( ::door_power_on, ::door_power_off, ::door_range, ::cost_door, 0, 0, door );
}
if ( isDefined( door.script_noteworthy ) && door.script_noteworthy == "local_electric_door" )
{
power_sources = 0;
if ( !is_true( level.power_local_doors_globally ) )
{
power_sources = 1;
}
add_powered_item( ::door_local_power_on, ::door_local_power_off, ::door_range, ::cost_door, power_sources, 0, door );
}
}
thread watch_global_power();
}
add_powered_item( power_on_func, power_off_func, range_func, cost_func, power_sources, self_powered, target )
{
powered = spawnstruct();
powered.power_on_func = power_on_func;
powered.power_off_func = power_off_func;
powered.range_func = range_func;
powered.power_sources = power_sources;
powered.self_powered = self_powered;
powered.target = target;
powered.cost_func = cost_func;
powered.power = self_powered;
powered.powered_count = self_powered;
powered.depowered_count = 0;
if ( !isDefined( level.powered_items ) )
{
level.powered_items = [];
}
level.powered_items[ level.powered_items.size ] = powered;
return powered;
}
remove_powered_item( powered )
{
arrayremovevalue( level.powered_items, powered, 0 );
}
add_temp_powered_item( power_on_func, power_off_func, range_func, cost_func, power_sources, self_powered, target )
{
powered = add_powered_item( power_on_func, power_off_func, range_func, cost_func, power_sources, self_powered, target );
if ( isDefined( level.local_power ) )
{
foreach ( localpower in level.local_power )
{
if ( powered [[ powered.range_func ]]( 1, localpower.origin, localpower.radius ) )
{
powered change_power( 1, localpower.origin, localpower.radius );
if ( !isDefined( localpower.added_list ) )
{
localpower.added_list = [];
}
localpower.added_list[ localpower.added_list.size ] = powered;
}
}
}
thread watch_temp_powered_item( powered );
return powered;
}
watch_temp_powered_item( powered )
{
powered.target waittill( "death" );
remove_powered_item( powered );
if ( isDefined( level.local_power ) )
{
foreach ( localpower in level.local_power )
{
if ( isDefined( localpower.added_list ) )
{
arrayremovevalue( localpower.added_list, powered, 0 );
}
if ( isDefined( localpower.enabled_list ) )
{
arrayremovevalue( localpower.enabled_list, powered, 0 );
}
}
}
}
change_power_in_radius( delta, origin, radius )
{
changed_list = [];
for ( i = 0; i < level.powered_items.size; i++ )
{
powered = level.powered_items[ i ];
if ( powered.power_sources != 2 )
{
if ( powered [[ powered.range_func ]]( delta, origin, radius ) )
{
powered change_power( delta, origin, radius );
changed_list[ changed_list.size ] = powered;
}
}
}
return changed_list;
}
change_power( delta, origin, radius )
{
if ( delta > 0 )
{
if ( !self.power )
{
self.power = 1;
self [[ self.power_on_func ]]( origin, radius );
}
self.powered_count++;
}
else if ( delta < 0 )
{
if ( self.power )
{
self.power = 0;
self [[ self.power_off_func ]]( origin, radius );
}
self.depowered_count++;
}
}
revert_power_to_list( delta, origin, radius, powered_list )
{
for ( i = 0; i < powered_list.size; i++ )
{
powered = powered_list[ i ];
powered revert_power( delta, origin, radius );
}
}
revert_power( delta, origin, radius, powered_list )
{
if ( delta > 0 )
{
self.depowered_count--;
if ( self.depowered_count == 0 && self.powered_count > 0 && !self.power )
{
self.power = 1;
self [[ self.power_on_func ]]( origin, radius );
}
}
if ( delta < 0 )
{
self.powered_count--;
if ( self.powered_count == 0 && self.power )
{
self.power = 0;
self [[ self.power_off_func ]]( origin, radius );
}
}
}
add_local_power( origin, radius )
{
localpower = spawnstruct();
localpower.origin = origin;
localpower.radius = radius;
localpower.enabled_list = change_power_in_radius( 1, origin, radius );
if ( !isDefined( level.local_power ) )
{
level.local_power = [];
}
level.local_power[ level.local_power.size ] = localpower;
return localpower;
}
move_local_power( localpower, origin )
{
changed_list = [];
i = 0;
while ( i < level.powered_items.size )
{
powered = level.powered_items[ i ];
if ( powered.power_sources == 2 )
{
i++;
continue;
}
waspowered = isinarray( localpower.enabled_list, powered );
ispowered = powered [[ powered.range_func ]]( 1, origin, localpower.radius );
if ( ispowered && !waspowered )
{
powered change_power( 1, origin, localpower.radius );
localpower.enabled_list[ localpower.enabled_list.size ] = powered;
i++;
continue;
}
if ( !ispowered && waspowered )
{
powered revert_power( -1, localpower.origin, localpower.radius, localpower.enabled_list );
arrayremovevalue( localpower.enabled_list, powered, 0 );
}
i++;
}
localpower.origin = origin;
return localpower;
}
end_local_power( localpower )
{
if ( isDefined( localpower.enabled_list ) )
{
revert_power_to_list( -1, localpower.origin, localpower.radius, localpower.enabled_list );
}
localpower.enabled_list = undefined;
if ( isDefined( localpower.added_list ) )
{
revert_power_to_list( -1, localpower.origin, localpower.radius, localpower.added_list );
}
localpower.added_list = undefined;
arrayremovevalue( level.local_power, localpower, 0 );
}
has_local_power( origin )
{
if ( isDefined( level.local_power ) )
{
foreach ( localpower in level.local_power )
{
if ( distancesquared( localpower.origin, origin ) < ( localpower.radius * localpower.radius ) )
{
return 1;
}
}
}
return 0;
}
get_powered_item_cost()
{
if ( !is_true( self.power ) )
{
return 0;
}
if ( is_true( level._power_global ) && self.power_sources != 1 )
{
return 0;
}
cost = [[ self.cost_func ]]();
power_sources = self.powered_count;
if ( power_sources < 1 )
{
power_sources = 1;
}
return cost / power_sources;
}
get_local_power_cost( localpower )
{
cost = 0;
if ( isDefined( localpower ) && isDefined( localpower.enabled_list ) )
{
foreach ( powered in localpower.enabled_list )
{
cost += powered get_powered_item_cost();
}
}
else if ( isDefined( localpower ) && isDefined( localpower.added_list ) )
{
foreach ( powered in localpower.added_list )
{
cost += powered get_powered_item_cost();
}
}
return cost;
}
set_global_power( on_off )
{
maps/mp/_demo::bookmark( "zm_power", getTime(), undefined, undefined, 1 );
level._power_global = on_off;
for ( i = 0; i < level.powered_items.size; i++ )
{
powered = level.powered_items[ i ];
if ( isDefined( powered.target ) && powered.power_sources != 1 )
{
powered global_power( on_off );
wait_network_frame();
}
}
}
global_power( on_off )
{
if ( on_off )
{
if ( !self.power )
{
self.power = 1;
self [[ self.power_on_func ]]();
}
self.powered_count++;
}
else
{
self.powered_count--;
if ( self.powered_count == 0 && self.power )
{
self.power = 0;
self [[ self.power_off_func ]]();
}
}
}
never_power_on( origin, radius )
{
}
never_power_off( origin, radius )
{
}
cost_negligible()
{
if ( isDefined( self.one_time_cost ) )
{
cost = self.one_time_cost;
self.one_time_cost = undefined;
return cost;
}
return 0;
}
cost_low_if_local()
{
if ( isDefined( self.one_time_cost ) )
{
cost = self.one_time_cost;
self.one_time_cost = undefined;
return cost;
}
if ( is_true( level._power_global ) )
{
return 0;
}
if ( is_true( self.self_powered ) )
{
return 0;
}
return 1;
}
cost_high()
{
if ( isDefined( self.one_time_cost ) )
{
cost = self.one_time_cost;
self.one_time_cost = undefined;
return cost;
}
return 10;
}
door_range( delta, origin, radius )
{
if ( delta < 0 )
{
return 0;
}
if ( distancesquared( self.target.origin, origin ) < radius * radius )
{
return 1;
}
return 0;
}
door_power_on( origin, radius )
{
self.target.power_on = 1;
self.target notify( "power_on" );
}
door_power_off( origin, radius )
{
self.target notify( "power_off" );
self.target.power_on = 0;
}
door_local_power_on( origin, radius )
{
self.target.local_power_on = 1;
self.target notify( "local_power_on" );
}
door_local_power_off( origin, radius )
{
self.target notify( "local_power_off" );
self.target.local_power_on = 0;
}
cost_door()
{
if ( isDefined( self.target.power_cost ) )
{
if ( !isDefined( self.one_time_cost ) )
{
self.one_time_cost = 0;
}
self.one_time_cost += self.target.power_cost;
self.target.power_cost = 0;
}
if ( isDefined( self.one_time_cost ) )
{
cost = self.one_time_cost;
self.one_time_cost = undefined;
return cost;
}
return 0;
}
zombie_range( delta, origin, radius )
{
if ( delta > 0 )
{
return 0;
}
self.zombies = get_array_of_closest( origin, get_round_enemy_array(), undefined, undefined, radius );
if ( !isDefined( self.zombies ) )
{
return 0;
}
self.power = 1;
return 1;
}
zombie_power_off( origin, radius )
{
for ( i = 0; i < self.zombies.size; i++ )
{
self.zombies[ i ] thread stun_zombie();
wait 0.05;
}
}
stun_zombie()
{
self endon( "death" );
self notify( "stun_zombie" );
self endon( "stun_zombie" );
if ( self.health <= 0 )
{
return;
}
if ( is_true( self.ignore_inert ) )
{
return;
}
if ( isDefined( self.stun_zombie ) )
{
self thread [[ self.stun_zombie ]]();
return;
}
self thread maps/mp/zombies/_zm_ai_basic::start_inert();
}
perk_range( delta, origin, radius )
{
if ( isDefined( self.target ) )
{
perkorigin = self.target.origin;
if ( is_true( self.target.trigger_off ) )
{
perkorigin = self.target.realorigin;
}
else if ( is_true( self.target.disabled ) )
{
perkorigin += vectorScale( ( 0, 0, 1 ), 10000 );
}
if ( distancesquared( perkorigin, origin ) < radius * radius )
{
return 1;
}
}
return 0;
}
perk_power_on( origin, radius )
{
level notify( self.target maps/mp/zombies/_zm_perks::getvendingmachinenotify() + "_on" );
maps/mp/zombies/_zm_perks::perk_unpause( self.target.script_noteworthy );
}
perk_power_off( origin, radius )
{
notify_name = self.target maps/mp/zombies/_zm_perks::getvendingmachinenotify();
if ( isDefined( notify_name ) && notify_name == "revive" )
{
if ( level flag_exists( "solo_game" ) && flag( "solo_game" ) )
{
return;
}
}
self.target notify( "death" );
self.target thread maps/mp/zombies/_zm_perks::vending_trigger_think();
if ( isDefined( self.target.perk_hum ) )
{
self.target.perk_hum delete();
}
maps/mp/zombies/_zm_perks::perk_pause( self.target.script_noteworthy );
level notify( self.target maps/mp/zombies/_zm_perks::getvendingmachinenotify() + "_off" );
}
pap_range( delta, origin, radius )
{
if ( isDefined( self.target ) )
{
paporigin = self.target.origin;
if ( is_true( self.target.trigger_off ) )
{
paporigin = self.target.realorigin;
}
else if ( is_true( self.target.disabled ) )
{
paporigin += vectorScale( ( 0, 0, 1 ), 10000 );
}
if ( distancesquared( paporigin, origin ) < ( radius * radius ) )
{
return 1;
}
}
return 0;
}
pap_power_on( origin, radius )
{
level notify( "Pack_A_Punch_on" );
}
pap_power_off( origin, radius )
{
level notify( "Pack_A_Punch_off" );
self.target notify( "death" );
self.target thread maps/mp/zombies/_zm_perks::vending_weapon_upgrade();
}
pap_is_on()
{
if ( isDefined( self.powered ) )
{
return self.powered.power;
}
return 0;
}

2862
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_powerups.gsc
View File

File diff suppressed because it is too large Load Diff

3290
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_spawner.gsc
View File

File diff suppressed because it is too large Load Diff

576
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_stats.gsc
View File

@ -1,576 +0,0 @@
#include maps/mp/gametypes_zm/_globallogic;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_pers_upgrades;
#include maps/mp/gametypes_zm/_globallogic_score;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
level.player_stats_init = ::player_stats_init;
level.add_client_stat = ::add_client_stat;
level.track_gibs = ::do_stats_for_gibs;
}
player_stats_init()
{
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "kills", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "downs", 0 );
self.downs = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "downs" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "revives", 0 );
self.revives = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "revives" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "perks_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "headshots", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "gibs", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "head_gibs", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "melee_kills", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "grenade_kills", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "doors_purchased", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "distance_traveled", 0 );
self.distance_traveled = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "distance_traveled" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "total_shots", 0 );
self.total_shots = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "total_shots" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "hits", 0 );
self.hits = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "hits" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "deaths", 0 );
self.deaths = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "deaths" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "boards", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "wins", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "losses", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "time_played_total", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "weighted_rounds_played", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_boarding", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_revivenoperk", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_multikill_headshots", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_cash_back_bought", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_cash_back_prone", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_insta_kill", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_nube_5_times", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_jugg", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_jugg_downgrade_count", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_carpenter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_max_round_reached", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_flopper_counter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_perk_lose_counter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_pistol_points_counter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_double_points_counter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_sniper_counter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_box_weapon_counter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_melee_bonus_counter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_nube_counter", 0, 1 );
self maps/mp/zombies/_zm_pers_upgrades::pers_abilities_init_globals();
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "score", 0 );
if ( level.resetplayerscoreeveryround )
{
self.pers[ "score" ] = 0;
}
self.pers[ "score" ] = level.player_starting_points;
self.score = self.pers[ "score" ];
self incrementplayerstat( "score", self.score );
if ( isDefined( level.level_specific_stats_init ) )
{
[[ level.level_specific_stats_init ]]();
}
if ( !isDefined( self.stats_this_frame ) )
{
self.pers_upgrade_force_test = 1;
self.stats_this_frame = [];
self.pers_upgrades_awarded = [];
}
}
update_players_stats_at_match_end( players )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
game_mode = getDvar( "ui_gametype" );
game_mode_group = level.scr_zm_ui_gametype_group;
map_location_name = level.scr_zm_map_start_location;
if ( map_location_name == "" )
{
map_location_name = "default";
}
if ( isDefined( level.gamemodulewinningteam ) )
{
if ( level.gamemodulewinningteam == "B" )
{
matchrecorderincrementheaderstat( "winningTeam", 1 );
}
else if ( level.gamemodulewinningteam == "A" )
{
matchrecorderincrementheaderstat( "winningTeam", 2 );
}
}
recordmatchsummaryzombieendgamedata( game_mode, game_mode_group, map_location_name, level.round_number );
newtime = getTime();
i = 0;
while ( i < players.size )
{
player = players[ i ];
if ( player is_bot() )
{
i++;
continue;
}
distance = player get_stat_distance_traveled();
player addplayerstatwithgametype( "distance_traveled", distance );
player add_location_gametype_stat( level.scr_zm_map_start_location, level.scr_zm_ui_gametype, "time_played_total", player.pers[ "time_played_total" ] );
recordplayermatchend( player );
recordplayerstats( player, "presentAtEnd", 1 );
player maps/mp/zombies/_zm_weapons::updateweapontimingszm( newtime );
if ( isDefined( level._game_module_stat_update_func ) )
{
player [[ level._game_module_stat_update_func ]]();
}
old_high_score = player get_game_mode_stat( game_mode, "score" );
if ( player.score_total > old_high_score )
{
player set_game_mode_stat( game_mode, "score", player.score_total );
}
if ( gamemodeismode( level.gamemode_public_match ) )
{
player gamehistoryfinishmatch( 4, 0, 0, 0, 0, 0 );
if ( isDefined( player.pers[ "matchesPlayedStatsTracked" ] ) )
{
gamemode = maps/mp/gametypes_zm/_globallogic::getcurrentgamemode();
player maps/mp/gametypes_zm/_globallogic::incrementmatchcompletionstat( gamemode, "played", "completed" );
if ( isDefined( player.pers[ "matchesHostedStatsTracked" ] ) )
{
player maps/mp/gametypes_zm/_globallogic::incrementmatchcompletionstat( gamemode, "hosted", "completed" );
}
}
}
if ( !isDefined( player.pers[ "previous_distance_traveled" ] ) )
{
player.pers[ "previous_distance_traveled" ] = 0;
}
distancethisround = int( player.pers[ "distance_traveled" ] - player.pers[ "previous_distance_traveled" ] );
player.pers[ "previous_distance_traveled" ] = player.pers[ "distance_traveled" ];
player incrementplayerstat( "distance_traveled", distancethisround );
i++;
}
}
update_playing_utc_time( matchendutctime )
{
current_days = int( matchendutctime / 86400 );
last_days = self get_global_stat( "TIMESTAMPLASTDAY1" );
last_days = int( last_days / 86400 );
diff_days = current_days - last_days;
timestamp_name = "";
if ( diff_days > 0 )
{
for ( i = 5; i > diff_days; i-- )
{
timestamp_name = "TIMESTAMPLASTDAY" + ( i - diff_days );
timestamp_name_to = "TIMESTAMPLASTDAY" + i;
timestamp_value = self get_global_stat( timestamp_name );
self set_global_stat( timestamp_name_to, timestamp_value );
}
for ( i = 2; i <= diff_days && i < 6; i++ )
{
timestamp_name = "TIMESTAMPLASTDAY" + i;
self set_global_stat( timestamp_name, 0 );
}
self set_global_stat( "TIMESTAMPLASTDAY1", matchendutctime );
}
}
survival_classic_custom_stat_update()
{
}
grief_custom_stat_update()
{
}
add_game_mode_group_stat( game_mode, stat_name, value )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self adddstat( "PlayerStatsByGameTypeGroup", game_mode, stat_name, "statValue", value );
}
set_game_mode_group_stat( game_mode, stat_name, value )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self setdstat( "PlayerStatsByGameTypeGroup", game_mode, stat_name, "statValue", value );
}
get_game_mode_group_stat( game_mode, stat_name )
{
return self getdstat( "PlayerStatsByGameTypeGroup", game_mode, stat_name, "statValue" );
}
add_game_mode_stat( game_mode, stat_name, value )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self adddstat( "PlayerStatsByGameType", game_mode, stat_name, "statValue", value );
}
set_game_mode_stat( game_mode, stat_name, value )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self setdstat( "PlayerStatsByGameType", game_mode, stat_name, "statValue", value );
}
get_game_mode_stat( game_mode, stat_name )
{
return self getdstat( "PlayerStatsByGameType", game_mode, stat_name, "statValue" );
}
get_global_stat( stat_name )
{
return self getdstat( "PlayerStatsList", stat_name, "StatValue" );
}
set_global_stat( stat_name, value )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self setdstat( "PlayerStatsList", stat_name, "StatValue", value );
}
add_global_stat( stat_name, value )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self adddstat( "PlayerStatsList", stat_name, "StatValue", value );
}
get_map_stat( stat_name, map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
return self getdstat( "PlayerStatsByMap", map, stat_name );
}
set_map_stat( stat_name, value, map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self setdstat( "PlayerStatsByMap", map, stat_name, value );
}
add_map_stat( stat_name, value, map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self adddstat( "PlayerStatsByMap", map, stat_name, value );
}
get_location_gametype_stat( start_location, game_type, stat_name )
{
return self getdstat( "PlayerStatsByStartLocation", start_location, "startLocationGameTypeStats", game_type, "stats", stat_name, "StatValue" );
}
set_location_gametype_stat( start_location, game_type, stat_name, value )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self setdstat( "PlayerStatsByStartLocation", start_location, "startLocationGameTypeStats", game_type, "stats", stat_name, "StatValue", value );
}
add_location_gametype_stat( start_location, game_type, stat_name, value )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self adddstat( "PlayerStatsByStartLocation", start_location, "startLocationGameTypeStats", game_type, "stats", stat_name, "StatValue", value );
}
get_map_weaponlocker_stat( stat_name, map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
return self getdstat( "PlayerStatsByMap", map, "weaponLocker", stat_name );
}
set_map_weaponlocker_stat( stat_name, value, map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
if ( isDefined( value ) )
{
self setdstat( "PlayerStatsByMap", map, "weaponLocker", stat_name, value );
}
else
{
self setdstat( "PlayerStatsByMap", map, "weaponLocker", stat_name, 0 );
}
}
add_map_weaponlocker_stat( stat_name, value, map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self adddstat( "PlayerStatsByMap", map, "weaponLocker", stat_name, value );
}
has_stored_weapondata( map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
storedweapon = self get_map_weaponlocker_stat( "name", map );
if ( isDefined( storedweapon ) || isstring( storedweapon ) && storedweapon == "" || isint( storedweapon ) && storedweapon == 0 )
{
return 0;
}
return 1;
}
get_stored_weapondata( map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
if ( self has_stored_weapondata( map ) )
{
weapondata = [];
weapondata[ "name" ] = self get_map_weaponlocker_stat( "name", map );
weapondata[ "lh_clip" ] = self get_map_weaponlocker_stat( "lh_clip", map );
weapondata[ "clip" ] = self get_map_weaponlocker_stat( "clip", map );
weapondata[ "stock" ] = self get_map_weaponlocker_stat( "stock", map );
weapondata[ "alt_clip" ] = self get_map_weaponlocker_stat( "alt_clip", map );
weapondata[ "alt_stock" ] = self get_map_weaponlocker_stat( "alt_stock", map );
return weapondata;
}
return undefined;
}
clear_stored_weapondata( map ) //checked matches cerberus output
{
if ( !isDefined( map ) )
{
map = level.script;
}
self set_map_weaponlocker_stat( "name", "", map );
self set_map_weaponlocker_stat( "lh_clip", 0, map );
self set_map_weaponlocker_stat( "clip", 0, map );
self set_map_weaponlocker_stat( "stock", 0, map );
self set_map_weaponlocker_stat( "alt_clip", 0, map );
self set_map_weaponlocker_stat( "alt_stock", 0, map );
}
set_stored_weapondata( weapondata, map )
{
if ( !isDefined( map ) )
{
map = level.script;
}
self set_map_weaponlocker_stat( "name", weapondata[ "name" ], map );
self set_map_weaponlocker_stat( "lh_clip", weapondata[ "lh_clip" ], map );
self set_map_weaponlocker_stat( "clip", weapondata[ "clip" ], map );
self set_map_weaponlocker_stat( "stock", weapondata[ "stock" ], map );
self set_map_weaponlocker_stat( "alt_clip", weapondata[ "alt_clip" ], map );
self set_map_weaponlocker_stat( "alt_stock", weapondata[ "alt_stock" ], map );
}
add_client_stat( stat_name, stat_value, include_gametype )
{
if ( !self player_stat_exists( stat_name ) )
{
return;
}
if ( getDvar( "ui_zm_mapstartlocation" ) == "" || is_true( level.zm_disable_recording_stats ) )
{
return;
}
if ( !isDefined( include_gametype ) )
{
include_gametype = 1;
}
self maps/mp/gametypes_zm/_globallogic_score::incpersstat( stat_name, stat_value, 0, include_gametype );
self.stats_this_frame[ stat_name ] = 1;
}
increment_player_stat( stat_name )
{
if ( !self player_stat_exists( stat_name ) )
{
return;
}
if ( getDvar( "ui_zm_mapstartlocation" ) == "" || is_true( level.zm_disable_recording_stats ) )
{
return;
}
self incrementplayerstat( stat_name, 1 );
}
increment_client_stat( stat_name, include_gametype )
{
if ( !self player_stat_exists( stat_name ) )
{
return;
}
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
add_client_stat( stat_name, 1, include_gametype );
}
set_client_stat( stat_name, stat_value, include_gametype )
{
if ( !self player_stat_exists( stat_name ) )
{
return;
}
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
current_stat_count = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( stat_name );
self maps/mp/gametypes_zm/_globallogic_score::incpersstat( stat_name, stat_value - current_stat_count, 0, include_gametype );
self.stats_this_frame[ stat_name ] = 1;
}
zero_client_stat( stat_name, include_gametype )
{
if ( !self player_stat_exists( stat_name ) )
{
return;
}
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
current_stat_count = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( stat_name );
self maps/mp/gametypes_zm/_globallogic_score::incpersstat( stat_name, current_stat_count * -1, 0, include_gametype );
self.stats_this_frame[ stat_name ] = 1;
}
increment_map_cheat_stat( stat_name )
{
if ( is_true( level.zm_disable_recording_stats ) )
{
return;
}
self adddstat( "PlayerStatsByMap", level.script, "cheats", stat_name, 1 );
}
get_stat_distance_traveled()
{
miles = int( self.pers[ "distance_traveled" ] / 63360 );
remainder = ( self.pers[ "distance_traveled" ] / 63360 ) - miles;
if ( miles < 1 && remainder < 0.5 )
{
miles = 1;
}
else if ( remainder >= 0.5 )
{
miles++;
}
return miles;
}
update_global_counters_on_match_end()
{
}
get_specific_stat( stat_category, stat_name )
{
return self getdstat( stat_category, stat_name, "StatValue" );
}
do_stats_for_gibs( zombie, limb_tags_array )
{
if ( isDefined( zombie ) && isDefined( zombie.attacker ) && isplayer( zombie.attacker ) )
{
i = 0;
while ( i < limb_tags_array.size )
{
stat_name = undefined;
if ( limb == level._zombie_gib_piece_index_head )
{
stat_name = "head_gibs";
}
if ( !isDefined( stat_name ) )
{
i++;
continue;
}
zombie.attacker increment_client_stat( stat_name, 0 );
zombie.attacker increment_client_stat( "gibs" );
i++;
}
}
}
adjustrecentstats()
{
if ( !level.onlinegame || !gamemodeismode( level.gamemode_public_match ) )
{
return;
}
self.pers[ "lastHighestScore" ] = self getdstat( "HighestStats", "highest_score" );
currgametype = level.gametype;
self gamehistorystartmatch( getgametypeenumfromname( currgametype, 0 ) );
}
uploadstatssoon()
{
self notify( "upload_stats_soon" );
self endon( "upload_stats_soon" );
self endon( "disconnect" );
wait 1;
uploadstats( self );
}
player_stat_exists( stat_name )
{
return isDefined( self.pers[ stat_name ] );
}

2807
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_weapons.gsc
View File

File diff suppressed because it is too large Load Diff

799
Plutonium specific gsc-related fixes/18 Player ZM Fixes/maps/mp/zombies/_zm_zonemgr.gsc
View File

@ -1,799 +0,0 @@
#include maps/mp/zombies/_zm_zonemgr;
#include maps/mp/gametypes_zm/_zm_gametype;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
flag_init( "zones_initialized" );
level.zones = [];
level.zone_flags = [];
level.zone_scanning_active = 0;
if ( !isDefined( level.create_spawner_list_func ) )
{
level.create_spawner_list_func = ::create_spawner_list;
}
}
zone_is_enabled( zone_name )
{
if ( !isDefined( level.zones ) || !isDefined( level.zones[ zone_name ] ) || !level.zones[ zone_name ].is_enabled )
{
return 0;
}
return 1;
}
get_player_zone()
{
player_zone = undefined;
keys = getarraykeys( level.zones );
for ( i = 0; i < keys.size; i++ )
{
if ( self entity_in_zone( keys[ i ] ) )
{
player_zone = keys[ i ];
break;
}
}
return player_zone;
}
get_zone_from_position( v_pos, ignore_enabled_check )
{
zone = undefined;
scr_org = spawn( "script_origin", v_pos );
keys = getarraykeys(level.zones);
for ( i = 0; i < keys.size; i++ )
{
if ( scr_org entity_in_zone( keys[ i ], ignore_enabled_check ) )
{
zone = keys [i ];
break;
}
}
scr_org delete();
return zone;
}
get_zone_magic_boxes( zone_name )
{
if ( isDefined( zone_name ) && !zone_is_enabled( zone_name ) )
{
return undefined;
}
zone = level.zones[ zone_name ];
return zone.magic_boxes;
}
get_zone_zbarriers( zone_name )
{
if ( isDefined( zone_name ) && !zone_is_enabled( zone_name ) )
{
return undefined;
}
zone = level.zones[ zone_name ];
return zone.zbarriers;
}
get_players_in_zone( zone_name, return_players )
{
if ( !zone_is_enabled( zone_name ) )
{
return 0;
}
zone = level.zones[zone_name];
num_in_zone = 0;
players_in_zone = [];
players = get_players();
for ( i = 0; i < zone.volumes.size; i++ )
{
for ( j = 0; j < players.size; j++ )
{
if ( players[ j ] istouching( zone.volumes[ i ] ) )
{
num_in_zone++;
players_in_zone[ players_in_zone.size ] = players[ j ];
}
}
}
if ( isdefined( return_players ) )
{
return players_in_zone;
}
return num_in_zone;
}
player_in_zone( zone_name )
{
if ( !zone_is_enabled( zone_name ) )
{
return 0;
}
zone = level.zones[ zone_name ];
for ( i = 0; i < zone.volumes.size; i++ )
{
players = get_players();
for ( j = 0; j < players.size; j++ )
{
if ( players[ j ] istouching( zone.volumes[ i ] ) && !players[ j ] .sessionstate == "spectator" )
{
return 1;
}
}
}
return 0;
}
entity_in_zone( zone_name, ignore_enabled_check )
{
if ( !zone_is_enabled( zone_name ) && !is_true( ignore_enabled_check ) )
{
return 0;
}
zone = level.zones[ zone_name ];
for ( i = 0; i < zone.volumes.size; i++ )
{
if ( self istouching( zone.volumes[ i ] ) )
{
return 1;
}
}
return 0;
}
deactivate_initial_barrier_goals()
{
special_goals = getstructarray( "exterior_goal", "targetname" );
for ( i = 0; i < special_goals.size; i++ )
{
if ( isdefined( special_goals[ i ].script_noteworthy ) )
{
special_goals[ i ].is_active = 0;
special_goals[ i ] trigger_off();
}
}
}
zone_init( zone_name )
{
if ( isDefined( level.zones[ zone_name ] ) )
{
return;
}
level.zones[ zone_name ] = spawnstruct();
zone = level.zones[ zone_name ];
zone.is_enabled = 0;
zone.is_occupied = 0;
zone.is_active = 0;
zone.adjacent_zones = [];
zone.is_spawning_allowed = 0;
spawn_points = maps/mp/gametypes_zm/_zm_gametype::get_player_spawns_for_gametype();
for( i = 0; i < spawn_points.size; i++ )
{
if ( spawn_points[ i ].script_noteworthy == zone_name )
{
spawn_points[ i ].locked = 0;
}
}
zone.volumes = [];
volumes = getentarray( zone_name, "targetname" );
i = 0;
for ( i = 0; i < volumes.size; i++ )
{
if ( volumes[ i ].classname == "info_volume" )
{
zone.volumes[ zone.volumes.size ] = volumes[ i ];
}
}
if ( isdefined( zone.volumes[ 0 ].target ) )
{
spots = getstructarray( zone.volumes[ 0 ].target, "targetname" );
zone.spawn_locations = [];
zone.dog_locations = [];
zone.screecher_locations = [];
zone.avogadro_locations = [];
zone.inert_locations = [];
zone.quad_locations = [];
zone.leaper_locations = [];
zone.brutus_locations = [];
zone.mechz_locations = [];
zone.astro_locations = [];
zone.napalm_locations = [];
zone.zbarriers = [];
zone.magic_boxes = [];
barricades = getstructarray( "exterior_goal", "targetname" );
box_locs = getstructarray( "treasure_chest_use", "targetname" );
for (i = 0; i < spots.size; i++)
{
spots[ i ].zone_name = zone_name;
if ( !is_true( spots[ i ].is_blocked ) )
{
spots[ i ].is_enabled = 1;
}
else
{
spots[ i ].is_enabled = 0;
}
tokens = strtok( spots[ i ].script_noteworthy, " " );
foreach ( token in tokens )
{
if ( token == "dog_location" )
{
zone.dog_locations[ zone.dog_locations.size ] = spots[ i ];
}
else if ( token == "screecher_location" )
{
zone.screecher_locations[ zone.screecher_locations.size ] = spots[ i ];
}
else if ( token == "avogadro_location" )
{
zone.avogadro_locations[ zone.avogadro_locations.size ] = spots[ i] ;
}
else if ( token == "inert_location" )
{
zone.inert_locations[ zone.inert_locations.size ] = spots[ i ];
}
else if ( token == "quad_location" )
{
zone.quad_locations[ zone.quad_locations.size ] = spots[ i ];
}
else if ( token == "leaper_location" )
{
zone.leaper_locations[ zone.leaper_locations.size ] = spots[ i ];
}
else if ( token == "brutus_location" )
{
zone.brutus_locations[ zone.brutus_locations.size ] = spots[ i ];
}
else if ( token == "mechz_location" )
{
zone.mechz_locations[ zone.mechz_locations.size ] = spots[ i ];
}
else if ( token == "astro_location" )
{
zone.astro_locations[ zone.astro_locations.size ] = spots[ i ];
}
else if ( token == "napalm_location" )
{
zone.napalm_locations[ zone.napalm_locations.size ] = spots[ i ];
}
else
{
zone.spawn_locations[ zone.spawn_locations.size ] = spots[ i ];
}
}
if ( isdefined( spots[ i ].script_string ) )
{
barricade_id = spots[ i ].script_string;
for ( k = 0; k < barricades.size; k++ )
{
if ( isdefined( barricades[ k ].script_string ) && barricades[ k ].script_string == barricade_id )
{
nodes = getnodearray( barricades[ k ].target, "targetname" );
for ( j = 0; j < nodes.size; j++ )
{
if ( isdefined( nodes[ j ].type ) && nodes[ j ].type == "Begin" )
{
spots[ i ].target = nodes[ j ].targetname;
}
}
}
}
}
}
for ( i = 0; i < barricades.size; i++ )
{
targets = getentarray( barricades[ i ].target, "targetname" );
for ( j = 0; j < targets.size; j++ )
{
if ( targets[ j ] iszbarrier() && isdefined( targets[ j ].script_string ) && targets[ j ].script_string == zone_name )
{
zone.zbarriers[ zone.zbarriers.size ] = targets[ j ];
}
}
}
for ( i = 0; i < box_locs.size; i++ )
{
chest_ent = getent( box_locs[ i ].script_noteworthy + "_zbarrier", "script_noteworthy" );
if ( chest_ent entity_in_zone( zone_name, 1 ) )
{
zone.magic_boxes[zone.magic_boxes.size] = box_locs[ i ];
}
}
}
}
enable_zone( zone_name )
{
if ( level.zones[ zone_name ].is_enabled )
{
return;
}
level.zones[ zone_name ].is_enabled = 1;
level.zones[zone_name].is_spawning_allowed = 1;
level notify( zone_name );
spawn_points = maps/mp/gametypes_zm/_zm_gametype::get_player_spawns_for_gametype();
for( i = 0; i < spawn_points.size; i++ )
{
if ( spawn_points[ i ].script_noteworthy == zone_name )
{
spawn_points[ i ].locked = 0;
}
}
entry_points = getstructarray( zone_name + "_barriers", "script_noteworthy" );
for( i = 0; i < entry_points.size; i++ )
{
entry_points[ i ].is_active = 1;
entry_points[ i ] trigger_on();
}
}
make_zone_adjacent( main_zone_name, adj_zone_name, flag_name )
{
main_zone = level.zones[ main_zone_name ];
if ( !isDefined( main_zone.adjacent_zones[ adj_zone_name ] ) )
{
main_zone.adjacent_zones[ adj_zone_name ] = spawnstruct();
adj_zone = main_zone.adjacent_zones[ adj_zone_name ];
adj_zone.is_connected = 0;
adj_zone.flags_do_or_check = 0;
if ( isarray( flag_name ) )
{
adj_zone.flags = flag_name;
}
else
{
adj_zone.flags[ 0 ] = flag_name;
}
}
else
{
adj_zone = main_zone.adjacent_zones[ adj_zone_name ];
size = adj_zone.flags.size;
adj_zone.flags_do_or_check = 1;
adj_zone.flags[ size ] = flag_name;
}
}
add_zone_flags( wait_flag, add_flags )
{
if ( !isarray( add_flags ) )
{
temp = add_flags;
add_flags = [];
add_flags[ 0 ] = temp;
}
keys = getarraykeys( level.zone_flags );
i = 0;
for ( i = 0; i < keys.size; i++ )
{
if ( keys[ i ] == wait_flag )
{
level.zone_flags[ keys[ i ] ] = arraycombine( level.zone_flags[ keys[ i ] ], add_flags, 1, 0 );
return;
}
}
level.zone_flags[ wait_flag ] = add_flags;
}
add_adjacent_zone( zone_name_a, zone_name_b, flag_name, one_way )
{
if ( !isDefined( one_way ) )
{
one_way = 0;
}
if ( !isDefined( level.flag[ flag_name ] ) )
{
flag_init( flag_name );
}
zone_init( zone_name_a );
zone_init( zone_name_b );
make_zone_adjacent( zone_name_a, zone_name_b, flag_name );
if ( !one_way )
{
make_zone_adjacent( zone_name_b, zone_name_a, flag_name );
}
}
setup_zone_flag_waits()
{
flags = [];
zkeys = getarraykeys( level.zones );
for ( z = 0; z < level.zones.size; z++ )
{
zone = level.zones[ zkeys[ z ] ];
azkeys = getarraykeys( zone.adjacent_zones );
for ( az = 0; az < zone.adjacent_zones.size; az++ )
{
azone = zone.adjacent_zones[ azkeys[ az ] ];
for ( f = 0; f < azone.flags.size; f++ )
{
flags = add_to_array( flags, azone.flags[ f ], 0);
}
}
}
for ( i = 0; i < flags.size; i++ )
{
level thread zone_flag_wait( flags[ i ] );
}
}
zone_flag_wait( flag_name )
{
if ( !isdefined( level.flag[ flag_name ] ) )
{
flag_init( flag_name );
}
flag_wait( flag_name );
flags_set = 0;
for ( z = 0; z < level.zones.size; z++ )
{
zkeys = getarraykeys( level.zones );
zone = level.zones[ zkeys[ z ] ];
for ( az = 0; az < zone.adjacent_zones.size; az++ )
{
azkeys = getarraykeys( zone.adjacent_zones );
azone = zone.adjacent_zones[ azkeys[ az ] ];
if ( !azone.is_connected )
{
if ( azone.flags_do_or_check )
{
flags_set = 0;
for ( f = 0; f < azone.flags.size; f++ )
{
if ( flag( azone.flags[ f ] ) )
{
flags_set = 1;
break;
}
}
}
else
{
flags_set = 1;
for ( f = 0; f < azone.flags.size; f++ )
{
if ( !flag(azone.flags[ f ] ) )
{
flags_set = 0;
}
}
}
if ( flags_set )
{
enable_zone( zkeys[ z ] );
azone.is_connected = 1;
if ( !level.zones[ azkeys[ az ] ].is_enabled )
{
enable_zone( azkeys[ az ] );
}
if ( flag( "door_can_close" ) )
{
azone thread door_close_disconnect( flag_name );
}
}
}
}
}
keys = getarraykeys( level.zone_flags );
for ( i = 0; i < keys.size; i++ )
{
if ( keys[ i ] == flag_name )
{
check_flag = level.zone_flags[ keys[ i ] ];
for ( k = 0; k < check_flag.size; k++ )
{
flag_set( check_flag[ k ] );
}
break;
}
}
}
door_close_disconnect( flag_name )
{
while ( flag( flag_name ) )
{
wait 1;
}
self.is_connected = 0;
level thread zone_flag_wait( flag_name );
}
connect_zones( zone_name_a, zone_name_b, one_way )
{
if ( !isDefined( one_way ) )
{
one_way = 0;
}
zone_init( zone_name_a );
zone_init( zone_name_b );
enable_zone( zone_name_a );
enable_zone( zone_name_b );
if ( !isDefined( level.zones[ zone_name_a ].adjacent_zones[ zone_name_b ] ) )
{
level.zones[ zone_name_a ].adjacent_zones[ zone_name_b ] = spawnstruct();
level.zones[ zone_name_a ].adjacent_zones[ zone_name_b ].is_connected = 1;
}
if ( !one_way )
{
if ( !isDefined( level.zones[ zone_name_b ].adjacent_zones[ zone_name_a ] ) )
{
level.zones[ zone_name_b ].adjacent_zones[ zone_name_a ] = spawnstruct();
level.zones[ zone_name_b ].adjacent_zones[ zone_name_a ].is_connected = 1;
}
}
}
manage_zones( initial_zone )
{
deactivate_initial_barrier_goals();
zone_choke = 0;
spawn_points = maps/mp/gametypes_zm/_zm_gametype::get_player_spawns_for_gametype();
for ( i = 0; i < spawn_points.size; i++ )
{
spawn_points[ i ].locked = 1;
}
if ( isDefined( level.zone_manager_init_func ) )
{
[[ level.zone_manager_init_func ]]();
}
if ( isarray( initial_zone ) )
{
for ( i = 0; i < initial_zone.size; i++ )
{
zone_init( initial_zone[ i ] );
enable_zone( initial_zone[ i ] );
}
}
else
{
zone_init( initial_zone );
enable_zone( initial_zone );
}
setup_zone_flag_waits();
zkeys = getarraykeys( level.zones );
level.zone_keys = zkeys;
level.newzones = [];
for ( z = 0; z < zkeys.size; z++ )
{
level.newzones[ zkeys[ z ] ] = spawnstruct();
}
oldzone = undefined;
flag_set( "zones_initialized" );
flag_wait( "begin_spawning" );
while ( getDvarInt( "noclip" ) == 0 || getDvarInt( "notarget" ) != 0 )
{
for( z = 0; z < zkeys.size; z++ )
{
level.newzones[ zkeys[ z ] ].is_active = 0;
level.newzones[ zkeys[ z ] ].is_occupied = 0;
}
a_zone_is_active = 0;
a_zone_is_spawning_allowed = 0;
level.zone_scanning_active = 1;
z = 0;
while ( z < zkeys.size )
{
zone = level.zones[ zkeys[ z ] ];
newzone = level.newzones[ zkeys[ z ] ];
if( !zone.is_enabled )
{
z++;
continue;
}
if ( isdefined(level.zone_occupied_func ) )
{
newzone.is_occupied = [[ level.zone_occupied_func ]]( zkeys[ z ] );
}
else
{
newzone.is_occupied = player_in_zone( zkeys[ z ] );
}
if ( newzone.is_occupied )
{
newzone.is_active = 1;
a_zone_is_active = 1;
if ( zone.is_spawning_allowed )
{
a_zone_is_spawning_allowed = 1;
}
if ( !isdefined(oldzone) || oldzone != newzone )
{
level notify( "newzoneActive", zkeys[ z ] );
oldzone = newzone;
}
azkeys = getarraykeys( zone.adjacent_zones );
for ( az = 0; az < zone.adjacent_zones.size; az++ )
{
if ( zone.adjacent_zones[ azkeys[ az ] ].is_connected && level.zones[ azkeys[ az ] ].is_enabled )
{
level.newzones[ azkeys[ az ] ].is_active = 1;
if ( level.zones[ azkeys[ az ] ].is_spawning_allowed )
{
a_zone_is_spawning_allowed = 1;
}
}
}
}
zone_choke++;
if ( zone_choke >= 3 )
{
zone_choke = 0;
wait 0.05;
}
z++;
}
level.zone_scanning_active = 0;
for ( z = 0; z < zkeys.size; z++ )
{
level.zones[ zkeys[ z ] ].is_active = level.newzones[ zkeys[ z ] ].is_active;
level.zones[ zkeys[ z ] ].is_occupied = level.newzones[ zkeys[ z ] ].is_occupied;
}
if ( !a_zone_is_active || !a_zone_is_spawning_allowed )
{
if ( isarray( initial_zone ) )
{
level.zones[ initial_zone[ 0 ] ].is_active = 1;
level.zones[ initial_zone[ 0 ] ].is_occupied = 1;
level.zones[ initial_zone[ 0 ] ].is_spawning_allowed = 1;
}
else
{
level.zones[ initial_zone ].is_active = 1;
level.zones[ initial_zone ].is_occupied = 1;
level.zones[ initial_zone ].is_spawning_allowed = 1;
}
}
[[ level.create_spawner_list_func ]]( zkeys );
level.active_zone_names = maps/mp/zombies/_zm_zonemgr::get_active_zone_names();
wait 1;
}
}
debug_show_spawn_locations()
{
}
create_spawner_list( zkeys )
{
level.zombie_spawn_locations = [];
level.inert_locations = [];
level.enemy_dog_locations = [];
level.zombie_screecher_locations = [];
level.zombie_avogadro_locations = [];
level.quad_locations = [];
level.zombie_leaper_locations = [];
level.zombie_astro_locations = [];
level.zombie_brutus_locations = [];
level.zombie_mechz_locations = [];
level.zombie_napalm_locations = [];
for ( z = 0; z < zkeys.size; z++ )
{
zone = level.zones[ zkeys[ z ] ];
if ( zone.is_enabled && zone.is_active && zone.is_spawning_allowed )
{
for ( i = 0; i < zone.spawn_locations.size; i++ )
{
if(zone.spawn_locations[ i ].is_enabled)
{
level.zombie_spawn_locations[ level.zombie_spawn_locations.size ] = zone.spawn_locations[ i ];
}
}
for ( x = 0; x < zone.inert_locations.size; x++ )
{
if ( zone.inert_locations[ x ].is_enabled)
{
level.inert_locations[ level.inert_locations.size ] = zone.inert_locations[ x ];
}
}
for ( x = 0; x < zone.dog_locations.size; x++ )
{
if ( zone.dog_locations[ x ].is_enabled )
{
level.enemy_dog_locations[ level.enemy_dog_locations.size ] = zone.dog_locations[ x ];
}
}
for ( x = 0; x < zone.screecher_locations.size; x++ )
{
if ( zone.screecher_locations[ x ].is_enabled)
{
level.zombie_screecher_locations[ level.zombie_screecher_locations.size ] = zone.screecher_locations[ x ];
}
}
for ( x = 0; x < zone.avogadro_locations.size; x++ )
{
if ( zone.avogadro_locations[ x ].is_enabled)
{
level.zombie_avogadro_locations[ level.zombie_avogadro_locations.size ] = zone.avogadro_locations[ x ];
}
}
for ( x = 0; x < zone.quad_locations.size; x++ )
{
if ( zone.quad_locations[ x ].is_enabled )
{
level.quad_locations[ level.quad_locations.size ] = zone.quad_locations[ x ];
}
}
for ( x = 0; x < zone.leaper_locations.size; x++ )
{
if ( zone.leaper_locations[ x ].is_enabled )
{
level.zombie_leaper_locations[ level.zombie_leaper_locations.size ] = zone.leaper_locations[ x ];
}
}
for ( x = 0; x < zone.astro_locations.size; x++ )
{
if ( zone.astro_locations[ x ].is_enabled )
{
level.zombie_astro_locations[ level.zombie_astro_locations.size ] = zone.astro_locations[ x ];
}
}
for ( x = 0; x < zone.napalm_locations.size; x++ )
{
if ( zone.napalm_locations[x].is_enabled )
{
level.zombie_napalm_locations[ level.zombie_napalm_locations.size ] = zone.napalm_locations[ x ];
}
}
for ( x = 0; x < zone.brutus_locations.size; x++ )
{
if ( zone.brutus_locations[ x ].is_enabled )
{
level.zombie_brutus_locations[ level.zombie_brutus_locations.size ] = zone.brutus_locations[ x ];
}
}
for ( x = 0; x < zone.mechz_locations.size; x++ )
{
if ( zone.mechz_locations[ x ].is_enabled )
{
level.zombie_mechz_locations[level.zombie_mechz_locations.size] = zone.mechz_locations[ x ];
}
}
}
}
}
get_active_zone_names()
{
ret_list = [];
if ( !isDefined( level.zone_keys ) )
{
return ret_list;
}
while ( level.zone_scanning_active )
{
wait 0.05;
}
for ( i = 0; i < level.zone_keys.size; i++ )
{
if ( level.zones[ level.zone_keys[ i ] ].is_active )
{
ret_list[ ret_list.size ] = level.zone_keys[ i ];
}
}
return ret_list;
}
is_player_in_zone( zone_name ) //checked changed to match cerberus output
{
zone = level.zones[ zone_name ];
for ( i = 0; i < zone.volumes.size; i++ )
{
if ( self istouching( level.zones[zone_name].volumes[ i ] ) && !self.sessionstate == "spectator" )
{
return 1;
}
}
return 0;
}

0
Plutonium specific gsc-related fixes/18 Player ZM Fixes/scripts/zm/ffotd_zm.gsc
View File

4
Plutonium specific gsc-related fixes/18 Player ZM Fixes/scripts/zm/zm_buried/ffotd_zm_buried.gsc
View File

@ -1,4 +0,0 @@
main()
{
}

0
Plutonium specific gsc-related fixes/18 Player ZM Fixes/scripts/zm/zm_highrise/ffotd_zm_highrise.gsc
View File

0
Plutonium specific gsc-related fixes/18 Player ZM Fixes/scripts/zm/zm_nuked/ffotd_zm_nuked.gsc
View File

0
Plutonium specific gsc-related fixes/18 Player ZM Fixes/scripts/zm/zm_prison/ffotd_zm_prison.gsc
View File

0
Plutonium specific gsc-related fixes/18 Player ZM Fixes/scripts/zm/zm_tomb/ffotd_zm_tomb.gsc
View File

0
Plutonium specific gsc-related fixes/18 Player ZM Fixes/scripts/zm/zm_transit/ffotd_zm_transit.gsc
View File