INSANEMODE/Public-BO2-Mods
1
0
Fork 0
mirror of https://github.com/JezuzLizard/Public-BO2-Mods.git synced 2025-06-08 02:58:24 -05:00
Code Issues Packages Projects Releases Wiki Activity

moving the project to its own repo

Browse Source
This commit is contained in:
JezuzLizard 2020-03-27 15:18:20 -07:00
parent 8021494436
commit 10ed027a75
37 changed files with 0 additions and 33108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/gametypes_zm/_clientids.gsc
View File

@ -1,16 +0,0 @@
init()
{
level.clientid = 0;
level thread onplayerconnect();
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player.clientid = level.clientid;
level.clientid++;
}
}

0
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/gametypes_zm/_globalentities.gsc
View File

25
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/gametypes_zm/_scoreboard.gsc
View File

@ -1,25 +0,0 @@
init()
{
setdvar( "g_ScoresColor_Spectator", ".25 .25 .25" );
setdvar( "g_ScoresColor_Free", ".76 .78 .10" );
setdvar( "g_teamColor_MyTeam", ".4 .7 .4" );
setdvar( "g_teamColor_EnemyTeam", "1 .315 0.35" );
setdvar( "g_teamColor_MyTeamAlt", ".35 1 1" );
setdvar( "g_teamColor_EnemyTeamAlt", "1 .5 0" );
setdvar( "g_teamColor_Squad", ".315 0.35 1" );
if ( level.createfx_enabled )
{
return;
}
if ( sessionmodeiszombiesgame() )
{
setdvar( "g_TeamIcon_Axis", "faction_cia" );
setdvar( "g_TeamIcon_Allies", "faction_cdc" );
}
else
{
setdvar( "g_TeamIcon_Axis", game[ "icons" ][ "axis" ] );
setdvar( "g_TeamIcon_Allies", game[ "icons" ][ "allies" ] );
}
}

65
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/gametypes_zm/_shellshock.gsc
View File

@ -1,65 +0,0 @@
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
precacheshellshock( "frag_grenade_mp" );
precacheshellshock( "damage_mp" );
precacherumble( "artillery_rumble" );
precacherumble( "grenade_rumble" );
}
shellshockondamage( cause, damage )
{
if ( cause != "MOD_EXPLOSIVE" && cause != "MOD_GRENADE" && cause != "MOD_GRENADE_SPLASH" || cause == "MOD_PROJECTILE" && cause == "MOD_PROJECTILE_SPLASH" )
{
time = 0;
if ( damage >= 90 )
{
time = 4;
}
else if ( damage >= 50 )
{
time = 3;
}
else if ( damage >= 25 )
{
time = 2;
}
else
{
if ( damage > 10 )
{
time = 2;
}
}
if ( time )
{
if ( self mayapplyscreeneffect() )
{
self shellshock( "frag_grenade_mp", 0.5 );
}
}
}
}
endondeath()
{
self waittill( "death" );
waittillframeend;
self notify( "end_explode" );
}
endontimer( timer )
{
self endon( "disconnect" );
wait timer;
self notify( "end_on_timer" );
}
rcbomb_earthquake( position )
{
playrumbleonposition( "grenade_rumble", position );
earthquake( 0.5, 0.5, self.origin, 512 );
}

2076
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/gametypes_zm/_zm_gametype.gsc
View File

File diff suppressed because it is too large Load Diff

31
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/gametypes_zm/zclassic.gsc
View File

@ -1,31 +0,0 @@
#include maps/mp/zombies/_zm_stats;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
#include maps/mp/gametypes_zm/_zm_gametype;
#include maps/mp/zombies/_zm_stats;
main()
{
maps/mp/gametypes_zm/_zm_gametype::main();
level.onprecachegametype = ::onprecachegametype;
level.onstartgametype = ::onstartgametype;
level._game_module_custom_spawn_init_func = ::custom_spawn_init_func;
level._game_module_stat_update_func = ::survival_classic_custom_stat_update;
maps/mp/gametypes_zm/_zm_gametype::post_gametype_main( "zclassic" );
}
onprecachegametype()
{
level.playersuicideallowed = 1;
level.canplayersuicide = ::canplayersuicide;
level.suicide_weapon = "death_self_zm";
precacheitem( "death_self_zm" );
maps/mp/gametypes_zm/_zm_gametype::rungametypeprecache( "zclassic" );
}
onstartgametype()
{
maps/mp/gametypes_zm/_zm_gametype::rungametypemain( "zclassic", ::zclassic_main );
}

523
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_load.gsc
View File

@ -1,523 +0,0 @@
#include maps/mp/gametypes_zm/_spawnlogic;
#include maps/mp/animscripts/traverse/shared;
#include maps/mp/animscripts/utility;
#include maps/mp/zombies/_load;
#include maps/mp/_createfx;
#include maps/mp/_music;
#include maps/mp/_busing;
#include maps/mp/_script_gen;
#include maps/mp/_utility;
#include common_scripts/utility;
main( bscriptgened, bcsvgened, bsgenabled )
{
if ( !isDefined( level.script_gen_dump_reasons ) )
{
level.script_gen_dump_reasons = [];
}
if ( !isDefined( bsgenabled ) )
{
level.script_gen_dump_reasons[ level.script_gen_dump_reasons.size ] = "First run";
}
if ( !isDefined( bcsvgened ) )
{
bcsvgened = 0;
}
level.bcsvgened = bcsvgened;
if ( !isDefined( bscriptgened ) )
{
bscriptgened = 0;
}
else
{
bscriptgened = 1;
}
level.bscriptgened = bscriptgened;
level._loadstarted = 1;
struct_class_init();
level.clientscripts = getDvar( "cg_usingClientScripts" ) != "";
level._client_exploders = [];
level._client_exploder_ids = [];
if ( !isDefined( level.flag ) )
{
level.flag = [];
level.flags_lock = [];
}
if ( !isDefined( level.timeofday ) )
{
level.timeofday = "day";
}
flag_init( "scriptgen_done" );
level.script_gen_dump_reasons = [];
if ( !isDefined( level.script_gen_dump ) )
{
level.script_gen_dump = [];
level.script_gen_dump_reasons[ 0 ] = "First run";
}
if ( !isDefined( level.script_gen_dump2 ) )
{
level.script_gen_dump2 = [];
}
if ( isDefined( level.createfxent ) && isDefined( level.script ) )
{
script_gen_dump_addline( "maps\\mp\\createfx\\" + level.script + "_fx::main();", level.script + "_fx" );
}
while ( isDefined( level.script_gen_dump_preload ) )
{
i = 0;
while ( i < level.script_gen_dump_preload.size )
{
script_gen_dump_addline( level.script_gen_dump_preload[ i ].string, level.script_gen_dump_preload[ i ].signature );
i++;
}
}
if ( getDvar( "scr_RequiredMapAspectratio" ) == "" )
{
setdvar( "scr_RequiredMapAspectratio", "1" );
}
setdvar( "r_waterFogTest", 0 );
precacherumble( "reload_small" );
precacherumble( "reload_medium" );
precacherumble( "reload_large" );
precacherumble( "reload_clipin" );
precacherumble( "reload_clipout" );
precacherumble( "reload_rechamber" );
precacherumble( "pullout_small" );
precacherumble( "buzz_high" );
precacherumble( "riotshield_impact" );
registerclientsys( "levelNotify" );
level.aitriggerspawnflags = getaitriggerflags();
level.vehicletriggerspawnflags = getvehicletriggerflags();
level.physicstracemaskphysics = 1;
level.physicstracemaskvehicle = 2;
level.physicstracemaskwater = 4;
level.physicstracemaskclip = 8;
level.physicstracecontentsvehicleclip = 16;
level.createfx_enabled = getDvar( "createfx" ) != "";
level thread start_intro_screen_zm();
thread maps/mp/_interactive_objects::init();
maps/mp/_audio::init();
thread maps/mp/_busing::businit();
thread maps/mp/_music::music_init();
thread maps/mp/_fxanim::init();
thread maps/mp/_serverfaceanim_mp::init();
if ( level.createfx_enabled )
{
setinitialplayersconnected();
}
visionsetnight( "default_night" );
setup_traversals();
maps/mp/_art::main();
setupexploders();
parse_structs();
thread footsteps();
/*
/#
level thread level_notify_listener();
level thread client_notify_listener();
#/
*/
thread maps/mp/_createfx::fx_init();
if ( level.createfx_enabled )
{
calculate_map_center();
maps/mp/_createfx::createfx();
}
if ( getDvar( "r_reflectionProbeGenerate" ) == "1" )
{
maps/mp/_global_fx::main();
level waittill( "eternity" );
}
thread maps/mp/_global_fx::main();
maps/mp/_demo::init();
p = 0;
while ( p < 6 )
{
switch( p )
{
case 0:
triggertype = "trigger_multiple";
break;
case 1:
triggertype = "trigger_once";
break;
case 2:
triggertype = "trigger_use";
break;
case 3:
triggertype = "trigger_radius";
break;
case 4:
triggertype = "trigger_lookat";
break;
default:
/*
/#
assert( p == 5 );
#/
*/
triggertype = "trigger_damage";
break;
}
triggers = getentarray( triggertype, "classname" );
i = 0;
while ( i < triggers.size )
{
if ( isDefined( triggers[ i ].script_prefab_exploder ) )
{
triggers[ i ].script_exploder = triggers[ i ].script_prefab_exploder;
}
if ( isDefined( triggers[ i ].script_exploder ) )
{
level thread maps/mp/zombies/_load::exploder_load( triggers[ i ] );
}
i++;
}
p++;
}
}
level_notify_listener()
{
while ( 1 )
{
val = getDvar( "level_notify" );
if ( val != "" )
{
level notify( val );
setdvar( "level_notify", "" );
}
wait 0.2;
}
}
client_notify_listener()
{
while ( 1 )
{
val = getDvar( "client_notify" );
if ( val != "" )
{
clientnotify( val );
setdvar( "client_notify", "" );
}
wait 0.2;
}
}
footsteps()
{
if ( is_true( level.fx_exclude_footsteps ) )
{
return;
}
maps/mp/animscripts/utility::setfootstepeffect( "asphalt", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "brick", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "carpet", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "cloth", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "concrete", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "dirt", loadfx( "bio/player/fx_footstep_sand" ) );
maps/mp/animscripts/utility::setfootstepeffect( "foliage", loadfx( "bio/player/fx_footstep_sand" ) );
maps/mp/animscripts/utility::setfootstepeffect( "gravel", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "grass", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "metal", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "mud", loadfx( "bio/player/fx_footstep_mud" ) );
maps/mp/animscripts/utility::setfootstepeffect( "paper", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "plaster", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "rock", loadfx( "bio/player/fx_footstep_dust" ) );
maps/mp/animscripts/utility::setfootstepeffect( "sand", loadfx( "bio/player/fx_footstep_sand" ) );
maps/mp/animscripts/utility::setfootstepeffect( "water", loadfx( "bio/player/fx_footstep_water" ) );
maps/mp/animscripts/utility::setfootstepeffect( "wood", loadfx( "bio/player/fx_footstep_dust" ) );
}
parse_structs()
{
i = 0;
while ( i < level.struct.size )
{
if ( isDefined( level.struct[ i ].targetname ) )
{
if ( level.struct[ i ].targetname == "flak_fire_fx" )
{
level._effect[ "flak20_fire_fx" ] = loadfx( "weapon/tracer/fx_tracer_flak_single_noExp" );
level._effect[ "flak38_fire_fx" ] = loadfx( "weapon/tracer/fx_tracer_quad_20mm_Flak38_noExp" );
level._effect[ "flak_cloudflash_night" ] = loadfx( "weapon/flak/fx_flak_cloudflash_night" );
level._effect[ "flak_burst_single" ] = loadfx( "weapon/flak/fx_flak_single_day_dist" );
}
if ( level.struct[ i ].targetname == "fake_fire_fx" )
{
level._effect[ "distant_muzzleflash" ] = loadfx( "weapon/muzzleflashes/heavy" );
}
if ( level.struct[ i ].targetname == "spotlight_fx" )
{
level._effect[ "spotlight_beam" ] = loadfx( "env/light/fx_ray_spotlight_md" );
}
}
i++;
}
}
exploder_load( trigger )
{
level endon( "killexplodertridgers" + trigger.script_exploder );
trigger waittill( "trigger" );
if ( isDefined( trigger.script_chance ) && randomfloat( 1 ) > trigger.script_chance )
{
if ( isDefined( trigger.script_delay ) )
{
wait trigger.script_delay;
}
else
{
wait 4;
}
level thread exploder_load( trigger );
return;
}
maps/mp/_utility::exploder( trigger.script_exploder );
level notify( "killexplodertridgers" + trigger.script_exploder );
}
setupexploders()
{
ents = getentarray( "script_brushmodel", "classname" );
smodels = getentarray( "script_model", "classname" );
i = 0;
while ( i < smodels.size )
{
ents[ ents.size ] = smodels[ i ];
i++;
}
i = 0;
while ( i < ents.size )
{
if ( isDefined( ents[ i ].script_prefab_exploder ) )
{
ents[ i ].script_exploder = ents[ i ].script_prefab_exploder;
}
if ( isDefined( ents[ i ].script_exploder ) )
{
if ( ents[ i ].model == "fx" || !isDefined( ents[ i ].targetname ) && ents[ i ].targetname != "exploderchunk" )
{
ents[ i ] hide();
i++;
continue;
}
else
{
if ( isDefined( ents[ i ].targetname ) && ents[ i ].targetname == "exploder" )
{
ents[ i ] hide();
ents[ i ] notsolid();
i++;
continue;
}
else
{
if ( isDefined( ents[ i ].targetname ) && ents[ i ].targetname == "exploderchunk" )
{
ents[ i ] hide();
ents[ i ] notsolid();
}
}
}
}
i++;
}
script_exploders = [];
potentialexploders = getentarray( "script_brushmodel", "classname" );
i = 0;
while ( i < potentialexploders.size )
{
if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
{
potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
}
if ( isDefined( potentialexploders[ i ].script_exploder ) )
{
script_exploders[ script_exploders.size ] = potentialexploders[ i ];
}
i++;
}
potentialexploders = getentarray( "script_model", "classname" );
i = 0;
while ( i < potentialexploders.size )
{
if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
{
potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
}
if ( isDefined( potentialexploders[ i ].script_exploder ) )
{
script_exploders[ script_exploders.size ] = potentialexploders[ i ];
}
i++;
}
potentialexploders = getentarray( "item_health", "classname" );
i = 0;
while ( i < potentialexploders.size )
{
if ( isDefined( potentialexploders[ i ].script_prefab_exploder ) )
{
potentialexploders[ i ].script_exploder = potentialexploders[ i ].script_prefab_exploder;
}
if ( isDefined( potentialexploders[ i ].script_exploder ) )
{
script_exploders[ script_exploders.size ] = potentialexploders[ i ];
}
i++;
}
if ( !isDefined( level.createfxent ) )
{
level.createfxent = [];
}
acceptabletargetnames = [];
acceptabletargetnames[ "exploderchunk visible" ] = 1;
acceptabletargetnames[ "exploderchunk" ] = 1;
acceptabletargetnames[ "exploder" ] = 1;
i = 0;
while ( i < script_exploders.size )
{
exploder = script_exploders[ i ];
ent = createexploder( exploder.script_fxid );
ent.v = [];
ent.v[ "origin" ] = exploder.origin;
ent.v[ "angles" ] = exploder.angles;
ent.v[ "delay" ] = exploder.script_delay;
ent.v[ "firefx" ] = exploder.script_firefx;
ent.v[ "firefxdelay" ] = exploder.script_firefxdelay;
ent.v[ "firefxsound" ] = exploder.script_firefxsound;
ent.v[ "firefxtimeout" ] = exploder.script_firefxtimeout;
ent.v[ "earthquake" ] = exploder.script_earthquake;
ent.v[ "damage" ] = exploder.script_damage;
ent.v[ "damage_radius" ] = exploder.script_radius;
ent.v[ "soundalias" ] = exploder.script_soundalias;
ent.v[ "repeat" ] = exploder.script_repeat;
ent.v[ "delay_min" ] = exploder.script_delay_min;
ent.v[ "delay_max" ] = exploder.script_delay_max;
ent.v[ "target" ] = exploder.target;
ent.v[ "ender" ] = exploder.script_ender;
ent.v[ "type" ] = "exploder";
if ( !isDefined( exploder.script_fxid ) )
{
ent.v[ "fxid" ] = "No FX";
}
else
{
ent.v[ "fxid" ] = exploder.script_fxid;
}
ent.v[ "exploder" ] = exploder.script_exploder;
/*
/#
assert( isDefined( exploder.script_exploder ), "Exploder at origin " + exploder.origin + " has no script_exploder" );
#/
*/
if ( !isDefined( ent.v[ "delay" ] ) )
{
ent.v[ "delay" ] = 0;
}
if ( isDefined( exploder.target ) )
{
org = getent( ent.v[ "target" ], "targetname" ).origin;
ent.v[ "angles" ] = vectorToAngles( org - ent.v[ "origin" ] );
}
if ( exploder.classname == "script_brushmodel" || isDefined( exploder.model ) )
{
ent.model = exploder;
ent.model.disconnect_paths = exploder.script_disconnectpaths;
}
if ( isDefined( exploder.targetname ) && isDefined( acceptabletargetnames[ exploder.targetname ] ) )
{
ent.v[ "exploder_type" ] = exploder.targetname;
}
else
{
ent.v[ "exploder_type" ] = "normal";
}
ent maps/mp/_createfx::post_entity_creation_function();
i++;
}
level.createfxexploders = [];
i = 0;
while ( i < level.createfxent.size )
{
ent = level.createfxent[ i ];
if ( ent.v[ "type" ] != "exploder" )
{
i++;
continue;
}
else
{
ent.v[ "exploder_id" ] = getexploderid( ent );
if ( !isDefined( level.createfxexploders[ ent.v[ "exploder" ] ] ) )
{
level.createfxexploders[ ent.v[ "exploder" ] ] = [];
}
level.createfxexploders[ ent.v[ "exploder" ] ][ level.createfxexploders[ ent.v[ "exploder" ] ].size ] = ent;
}
i++;
}
}
setup_traversals()
{
potential_traverse_nodes = getallnodes();
i = 0;
while ( i < potential_traverse_nodes.size )
{
node = potential_traverse_nodes[ i ];
if ( node.type == "Begin" )
{
node maps/mp/animscripts/traverse/shared::init_traverse();
}
i++;
}
}
calculate_map_center()
{
if ( !isDefined( level.mapcenter ) )
{
level.nodesmins = ( 0, 0, 0 );
level.nodesmaxs = ( 0, 0, 0 );
level.mapcenter = maps/mp/gametypes_zm/_spawnlogic::findboxcenter( level.nodesmins, level.nodesmaxs );
/*
/#
println( "map center: ", level.mapcenter );
#/
*/
setmapcenter( level.mapcenter );
}
}
start_intro_screen_zm()
{
if ( level.createfx_enabled )
{
return;
}
if ( !isDefined( level.introscreen ) )
{
level.introscreen = newhudelem();
level.introscreen.x = 0;
level.introscreen.y = 0;
level.introscreen.horzalign = "fullscreen";
level.introscreen.vertalign = "fullscreen";
level.introscreen.foreground = 0;
level.introscreen setshader( "black", 640, 480 );
level.introscreen.immunetodemogamehudsettings = 1;
level.introscreen.immunetodemofreecamera = 1;
wait 0.05;
}
level.introscreen.alpha = 1;
players = get_players();
i = 0;
while ( i < players.size )
{
players[ i ] freezecontrols( 1 );
i++;
}
wait 1;
}

6093
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm.gsc
View File

File diff suppressed because it is too large Load Diff

571
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_ai_basic.gsc
View File

@ -1,571 +0,0 @@
#include maps/mp/animscripts/zm_shared;
#include maps/mp/animscripts/zm_run;
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
find_flesh()
{
self endon( "death" );
level endon( "intermission" );
self endon( "stop_find_flesh" );
if ( level.intermission )
{
return;
}
self.ai_state = "find_flesh";
self.helitarget = 1;
self.ignoreme = 0;
self.nododgemove = 1;
self.ignore_player = [];
self maps/mp/zombies/_zm_spawner::zombie_history( "find flesh -> start" );
self.goalradius = 32;
if ( isDefined( self.custom_goalradius_override ) )
{
self.goalradius = self.custom_goalradius_override;
}
while ( 1 )
{
zombie_poi = undefined;
if ( isDefined( level.zombietheaterteleporterseeklogicfunc ) )
{
self [[ level.zombietheaterteleporterseeklogicfunc ]]();
}
if ( isDefined( level._poi_override ) )
{
zombie_poi = self [[ level._poi_override ]]();
}
if ( !isDefined( zombie_poi ) )
{
zombie_poi = self get_zombie_point_of_interest( self.origin );
}
players = get_players();
if ( !isDefined( self.ignore_player ) || players.size == 1 )
{
self.ignore_player = [];
}
else
{
while ( !isDefined( level._should_skip_ignore_player_logic ) || !( [[ level._should_skip_ignore_player_logic ]]() ) )
{
i = 0;
while ( i < self.ignore_player.size )
{
while ( isDefined( self.ignore_player[ i ] ) && isDefined( self.ignore_player[ i ].ignore_counter ) && self.ignore_player[ i ].ignore_counter > 3 )
{
self.ignore_player[ i ].ignore_counter = 0;
self.ignore_player = arrayremovevalue( self.ignore_player, self.ignore_player[ i ] );
if ( !isDefined( self.ignore_player ) )
{
self.ignore_player = [];
}
i = 0;
}
i++;
}
}
}
player = get_closest_valid_player( self.origin, self.ignore_player );
while ( !isDefined( player ) && !isDefined( zombie_poi ) )
{
self maps/mp/zombies/_zm_spawner::zombie_history( "find flesh -> can't find player, continue" );
if ( isDefined( self.ignore_player ) )
{
while ( isDefined( level._should_skip_ignore_player_logic ) && [[ level._should_skip_ignore_player_logic ]]() )
{
wait 1;
}
self.ignore_player = [];
}
wait 1;
}
if ( !isDefined( level.check_for_alternate_poi ) || !( [[ level.check_for_alternate_poi ]]() ) )
{
self.enemyoverride = zombie_poi;
self.favoriteenemy = player;
}
self thread zombie_pathing();
while ( players.size > 1 )
{
i = 0;
while ( i < self.ignore_player.size )
{
if ( isDefined( self.ignore_player[ i ] ) )
{
if ( !isDefined( self.ignore_player[ i ].ignore_counter ) )
{
self.ignore_player[ i ].ignore_counter = 0;
i++;
continue;
}
else
{
self.ignore_player[ i ].ignore_counter += 1;
}
}
i++;
}
}
self thread attractors_generated_listener();
if ( isDefined( level._zombie_path_timer_override ) )
{
self.zombie_path_timer = [[ level._zombie_path_timer_override ]]();
}
else
{
self.zombie_path_timer = getTime() + ( randomfloatrange( 1, 3 ) * 1000 );
}
while ( getTime() < self.zombie_path_timer )
{
wait 0.1;
}
self notify( "path_timer_done" );
self maps/mp/zombies/_zm_spawner::zombie_history( "find flesh -> bottom of loop" );
debug_print( "Zombie is re-acquiring enemy, ending breadcrumb search" );
self notify( "zombie_acquire_enemy" );
}
}
init_inert_zombies()
{
level init_inert_substates();
}
init_inert_substates()
{
level.inert_substates = [];
level.inert_substates[ level.inert_substates.size ] = "inert1";
level.inert_substates[ level.inert_substates.size ] = "inert2";
level.inert_substates[ level.inert_substates.size ] = "inert3";
level.inert_substates[ level.inert_substates.size ] = "inert4";
level.inert_substates[ level.inert_substates.size ] = "inert5";
level.inert_substates[ level.inert_substates.size ] = "inert6";
level.inert_substates[ level.inert_substates.size ] = "inert7";
level.inert_substates = array_randomize( level.inert_substates );
level.inert_substate_index = 0;
level.inert_trans_walk = [];
level.inert_trans_walk[ level.inert_trans_walk.size ] = "inert_2_walk_1";
level.inert_trans_walk[ level.inert_trans_walk.size ] = "inert_2_walk_2";
level.inert_trans_walk[ level.inert_trans_walk.size ] = "inert_2_walk_3";
level.inert_trans_walk[ level.inert_trans_walk.size ] = "inert_2_walk_4";
level.inert_trans_run = [];
level.inert_trans_run[ level.inert_trans_run.size ] = "inert_2_run_1";
level.inert_trans_run[ level.inert_trans_run.size ] = "inert_2_run_2";
level.inert_trans_sprint = [];
level.inert_trans_sprint[ level.inert_trans_sprint.size ] = "inert_2_sprint_1";
level.inert_trans_sprint[ level.inert_trans_sprint.size ] = "inert_2_sprint_2";
level.inert_crawl_substates = [];
level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert1";
level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert2";
level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert3";
level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert4";
level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert5";
level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert6";
level.inert_crawl_substates[ level.inert_crawl_substates.size ] = "inert7";
level.inert_crawl_trans_walk = [];
level.inert_crawl_trans_walk[ level.inert_crawl_trans_walk.size ] = "inert_2_walk_1";
level.inert_crawl_trans_run = [];
level.inert_crawl_trans_run[ level.inert_crawl_trans_run.size ] = "inert_2_run_1";
level.inert_crawl_trans_run[ level.inert_crawl_trans_run.size ] = "inert_2_run_2";
level.inert_crawl_trans_sprint = [];
level.inert_crawl_trans_sprint[ level.inert_crawl_trans_sprint.size ] = "inert_2_sprint_1";
level.inert_crawl_trans_sprint[ level.inert_crawl_trans_sprint.size ] = "inert_2_sprint_2";
level.inert_crawl_substates = array_randomize( level.inert_crawl_substates );
level.inert_crawl_substate_index = 0;
}
get_inert_substate()
{
substate = level.inert_substates[ level.inert_substate_index ];
level.inert_substate_index++;
if ( level.inert_substate_index >= level.inert_substates.size )
{
level.inert_substates = array_randomize( level.inert_substates );
level.inert_substate_index = 0;
}
return substate;
}
get_inert_crawl_substate()
{
substate = level.inert_crawl_substates[ level.inert_crawl_substate_index ];
level.inert_crawl_substate_index++;
if ( level.inert_crawl_substate_index >= level.inert_crawl_substates.size )
{
level.inert_crawl_substates = array_randomize( level.inert_crawl_substates );
level.inert_crawl_substate_index = 0;
}
return substate;
}
start_inert( in_place )
{
self endon( "death" );
if ( isDefined( self.is_inert ) && self.is_inert )
{
self maps/mp/zombies/_zm_spawner::zombie_history( "is_inert already set " + getTime() );
return;
}
self.is_inert = 1;
self notify( "start_inert" );
self maps/mp/zombies/_zm_spawner::zombie_eye_glow_stop();
self maps/mp/zombies/_zm_spawner::zombie_history( "is_inert set " + getTime() );
self playsound( "zmb_zombie_go_inert" );
if ( isDefined( self.barricade_enter ) && self.barricade_enter )
{
while ( isDefined( self.barricade_enter ) && self.barricade_enter )
{
wait 0.1;
}
}
else if ( isDefined( self.ai_state ) && self.ai_state == "zombie_goto_entrance" )
{
self notify( "stop_zombie_goto_entrance" );
self maps/mp/zombies/_zm_spawner::reset_attack_spot();
}
if ( isDefined( self.completed_emerging_into_playable_area ) && self.completed_emerging_into_playable_area )
{
self notify( "stop_find_flesh" );
self notify( "zombie_acquire_enemy" );
}
else
{
in_place = 1;
}
if ( isDefined( self.in_the_ground ) && self.in_the_ground )
{
self waittill( "risen", find_flesh_struct_string );
if ( self maps/mp/zombies/_zm_spawner::should_skip_teardown( find_flesh_struct_string ) )
{
if ( isDefined( self.completed_emerging_into_playable_area ) && !self.completed_emerging_into_playable_area )
{
self waittill( "completed_emerging_into_playable_area" );
}
self notify( "stop_find_flesh" );
self notify( "zombie_acquire_enemy" );
}
}
while ( isDefined( self.is_traversing ) && self.is_traversing )
{
while ( self isinscriptedstate() )
{
wait 0,1;
}
}
if ( isDefined( self.doing_equipment_attack ) && self.doing_equipment_attack )
{
self stopanimscripted();
}
if ( isDefined( self.inert_delay ) )
{
self [[ self.inert_delay ]]();
self maps/mp/zombies/_zm_spawner::zombie_history( "inert_delay done " + getTime() );
}
self inert_think( in_place );
}
inert_think( in_place )
{
self endon( "death" );
self.ignoreall = 1;
self animmode( "normal" );
if ( self.has_legs )
{
if ( isDefined( in_place ) && in_place )
{
self setgoalpos( self.origin );
if ( randomint( 100 ) > 50 )
{
self maps/mp/zombies/_zm_spawner::zombie_history( "inert 1 " + getTime() );
self setanimstatefromasd( "zm_inert", "inert1" );
}
else
{
self maps/mp/zombies/_zm_spawner::zombie_history( "inert 2 " + getTime() );
self setanimstatefromasd( "zm_inert", "inert2" );
}
self.in_place = 1;
}
else
{
substate = get_inert_substate();
if ( isDefined( level.inert_substate_override ) )
{
substate = self [[ level.inert_substate_override ]]( substate );
}
self setanimstatefromasd( "zm_inert", substate );
self maps/mp/zombies/_zm_spawner::zombie_history( "zm_inert ASD " + getTime() );
if ( substate != "inert3" && substate != "inert4" || substate == "inert5" && substate == "inert6" )
{
self thread inert_watch_goal();
}
else
{
self.in_place = 1;
}
}
}
else
{
self setanimstatefromasd( "zm_inert_crawl", get_inert_crawl_substate() );
self maps/mp/zombies/_zm_spawner::zombie_history( "zm_inert_crawl ASD " + getTime() );
}
self thread inert_wakeup();
self waittill( "stop_zombie_inert" );
self maps/mp/zombies/_zm_spawner::zombie_history( "stop_zombie_inert " + getTime() );
self playsound( "zmb_zombie_end_inert" );
self inert_transition();
self maps/mp/zombies/_zm_spawner::zombie_history( "inert transition done" );
if ( isDefined( self.ai_state ) && self.ai_state == "zombie_goto_entrance" )
{
self thread maps/mp/zombies/_zm_spawner::zombie_goto_entrance( self.first_node );
}
if ( isDefined( self.inert_wakeup_override ) )
{
self [[ self.inert_wakeup_override ]]();
}
else
{
if ( isDefined( self.completed_emerging_into_playable_area ) && self.completed_emerging_into_playable_area )
{
self.ignoreall = 0;
if ( isDefined( level.ignore_find_flesh ) && !( self [[ level.ignore_find_flesh ]]() ) )
{
self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
}
}
}
self.becoming_inert = undefined;
self.is_inert = undefined;
self.in_place = undefined;
self maps/mp/animscripts/zm_run::needsupdate();
self maps/mp/zombies/_zm_spawner::zombie_history( "is_inert cleared " + getTime() );
}
inert_watch_goal()
{
self endon( "death" );
self endon( "stop_zombie_inert" );
while ( 1 )
{
self waittill( "goal" );
locs = array_randomize( level.enemy_dog_locations );
_a481 = locs;
_k481 = getFirstArrayKey( _a481 );
while ( isDefined( _k481 ) )
{
loc = _a481[ _k481 ];
dist_sq = distancesquared( self.origin, loc.origin );
if ( dist_sq > 90000 )
{
self setgoalpos( loc.origin );
break;
}
_k481 = getNextArrayKey( _a481, _k481 );
}
if ( locs.size > 0 )
{
self setgoalpos( locs[ 0 ].origin );
}
}
}
inert_wakeup()
{
self endon( "death" );
self endon( "stop_zombie_inert" );
wait 0.1;
self thread inert_damage();
self thread inert_bump();
while ( 1 )
{
current_time = getTime();
players = get_players();
_a522 = players;
_k522 = getFirstArrayKey( _a522 );
while ( isDefined( _k522 ) )
{
player = _a522[ _k522 ];
dist_sq = distancesquared( self.origin, player.origin );
if ( dist_sq < 4096 )
{
self stop_inert();
return;
}
if ( dist_sq < 360000 )
{
if ( player issprinting() )
{
self stop_inert();
return;
}
}
if ( dist_sq < 5760000 )
{
if ( ( current_time - player.lastfiretime ) < 100 )
{
self stop_inert();
return;
}
}
_k522 = getNextArrayKey( _a522, _k522 );
}
wait 0.1;
}
}
inert_bump()
{
self endon( "death" );
self endon( "stop_zombie_inert" );
while ( 1 )
{
zombies = getaiarray( level.zombie_team );
_a562 = zombies;
_k562 = getFirstArrayKey( _a562 );
while ( isDefined( _k562 ) )
{
zombie = _a562[ _k562 ];
if ( zombie == self )
{
}
else if ( isDefined( zombie.is_inert ) && zombie.is_inert )
{
}
else
{
if ( isDefined( zombie.becoming_inert ) && zombie.becoming_inert )
{
break;
}
else
{
dist_sq = distancesquared( self.origin, zombie.origin );
if ( dist_sq < 1296 )
{
self stop_inert();
return;
}
}
}
_k562 = getNextArrayKey( _a562, _k562 );
}
wait 0.2;
}
}
inert_damage()
{
self endon( "death" );
self endon( "stop_zombie_inert" );
while ( 1 )
{
self waittill( "damage", amount, inflictor, direction, point, type, tagname, modelname, partname, weaponname, idflags );
while ( weaponname == "emp_grenade_zm" )
{
continue;
}
while ( isDefined( inflictor ) )
{
if ( isDefined( inflictor._trap_type ) && inflictor._trap_type == "fire" )
{
continue;
}
}
}
self stop_inert();
}
grenade_watcher( grenade )
{
grenade waittill( "explode", grenade_origin );
zombies = get_array_of_closest( grenade_origin, get_round_enemy_array(), undefined, undefined, 2400 );
if ( !isDefined( zombies ) )
{
return;
}
_a633 = zombies;
_k633 = getFirstArrayKey( _a633 );
while ( isDefined( _k633 ) )
{
zombie = _a633[ _k633 ];
zombie stop_inert();
_k633 = getNextArrayKey( _a633, _k633 );
}
}
stop_inert()
{
self notify( "stop_zombie_inert" );
}
inert_transition()
{
self endon( "death" );
self endon( "stop_zombie_inert_transition" );
trans_num = 4;
trans_set = level.inert_trans_walk;
animstate = "zm_inert_trans";
if ( !self.has_legs )
{
trans_num = 1;
trans_set = level.inert_crawl_trans_walk;
animstate = "zm_inert_crawl_trans";
}
if ( self.zombie_move_speed == "run" )
{
if ( self.has_legs )
{
trans_set = level.inert_trans_run;
}
else
{
trans_set = level.inert_crawl_trans_run;
}
trans_num = 2;
}
else
{
if ( self.zombie_move_speed == "sprint" )
{
if ( self.has_legs )
{
trans_set = level.inert_trans_sprint;
}
else
{
trans_set = level.inert_crawl_trans_sprint;
}
trans_num = 2;
}
}
self thread inert_eye_glow();
self setanimstatefromasd( animstate, trans_set[ randomint( trans_num ) ] );
self maps/mp/zombies/_zm_spawner::zombie_history( "inert_trans_anim " + getTime() );
maps/mp/animscripts/zm_shared::donotetracks( "inert_trans_anim" );
}
inert_eye_glow()
{
self endon( "death" );
while ( 1 )
{
self waittill( "inert_trans_anim", note );
if ( note == "end" )
{
return;
continue;
}
else
{
if ( note == "zmb_awaken" )
{
self maps/mp/zombies/_zm_spawner::zombie_eye_glow();
return;
}
}
}
}

742
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_ai_dogs.gsc
View File

@ -1,742 +0,0 @@
#include maps/mp/zombies/_zm_net;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm;
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
level.dogs_enabled = 1;
level.dog_rounds_enabled = 0;
level.dog_round_count = 1;
level.dog_spawners = [];
level.enemy_dog_spawns = [];
level.enemy_dog_locations = [];
flag_init( "dog_clips" );
precacherumble( "explosion_generic" );
precacheshellshock( "dog_bite" );
if ( getDvar( "zombie_dog_animset" ) == "" )
{
setdvar( "zombie_dog_animset", "zombie" );
}
if ( getDvar( "scr_dog_health_walk_multiplier" ) == "" )
{
setdvar( "scr_dog_health_walk_multiplier", "4.0" );
}
if ( getDvar( "scr_dog_run_distance" ) == "" )
{
setdvar( "scr_dog_run_distance", "500" );
}
level.melee_range_sav = getDvar( "ai_meleeRange" );
level.melee_width_sav = getDvar( "ai_meleeWidth" );
level.melee_height_sav = getDvar( "ai_meleeHeight" );
setdvar( "dog_MeleeDamage", "100" );
set_zombie_var( "dog_fire_trail_percent", 50 );
level._effect[ "lightning_dog_spawn" ] = loadfx( "maps/zombie/fx_zombie_dog_lightning_buildup" );
level._effect[ "dog_eye_glow" ] = loadfx( "maps/zombie/fx_zombie_dog_eyes" );
level._effect[ "dog_gib" ] = loadfx( "maps/zombie/fx_zombie_dog_explosion" );
level._effect[ "dog_trail_fire" ] = loadfx( "maps/zombie/fx_zombie_dog_fire_trail" );
level._effect[ "dog_trail_ash" ] = loadfx( "maps/zombie/fx_zombie_dog_ash_trail" );
dog_spawner_init();
level thread dog_clip_monitor();
}
enable_dog_rounds()
{
level.dog_rounds_enabled = 1;
if ( !isDefined( level.dog_round_track_override ) )
{
level.dog_round_track_override = ::dog_round_tracker;
}
level thread [[ level.dog_round_track_override ]]();
}
dog_spawner_init()
{
level.dog_spawners = getentarray( "zombie_dog_spawner", "script_noteworthy" );
later_dogs = getentarray( "later_round_dog_spawners", "script_noteworthy" );
level.dog_spawners = arraycombine( level.dog_spawners, later_dogs, 1, 0 );
if ( level.dog_spawners.size == 0 )
{
return;
}
i = 0;
while ( i < level.dog_spawners.size )
{
if ( maps/mp/zombies/_zm_spawner::is_spawner_targeted_by_blocker( level.dog_spawners[ i ] ) )
{
level.dog_spawners[ i ].is_enabled = 0;
i++;
continue;
}
else
{
level.dog_spawners[ i ].is_enabled = 1;
level.dog_spawners[ i ].script_forcespawn = 1;
}
i++;
}
level.dog_health = 100;
array_thread( level.dog_spawners, ::add_spawn_function, ::dog_init );
level.enemy_dog_spawns = getentarray( "zombie_spawner_dog_init", "targetname" );
}
dog_round_spawning()
{
level endon( "intermission" );
level.dog_targets = getplayers();
i = 0;
while ( i < level.dog_targets.size )
{
level.dog_targets[ i ].hunted_by = 0;
i++;
}
if ( level.intermission )
{
return;
}
level.dog_intermission = 1;
level thread dog_round_aftermath();
players = get_players();
array_thread( players, ::play_dog_round );
wait 1;
playsoundatposition( "vox_zmba_event_dogstart_0", ( 0, 0, 0 ) );
wait 6;
if ( level.dog_round_count < 3 )
{
max = players.size * 6;
}
else
{
max = players.size * 8;
}
level.zombie_total = max;
dog_health_increase();
count = 0;
while ( count < max )
{
num_player_valid = get_number_of_valid_players();
while ( get_current_zombie_count() >= ( num_player_valid * 2 ) )
{
wait 2;
num_player_valid = get_number_of_valid_players();
}
players = get_players();
favorite_enemy = get_favorite_enemy();
if ( isDefined( level.dog_spawn_func ) )
{
spawn_loc = [[ level.dog_spawn_func ]]( level.dog_spawners, favorite_enemy );
ai = spawn_zombie( level.dog_spawners[ 0 ] );
if ( isDefined( ai ) )
{
ai.favoriteenemy = favorite_enemy;
spawn_loc thread dog_spawn_fx( ai, spawn_loc );
level.zombie_total--;
count++;
}
}
else
{
spawn_point = dog_spawn_factory_logic( level.enemy_dog_spawns, favorite_enemy );
ai = spawn_zombie( level.dog_spawners[ 0 ] );
if ( isDefined( ai ) )
{
ai.favoriteenemy = favorite_enemy;
spawn_point thread dog_spawn_fx( ai, spawn_point );
level.zombie_total--;
count++;
flag_set( "dog_clips" );
}
}
waiting_for_next_dog_spawn( count, max );
}
}
waiting_for_next_dog_spawn( count, max )
{
default_wait = 1.5;
if ( level.dog_round_count == 1 )
{
default_wait = 3;
}
else if ( level.dog_round_count == 2 )
{
default_wait = 2.5;
}
else if ( level.dog_round_count == 3 )
{
default_wait = 2;
}
else
{
default_wait = 1.5;
}
default_wait -= count / max;
wait default_wait;
}
dog_round_aftermath()
{
level waittill( "last_dog_down" );
level thread maps/mp/zombies/_zm_audio::change_zombie_music( "dog_end" );
power_up_origin = level.last_dog_origin;
if ( isDefined( power_up_origin ) )
{
level thread maps/mp/zombies/_zm_powerups::specific_powerup_drop( "full_ammo", power_up_origin );
}
wait 2;
clientnotify( "dog_stop" );
wait 6;
level.dog_intermission = 0;
}
dog_spawn_fx( ai, ent )
{
ai endon( "death" );
ai setfreecameralockonallowed( 0 );
playfx( level._effect[ "lightning_dog_spawn" ], ent.origin );
playsoundatposition( "zmb_hellhound_prespawn", ent.origin );
wait 1.5;
playsoundatposition( "zmb_hellhound_bolt", ent.origin );
earthquake( 0.5, 0.75, ent.origin, 1000 );
playrumbleonposition( "explosion_generic", ent.origin );
playsoundatposition( "zmb_hellhound_spawn", ent.origin );
angle = vectorToAngles( ai.favoriteenemy.origin - ent.origin );
angles = ( ai.angles[ 0 ], angle[ 1 ], ai.angles[ 2 ] );
ai forceteleport( ent.origin, angles );
ai zombie_setup_attack_properties_dog();
ai stop_magic_bullet_shield();
wait 0.1;
ai show();
ai setfreecameralockonallowed( 1 );
ai.ignoreme = 0;
ai notify( "visible" );
}
dog_spawn_sumpf_logic( dog_array, favorite_enemy )
{
dog_array = array_randomize( dog_array );
i = 0;
while ( i < dog_array.size )
{
if ( isDefined( level.old_dog_spawn ) && level.old_dog_spawn == dog_array[ i ] )
{
i++;
continue;
}
else
{
if ( distancesquared( dog_array[ i ].origin, favorite_enemy.origin ) > 160000 && distancesquared( dog_array[ i ].origin, favorite_enemy.origin ) < 640000 )
{
if ( distancesquared( ( 0, 0, dog_array[ i ].origin[ 2 ] ), ( 0, 0, favorite_enemy.origin[ 2 ] ) ) > 10000 )
{
i++;
continue;
}
else level.old_dog_spawn = dog_array[ i ];
return dog_array[ i ];
}
}
i++;
}
return dog_array[ 0 ];
}
dog_spawn_factory_logic( dog_array, favorite_enemy )
{
dog_locs = array_randomize( level.enemy_dog_locations );
i = 0;
while ( i < dog_locs.size )
{
if ( isDefined( level.old_dog_spawn ) && level.old_dog_spawn == dog_locs[ i ] )
{
i++;
continue;
}
else
{
dist_squared = distancesquared( dog_locs[ i ].origin, favorite_enemy.origin );
if ( dist_squared > 160000 && dist_squared < 1000000 )
{
level.old_dog_spawn = dog_locs[ i ];
return dog_locs[ i ];
}
}
i++;
}
return dog_locs[ 0 ];
}
get_favorite_enemy()
{
dog_targets = getplayers();
least_hunted = dog_targets[ 0 ];
i = 0;
while ( i < dog_targets.size )
{
if ( !isDefined( dog_targets[ i ].hunted_by ) )
{
dog_targets[ i ].hunted_by = 0;
}
if ( !is_player_valid( dog_targets[ i ] ) )
{
i++;
continue;
}
else
{
if ( !is_player_valid( least_hunted ) )
{
least_hunted = dog_targets[ i ];
}
if ( dog_targets[ i ].hunted_by < least_hunted.hunted_by )
{
least_hunted = dog_targets[ i ];
}
}
i++;
}
least_hunted.hunted_by += 1;
return least_hunted;
}
dog_health_increase()
{
players = getplayers();
if ( level.dog_round_count == 1 )
{
level.dog_health = 400;
}
else if ( level.dog_round_count == 2 )
{
level.dog_health = 900;
}
else if ( level.dog_round_count == 3 )
{
level.dog_health = 1300;
}
else
{
if ( level.dog_round_count == 4 )
{
level.dog_health = 1600;
}
}
if ( level.dog_health > 1600 )
{
level.dog_health = 1600;
}
}
dog_round_tracker()
{
level.dog_round_count = 1;
level.next_dog_round = level.round_number + randomintrange( 4, 7 );
old_spawn_func = level.round_spawn_func;
old_wait_func = level.round_wait_func;
while ( 1 )
{
level waittill( "between_round_over" );
if ( level.round_number == level.next_dog_round )
{
level.music_round_override = 1;
old_spawn_func = level.round_spawn_func;
old_wait_func = level.round_wait_func;
dog_round_start();
level.round_spawn_func = ::dog_round_spawning;
level.next_dog_round = level.round_number + randomintrange( 4, 6 );
continue;
}
else
{
if ( flag( "dog_round" ) )
{
dog_round_stop();
level.round_spawn_func = old_spawn_func;
level.round_wait_func = old_wait_func;
level.music_round_override = 0;
level.dog_round_count += 1;
}
}
}
}
dog_round_start()
{
flag_set( "dog_round" );
flag_set( "dog_clips" );
level thread maps/mp/zombies/_zm_audio::change_zombie_music( "dog_start" );
if ( !isDefined( level.doground_nomusic ) )
{
level.doground_nomusic = 0;
}
level.doground_nomusic = 1;
level notify( "dog_round_starting" );
clientnotify( "dog_start" );
if ( isDefined( level.dog_melee_range ) )
{
setdvar( "ai_meleeRange", level.dog_melee_range );
}
else
{
setdvar( "ai_meleeRange", 100 );
}
}
dog_round_stop()
{
flag_clear( "dog_round" );
flag_clear( "dog_clips" );
if ( !isDefined( level.doground_nomusic ) )
{
level.doground_nomusic = 0;
}
level.doground_nomusic = 0;
level notify( "dog_round_ending" );
clientnotify( "dog_stop" );
setdvar( "ai_meleeRange", level.melee_range_sav );
setdvar( "ai_meleeWidth", level.melee_width_sav );
setdvar( "ai_meleeHeight", level.melee_height_sav );
}
play_dog_round()
{
self playlocalsound( "zmb_dog_round_start" );
variation_count = 5;
wait 4.5;
players = getplayers();
num = randomintrange( 0, players.size );
players[ num ] maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "dog_spawn" );
}
dog_init()
{
self.targetname = "zombie_dog";
self.script_noteworthy = undefined;
self.animname = "zombie_dog";
self.ignoreall = 1;
self.ignoreme = 1;
self.allowdeath = 1;
self.allowpain = 0;
self.force_gib = 1;
self.is_zombie = 1;
self.has_legs = 1;
self.gibbed = 0;
self.head_gibbed = 0;
self.default_goalheight = 40;
self.ignore_inert = 1;
self.grenadeawareness = 0;
self.badplaceawareness = 0;
self.ignoresuppression = 1;
self.suppressionthreshold = 1;
self.nododgemove = 1;
self.dontshootwhilemoving = 1;
self.pathenemylookahead = 0;
self.badplaceawareness = 0;
self.chatinitialized = 0;
self.team = level.zombie_team;
health_multiplier = 1;
if ( getDvar( "scr_dog_health_walk_multiplier" ) != "" )
{
health_multiplier = getDvarFloat( "scr_dog_health_walk_multiplier" );
}
self.maxhealth = int( level.dog_health * health_multiplier );
self.health = int( level.dog_health * health_multiplier );
self.freezegun_damage = 0;
self.zombie_move_speed = "sprint";
self thread dog_run_think();
self thread dog_stalk_audio();
self thread maps/mp/zombies/_zm::round_spawn_failsafe();
self ghost();
self thread magic_bullet_shield();
self dog_fx_eye_glow();
self dog_fx_trail();
self thread dog_death();
level thread maps/mp/zombies/_zm_spawner::zombie_death_event( self );
self thread maps/mp/zombies/_zm_spawner::enemy_death_detection();
self.a.disablepain = 1;
self disable_react();
self clearenemy();
self cleargoalvolume();
self.flame_damage_time = 0;
self.meleedamage = 40;
self.thundergun_knockdown_func = ::dog_thundergun_knockdown;
self maps/mp/zombies/_zm_spawner::zombie_history( "zombie_dog_spawn_init -> Spawned = " + self.origin );
if ( isDefined( level.achievement_monitor_func ) )
{
self [[ level.achievement_monitor_func ]]();
}
}
dog_fx_eye_glow()
{
self.fx_dog_eye = spawn( "script_model", self gettagorigin( "J_EyeBall_LE" ) );
self.fx_dog_eye.angles = self gettagangles( "J_EyeBall_LE" );
self.fx_dog_eye setmodel( "tag_origin" );
self.fx_dog_eye linkto( self, "J_EyeBall_LE" );
}
dog_fx_trail()
{
if ( !is_mature() || randomint( 100 ) > level.zombie_vars[ "dog_fire_trail_percent" ] )
{
self.fx_dog_trail_type = level._effect[ "dog_trail_ash" ];
self.fx_dog_trail_sound = "zmb_hellhound_loop_breath";
}
else
{
self.a.nodeath = 1;
self.fx_dog_trail_type = level._effect[ "dog_trail_fire" ];
self.fx_dog_trail_sound = "zmb_hellhound_loop_fire";
}
self.fx_dog_trail = spawn( "script_model", self gettagorigin( "tag_origin" ) );
self.fx_dog_trail.angles = self gettagangles( "tag_origin" );
self.fx_dog_trail setmodel( "tag_origin" );
self.fx_dog_trail linkto( self, "tag_origin" );
}
dog_death()
{
self waittill( "death" );
if ( get_current_zombie_count() == 0 && level.zombie_total == 0 )
{
level.last_dog_origin = self.origin;
level notify( "last_dog_down" );
}
if ( isplayer( self.attacker ) )
{
event = "death";
if ( issubstr( self.damageweapon, "knife_ballistic_" ) )
{
event = "ballistic_knife_death";
}
self.attacker maps/mp/zombies/_zm_score::player_add_points( event, self.damagemod, self.damagelocation, 1 );
if ( randomintrange( 0, 100 ) >= 80 )
{
self.attacker maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "hellhound" );
}
self.attacker maps/mp/zombies/_zm_stats::increment_client_stat( "zdogs_killed" );
self.attacker maps/mp/zombies/_zm_stats::increment_player_stat( "zdogs_killed" );
}
if ( isDefined( self.attacker ) && isai( self.attacker ) )
{
self.attacker notify( "killed" );
}
self stoploopsound();
self.fx_dog_trail delete();
if ( isDefined( self.a.nodeath ) )
{
level thread dog_explode_fx( self.origin );
self delete();
}
else
{
self playsound( "zmb_hellhound_vocals_death" );
}
}
dog_explode_fx( origin )
{
playfx( level._effect[ "dog_gib" ], origin );
playsoundatposition( "zmb_hellhound_explode", origin );
}
zombie_setup_attack_properties_dog()
{
self maps/mp/zombies/_zm_spawner::zombie_history( "zombie_setup_attack_properties()" );
self thread dog_behind_audio();
self.ignoreall = 0;
self.pathenemyfightdist = 64;
self.meleeattackdist = 64;
self.disablearrivals = 1;
self.disableexits = 1;
}
stop_dog_sound_on_death()
{
self waittill( "death" );
self stopsounds();
}
dog_behind_audio()
{
self thread stop_dog_sound_on_death();
self endon( "death" );
self waittill_any( "dog_running", "dog_combat" );
self playsound( "zmb_hellhound_vocals_close" );
wait 3;
while ( 1 )
{
players = get_players();
i = 0;
while ( i < players.size )
{
vectorAngle = vectorToAngles( self.origin - players[ i ].origin );
dogangle = AbsAngleClamp180( vectorAngle[ 1 ] - players[ i ].angles[ 1 ] );
if ( isalive( players[ i ] ) && !isDefined( players[ i ].revivetrigger ) )
{
if ( Abs( dogangle ) > 90 && distance2d( self.origin, players[ i ].origin ) > 100 )
{
self playsound( "zmb_hellhound_vocals_close" );
wait 3;
}
}
i++;
}
wait 0.75;
}
}
dog_clip_monitor()
{
clips_on = 0;
level.dog_clips = getentarray( "dog_clips", "targetname" );
while ( 1 )
{
i = 0;
while ( i < level.dog_clips.size )
{
level.dog_clips[ i ] trigger_off();
level.dog_clips[ i ] connectpaths();
i++;
}
flag_wait( "dog_clips" );
if ( isDefined( level.no_dog_clip ) && level.no_dog_clip == 1 )
{
return;
}
i = 0;
while ( i < level.dog_clips.size )
{
level.dog_clips[ i ] trigger_on();
level.dog_clips[ i ] disconnectpaths();
wait_network_frame();
i++;
}
dog_is_alive = 1;
while ( dog_is_alive || flag( "dog_round" ) )
{
dog_is_alive = 0;
dogs = getentarray( "zombie_dog", "targetname" );
i = 0;
while ( i < dogs.size )
{
if ( isalive( dogs[ i ] ) )
{
dog_is_alive = 1;
}
i++;
}
wait 1;
}
flag_clear( "dog_clips" );
wait 1;
}
}
special_dog_spawn( spawners, num_to_spawn )
{
dogs = getaispeciesarray( "all", "zombie_dog" );
if ( isDefined( dogs ) && dogs.size >= 9 )
{
return 0;
}
if ( !isDefined( num_to_spawn ) )
{
num_to_spawn = 1;
}
spawn_point = undefined;
count = 0;
while ( count < num_to_spawn )
{
players = get_players();
favorite_enemy = get_favorite_enemy();
if ( isDefined( spawners ) )
{
spawn_point = spawners[ randomint( spawners.size ) ];
ai = spawn_zombie( spawn_point );
if ( isDefined( ai ) )
{
ai.favoriteenemy = favorite_enemy;
spawn_point thread dog_spawn_fx( ai );
count++;
flag_set( "dog_clips" );
}
}
else if ( isDefined( level.dog_spawn_func ) )
{
spawn_loc = [[ level.dog_spawn_func ]]( level.dog_spawners, favorite_enemy );
ai = spawn_zombie( level.dog_spawners[ 0 ] );
if ( isDefined( ai ) )
{
ai.favoriteenemy = favorite_enemy;
spawn_loc thread dog_spawn_fx( ai, spawn_loc );
count++;
flag_set( "dog_clips" );
}
}
else
{
spawn_point = dog_spawn_factory_logic( level.enemy_dog_spawns, favorite_enemy );
ai = spawn_zombie( level.dog_spawners[ 0 ] );
if ( isDefined( ai ) )
{
ai.favoriteenemy = favorite_enemy;
spawn_point thread dog_spawn_fx( ai, spawn_point );
count++;
flag_set( "dog_clips" );
}
}
waiting_for_next_dog_spawn( count, num_to_spawn );
}
return 1;
}
dog_run_think()
{
self endon( "death" );
self waittill( "visible" );
if ( self.health > level.dog_health )
{
self.maxhealth = level.dog_health;
self.health = level.dog_health;
}
maps/mp/zombies/_zm_net::network_safe_play_fx_on_tag( "dog_fx", 2, self.fx_dog_trail_type, self.fx_dog_trail, "tag_origin" );
self playloopsound( self.fx_dog_trail_sound );
while ( 1 )
{
if ( !is_player_valid( self.favoriteenemy ) )
{
self.favoriteenemy = get_favorite_enemy();
}
wait 0.2;
}
}
dog_stalk_audio()
{
self endon( "death" );
self endon( "dog_running" );
self endon( "dog_combat" );
while ( 1 )
{
self playsound( "zmb_hellhound_vocals_amb" );
wait randomfloatrange( 3, 6 );
}
}
dog_thundergun_knockdown( player, gib )
{
self endon( "death" );
damage = int( self.maxhealth * 0.5 );
self dodamage( damage, player.origin, player );
}

642
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_ai_faller.gsc
View File

@ -1,642 +0,0 @@
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/animscripts/zm_shared;
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
zombie_faller_delete()
{
level.zombie_total++;
self maps/mp/zombies/_zm_spawner::reset_attack_spot();
if ( isDefined( self.zombie_faller_location ) )
{
self.zombie_faller_location.is_enabled = 1;
self.zombie_faller_location = undefined;
}
self delete();
}
faller_script_parameters()
{
while ( isDefined( self.script_parameters ) )
{
parms = strtok( self.script_parameters, ";" );
while ( isDefined( parms ) && parms.size > 0 )
{
i = 0;
while ( i < parms.size )
{
if ( parms[ i ] == "drop_now" )
{
self.drop_now = 1;
}
if ( parms[ i ] == "drop_not_occupied" )
{
self.drop_not_occupied = 1;
}
if ( parms[ i ] == "emerge_top" )
{
self.emerge_top = 1;
}
if ( parms[ i ] == "emerge_bottom" )
{
self.emerge_bottom = 1;
}
i++;
}
}
}
}
setup_deathfunc( func_name )
{
self endon( "death" );
while ( isDefined( self.zombie_init_done ) && !self.zombie_init_done )
{
wait_network_frame();
}
if ( isDefined( func_name ) )
{
self.deathfunction = func_name;
}
else if ( isDefined( level.custom_faller_death ) )
{
self.deathfunction = level.custom_faller_death;
}
else
{
self.deathfunction = ::zombie_fall_death_func;
}
}
do_zombie_fall( spot )
{
self endon( "death" );
self.zombie_faller_location = spot;
self.zombie_faller_location.is_enabled = 0;
self.zombie_faller_location faller_script_parameters();
if ( isDefined( self.zombie_faller_location.emerge_bottom ) || self.zombie_faller_location.emerge_bottom && isDefined( self.zombie_faller_location.emerge_top ) && self.zombie_faller_location.emerge_top )
{
self do_zombie_emerge( spot );
return;
}
self thread setup_deathfunc();
self.no_powerups = 1;
self.in_the_ceiling = 1;
self.anchor = spawn( "script_origin", self.origin );
self.anchor.angles = self.angles;
self linkto( self.anchor );
if ( !isDefined( spot.angles ) )
{
spot.angles = ( 0, 0, -1 );
}
anim_org = spot.origin;
anim_ang = spot.angles;
self ghost();
self.anchor moveto( anim_org, 0,05 );
self.anchor waittill( "movedone" );
target_org = get_desired_origin();
if ( isDefined( target_org ) )
{
anim_ang = vectorToAngles( target_org - self.origin );
self.anchor rotateto( ( 0, anim_ang[ 1 ], 0 ), 0,05 );
self.anchor waittill( "rotatedone" );
}
self unlink();
if ( isDefined( self.anchor ) )
{
self.anchor delete();
}
self thread maps/mp/zombies/_zm_spawner::hide_pop();
self thread zombie_fall_death( spot );
self thread zombie_fall_fx( spot );
self thread zombie_faller_death_wait();
self thread zombie_faller_do_fall();
self.no_powerups = 0;
self notify( "risen" );
}
zombie_faller_do_fall()
{
self endon( "death" );
self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_emerge" );
self maps/mp/animscripts/zm_shared::donotetracks( "emerge_anim", ::handle_fall_notetracks, self.zombie_faller_location );
self.zombie_faller_wait_start = getTime();
self.zombie_faller_should_drop = 0;
self thread zombie_fall_wait();
self thread zombie_faller_watch_all_players();
while ( !self.zombie_faller_should_drop )
{
if ( self zombie_fall_should_attack( self.zombie_faller_location ) )
{
self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_attack" );
self maps/mp/animscripts/zm_shared::donotetracks( "attack_anim", ::handle_fall_notetracks, self.zombie_faller_location );
if ( !self zombie_faller_always_drop() && randomfloat( 1 ) > 0.5 )
{
self.zombie_faller_should_drop = 1;
}
continue;
}
else if ( self zombie_faller_always_drop() )
{
self.zombie_faller_should_drop = 1;
break;
}
else if ( getTime() >= ( self.zombie_faller_wait_start + 20000 ) )
{
self.zombie_faller_should_drop = 1;
break;
}
else if ( self zombie_faller_drop_not_occupied() )
{
self.zombie_faller_should_drop = 1;
break;
}
else self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_attack" );
self maps/mp/animscripts/zm_shared::donotetracks( "attack_anim", ::handle_fall_notetracks, self.zombie_faller_location );
}
self notify( "falling" );
spot = self.zombie_faller_location;
self zombie_faller_enable_location();
self animscripted( self.origin, spot.angles, "zm_faller_fall" );
self maps/mp/animscripts/zm_shared::donotetracks( "fall_anim", ::handle_fall_notetracks, spot );
self.deathfunction = ::zombie_death_animscript;
self notify( "fall_anim_finished" );
spot notify( "stop_zombie_fall_fx" );
self stopanimscripted();
landanimdelta = 15;
ground_pos = groundpos_ignore_water_new( self.origin );
physdist = ( self.origin[ 2 ] - ground_pos[ 2 ] ) + landanimdelta;
if ( physdist > 0 )
{
self animcustom( ::zombie_fall_loop );
self waittill( "faller_on_ground" );
self animcustom( ::zombie_land );
self waittill( "zombie_land_done" );
}
self.in_the_ceiling = 0;
self traversemode( "gravity" );
self.no_powerups = 0;
}
zombie_fall_loop()
{
self endon( "death" );
self setanimstatefromasd( "zm_faller_fall_loop" );
while ( 1 )
{
ground_pos = groundpos_ignore_water_new( self.origin );
if ( ( self.origin[ 2 ] - ground_pos[ 2 ] ) < 20 )
{
self notify( "faller_on_ground" );
return;
}
else
{
wait 0.05;
}
}
}
zombie_land()
{
self setanimstatefromasd( "zm_faller_land" );
maps/mp/animscripts/zm_shared::donotetracks( "land_anim" );
self notify( "zombie_land_done" );
}
zombie_faller_always_drop()
{
if ( isDefined( self.zombie_faller_location.drop_now ) && self.zombie_faller_location.drop_now )
{
return 1;
}
return 0;
}
zombie_faller_drop_not_occupied()
{
if ( isDefined( self.zombie_faller_location.drop_not_occupied ) && self.zombie_faller_location.drop_not_occupied )
{
if ( isDefined( self.zone_name ) && isDefined( level.zones[ self.zone_name ] ) )
{
return !level.zones[ self.zone_name ].is_occupied;
}
}
return 0;
}
zombie_faller_watch_all_players()
{
players = get_players();
i = 0;
while ( i < players.size )
{
self thread zombie_faller_watch_player( players[ i ] );
i++;
}
}
zombie_faller_watch_player( player )
{
self endon( "falling" );
self endon( "death" );
player endon( "disconnect" );
range = 200;
rangesqr = range * range;
timer = 5000;
inrange = 0;
inrangetime = 0;
closerange = 60;
closerangesqr = closerange * closerange;
dirtoplayerenter = ( 0, 0, -1 );
incloserange = 0;
while ( 1 )
{
distsqr = distance2dsquared( self.origin, player.origin );
if ( distsqr < rangesqr )
{
if ( inrange )
{
if ( ( inrangetime + timer ) < getTime() )
{
self.zombie_faller_should_drop = 1;
return;
}
}
else
{
inrange = 1;
inrangetime = getTime();
}
}
else
{
inrange = 0;
}
if ( distsqr < closerangesqr )
{
if ( !incloserange )
{
dirtoplayerenter = player.origin - self.origin;
dirtoplayerenter = ( dirtoplayerenter[ 0 ], dirtoplayerenter[ 1 ], 0 );
dirtoplayerenter = vectornormalize( dirtoplayerenter );
}
incloserange = 1;
}
else
{
if ( incloserange )
{
dirtoplayerexit = player.origin - self.origin;
dirtoplayerexit = ( dirtoplayerexit[ 0 ], dirtoplayerexit[ 1 ], 0 );
dirtoplayerexit = vectornormalize( dirtoplayerexit );
if ( vectordot( dirtoplayerenter, dirtoplayerexit ) < 0 )
{
self.zombie_faller_should_drop = 1;
return;
}
}
else
{
incloserange = 0;
}
wait 0.1;
}
}
}
zombie_fall_wait()
{
self endon( "falling" );
self endon( "death" );
while ( isDefined( self.zone_name ) )
{
while ( isDefined( level.zones ) && isDefined( level.zones[ self.zone_name ] ) )
{
zone = level.zones[ self.zone_name ];
while ( 1 )
{
if ( !zone.is_enabled || !zone.is_active )
{
if ( !self potentially_visible( 2250000 ) )
{
if ( self.health != level.zombie_health )
{
self.zombie_faller_should_drop = 1;
return;
}
else self zombie_faller_delete();
return;
}
}
wait 0.5;
}
}
}
}
zombie_fall_should_attack( spot )
{
victims = zombie_fall_get_vicitims( spot );
return victims.size > 0;
}
zombie_fall_get_vicitims( spot )
{
ret = [];
players = getplayers();
checkdist2 = 40;
checkdist2 *= checkdist2;
i = 0;
while ( i < players.size )
{
player = players[ i ];
if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
i++;
continue;
}
else stance = player getstance();
if ( stance == "crouch" || stance == "prone" )
{
i++;
continue;
}
else
{
zcheck = self.origin[ 2 ] - player.origin[ 2 ];
if ( zcheck < 0 || zcheck > 120 )
{
i++;
continue;
}
else
{
dist2 = distance2dsquared( player.origin, self.origin );
if ( dist2 < checkdist2 )
{
ret[ ret.size ] = player;
}
}
}
i++;
}
return ret;
}
get_fall_anim( spot )
{
return level._zombie_fall_anims[ self.animname ][ "fall" ];
}
zombie_faller_enable_location()
{
if ( isDefined( self.zombie_faller_location ) )
{
self.zombie_faller_location.is_enabled = 1;
self.zombie_faller_location = undefined;
}
}
zombie_faller_death_wait( endon_notify )
{
self endon( "falling" );
if ( isDefined( endon_notify ) )
{
self endon( endon_notify );
}
self waittill( "death" );
self zombie_faller_enable_location();
}
zombie_fall_death_func()
{
self animmode( "noclip" );
self.deathanim = "zm_faller_emerge_death";
return self maps/mp/zombies/_zm_spawner::zombie_death_animscript();
}
zombie_fall_death( spot )
{
self endon( "fall_anim_finished" );
while ( self.health > 1 )
{
self waittill( "damage", amount, attacker, dir, p, type );
}
self stopanimscripted();
spot notify( "stop_zombie_fall_fx" );
}
_damage_mod_to_damage_type( type )
{
toks = strtok( type, "_" );
if ( toks.size < 2 )
{
return type;
}
returnstr = toks[ 1 ];
i = 2;
while ( i < toks.size )
{
returnstr += toks[ i ];
i++;
}
returnstr = tolower( returnstr );
return returnstr;
}
zombie_fall_fx( spot )
{
spot thread zombie_fall_dust_fx( self );
spot thread zombie_fall_burst_fx();
playsoundatposition( "zmb_zombie_spawn", spot.origin );
self endon( "death" );
spot endon( "stop_zombie_fall_fx" );
wait 1;
if ( self.zombie_move_speed != "sprint" )
{
wait 1;
}
}
zombie_fall_burst_fx()
{
self endon( "stop_zombie_fall_fx" );
self endon( "fall_anim_finished" );
playfx( level._effect[ "rise_burst" ], self.origin + ( 0, 0, randomintrange( 5, 10 ) ) );
wait 0.25;
playfx( level._effect[ "rise_billow" ], self.origin + ( randomintrange( -10, 10 ), randomintrange( -10, 10 ), randomintrange( 5, 10 ) ) );
}
zombie_fall_dust_fx( zombie )
{
dust_tag = "J_SpineUpper";
self endon( "stop_zombie_fall_dust_fx" );
self thread stop_zombie_fall_dust_fx( zombie );
dust_time = 4.5;
dust_interval = 0.3;
t = 0;
while ( t < dust_time )
{
playfxontag( level._effect[ "rise_dust" ], zombie, dust_tag );
wait dust_interval;
t += dust_interval;
}
}
stop_zombie_fall_dust_fx( zombie )
{
zombie waittill( "death" );
self notify( "stop_zombie_fall_dust_fx" );
}
handle_fall_notetracks( note, spot )
{
if ( note == "deathout" )
{
self.deathfunction = ::faller_death_ragdoll;
}
else
{
while ( note == "fire" )
{
victims = zombie_fall_get_vicitims( spot );
i = 0;
while ( i < victims.size )
{
victims[ i ] dodamage( self.meleedamage, self.origin, self, self, "none", "MOD_MELEE" );
self.zombie_faller_should_drop = 1;
i++;
}
}
}
}
faller_death_ragdoll()
{
self startragdoll();
self launchragdoll( ( 0, 0, -1 ) );
return self maps/mp/zombies/_zm_spawner::zombie_death_animscript();
}
in_player_fov( player )
{
playerangles = player getplayerangles();
playerforwardvec = anglesToForward( playerangles );
playerunitforwardvec = vectornormalize( playerforwardvec );
banzaipos = self.origin;
playerpos = player getorigin();
playertobanzaivec = banzaipos - playerpos;
playertobanzaiunitvec = vectornormalize( playertobanzaivec );
forwarddotbanzai = vectordot( playerunitforwardvec, playertobanzaiunitvec );
anglefromcenter = acos( forwarddotbanzai );
playerfov = getDvarFloat( "cg_fov" );
banzaivsplayerfovbuffer = getDvarFloat( "g_banzai_player_fov_buffer" );
if ( banzaivsplayerfovbuffer <= 0 )
{
banzaivsplayerfovbuffer = 0.2;
}
inplayerfov = anglefromcenter <= ( ( playerfov * 0.5 ) * ( 1 - banzaivsplayerfovbuffer ) );
return inplayerfov;
}
potentially_visible( how_close )
{
if ( !isDefined( how_close ) )
{
how_close = 1000000;
}
potentiallyvisible = 0;
players = getplayers();
i = 0;
while ( i < players.size )
{
dist = distancesquared( self.origin, players[ i ].origin );
if ( dist < how_close )
{
inplayerfov = self in_player_fov( players[ i ] );
if ( inplayerfov )
{
potentiallyvisible = 1;
break;
}
}
else
{
i++;
}
}
return potentiallyvisible;
}
do_zombie_emerge( spot )
{
self endon( "death" );
self thread setup_deathfunc( ::faller_death_ragdoll );
self.no_powerups = 1;
self.in_the_ceiling = 1;
anim_org = spot.origin;
anim_ang = spot.angles;
self thread zombie_emerge_fx( spot );
self thread zombie_faller_death_wait( "risen" );
if ( isDefined( level.custom_faller_entrance_logic ) )
{
self thread [[ level.custom_faller_entrance_logic ]]();
}
self zombie_faller_emerge( spot );
self.create_eyes = 1;
wait 0.1;
self notify( "risen" );
self zombie_faller_enable_location();
}
zombie_faller_emerge( spot )
{
self endon( "death" );
if ( isDefined( self.zombie_faller_location.emerge_bottom ) && self.zombie_faller_location.emerge_bottom )
{
self animscripted( self.zombie_faller_location.origin, self.zombie_faller_location.angles, "zombie_riser_elevator_from_floor" );
}
else
{
self animscripted( self.zombie_faller_location.origin, self.zombie_faller_location.angles, "zombie_riser_elevator_from_ceiling" );
}
self maps/mp/animscripts/zm_shared::donotetracks( "rise_anim" );
self.deathfunction = ::zombie_death_animscript;
self.in_the_ceiling = 0;
self.no_powerups = 0;
}
zombie_emerge_fx( spot )
{
spot thread zombie_emerge_dust_fx( self );
playsoundatposition( "zmb_zombie_spawn", spot.origin );
self endon( "death" );
spot endon( "stop_zombie_fall_fx" );
wait 1;
}
zombie_emerge_dust_fx( zombie )
{
dust_tag = "J_SpineUpper";
self endon( "stop_zombie_fall_dust_fx" );
self thread stop_zombie_fall_dust_fx( zombie );
dust_time = 3.5;
dust_interval = 0.5;
t = 0;
while ( t < dust_time )
{
playfxontag( level._effect[ "rise_dust" ], zombie, dust_tag );
wait dust_interval;
t += dust_interval;
}
}
stop_zombie_emerge_dust_fx( zombie )
{
zombie waittill( "death" );
self notify( "stop_zombie_fall_dust_fx" );
}

10
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_bot.gsc
View File

@ -1,10 +0,0 @@
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
/#
println( "ZM >> Zombiemode Server Scripts Init (_zm_bot.gsc)" );
#/
}

915
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_equip_hacker.gsc
View File

@ -1,915 +0,0 @@
#include maps/mp/zombies/_zm_equip_hacker;
#include maps/mp/zombies/_zm_audio;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( !maps/mp/zombies/_zm_equipment::is_equipment_included( "equip_hacker_zm" ) )
{
return;
}
maps/mp/zombies/_zm_equipment::register_equipment( "equip_hacker_zm", &"ZOMBIE_EQUIP_HACKER_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_HACKER_HOWTO", undefined, "hacker" );
level._hackable_objects = [];
level._pooled_hackable_objects = [];
onplayerconnect_callback( ::hacker_on_player_connect );
level thread hack_trigger_think();
level thread hacker_trigger_pool_think();
level thread hacker_round_reward();
/*
if ( getDvarInt( #"53BD7080" ) == 1 )
{
level thread hacker_debug();
}
*/
}
hacker_round_reward()
{
while ( 1 )
{
level waittill( "end_of_round" );
if ( !isDefined( level._from_nml ) )
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( isDefined( players[ i ] get_player_equipment() ) && players[ i ] get_player_equipment() == "equip_hacker_zm" )
{
if ( isDefined( players[ i ].equipment_got_in_round[ "equip_hacker_zm" ] ) )
{
got_in_round = players[ i ].equipment_got_in_round[ "equip_hacker_zm" ];
rounds_kept = level.round_number - got_in_round;
rounds_kept -= 1;
if ( rounds_kept > 0 )
{
rounds_kept = min( rounds_kept, 5 );
score = rounds_kept * 500;
players[ i ] maps/mp/zombies/_zm_score::add_to_player_score( int( score ) );
}
}
}
i++;
}
}
else level._from_nml = undefined;
}
}
hacker_debug()
{
while ( 1 )
{
i = 0;
while ( i < level._hackable_objects.size )
{
hackable = level._hackable_objects[ i ];
if ( isDefined( hackable.pooled ) && hackable.pooled )
{
if ( isDefined( hackable._trigger ) )
{
col = vectorScale( ( 0, 0, 1 ), 255 );
if ( isDefined( hackable.custom_debug_color ) )
{
col = hackable.custom_debug_color;
}
/#
print3d( hackable.origin, "+", col, 1, 1 );
#/
}
else
{
/#
print3d( hackable.origin, "+", vectorScale( ( 0, 0, 1 ), 255 ), 1, 1 );
#/
}
i++;
continue;
}
else
{
/#
print3d( hackable.origin, "+", vectorScale( ( 0, 0, 1 ), 255 ), 1, 1 );
#/
}
i++;
}
wait 0.1;
}
}
hacker_trigger_pool_think()
{
if ( !isDefined( level._zombie_hacker_trigger_pool_size ) )
{
level._zombie_hacker_trigger_pool_size = 8;
}
pool_active = 0;
level._hacker_pool = [];
while ( 1 )
{
if ( pool_active )
{
if ( !any_hackers_active() )
{
destroy_pooled_items();
}
else
{
sweep_pooled_items();
add_eligable_pooled_items();
}
}
else
{
if ( any_hackers_active() )
{
pool_active = 1;
}
}
wait 0.1;
}
}
destroy_pooled_items()
{
pool_active = 0;
i = 0;
while ( i < level._hacker_pool.size )
{
level._hacker_pool[ i ]._trigger delete();
level._hacker_pool[ i ]._trigger = undefined;
i++;
}
level._hacker_pool = [];
}
sweep_pooled_items()
{
new_hacker_pool = [];
i = 0;
while ( i < level._hacker_pool.size )
{
if ( level._hacker_pool[ i ] should_pooled_object_exist() )
{
new_hacker_pool[ new_hacker_pool.size ] = level._hacker_pool[ i ];
i++;
continue;
}
else
{
if ( isDefined( level._hacker_pool[ i ]._trigger ) )
{
level._hacker_pool[ i ]._trigger delete();
}
level._hacker_pool[ i ]._trigger = undefined;
}
i++;
}
level._hacker_pool = new_hacker_pool;
}
should_pooled_object_exist()
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( players[ i ] hacker_active() )
{
if ( isDefined( self.entity ) )
{
if ( self.entity != players[ i ] )
{
if ( distance2dsquared( players[ i ].origin, self.entity.origin ) <= ( self.radius * self.radius ) )
{
return 1;
}
}
}
else
{
if ( distance2dsquared( players[ i ].origin, self.origin ) <= ( self.radius * self.radius ) )
{
return 1;
}
}
}
i++;
}
return 0;
}
add_eligable_pooled_items()
{
candidates = [];
i = 0;
while ( i < level._hackable_objects.size )
{
hackable = level._hackable_objects[ i ];
if ( isDefined( hackable.pooled ) && hackable.pooled && !isDefined( hackable._trigger ) )
{
if ( !isinarray( level._hacker_pool, hackable ) )
{
if ( hackable should_pooled_object_exist() )
{
candidates[ candidates.size ] = hackable;
}
}
}
i++;
}
i = 0;
while ( i < candidates.size )
{
candidate = candidates[ i ];
height = 72;
radius = 32;
if ( isDefined( candidate.radius ) )
{
radius = candidate.radius;
}
if ( isDefined( candidate.height ) )
{
height = candidate.height;
}
trigger = spawn( "trigger_radius_use", candidate.origin, 0, radius, height );
trigger usetriggerrequirelookat();
trigger triggerignoreteam();
trigger setcursorhint( "HINT_NOICON" );
trigger.radius = radius;
trigger.height = height;
trigger.beinghacked = 0;
candidate._trigger = trigger;
level._hacker_pool[ level._hacker_pool.size ] = candidate;
i++;
}
}
get_hackable_trigger()
{
if ( isDefined( self.door ) )
{
return self.door;
}
else
{
if ( isDefined( self.perk ) )
{
return self.perk;
}
else
{
if ( isDefined( self.window ) )
{
return self.window.unitrigger_stub.trigger;
}
else
{
if ( isDefined( self.classname ) && getsubstr( self.classname, 0, 7 ) == "trigger_" )
{
return self;
}
}
}
}
}
any_hackers_active()
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( players[ i ] hacker_active() )
{
return 1;
}
i++;
}
return 0;
}
register_hackable( name, callback_func, qualifier_func )
{
structs = getstructarray( name, "script_noteworthy" );
if ( !isDefined( structs ) )
{
/#
println( "Error: register_hackable called on script_noteworthy " + name + " but no such structs exist." );
#/
return;
}
i = 0;
while ( i < structs.size )
{
if ( !isinarray( level._hackable_objects, structs[ i ] ) )
{
structs[ i ]._hack_callback_func = callback_func;
structs[ i ]._hack_qualifier_func = qualifier_func;
structs[ i ].pooled = level._hacker_pooled;
if ( isDefined( structs[ i ].targetname ) )
{
structs[ i ].hacker_target = getent( structs[ i ].targetname, "targetname" );
}
level._hackable_objects[ level._hackable_objects.size ] = structs[ i ];
if ( isDefined( level._hacker_pooled ) )
{
level._pooled_hackable_objects[ level._pooled_hackable_objects.size ] = structs[ i ];
}
structs[ i ] thread hackable_object_thread();
wait_network_frame();
}
i++;
}
}
register_hackable_struct( struct, callback_func, qualifier_func )
{
if ( !isinarray( level._hackable_objects, struct ) )
{
struct._hack_callback_func = callback_func;
struct._hack_qualifier_func = qualifier_func;
struct.pooled = level._hacker_pooled;
if ( isDefined( struct.targetname ) )
{
struct.hacker_target = getent( struct.targetname, "targetname" );
}
level._hackable_objects[ level._hackable_objects.size ] = struct;
if ( isDefined( level._hacker_pooled ) )
{
level._pooled_hackable_objects[ level._pooled_hackable_objects.size ] = struct;
}
struct thread hackable_object_thread();
}
}
register_pooled_hackable_struct( struct, callback_func, qualifier_func )
{
level._hacker_pooled = 1;
register_hackable_struct( struct, callback_func, qualifier_func );
level._hacker_pooled = undefined;
}
register_pooled_hackable( name, callback_func, qualifier_func )
{
level._hacker_pooled = 1;
register_hackable( name, callback_func, qualifier_func );
level._hacker_pooled = undefined;
}
deregister_hackable_struct( struct )
{
if ( isinarray( level._hackable_objects, struct ) )
{
new_list = [];
i = 0;
while ( i < level._hackable_objects.size )
{
if ( level._hackable_objects[ i ] != struct )
{
new_list[ new_list.size ] = level._hackable_objects[ i ];
i++;
continue;
}
else
{
level._hackable_objects[ i ] notify( "hackable_deregistered" );
if ( isDefined( level._hackable_objects[ i ]._trigger ) )
{
level._hackable_objects[ i ]._trigger delete();
}
if ( isDefined( level._hackable_objects[ i ].pooled ) && level._hackable_objects[ i ].pooled )
{
arrayremovevalue( level._hacker_pool, level._hackable_objects[ i ] );
arrayremovevalue( level._pooled_hackable_objects, level._hackable_objects[ i ] );
}
}
i++;
}
level._hackable_objects = new_list;
}
}
deregister_hackable( noteworthy )
{
new_list = [];
i = 0;
while ( i < level._hackable_objects.size )
{
if ( !isDefined( level._hackable_objects[ i ].script_noteworthy ) || level._hackable_objects[ i ].script_noteworthy != noteworthy )
{
new_list[ new_list.size ] = level._hackable_objects[ i ];
}
else
{
level._hackable_objects[ i ] notify( "hackable_deregistered" );
if ( isDefined( level._hackable_objects[ i ]._trigger ) )
{
level._hackable_objects[ i ]._trigger delete();
}
}
if ( isDefined( level._hackable_objects[ i ].pooled ) && level._hackable_objects[ i ].pooled )
{
arrayremovevalue( level._hacker_pool, level._hackable_objects[ i ] );
}
i++;
}
level._hackable_objects = new_list;
}
hack_trigger_think()
{
while ( 1 )
{
players = get_players();
i = 0;
while ( i < players.size )
{
player = players[ i ];
j = 0;
while ( j < level._hackable_objects.size )
{
hackable = level._hackable_objects[ j ];
if ( isDefined( hackable._trigger ) )
{
qualifier_passed = 1;
if ( isDefined( hackable._hack_qualifier_func ) )
{
qualifier_passed = hackable [[ hackable._hack_qualifier_func ]]( player );
}
if ( player hacker_active() && qualifier_passed && !hackable._trigger.beinghacked )
{
hackable._trigger setinvisibletoplayer( player, 0 );
j++;
continue;
}
else
{
hackable._trigger setinvisibletoplayer( player, 1 );
}
}
j++;
}
i++;
}
wait 0.1;
}
}
is_facing( facee )
{
orientation = self getplayerangles();
forwardvec = anglesToForward( orientation );
forwardvec2d = ( forwardvec[ 0 ], forwardvec[ 1 ], 0 );
unitforwardvec2d = vectornormalize( forwardvec2d );
tofaceevec = facee.origin - self.origin;
tofaceevec2d = ( tofaceevec[ 0 ], tofaceevec[ 1 ], 0 );
unittofaceevec2d = vectornormalize( tofaceevec2d );
dotproduct = vectordot( unitforwardvec2d, unittofaceevec2d );
dot_limit = 0.8;
if ( isDefined( facee.dot_limit ) )
{
dot_limit = facee.dot_limit;
}
return dotproduct > dot_limit;
}
can_hack( hackable )
{
if ( !isalive( self ) )
{
return 0;
}
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
return 0;
}
if ( !self hacker_active() )
{
return 0;
}
if ( !isDefined( hackable._trigger ) )
{
return 0;
}
if ( isDefined( hackable.player ) )
{
if ( hackable.player != self )
{
return 0;
}
}
if ( self throwbuttonpressed() )
{
return 0;
}
if ( self fragbuttonpressed() )
{
return 0;
}
if ( isDefined( hackable._hack_qualifier_func ) )
{
if ( !( hackable [[ hackable._hack_qualifier_func ]]( self ) ) )
{
return 0;
}
}
if ( !isinarray( level._hackable_objects, hackable ) )
{
return 0;
}
radsquared = 1024;
if ( isDefined( hackable.radius ) )
{
radsquared = hackable.radius * hackable.radius;
}
origin = hackable.origin;
if ( isDefined( hackable.entity ) )
{
origin = hackable.entity.origin;
}
if ( distance2dsquared( self.origin, origin ) > radsquared )
{
return 0;
}
if ( !isDefined( hackable.no_touch_check ) && !self istouching( hackable._trigger ) )
{
return 0;
}
if ( !self is_facing( hackable ) )
{
return 0;
}
if ( !isDefined( hackable.no_sight_check ) && !sighttracepassed( self.origin + vectorScale( ( 0, 0, 1 ), 50 ), origin, 0, undefined ) )
{
return 0;
}
if ( !isDefined( hackable.no_bullet_trace ) && !bullettracepassed( self.origin + vectorScale( ( 0, 0, 1 ), 50 ), origin, 0, undefined ) )
{
return 0;
}
return 1;
}
is_hacking( hackable )
{
if ( can_hack( hackable ) )
{
return self usebuttonpressed();
}
}
set_hack_hint_string()
{
if ( isDefined( self._trigger ) )
{
if ( isDefined( self.custom_string ) )
{
self._trigger sethintstring( self.custom_string );
return;
}
else if ( !isDefined( self.script_int ) || self.script_int <= 0 )
{
self._trigger sethintstring( &"ZOMBIE_HACK_NO_COST" );
return;
}
else
{
self._trigger sethintstring( &"ZOMBIE_HACK", self.script_int );
}
}
}
tidy_on_deregister( hackable )
{
self endon( "clean_up_tidy_up" );
hackable waittill( "hackable_deregistered" );
if ( isDefined( self.hackerprogressbar ) )
{
self.hackerprogressbar maps/mp/gametypes_zm/_hud_util::destroyelem();
}
if ( isDefined( self.hackertexthud ) )
{
self.hackertexthud destroy();
}
}
hacker_do_hack( hackable )
{
timer = 0;
hacked = 0;
hackable._trigger.beinghacked = 1;
if ( !isDefined( self.hackerprogressbar ) )
{
self.hackerprogressbar = self maps/mp/gametypes_zm/_hud_util::createprimaryprogressbar();
}
if ( !isDefined( self.hackertexthud ) )
{
self.hackertexthud = newclienthudelem( self );
}
hack_duration = hackable.script_float;
if ( self hasperk( "specialty_fastreload" ) )
{
hack_duration *= 0.66;
}
hack_duration = max( 1.5, hack_duration );
self thread tidy_on_deregister( hackable );
self.hackerprogressbar maps/mp/gametypes_zm/_hud_util::updatebar( 0.01, 1 / hack_duration );
self.hackertexthud.alignx = "center";
self.hackertexthud.aligny = "middle";
self.hackertexthud.horzalign = "center";
self.hackertexthud.vertalign = "bottom";
self.hackertexthud.y = -113;
if ( issplitscreen() )
{
self.hackertexthud.y = -107;
}
self.hackertexthud.foreground = 1;
self.hackertexthud.font = "default";
self.hackertexthud.fontscale = 1.8;
self.hackertexthud.alpha = 1;
self.hackertexthud.color = ( 0, 0, 1 );
self.hackertexthud settext( &"ZOMBIE_HACKING" );
self playloopsound( "zmb_progress_bar", 0,5 );
while ( self is_hacking( hackable ) )
{
wait 0.05;
timer += 0.05;
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
break;
}
else if ( timer >= hack_duration )
{
hacked = 1;
break;
}
else
{
}
}
self stoploopsound( 0.5 );
if ( hacked )
{
self playsound( "vox_mcomp_hack_success" );
}
else self playsound( "vox_mcomp_hack_fail" );
if ( isDefined( self.hackerprogressbar ) )
{
self.hackerprogressbar maps/mp/gametypes_zm/_hud_util::destroyelem();
}
if ( isDefined( self.hackertexthud ) )
{
self.hackertexthud destroy();
}
hackable set_hack_hint_string();
if ( isDefined( hackable._trigger ) )
{
hackable._trigger.beinghacked = 0;
}
self notify( "clean_up_tidy_up" );
return hacked;
}
lowreadywatcher( player )
{
player endon( "disconnected" );
self endon( "kill_lowreadywatcher" );
self waittill( "hackable_deregistered" );
}
hackable_object_thread()
{
self endon( "hackable_deregistered" );
height = 72;
radius = 64;
if ( isDefined( self.radius ) )
{
radius = self.radius;
}
if ( isDefined( self.height ) )
{
height = self.height;
}
if ( !isDefined( self.pooled ) )
{
trigger = spawn( "trigger_radius_use", self.origin, 0, radius, height );
trigger usetriggerrequirelookat();
trigger setcursorhint( "HINT_NOICON" );
trigger.radius = radius;
trigger.height = height;
trigger.beinghacked = 0;
self._trigger = trigger;
}
cost = 0;
if ( isDefined( self.script_int ) )
{
cost = self.script_int;
}
duration = 1;
if ( isDefined( self.script_float ) )
{
duration = self.script_float;
}
while ( 1 )
{
wait 0.1;
while ( !isDefined( self._trigger ) )
{
continue;
}
players = get_players();
if ( isDefined( self._trigger ) )
{
if ( isDefined( self.entity ) )
{
self.origin = self.entity.origin;
self._trigger.origin = self.entity.origin;
if ( isDefined( self.trigger_offset ) )
{
self._trigger.origin += self.trigger_offset;
}
}
}
i = 0;
while ( i < players.size )
{
if ( players[ i ] can_hack( self ) )
{
self set_hack_hint_string();
break;
}
else
{
i++;
}
}
i = 0;
while ( i < players.size )
{
hacker = players[ i ];
if ( !hacker is_hacking( self ) )
{
i++;
continue;
}
else if ( hacker.score >= cost || cost <= 0 )
{
self thread lowreadywatcher( hacker );
hack_success = hacker hacker_do_hack( self );
self notify( "kill_lowreadywatcher" );
if ( isDefined( hacker ) )
{
}
if ( isDefined( hacker ) && hack_success )
{
if ( cost )
{
if ( cost > 0 )
{
hacker maps/mp/zombies/_zm_score::minus_to_player_score( cost );
break;
}
else
{
hacker maps/mp/zombies/_zm_score::add_to_player_score( cost * -1 );
}
}
hacker notify( "successful_hack" );
if ( isDefined( self._hack_callback_func ) )
{
self thread [[ self._hack_callback_func ]]( hacker );
}
}
i++;
continue;
}
else
{
hacker play_sound_on_ent( "no_purchase" );
hacker maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "no_money", undefined, 1 );
}
i++;
}
}
}
hacker_on_player_connect()
{
struct = spawnstruct();
struct.origin = self.origin;
struct.radius = 48;
struct.height = 64;
struct.script_float = 10;
struct.script_int = 500;
struct.entity = self;
struct.trigger_offset = vectorScale( ( 0, 0, 1 ), 48 );
register_pooled_hackable_struct( struct, ::player_hack, ::player_qualifier );
struct thread player_hack_disconnect_watcher( self );
}
player_hack_disconnect_watcher( player )
{
player waittill( "disconnect" );
deregister_hackable_struct( self );
}
player_hack( hacker )
{
if ( isDefined( self.entity ) )
{
self.entity maps/mp/zombies/_zm_score::player_add_points( "hacker_transfer", 500 );
}
if ( isDefined( hacker ) )
{
hacker thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "hack_plr" );
}
}
player_qualifier( player )
{
if ( player == self.entity )
{
return 0;
}
if ( self.entity maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
return 0;
}
if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
return 0;
}
if ( isDefined( self.entity.sessionstate == "spectator" ) && self.entity.sessionstate == "spectator" )
{
return 0;
}
return 1;
}
hide_hint_when_hackers_active( custom_logic_func, custom_logic_func_param )
{
invis_to_any = 0;
while ( 1 )
{
if ( isDefined( custom_logic_func ) )
{
self [[ custom_logic_func ]]( custom_logic_func_param );
}
if ( maps/mp/zombies/_zm_equip_hacker::any_hackers_active() )
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( players[ i ] hacker_active() )
{
self setinvisibletoplayer( players[ i ], 1 );
invis_to_any = 1;
i++;
continue;
}
else
{
self setinvisibletoplayer( players[ i ], 0 );
}
i++;
}
}
else while ( invis_to_any )
{
invis_to_any = 0;
players = get_players();
i = 0;
while ( i < players.size )
{
self setinvisibletoplayer( players[ i ], 0 );
i++;
}
}
wait 0.1;
}
}
hacker_debug_print( msg, color )
{
/#
if ( !getDvarInt( #"428DE100" ) )
{
return;
}
if ( !isDefined( color ) )
{
color = ( 0, 0, 1 );
}
print3d( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), msg, color, 1, 1, 40 );
#/
}

1953
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_equipment.gsc
View File

File diff suppressed because it is too large Load Diff

81
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_gump.gsc
View File

@ -1,81 +0,0 @@
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( isDefined( level.disable_blackscreen_clientfield ) && !level.disable_blackscreen_clientfield )
{
registerclientfield( "toplayer", "blackscreen", 1, 1, "int" );
}
if ( !isDefined( level.uses_gumps ) )
{
level.uses_gumps = 0;
}
if ( isDefined( level.uses_gumps ) && level.uses_gumps )
{
onplayerconnect_callback( ::player_connect_gump );
}
}
player_teleport_blackscreen_on()
{
if ( isDefined( level.disable_blackscreen_clientfield ) && level.disable_blackscreen_clientfield )
{
return;
}
if ( isDefined( level.uses_gumps ) && level.uses_gumps )
{
self setclientfieldtoplayer( "blackscreen", 1 );
wait 0.05;
self setclientfieldtoplayer( "blackscreen", 0 );
}
}
player_connect_gump()
{
}
player_watch_spectate_change()
{
if ( isDefined( level.disable_blackscreen_clientfield ) && level.disable_blackscreen_clientfield )
{
return;
}
self endon( "disconnect" );
while ( 1 )
{
self waittill( "spectator_cycle" );
self setclientfieldtoplayer( "blackscreen", 1 );
wait 0.05;
self setclientfieldtoplayer( "blackscreen", 0 );
}
}
gump_test()
{
/*
/#
wait 10;
pos1 = ( -4904, -7657, 4 );
pos3 = ( 7918, -6506, 177 );
pos2 = ( 1986, -73, 4 );
players = get_players();
if ( isDefined( players[ 0 ] ) )
{
players[ 0 ] setorigin( pos1 );
}
wait 0.05;
if ( isDefined( players[ 1 ] ) )
{
players[ 1 ] setorigin( pos2 );
}
wait 0.05;
if ( isDefined( players[ 2 ] ) )
{
players[ 2 ] setorigin( pos3 );
#/
}
*/
}

131
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_hackables_boards.gsc
View File

@ -1,131 +0,0 @@
#include maps/mp/zombies/_zm_blockers;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_equip_hacker;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
hack_boards()
{
windows = getstructarray( "exterior_goal", "targetname" );
i = 0;
while ( i < windows.size )
{
window = windows[ i ];
struct = spawnstruct();
spot = window;
if ( isDefined( window.trigger_location ) )
{
spot = window.trigger_location;
}
org = groundpos( spot.origin ) + vectorScale( ( 0, 0, 1 ), 4 );
r = 96;
h = 96;
if ( isDefined( spot.radius ) )
{
r = spot.radius;
}
if ( isDefined( spot.height ) )
{
h = spot.height;
}
struct.origin = org + vectorScale( ( 0, 0, 1 ), 48 );
struct.radius = r;
struct.height = h;
struct.script_float = 2;
struct.script_int = 0;
struct.window = window;
struct.no_bullet_trace = 1;
struct.no_sight_check = 1;
struct.dot_limit = 0.7;
struct.no_touch_check = 1;
struct.last_hacked_round = 0;
struct.num_hacks = 0;
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::board_hack, ::board_qualifier );
i++;
}
}
board_hack( hacker )
{
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
num_chunks_checked = 0;
last_repaired_chunk = undefined;
if ( self.last_hacked_round != level.round_number )
{
self.last_hacked_round = level.round_number;
self.num_hacks = 0;
}
self.num_hacks++;
if ( self.num_hacks < 3 )
{
hacker maps/mp/zombies/_zm_score::add_to_player_score( 100 );
}
else
{
cost = int( min( 300, hacker.score ) );
if ( cost )
{
hacker maps/mp/zombies/_zm_score::minus_to_player_score( cost );
}
}
while ( 1 )
{
if ( all_chunks_intact( self.window, self.window.barrier_chunks ) )
{
break;
}
else chunk = get_random_destroyed_chunk( self.window, self.window.barrier_chunks );
if ( !isDefined( chunk ) )
{
break;
}
else self.window thread maps/mp/zombies/_zm_blockers::replace_chunk( self.window, chunk, undefined, 0, 1 );
last_repaired_chunk = chunk;
if ( isDefined( self.clip ) )
{
self.window.clip enable_trigger();
self.window.clip disconnectpaths();
}
else
{
blocker_disconnect_paths( self.window.neg_start, self.window.neg_end );
}
wait_network_frame();
num_chunks_checked++;
if ( num_chunks_checked >= 20 )
{
break;
}
else
{
}
}
if ( isDefined( self.window.zbarrier ) )
{
while ( isDefined( last_repaired_chunk ) )
{
while ( self.window.zbarrier getzbarrierpiecestate( last_repaired_chunk ) == "closing" )
{
wait 0.05;
}
}
}
else while ( isDefined( last_repaired_chunk ) && last_repaired_chunk.state == "mid_repair" )
{
wait 0.05;
}
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( self, ::board_hack, ::board_qualifier );
self.window notify( "blocker_hacked" );
self.window notify( "no valid boards" );
}
board_qualifier( player )
{
if ( all_chunks_intact( self.window, self.window.barrier_chunks ) || no_valid_repairable_boards( self.window, self.window.barrier_chunks ) )
{
return 0;
}
return 1;
}

371
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_hackables_box.gsc
View File

@ -1,371 +0,0 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_equip_hacker;
#include maps/mp/zombies/_zm_magicbox;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
box_hacks()
{
boxes = getstructarray( "treasure_chest_use", "targetname" );
i = 0;
while ( i < boxes.size )
{
box = boxes[ i ];
box.box_hacks[ "respin" ] = ::init_box_respin;
box.box_hacks[ "respin_respin" ] = ::init_box_respin_respin;
box.box_hacks[ "summon_box" ] = ::init_summon_box;
box.last_hacked_round = 0;
i++;
}
level._zombiemode_chest_joker_chance_override_func = ::check_for_free_locations;
level._zombiemode_custom_box_move_logic = ::custom_box_move_logic;
level._zombiemode_check_firesale_loc_valid_func = ::custom_check_firesale_loc_valid_func;
init_summon_hacks();
}
custom_check_firesale_loc_valid_func()
{
if ( isDefined( self.unitrigger_stub ) )
{
box = self.unitrigger_stub.trigger_target;
}
else
{
if ( isDefined( self.stub ) )
{
box = self.stub.trigger_target;
}
}
if ( box.last_hacked_round >= level.round_number )
{
return 0;
}
return 1;
}
custom_box_move_logic()
{
num_hacked_locs = 0;
i = 0;
while ( i < level.chests.size )
{
if ( level.chests[ i ].last_hacked_round >= level.round_number )
{
num_hacked_locs++;
}
i++;
}
if ( num_hacked_locs == 0 )
{
maps/mp/zombies/_zm_magicbox::default_box_move_logic();
return;
}
found_loc = 0;
original_spot = level.chest_index;
while ( !found_loc )
{
level.chest_index++;
if ( original_spot == level.chest_index )
{
level.chest_index++;
}
level.chest_index %= level.chests.size;
if ( level.chests[ level.chest_index ].last_hacked_round < level.round_number )
{
found_loc = 1;
}
}
}
check_for_free_locations( chance )
{
boxes = level.chests;
stored_chance = chance;
chance = -1;
i = 0;
while ( i < boxes.size )
{
if ( i == level.chest_index )
{
i++;
continue;
}
else if ( boxes[ i ].last_hacked_round < level.round_number )
{
chance = stored_chance;
break;
}
else
{
i++;
}
}
return chance;
}
init_box_respin( chest, player )
{
self thread box_respin_think( chest, player );
}
box_respin_think( chest, player )
{
respin_hack = spawnstruct();
respin_hack.origin = self.origin + vectorScale( ( 0, 0, 1 ), 24 );
respin_hack.radius = 48;
respin_hack.height = 72;
respin_hack.script_int = 600;
respin_hack.script_float = 1.5;
respin_hack.player = player;
respin_hack.no_bullet_trace = 1;
respin_hack.chest = chest;
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( respin_hack, ::respin_box, ::hack_box_qualifier );
self.weapon_model waittill_either( "death", "kill_respin_think_thread" );
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( respin_hack );
}
respin_box_thread( hacker )
{
if ( isDefined( self.chest.zbarrier.weapon_model ) )
{
self.chest.zbarrier.weapon_model notify( "kill_respin_think_thread" );
}
self.chest.no_fly_away = 1;
self.chest.zbarrier notify( "box_hacked_respin" );
self.chest disable_trigger();
play_sound_at_pos( "open_chest", self.chest.zbarrier.origin );
play_sound_at_pos( "music_chest", self.chest.zbarrier.origin );
maps/mp/zombies/_zm_weapons::unacquire_weapon_toggle( self.chest.zbarrier.weapon_string );
self.chest.zbarrier thread maps/mp/zombies/_zm_magicbox::treasure_chest_weapon_spawn( self.chest, hacker, 1 );
self.chest.zbarrier waittill( "randomization_done" );
self.chest.no_fly_away = undefined;
if ( !flag( "moving_chest_now" ) )
{
self.chest enable_trigger();
self.chest thread maps/mp/zombies/_zm_magicbox::treasure_chest_timeout();
}
}
respin_box( hacker )
{
self thread respin_box_thread( hacker );
}
hack_box_qualifier( player )
{
if ( player == self.chest.chest_user && isDefined( self.chest.weapon_out ) )
{
return 1;
}
return 0;
}
init_box_respin_respin( chest, player )
{
self thread box_respin_respin_think( chest, player );
}
box_respin_respin_think( chest, player )
{
respin_hack = spawnstruct();
respin_hack.origin = self.origin + vectorScale( ( 0, 0, 1 ), 24 );
respin_hack.radius = 48;
respin_hack.height = 72;
respin_hack.script_int = -950;
respin_hack.script_float = 1.5;
respin_hack.player = player;
respin_hack.no_bullet_trace = 1;
respin_hack.chest = chest;
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( respin_hack, ::respin_respin_box, ::hack_box_qualifier );
self.weapon_model waittill_either( "death", "kill_respin_respin_think_thread" );
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( respin_hack );
}
respin_respin_box( hacker )
{
org = self.chest.zbarrier.origin;
if ( isDefined( self.chest.zbarrier.weapon_model ) )
{
self.chest.zbarrier.weapon_model notify( "kill_respin_respin_think_thread" );
self.chest.zbarrier.weapon_model notify( "kill_weapon_movement" );
self.chest.zbarrier.weapon_model moveto( org + vectorScale( ( 0, 0, 1 ), 40 ), 0,5 );
}
if ( isDefined( self.chest.zbarrier.weapon_model_dw ) )
{
self.chest.zbarrier.weapon_model_dw notify( "kill_weapon_movement" );
self.chest.zbarrier.weapon_model_dw moveto( ( org + vectorScale( ( 0, 0, 1 ), 40 ) ) - vectorScale( ( 0, 0, 1 ), 3 ), 0,5 );
}
self.chest.zbarrier notify( "box_hacked_rerespin" );
self.chest.box_rerespun = 1;
self thread fake_weapon_powerup_thread( self.chest.zbarrier.weapon_model, self.chest.zbarrier.weapon_model_dw );
}
fake_weapon_powerup_thread( weapon1, weapon2 )
{
weapon1 endon( "death" );
playfxontag( level._effect[ "powerup_on_solo" ], weapon1, "tag_origin" );
playsoundatposition( "zmb_spawn_powerup", weapon1.origin );
weapon1 playloopsound( "zmb_spawn_powerup_loop" );
self thread fake_weapon_powerup_timeout( weapon1, weapon2 );
while ( isDefined( weapon1 ) )
{
waittime = randomfloatrange( 2.5, 5 );
yaw = randomint( 360 );
if ( yaw > 300 )
{
yaw = 300;
}
else
{
if ( yaw < 60 )
{
yaw = 60;
}
}
yaw = weapon1.angles[ 1 ] + yaw;
weapon1 rotateto( ( -60 + randomint( 120 ), yaw, -45 + randomint( 90 ) ), waittime, waittime * 0.5, waittime * 0.5 );
if ( isDefined( weapon2 ) )
{
weapon2 rotateto( ( -60 + randomint( 120 ), yaw, -45 + randomint( 90 ) ), waittime, waittime * 0.5, waittime * 0.5 );
}
wait randomfloat( waittime - 0,1 );
}
}
fake_weapon_powerup_timeout( weapon1, weapon2 )
{
weapon1 endon( "death" );
wait 15;
i = 0;
while ( i < 40 )
{
if ( i % 2 )
{
weapon1 hide();
if ( isDefined( weapon2 ) )
{
weapon2 hide();
}
}
else
{
weapon1 show();
if ( isDefined( weapon2 ) )
{
weapon2 hide();
}
}
if ( i < 15 )
{
wait 0.5;
i++;
continue;
}
else if ( i < 25 )
{
wait 0.25;
i++;
continue;
}
else
{
wait 0.1;
}
i++;
}
self.chest notify( "trigger" );
if ( isDefined( weapon1 ) )
{
weapon1 delete();
}
if ( isDefined( weapon2 ) )
{
weapon2 delete();
}
}
init_summon_hacks()
{
chests = getstructarray( "treasure_chest_use", "targetname" );
i = 0;
while ( i < chests.size )
{
chest = chests[ i ];
chest init_summon_box( chest.hidden );
i++;
}
}
init_summon_box( create )
{
if ( create )
{
if ( isDefined( self._summon_hack_struct ) )
{
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self._summon_hack_struct );
self._summon_hack_struct = undefined;
}
struct = spawnstruct();
struct.origin = self.chest_box.origin + vectorScale( ( 0, 0, 1 ), 24 );
struct.radius = 48;
struct.height = 72;
struct.script_int = 1200;
struct.script_float = 5;
struct.no_bullet_trace = 1;
struct.chest = self;
self._summon_hack_struct = struct;
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::summon_box, ::summon_box_qualifier );
}
else
{
if ( isDefined( self._summon_hack_struct ) )
{
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self._summon_hack_struct );
self._summon_hack_struct = undefined;
}
}
}
summon_box_thread( hacker )
{
self.chest.last_hacked_round = level.round_number + randomintrange( 2, 5 );
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
self.chest thread maps/mp/zombies/_zm_magicbox::show_chest();
self.chest notify( "kill_chest_think" );
self.chest.auto_open = 1;
self.chest.no_charge = 1;
self.chest.no_fly_away = 1;
self.chest.forced_user = hacker;
self.chest thread maps/mp/zombies/_zm_magicbox::treasure_chest_think();
self.chest.zbarrier waittill( "closed" );
self.chest.forced_user = undefined;
self.chest.auto_open = undefined;
self.chest.no_charge = undefined;
self.chest.no_fly_away = undefined;
self.chest thread maps/mp/zombies/_zm_magicbox::hide_chest();
}
summon_box( hacker )
{
self thread summon_box_thread( hacker );
if ( isDefined( hacker ) )
{
hacker thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "hack_box" );
}
}
summon_box_qualifier( player )
{
if ( self.chest.last_hacked_round > level.round_number )
{
return 0;
}
if ( isDefined( self.chest.zbarrier.chest_moving ) && self.chest.zbarrier.chest_moving )
{
return 0;
}
return 1;
}

108
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_hackables_doors.gsc
View File

@ -1,108 +0,0 @@
#include maps/mp/zombies/_zm_equip_hacker;
#include maps/mp/zombies/_zm_blockers;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
door_struct_debug()
{
while ( 1 )
{
wait 0.1;
origin = self.origin;
point = origin;
i = 1;
while ( i < 5 )
{
point = origin + ( anglesToForward( self.door.angles ) * ( i * 2 ) );
passed = bullettracepassed( point, origin, 0, undefined );
color = vectorScale( ( 1, 0, 0 ), 255 );
if ( !passed )
{
color = vectorScale( ( 1, 0, 0 ), 255 );
}
/#
print3d( point, "+", color, 1, 1 );
#/
i++;
}
}
}
hack_doors( targetname, door_activate_func )
{
if ( !isDefined( targetname ) )
{
targetname = "zombie_door";
}
doors = getentarray( targetname, "targetname" );
if ( !isDefined( door_activate_func ) )
{
door_activate_func = ::maps/mp/zombies/_zm_blockers::door_opened;
}
i = 0;
while ( i < doors.size )
{
door = doors[ i ];
struct = spawnstruct();
struct.origin = door.origin + ( anglesToForward( door.angles ) * 2 );
struct.radius = 48;
struct.height = 72;
struct.script_float = 32.7;
struct.script_int = 200;
struct.door = door;
struct.no_bullet_trace = 1;
struct.door_activate_func = door_activate_func;
trace_passed = 0;
door thread hide_door_buy_when_hacker_active( struct );
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::door_hack );
door thread watch_door_for_open( struct );
i++;
}
}
hide_door_buy_when_hacker_active( door_struct )
{
self endon( "death" );
self endon( "door_hacked" );
self endon( "door_opened" );
maps/mp/zombies/_zm_equip_hacker::hide_hint_when_hackers_active();
}
watch_door_for_open( door_struct )
{
self waittill( "door_opened" );
self endon( "door_hacked" );
remove_all_door_hackables_that_target_door( door_struct.door );
}
door_hack( hacker )
{
self.door notify( "door_hacked" );
self.door notify( "kill_door_think" );
remove_all_door_hackables_that_target_door( self.door );
self.door [[ self.door_activate_func ]]();
self.door._door_open = 1;
}
remove_all_door_hackables_that_target_door( door )
{
candidates = [];
i = 0;
while ( i < level._hackable_objects.size )
{
obj = level._hackable_objects[ i ];
if ( isDefined( obj.door ) && obj.door.target == door.target )
{
candidates[ candidates.size ] = obj;
}
i++;
}
i = 0;
while ( i < candidates.size )
{
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( candidates[ i ] );
i++;
}
}

46
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_hackables_packapunch.gsc
View File

@ -1,46 +0,0 @@
#include maps/mp/zombies/_zm_equip_hacker;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
hack_packapunch()
{
vending_weapon_upgrade_trigger = getentarray( "specialty_weapupgrade", "script_noteworthy" );
perk = getent( vending_weapon_upgrade_trigger[ 0 ].target, "targetname" );
if ( isDefined( perk ) )
{
struct = spawnstruct();
struct.origin = perk.origin + ( anglesToRight( perk.angles ) * 26 ) + vectorScale( ( 0, 0, 1 ), 48 );
struct.radius = 48;
struct.height = 48;
struct.script_float = 5;
struct.script_int = -1000;
level._pack_hack_struct = struct;
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( level._pack_hack_struct, ::packapunch_hack );
level._pack_hack_struct pack_trigger_think();
}
}
pack_trigger_think()
{
if ( !flag_exists( "enter_nml" ) )
{
return;
}
while ( 1 )
{
flag_wait( "enter_nml" );
self.script_int = -1000;
while ( flag( "enter_nml" ) )
{
wait 1;
}
}
}
packapunch_hack( hacker )
{
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( level._pack_hack_struct );
level._pack_hack_struct.script_int = 0;
level notify( "packapunch_hacked" );
}

87
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_hackables_perks.gsc
View File

@ -1,87 +0,0 @@
#include maps/mp/zombies/_zm_equip_hacker;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
hack_perks()
{
vending_triggers = getentarray( "zombie_vending", "targetname" );
i = 0;
while ( i < vending_triggers.size )
{
struct = spawnstruct();
if ( isDefined( vending_triggers[ i ].machine ) )
{
machine[ 0 ] = vending_triggers[ i ].machine;
}
else
{
machine = getentarray( vending_triggers[ i ].target, "targetname" );
}
struct.origin = machine[ 0 ].origin + ( anglesToRight( machine[ 0 ].angles ) * 18 ) + vectorScale( ( 0, 0, 1 ), 48 );
struct.radius = 48;
struct.height = 64;
struct.script_float = 5;
while ( !isDefined( vending_triggers[ i ].cost ) )
{
wait 0.05;
}
struct.script_int = int( vending_triggers[ i ].cost * -1 );
struct.perk = vending_triggers[ i ];
if ( isDefined( level._hack_perks_override ) )
{
struct = struct [[ level._hack_perks_override ]]();
}
vending_triggers[ i ].hackable = struct;
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::perk_hack, ::perk_hack_qualifier );
i++;
}
level._solo_revive_machine_expire_func = ::solo_revive_expire_func;
}
solo_revive_expire_func()
{
if ( isDefined( self.hackable ) )
{
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self.hackable );
self.hackable = undefined;
}
}
perk_hack_qualifier( player )
{
if ( isDefined( player._retain_perks ) )
{
return 0;
}
if ( isDefined( self.perk ) && isDefined( self.perk.script_noteworthy ) )
{
if ( player hasperk( self.perk.script_noteworthy ) )
{
return 1;
}
}
return 0;
}
perk_hack( hacker )
{
if ( flag( "solo_game" ) && self.perk.script_noteworthy == "specialty_quickrevive" )
{
hacker.lives--;
}
hacker notify( self.perk.script_noteworthy + "_stop" );
hacker playsoundtoplayer( "evt_perk_throwup", hacker );
while ( isDefined( hacker.perk_hud ) )
{
keys = getarraykeys( hacker.perk_hud );
i = 0;
while ( i < hacker.perk_hud.size )
{
hacker.perk_hud[ keys[ i ] ].x = i * 30;
i++;
}
}
}

79
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_hackables_powerups.gsc
View File

@ -1,79 +0,0 @@
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/zombies/_zm_net;
#include maps/mp/zombies/_zm_equip_hacker;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
unhackable_powerup( name )
{
ret = 0;
switch( name )
{
case "bonus_points_player":
case "bonus_points_team":
case "lose_points_team":
case "random_weapon":
ret = 1;
break;
}
return ret;
}
hack_powerups()
{
while ( 1 )
{
level waittill( "powerup_dropped", powerup );
if ( !unhackable_powerup( powerup.powerup_name ) )
{
struct = spawnstruct();
struct.origin = powerup.origin;
struct.radius = 65;
struct.height = 72;
struct.script_float = 5;
struct.script_int = 5000;
struct.powerup = powerup;
powerup thread powerup_pickup_watcher( struct );
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::powerup_hack );
}
}
}
powerup_pickup_watcher( powerup_struct )
{
self endon( "hacked" );
self waittill( "death" );
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( powerup_struct );
}
powerup_hack( hacker )
{
self.powerup notify( "hacked" );
if ( isDefined( self.powerup.zombie_grabbable ) && self.powerup.zombie_grabbable )
{
self.powerup notify( "powerup_timedout" );
origin = self.powerup.origin;
self.powerup delete();
self.powerup = maps/mp/zombies/_zm_net::network_safe_spawn( "powerup", 1, "script_model", origin );
if ( isDefined( self.powerup ) )
{
self.powerup maps/mp/zombies/_zm_powerups::powerup_setup( "full_ammo" );
self.powerup thread maps/mp/zombies/_zm_powerups::powerup_timeout();
self.powerup thread maps/mp/zombies/_zm_powerups::powerup_wobble();
self.powerup thread maps/mp/zombies/_zm_powerups::powerup_grab();
}
}
else
{
if ( self.powerup.powerup_name == "full_ammo" )
{
self.powerup maps/mp/zombies/_zm_powerups::powerup_setup( "fire_sale" );
}
else
{
self.powerup maps/mp/zombies/_zm_powerups::powerup_setup( "full_ammo" );
}
}
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
}

55
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_hackables_wallbuys.gsc
View File

@ -1,55 +0,0 @@
#include maps/mp/zombies/_zm_equip_hacker;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
hack_wallbuys()
{
weapon_spawns = getstructarray( "weapon_upgrade", "targetname" );
i = 0;
while ( i < weapon_spawns.size )
{
if ( weapontype( weapon_spawns[ i ].zombie_weapon_upgrade ) == "grenade" )
{
i++;
continue;
}
else if ( weapontype( weapon_spawns[ i ].zombie_weapon_upgrade ) == "melee" )
{
i++;
continue;
}
else if ( weapontype( weapon_spawns[ i ].zombie_weapon_upgrade ) == "mine" )
{
i++;
continue;
}
else if ( weapontype( weapon_spawns[ i ].zombie_weapon_upgrade ) == "bomb" )
{
i++;
continue;
}
else
{
struct = spawnstruct();
struct.origin = weapon_spawns[ i ].origin;
struct.radius = 48;
struct.height = 48;
struct.script_float = 2;
struct.script_int = 3000;
struct.wallbuy = weapon_spawns[ i ];
maps/mp/zombies/_zm_equip_hacker::register_pooled_hackable_struct( struct, ::wallbuy_hack );
}
i++;
}
bowie_triggers = getentarray( "bowie_upgrade", "targetname" );
array_thread( bowie_triggers, ::maps/mp/zombies/_zm_equip_hacker::hide_hint_when_hackers_active );
}
wallbuy_hack( hacker )
{
self.wallbuy.hacked = 1;
self.clientfieldname = ( self.wallbuy.zombie_weapon_upgrade + "_" ) + self.origin;
level setclientfield( self.clientfieldname, 2 );
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
}

1656
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_magicbox.gsc
View File

File diff suppressed because it is too large Load Diff

400
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_perk_electric_cherry.gsc
View File

@ -1,400 +0,0 @@
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/animscripts/shared;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_net;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
enable_electric_cherry_perk_for_level()
{
register_perk_basic_info( "specialty_grenadepulldeath", "electric_cherry", 2000, &"ZM_PRISON_PERK_CHERRY", "zombie_perk_bottle_cherry" );
register_perk_precache_func( "specialty_grenadepulldeath", ::electic_cherry_precache );
register_perk_clientfields( "specialty_grenadepulldeath", ::electric_cherry_register_clientfield, ::electric_cherry_set_clientfield );
register_perk_threads( "specialty_grenadepulldeath", ::electric_cherry_reload_attack, ::electric_cherry_perk_lost );
register_perk_machine( "specialty_grenadepulldeath", ::electric_cherry_perk_machine_setup, ::electric_cherry_perk_machine_think );
register_perk_host_migration_func( "specialty_grenadepulldeath", ::electric_cherry_host_migration_func );
if ( isDefined( level.custom_electric_cherry_perk_threads ) && level.custom_electric_cherry_perk_threads )
{
level thread [[ level.custom_electric_cherry_perk_threads ]]();
}
}
init_electric_cherry()
{
level.custom_laststand_func = ::electric_cherry_laststand;
set_zombie_var( "tesla_head_gib_chance", 50 );
registerclientfield( "allplayers", "electric_cherry_reload_fx", 9000, 2, "int" );
}
electic_cherry_precache()
{
precacheitem( "zombie_perk_bottle_cherry" );
precacheshader( "specialty_fastreload_zombies" );
precachemodel( "p6_zm_vending_electric_cherry_off" );
precachemodel( "p6_zm_vending_electric_cherry_on" );
precachestring( &"ZM_PRISON_PERK_CHERRY" );
level._effect[ "electriccherry" ] = loadfx( "misc/fx_zombie_cola_on" );
level._effect[ "electric_cherry_explode" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_down" );
level._effect[ "electric_cherry_reload_small" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_sm" );
level._effect[ "electric_cherry_reload_medium" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_player" );
level._effect[ "electric_cherry_reload_large" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_lg" );
level._effect[ "tesla_shock" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock" );
level._effect[ "tesla_shock_secondary" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock_secondary" );
}
electric_cherry_register_clientfield()
{
registerclientfield( "toplayer", "perk_electric_cherry", 9000, 1, "int" );
}
electric_cherry_set_clientfield( state )
{
self setclientfieldtoplayer( "perk_electric_cherry", state );
}
electric_cherry_perk_machine_setup( use_trigger, perk_machine, bump_trigger, collision )
{
use_trigger.script_sound = "mus_perks_cherry_jingle";
use_trigger.script_string = "electric_cherry_perk";
use_trigger.script_label = "mus_perks_cherry_sting";
use_trigger.target = "vending_electriccherry";
perk_machine.script_string = "electriccherry_perk";
perk_machine.targetname = "vendingelectric_cherry";
if ( isDefined( bump_trigger ) )
{
bump_trigger.script_string = "electriccherry_perk";
}
}
electric_cherry_perk_machine_think()
{
init_electric_cherry();
while ( 1 )
{
machine = getentarray( "vendingelectric_cherry", "targetname" );
machine_triggers = getentarray( "vending_electriccherry", "target" );
i = 0;
while ( i < machine.size )
{
machine[ i ] setmodel( "p6_zm_vending_electric_cherry_off" );
i++;
}
level thread do_initial_power_off_callback( machine, "electriccherry" );
array_thread( machine_triggers, ::set_power_on, 0 );
level waittill( "electric_cherry_on" );
i = 0;
while ( i < machine.size )
{
machine[ i ] setmodel( "p6_zm_vending_electric_cherry_on" );
machine[ i ] vibrate( vectorScale( ( 0, -1, 0 ), 100 ), 0.3, 0.4, 3 );
machine[ i ] playsound( "zmb_perks_power_on" );
machine[ i ] thread perk_fx( "electriccherry" );
machine[ i ] thread play_loop_on_machine();
i++;
}
level notify( "specialty_grenadepulldeath_power_on" );
array_thread( machine_triggers, ::set_power_on, 1 );
level waittill( "electric_cherry_off" );
array_thread( machine, ::turn_perk_off );
}
}
electric_cherry_host_migration_func()
{
a_electric_cherry_perk_machines = getentarray( "vending_electriccherry", "targetname" );
_a130 = a_electric_cherry_perk_machines;
_k130 = getFirstArrayKey( _a130 );
while ( isDefined( _k130 ) )
{
perk_machine = _a130[ _k130 ];
if ( isDefined( perk_machine.model ) && perk_machine.model == "p6_zm_vending_electric_cherry_on" )
{
perk_machine perk_fx( undefined, 1 );
perk_machine thread perk_fx( "electriccherry" );
}
_k130 = getNextArrayKey( _a130, _k130 );
}
}
electric_cherry_laststand()
{
visionsetlaststand( "zombie_last_stand", 1 );
if ( isDefined( self ) )
{
playfx( level._effect[ "electric_cherry_explode" ], self.origin );
self playsound( "zmb_cherry_explode" );
self notify( "electric_cherry_start" );
wait 0.05;
a_zombies = get_round_enemy_array();
a_zombies = get_array_of_closest( self.origin, a_zombies, undefined, undefined, 500 );
i = 0;
while ( i < a_zombies.size )
{
if ( isalive( self ) )
{
if ( a_zombies[ i ].health <= 1000 )
{
a_zombies[ i ] thread electric_cherry_death_fx();
if ( isDefined( self.cherry_kills ) )
{
self.cherry_kills++;
}
self maps/mp/zombies/_zm_score::add_to_player_score( 40 );
}
else
{
a_zombies[ i ] thread electric_cherry_stun();
a_zombies[ i ] thread electric_cherry_shock_fx();
}
wait 0.1;
a_zombies[ i ] dodamage( 1000, self.origin, self, self, "none" );
}
i++;
}
self notify( "electric_cherry_end" );
}
}
electric_cherry_death_fx()
{
self endon( "death" );
tag = "J_SpineUpper";
fx = "tesla_shock";
if ( self.isdog )
{
tag = "J_Spine1";
}
self playsound( "zmb_elec_jib_zombie" );
network_safe_play_fx_on_tag( "tesla_death_fx", 2, level._effect[ fx ], self, tag );
if ( isDefined( self.tesla_head_gib_func ) && !self.head_gibbed )
{
[[ self.tesla_head_gib_func ]]();
}
}
electric_cherry_shock_fx()
{
self endon( "death" );
tag = "J_SpineUpper";
fx = "tesla_shock_secondary";
if ( self.isdog )
{
tag = "J_Spine1";
}
self playsound( "zmb_elec_jib_zombie" );
network_safe_play_fx_on_tag( "tesla_shock_fx", 2, level._effect[ fx ], self, tag );
}
electric_cherry_stun()
{
self endon( "death" );
self notify( "stun_zombie" );
self endon( "stun_zombie" );
if ( self.health <= 0 )
{
/#
iprintln( "trying to stun a dead zombie" );
#/
return;
}
if ( self.ai_state != "find_flesh" )
{
return;
}
self.forcemovementscriptstate = 1;
self.ignoreall = 1;
i = 0;
while ( i < 2 )
{
self animscripted( self.origin, self.angles, "zm_afterlife_stun" );
self maps/mp/animscripts/shared::donotetracks( "stunned" );
i++;
}
self.forcemovementscriptstate = 0;
self.ignoreall = 0;
self setgoalpos( self.origin );
self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
}
electric_cherry_reload_attack()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "stop_electric_cherry_reload_attack" );
self.wait_on_reload = [];
self.consecutive_electric_cherry_attacks = 0;
while ( 1 )
{
self waittill( "reload_start" );
str_current_weapon = self getcurrentweapon();
while ( isinarray( self.wait_on_reload, str_current_weapon ) )
{
continue;
}
self.wait_on_reload[ self.wait_on_reload.size ] = str_current_weapon;
self.consecutive_electric_cherry_attacks++;
n_clip_current = self getweaponammoclip( str_current_weapon );
n_clip_max = weaponclipsize( str_current_weapon );
n_fraction = n_clip_current / n_clip_max;
perk_radius = linear_map( n_fraction, 1, 0, 32, 128 );
perk_dmg = linear_map( n_fraction, 1, 0, 1, 1045 );
self thread check_for_reload_complete( str_current_weapon );
if ( isDefined( self ) )
{
switch( self.consecutive_electric_cherry_attacks )
{
case 0:
case 1:
n_zombie_limit = undefined;
break;
case 2:
n_zombie_limit = 8;
break;
case 3:
n_zombie_limit = 4;
break;
case 4:
n_zombie_limit = 2;
break;
case default:
n_zombie_limit = 0;
}
self thread electric_cherry_cooldown_timer( str_current_weapon );
if ( isDefined( n_zombie_limit ) && n_zombie_limit == 0 )
{
continue;
}
self thread electric_cherry_reload_fx( n_fraction );
self notify( "electric_cherry_start" );
self playsound( "zmb_cherry_explode" );
a_zombies = get_round_enemy_array();
a_zombies = get_array_of_closest( self.origin, a_zombies, undefined, undefined, perk_radius );
n_zombies_hit = 0;
i = 0;
while ( i < a_zombies.size )
{
if ( isalive( self ) )
{
if ( isDefined( n_zombie_limit ) )
{
if ( n_zombies_hit < n_zombie_limit )
{
n_zombies_hit++;
}
else
{
break;
}
}
if ( a_zombies[ i ].health <= perk_dmg )
{
a_zombies[ i ] thread electric_cherry_death_fx();
if ( isDefined( self.cherry_kills ) )
{
self.cherry_kills++;
}
self maps/mp/zombies/_zm_score::add_to_player_score( 40 );
}
else
{
if ( !isDefined( a_zombies[ i ].is_brutus ) )
{
a_zombies[ i ] thread electric_cherry_stun();
}
a_zombies[ i ] thread electric_cherry_shock_fx();
}
wait 0.1;
a_zombies[ i ] dodamage( perk_dmg, self.origin, self, self, "none" );
}
i++;
}
self notify( "electric_cherry_end" );
}
}
}
electric_cherry_cooldown_timer( str_current_weapon )
{
self notify( "electric_cherry_cooldown_started" );
self endon( "electric_cherry_cooldown_started" );
self endon( "death" );
self endon( "disconnect" );
n_reload_time = weaponreloadtime( str_current_weapon );
if ( self hasperk( "specialty_fastreload" ) )
{
n_reload_time *= getDvarFloat( "perk_weapReloadMultiplier" );
}
n_cooldown_time = n_reload_time + 3;
wait n_cooldown_time;
self.consecutive_electric_cherry_attacks = 0;
}
check_for_reload_complete( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "player_lost_weapon_" + weapon );
self thread weapon_replaced_monitor( weapon );
while ( 1 )
{
self waittill( "reload" );
str_current_weapon = self getcurrentweapon();
if ( str_current_weapon == weapon )
{
arrayremovevalue( self.wait_on_reload, weapon );
self notify( "weapon_reload_complete_" + weapon );
return;
}
else
{
}
}
}
weapon_replaced_monitor( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "weapon_reload_complete_" + weapon );
while ( 1 )
{
self waittill( "weapon_change" );
primaryweapons = self getweaponslistprimaries();
if ( !isinarray( primaryweapons, weapon ) )
{
self notify( "player_lost_weapon_" + weapon );
arrayremovevalue( self.wait_on_reload, weapon );
return;
}
else
{
}
}
}
electric_cherry_reload_fx( n_fraction )
{
if ( n_fraction >= 0.67 )
{
self setclientfield( "electric_cherry_reload_fx", 1 );
}
else if ( n_fraction >= 0.33 && n_fraction < 0.67 )
{
self setclientfield( "electric_cherry_reload_fx", 2 );
}
else
{
self setclientfield( "electric_cherry_reload_fx", 3 );
}
wait 1;
self setclientfield( "electric_cherry_reload_fx", 0 );
}
electric_cherry_perk_lost()
{
self notify( "stop_electric_cherry_reload_attack" );
}

685
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_perk_upgrades.gsc
View File

@ -1,685 +0,0 @@
#include maps/mp/zombies/_zm_pers_upgrades_functions;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm_pers_upgrades;
#include maps/mp/zombies/_zm_pers_upgrades_system;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
pers_upgrade_init()
{
setup_pers_upgrade_boards();
setup_pers_upgrade_revive();
setup_pers_upgrade_multi_kill_headshots();
setup_pers_upgrade_cash_back();
setup_pers_upgrade_insta_kill();
setup_pers_upgrade_jugg();
setup_pers_upgrade_carpenter();
setup_pers_upgrade_flopper();
setup_pers_upgrade_perk_lose();
setup_pers_upgrade_pistol_points();
setup_pers_upgrade_double_points();
setup_pers_upgrade_sniper();
setup_pers_upgrade_box_weapon();
setup_pers_upgrade_nube();
level thread pers_upgrades_monitor();
}
pers_abilities_init_globals()
{
self.successful_revives = 0;
self.failed_revives = 0;
self.failed_cash_back_prones = 0;
self.pers[ "last_headshot_kill_time" ] = getTime();
self.pers[ "zombies_multikilled" ] = 0;
self.non_headshot_kill_counter = 0;
if ( isDefined( level.pers_upgrade_box_weapon ) && level.pers_upgrade_box_weapon )
{
self.pers_box_weapon_awarded = undefined;
}
if ( isDefined( level.pers_upgrade_nube ) && level.pers_upgrade_nube )
{
self thread pers_nube_unlock_watcher();
}
}
is_pers_system_active()
{
if ( !is_classic() )
{
return 0;
}
if ( is_pers_system_disabled() )
{
return 0;
}
return 1;
}
is_pers_system_disabled()
{
if ( level flag_exists( "sq_minigame_active" ) && flag( "sq_minigame_active" ) )
{
return 1;
}
return 0;
}
setup_pers_upgrade_boards()
{
if ( isDefined( level.pers_upgrade_boards ) && level.pers_upgrade_boards )
{
level.pers_boarding_round_start = 10;
level.pers_boarding_number_of_boards_required = 74;
pers_register_upgrade( "board", ::pers_upgrade_boards_active, "pers_boarding", level.pers_boarding_number_of_boards_required, 0 );
}
}
setup_pers_upgrade_revive()
{
if ( isDefined( level.pers_upgrade_revive ) && level.pers_upgrade_revive )
{
level.pers_revivenoperk_number_of_revives_required = 17;
level.pers_revivenoperk_number_of_chances_to_keep = 1;
pers_register_upgrade( "revive", ::pers_upgrade_revive_active, "pers_revivenoperk", level.pers_revivenoperk_number_of_revives_required, 1 );
}
}
setup_pers_upgrade_multi_kill_headshots()
{
if ( isDefined( level.pers_upgrade_multi_kill_headshots ) && level.pers_upgrade_multi_kill_headshots )
{
level.pers_multikill_headshots_required = 5;
level.pers_multikill_headshots_upgrade_reset_counter = 25;
pers_register_upgrade( "multikill_headshots", ::pers_upgrade_headshot_active, "pers_multikill_headshots", level.pers_multikill_headshots_required, 0 );
}
}
setup_pers_upgrade_cash_back()
{
if ( isDefined( level.pers_upgrade_cash_back ) && level.pers_upgrade_cash_back )
{
level.pers_cash_back_num_perks_required = 50;
level.pers_cash_back_perk_buys_prone_required = 15;
level.pers_cash_back_failed_prones = 1;
level.pers_cash_back_money_reward = 1000;
pers_register_upgrade( "cash_back", ::pers_upgrade_cash_back_active, "pers_cash_back_bought", level.pers_cash_back_num_perks_required, 0 );
add_pers_upgrade_stat( "cash_back", "pers_cash_back_prone", level.pers_cash_back_perk_buys_prone_required );
}
}
setup_pers_upgrade_insta_kill()
{
if ( isDefined( level.pers_upgrade_insta_kill ) && level.pers_upgrade_insta_kill )
{
level.pers_insta_kill_num_required = 2;
level.pers_insta_kill_upgrade_active_time = 18;
pers_register_upgrade( "insta_kill", ::pers_upgrade_insta_kill_active, "pers_insta_kill", level.pers_insta_kill_num_required, 0 );
}
}
setup_pers_upgrade_jugg()
{
if ( isDefined( level.pers_upgrade_jugg ) && level.pers_upgrade_jugg )
{
level.pers_jugg_hit_and_die_total = 3;
level.pers_jugg_hit_and_die_round_limit = 2;
level.pers_jugg_round_reached_max = 1;
level.pers_jugg_round_lose_target = 15;
level.pers_jugg_upgrade_health_bonus = 90;
pers_register_upgrade( "jugg", ::pers_upgrade_jugg_active, "pers_jugg", level.pers_jugg_hit_and_die_total, 0 );
}
}
setup_pers_upgrade_carpenter()
{
if ( isDefined( level.pers_upgrade_carpenter ) && level.pers_upgrade_carpenter )
{
level.pers_carpenter_zombie_kills = 1;
pers_register_upgrade( "carpenter", ::pers_upgrade_carpenter_active, "pers_carpenter", level.pers_carpenter_zombie_kills, 0 );
}
}
setup_pers_upgrade_flopper()
{
if ( isDefined( level.pers_upgrade_flopper ) && level.pers_upgrade_flopper )
{
level.pers_flopper_damage_counter = 6;
level.pers_flopper_counter = 1;
level.pers_flopper_min_fall_damage_activate = 30;
level.pers_flopper_min_fall_damage_deactivate = 50;
pers_register_upgrade( "flopper", ::pers_upgrade_flopper_active, "pers_flopper_counter", level.pers_flopper_counter, 0 );
}
}
setup_pers_upgrade_perk_lose()
{
if ( isDefined( level.pers_upgrade_perk_lose ) && level.pers_upgrade_perk_lose )
{
level.pers_perk_round_reached_max = 6;
level.pers_perk_lose_counter = 3;
pers_register_upgrade( "perk_lose", ::pers_upgrade_perk_lose_active, "pers_perk_lose_counter", level.pers_perk_lose_counter, 0 );
}
}
setup_pers_upgrade_pistol_points()
{
if ( isDefined( level.pers_upgrade_pistol_points ) && level.pers_upgrade_pistol_points )
{
level.pers_pistol_points_num_kills_in_game = 8;
level.pers_pistol_points_accuracy = 0.25;
level.pers_pistol_points_counter = 1;
pers_register_upgrade( "pistol_points", ::pers_upgrade_pistol_points_active, "pers_pistol_points_counter", level.pers_pistol_points_counter, 0 );
}
}
setup_pers_upgrade_double_points()
{
if ( isDefined( level.pers_upgrade_double_points ) && level.pers_upgrade_double_points )
{
level.pers_double_points_score = 2500;
level.pers_double_points_counter = 1;
pers_register_upgrade( "double_points", ::pers_upgrade_double_points_active, "pers_double_points_counter", level.pers_double_points_counter, 0 );
}
}
setup_pers_upgrade_sniper()
{
if ( isDefined( level.pers_upgrade_sniper ) && level.pers_upgrade_sniper )
{
level.pers_sniper_round_kills_counter = 5;
level.pers_sniper_kill_distance = 800;
level.pers_sniper_counter = 1;
level.pers_sniper_misses = 3;
pers_register_upgrade( "sniper", ::pers_upgrade_sniper_active, "pers_sniper_counter", level.pers_sniper_counter, 0 );
}
}
setup_pers_upgrade_box_weapon()
{
if ( isDefined( level.pers_upgrade_box_weapon ) && level.pers_upgrade_box_weapon )
{
level.pers_box_weapon_counter = 5;
level.pers_box_weapon_lose_round = 10;
pers_register_upgrade( "box_weapon", ::pers_upgrade_box_weapon_active, "pers_box_weapon_counter", level.pers_box_weapon_counter, 0 );
}
}
setup_pers_upgrade_nube()
{
if ( isDefined( level.pers_upgrade_nube ) && level.pers_upgrade_nube )
{
level.pers_nube_counter = 1;
level.pers_nube_lose_round = 10;
level.pers_numb_num_kills_unlock = 5;
pers_register_upgrade( "nube", ::pers_upgrade_nube_active, "pers_nube_counter", level.pers_nube_counter, 0 );
}
}
pers_upgrade_boards_active()
{
self endon( "disconnect" );
last_round_number = level.round_number;
while ( 1 )
{
self waittill( "pers_stats_end_of_round" );
if ( level.round_number >= last_round_number )
{
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( self.rebuild_barrier_reward == 0 )
{
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_boarding", 0 );
return;
}
}
}
last_round_number = level.round_number;
}
}
pers_upgrade_revive_active()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "player_failed_revive" );
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( self.failed_revives >= level.pers_revivenoperk_number_of_chances_to_keep )
{
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_revivenoperk", 0 );
self.failed_revives = 0;
return;
}
}
}
}
pers_upgrade_headshot_active()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "zombie_death_no_headshot" );
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
self.non_headshot_kill_counter++;
if ( self.non_headshot_kill_counter >= level.pers_multikill_headshots_upgrade_reset_counter )
{
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_multikill_headshots", 0 );
self.non_headshot_kill_counter = 0;
return;
}
}
}
}
pers_upgrade_cash_back_active()
{
self endon( "disconnect" );
wait 0.5;
wait 0.5;
while ( 1 )
{
self waittill( "cash_back_failed_prone" );
wait 0.1;
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
self.failed_cash_back_prones++;
if ( self.failed_cash_back_prones >= level.pers_cash_back_failed_prones )
{
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_cash_back_bought", 0 );
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_cash_back_prone", 0 );
self.failed_cash_back_prones = 0;
wait 0.4;
return;
}
}
}
}
pers_upgrade_insta_kill_active()
{
self endon( "disconnect" );
wait 0.2;
wait 0.2;
while ( 1 )
{
self waittill( "pers_melee_swipe" );
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( isDefined( level.pers_melee_swipe_zombie_swiper ) )
{
e_zombie = level.pers_melee_swipe_zombie_swiper;
if ( isalive( e_zombie ) && isDefined( e_zombie.is_zombie ) && e_zombie.is_zombie )
{
e_zombie.marked_for_insta_upgraded_death = 1;
e_zombie dodamage( e_zombie.health + 666, e_zombie.origin, self, self, "none", "MOD_PISTOL_BULLET", 0, "knife_zm" );
}
level.pers_melee_swipe_zombie_swiper = undefined;
}
break;
}
else
{
}
}
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_insta_kill", 0 );
self kill_insta_kill_upgrade_hud_icon();
wait 0.4;
}
is_insta_kill_upgraded_and_active()
{
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( self maps/mp/zombies/_zm_powerups::is_insta_kill_active() )
{
if ( isDefined( self.pers_upgrades_awarded[ "insta_kill" ] ) && self.pers_upgrades_awarded[ "insta_kill" ] )
{
return 1;
}
}
}
return 0;
}
pers_upgrade_jugg_active()
{
self endon( "disconnect" );
wait 0.5;
wait 0.5;
self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "jugg_upgrade", 1, 0 );
while ( 1 )
{
level waittill( "start_of_round" );
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( level.round_number == level.pers_jugg_round_lose_target )
{
self maps/mp/zombies/_zm_stats::increment_client_stat( "pers_jugg_downgrade_count", 0 );
wait 0.5;
if ( self.pers[ "pers_jugg_downgrade_count" ] >= level.pers_jugg_round_reached_max )
{
break;
}
}
}
else
{
}
}
self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "jugg_upgrade", 1, 1 );
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_jugg", 0 );
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_jugg_downgrade_count", 0 );
}
pers_upgrade_carpenter_active()
{
self endon( "disconnect" );
wait 0.2;
wait 0.2;
level waittill( "carpenter_finished" );
self.pers_carpenter_kill = undefined;
while ( 1 )
{
self waittill( "carpenter_zombie_killed_check_finished" );
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( !isDefined( self.pers_carpenter_kill ) )
{
break;
}
else
{
}
self.pers_carpenter_kill = undefined;
}
}
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_carpenter", 0 );
wait 0.4;
}
persistent_carpenter_ability_check()
{
if ( isDefined( level.pers_upgrade_carpenter ) && level.pers_upgrade_carpenter )
{
self endon( "disconnect" );
if ( isDefined( self.pers_upgrades_awarded[ "carpenter" ] ) && self.pers_upgrades_awarded[ "carpenter" ] )
{
level.pers_carpenter_boards_active = 1;
}
self.pers_carpenter_zombie_check_active = 1;
self.pers_carpenter_kill = undefined;
carpenter_extra_time = 3;
carpenter_finished_start_time = undefined;
level.carpenter_finished_start_time = undefined;
while ( 1 )
{
if ( !is_pers_system_disabled() )
{
if ( !isDefined( level.carpenter_powerup_active ) )
{
if ( !isDefined( level.carpenter_finished_start_time ) )
{
level.carpenter_finished_start_time = getTime();
}
time = getTime();
dt = ( time - level.carpenter_finished_start_time ) / 1000;
if ( dt >= carpenter_extra_time )
{
break;
}
}
else if ( isDefined( self.pers_carpenter_kill ) )
{
if ( isDefined( self.pers_upgrades_awarded[ "carpenter" ] ) && self.pers_upgrades_awarded[ "carpenter" ] )
{
break;
}
else self maps/mp/zombies/_zm_stats::increment_client_stat( "pers_carpenter", 0 );
}
}
wait 0.05;
}
self notify( "carpenter_zombie_killed_check_finished" );
self.pers_carpenter_zombie_check_active = undefined;
level.pers_carpenter_boards_active = undefined;
}
}
pers_zombie_death_location_check( attacker, v_pos )
{
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( is_player_valid( attacker ) )
{
if ( isDefined( attacker.pers_carpenter_zombie_check_active ) )
{
if ( !check_point_in_playable_area( v_pos ) )
{
attacker.pers_carpenter_kill = 1;
}
}
}
}
}
insta_kill_pers_upgrade_icon()
{
if ( self.zombie_vars[ "zombie_powerup_insta_kill_ug_on" ] )
{
self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] = level.pers_insta_kill_upgrade_active_time;
return;
}
self.zombie_vars[ "zombie_powerup_insta_kill_ug_on" ] = 1;
self._show_solo_hud = 1;
self thread time_remaining_pers_upgrade();
}
time_remaining_pers_upgrade()
{
self endon( "disconnect" );
self endon( "kill_insta_kill_upgrade_hud_icon" );
while ( self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] >= 0 )
{
wait 0.05;
self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] -= 0.05;
}
self kill_insta_kill_upgrade_hud_icon();
}
kill_insta_kill_upgrade_hud_icon()
{
self.zombie_vars[ "zombie_powerup_insta_kill_ug_on" ] = 0;
self._show_solo_hud = 0;
self.zombie_vars[ "zombie_powerup_insta_kill_ug_time" ] = level.pers_insta_kill_upgrade_active_time;
self notify( "kill_insta_kill_upgrade_hud_icon" );
}
pers_upgrade_flopper_active()
{
self endon( "disconnect" );
wait 0.5;
/*
/#
iprintlnbold( "*** WE'VE GOT FLOPPER UPGRADED ***" );
#/
*/
wait 0.5;
self thread maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_flopper_watcher();
self waittill( "pers_flopper_lost" );
/*
/#
iprintlnbold( "*** OH NO: Lost FLOPPER Upgrade ***" );
#/
*/
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_flopper_counter", 0 );
self.pers_num_flopper_damages = 0;
}
pers_upgrade_perk_lose_active()
{
self endon( "disconnect" );
wait 0.5;
/*
/#
iprintlnbold( "*** WE'VE GOT PERK LOSE UPGRADED ***" );
#/
*/
wait 0.5;
self.pers_perk_lose_start_round = level.round_number;
self waittill( "pers_perk_lose_lost" );
/*
/#
iprintlnbold( "*** OH NO: Lost PERK LOSE Upgrade ***" );
#/
*/
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_perk_lose_counter", 0 );
}
pers_upgrade_pistol_points_active()
{
self endon( "disconnect" );
wait 0.5;
/*
/#
iprintlnbold( "*** WE'VE GOT PISTOL POINTS UPGRADED ***" );
#/
*/
wait 0.5;
while ( 1 )
{
self waittill( "pers_pistol_points_kill" );
accuracy = self maps/mp/zombies/_zm_pers_upgrades_functions::pers_get_player_accuracy();
if ( accuracy > level.pers_pistol_points_accuracy )
{
break;
}
else
{
}
}
/*
/#
iprintlnbold( "*** OH NO: Lost PISTOL POINTS Upgrade ***" );
#/
*/
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_pistol_points_counter", 0 );
}
pers_upgrade_double_points_active()
{
self endon( "disconnect" );
wait 0.5;
/*
/#
iprintlnbold( "*** WE'VE GOT DOUBLE POINTS UPGRADED ***" );
#/
*/
wait 0.5;
self waittill( "double_points_lost" );
/*
/#
iprintlnbold( "*** OH NO: Lost DOUBLE POINTS Upgrade ***" );
#/
*/
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_double_points_counter", 0 );
}
pers_upgrade_sniper_active()
{
self endon( "disconnect" );
wait 0.5;
/*
/#
iprintlnbold( "*** WE'VE GOT SNIPER UPGRADED ***" );
#/
*/
wait 0.5;
self waittill( "pers_sniper_lost" );
/*
/#
iprintlnbold( "*** OH NO: Lost SNIPER Upgrade ***" );
#/
*/
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_sniper_counter", 0 );
}
pers_upgrade_box_weapon_active()
{
self endon( "disconnect" );
wait 0.5;
/*
/#
iprintlnbold( "*** WE'VE GOT BOX WEAPON UPGRADED ***" );
#/
*/
self thread maps/mp/zombies/_zm_pers_upgrades_functions::pers_magic_box_teddy_bear();
wait 0.5;
self.pers_box_weapon_awarded = 1;
while ( 1 )
{
level waittill( "start_of_round" );
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( level.round_number >= level.pers_box_weapon_lose_round )
{
break;
}
}
else
{
}
}
/*
/#
iprintlnbold( "*** OH NO: Lost BOX WEAPON Upgrade ***" );
#/
*/
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_box_weapon_counter", 0 );
}
pers_upgrade_nube_active()
{
self endon( "disconnect" );
wait 0.5;
/*
/#
iprintlnbold( "*** WE'VE GOT NUBE UPGRADED ***" );
#/
*/
wait 0.5;
while ( 1 )
{
level waittill( "start_of_round" );
if ( maps/mp/zombies/_zm_pers_upgrades::is_pers_system_active() )
{
if ( level.round_number >= level.pers_nube_lose_round )
{
break;
}
}
else
{
}
}
/*
/#
iprintlnbold( "*** OH NO: Lost NUBE Upgrade ***" );
#/
*/
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_nube_counter", 0 );
}

4163
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_perks.gsc
View File

File diff suppressed because it is too large Load Diff

1445
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_pers_upgrades_functions.gsc
View File

File diff suppressed because it is too large Load Diff

278
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_pers_upgrades_system.gsc
View File

@ -1,278 +0,0 @@
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm;
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
pers_register_upgrade( name, upgrade_active_func, stat_name, stat_desired_value, game_end_reset_if_not_achieved )
{
if ( !isDefined( level.pers_upgrades ) )
{
level.pers_upgrades = [];
level.pers_upgrades_keys = [];
}
if ( isDefined( level.pers_upgrades[ name ] ) )
{
/*
/#
assert( 0, "A persistent upgrade is already registered for name: " + name );
#/
*/
}
level.pers_upgrades_keys[ level.pers_upgrades_keys.size ] = name;
level.pers_upgrades[ name ] = spawnstruct();
level.pers_upgrades[ name ].stat_names = [];
level.pers_upgrades[ name ].stat_desired_values = [];
level.pers_upgrades[ name ].upgrade_active_func = upgrade_active_func;
level.pers_upgrades[ name ].game_end_reset_if_not_achieved = game_end_reset_if_not_achieved;
add_pers_upgrade_stat( name, stat_name, stat_desired_value );
/*
/#
if ( isDefined( level.devgui_add_ability ) )
{
[[ level.devgui_add_ability ]]( name, upgrade_active_func, stat_name, stat_desired_value, game_end_reset_if_not_achieved );
#/
}
*/
}
add_pers_upgrade_stat( name, stat_name, stat_desired_value )
{
if ( !isDefined( level.pers_upgrades[ name ] ) )
{
/*
/#
assert( 0, name + " - Persistent upgrade is not registered yet." );
#/
*/
}
stats_size = level.pers_upgrades[ name ].stat_names.size;
level.pers_upgrades[ name ].stat_names[ stats_size ] = stat_name;
level.pers_upgrades[ name ].stat_desired_values[ stats_size ] = stat_desired_value;
}
pers_upgrades_monitor()
{
if ( !isDefined( level.pers_upgrades ) )
{
return;
}
if ( !is_classic() )
{
return;
}
level thread wait_for_game_end();
while ( 1 )
{
waittillframeend;
players = getplayers();
player_index = 0;
while ( player_index < players.size )
{
player = players[ player_index ];
if ( is_player_valid( player ) && isDefined( player.stats_this_frame ) )
{
if ( !player.stats_this_frame.size && isDefined( player.pers_upgrade_force_test ) && !player.pers_upgrade_force_test )
{
player_index++;
continue;
}
else
{
pers_upgrade_index = 0;
while ( pers_upgrade_index < level.pers_upgrades_keys.size )
{
pers_upgrade = level.pers_upgrades[ level.pers_upgrades_keys[ pers_upgrade_index ] ];
is_stat_updated = player is_any_pers_upgrade_stat_updated( pers_upgrade );
if ( is_stat_updated )
{
should_award = player check_pers_upgrade( pers_upgrade );
if ( should_award )
{
if ( isDefined( player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] ) && player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] )
{
//this checks whether the play already has the upgrade
pers_upgrade_index++;
continue;
}
else
{
player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] = 1;
if ( flag( "initial_blackscreen_passed" ) && !is_true( player.is_hotjoining ) )
{
type = "upgrade";
if ( isDefined( level.snd_pers_upgrade_force_type ) )
{
type = level.snd_pers_upgrade_force_type;
}
player playsoundtoplayer( "evt_player_upgrade", player );
if ( isDefined( level.pers_upgrade_vo_spoken ) && level.pers_upgrade_vo_spoken )
{
player delay_thread( 1, ::create_and_play_dialog, "general", type, undefined, level.snd_pers_upgrade_force_variant );
}
else
{
player delay_thread( 1, ::play_vox_to_player, "general", type, level.snd_pers_upgrade_force_variant );
}
if ( isDefined( player.upgrade_fx_origin ) )
{
fx_org = player.upgrade_fx_origin;
player.upgrade_fx_origin = undefined;
}
else
{
fx_org = player.origin;
v_dir = anglesToForward( player getplayerangles() );
v_up = anglesToUp( player getplayerangles() );
fx_org = ( fx_org + ( v_dir * 30 ) ) + ( v_up * 12 );
}
playfx( level._effect[ "upgrade_aquired" ], fx_org );
level thread maps/mp/zombies/_zm::disable_end_game_intermission( 1.5 );
}
/#
player iprintlnbold( "Upgraded!" );
#/
if ( isDefined( pers_upgrade.upgrade_active_func ) )
{
player thread [[ pers_upgrade.upgrade_active_func ]]();
}
pers_upgrade_index++;
continue;
}
}
else
{
if ( isDefined( player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] ) && player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] )
{
if ( flag( "initial_blackscreen_passed" ) && !is_true( player.is_hotjoining ) )
{
player playsoundtoplayer( "evt_player_downgrade", player );
}
/*
/#
player iprintlnbold( "Downgraded!" );
#/
*/
}
player.pers_upgrades_awarded[ level.pers_upgrades_keys[ pers_upgrade_index ] ] = 0;
}
}
pers_upgrade_index++;
}
player.pers_upgrade_force_test = 0;
player.stats_this_frame = [];
}
}
player_index++;
}
wait 0.05;
}
}
wait_for_game_end()
{
if ( !is_classic() )
{
return;
}
level waittill( "end_game" );
players = getplayers();
player_index = 0;
while ( player_index < players.size )
{
player = players[ player_index ];
index = 0;
while ( index < level.pers_upgrades_keys.size )
{
str_name = level.pers_upgrades_keys[ index ];
game_end_reset_if_not_achieved = level.pers_upgrades[ str_name ].game_end_reset_if_not_achieved;
while ( isDefined( game_end_reset_if_not_achieved ) && game_end_reset_if_not_achieved == 1 )
{
while ( isDefined( player.pers_upgrades_awarded[ str_name ] ) && !player.pers_upgrades_awarded[ str_name ] )
{
stat_index = 0;
while ( stat_index < level.pers_upgrades[ str_name ].stat_names.size )
{
player maps/mp/zombies/_zm_stats::zero_client_stat( level.pers_upgrades[ str_name ].stat_names[ stat_index ], 0 );
stat_index++;
}
}
}
index++;
}
player_index++;
}
}
check_pers_upgrade( pers_upgrade )
{
should_award = 1;
i = 0;
while ( i < pers_upgrade.stat_names.size )
{
stat_name = pers_upgrade.stat_names[ i ];
should_award = self check_pers_upgrade_stat( stat_name, pers_upgrade.stat_desired_values[ i ] );
if ( !should_award )
{
break;
}
else
{
i++;
}
}
return should_award;
}
is_any_pers_upgrade_stat_updated( pers_upgrade )
{
if ( isDefined( self.pers_upgrade_force_test ) && self.pers_upgrade_force_test )
{
return 1;
}
result = 0;
i = 0;
while ( i < pers_upgrade.stat_names.size )
{
stat_name = pers_upgrade.stat_names[ i ];
if ( isDefined( self.stats_this_frame[ stat_name ] ) )
{
result = 1;
break;
}
else
{
i++;
}
}
return result;
}
check_pers_upgrade_stat( stat_name, stat_desired_value )
{
should_award = 1;
current_stat_value = self maps/mp/zombies/_zm_stats::get_global_stat( stat_name );
if ( current_stat_value < stat_desired_value )
{
should_award = 0;
}
return should_award;
}
round_end()
{
if ( !is_classic() )
{
return;
}
self notify( "pers_stats_end_of_round" );
if ( isDefined( self.pers[ "pers_max_round_reached" ] ) )
{
if ( level.round_number > self.pers[ "pers_max_round_reached" ] )
{
self maps/mp/zombies/_zm_stats::set_client_stat( "pers_max_round_reached", level.round_number, 0 );
}
}
}

2965
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_powerups.gsc
View File

File diff suppressed because it is too large Load Diff

397
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_score.gsc
View File

@ -1,397 +0,0 @@
#include maps/mp/zombies/_zm_pers_upgrades_functions;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
level.score_cf_info = [];
score_cf_register_info( "damage", 1, 7 );
score_cf_register_info( "death_normal", 1, 3 );
score_cf_register_info( "death_torso", 1, 3 );
score_cf_register_info( "death_neck", 1, 3 );
score_cf_register_info( "death_head", 1, 3 );
score_cf_register_info( "death_melee", 1, 3 );
if ( !level.createfx_enabled )
{
registerclientfield( "allplayers", "score_cf_double_points_active", 1, 1, "int" );
}
}
score_cf_register_info( name, version, max_count )
{
if ( level.createfx_enabled )
{
return;
}
info = spawnstruct();
info.name = name;
info.cf_field = "score_cf_" + name;
info.version = version;
info.max_count = max_count;
info.bit_count = getminbitcountfornum( max_count );
info.players = [];
level.score_cf_info[ name ] = info;
registerclientfield( "allplayers", info.cf_field, info.version, info.bit_count, "int" );
}
score_cf_increment_info( name )
{
info = level.score_cf_info[ name ];
player_ent_index = self getentitynumber();
if ( !isDefined( info.players[ player_ent_index ] ) )
{
info.players[ player_ent_index ] = 0;
}
info.players[ player_ent_index ]++;
if ( info.players[ player_ent_index ] > info.max_count )
{
info.players[ player_ent_index ] = 0;
}
self setclientfield( info.cf_field, info.players[ player_ent_index ] );
}
score_cf_monitor()
{
if ( level.createfx_enabled )
{
return;
}
info_keys = getarraykeys( level.score_cf_info );
while ( 1 )
{
wait_network_frame();
players = get_players();
player_index = 0;
while ( player_index < players.size )
{
player = players[ player_index ];
player_ent_index = player getentitynumber();
info_index = 0;
while ( info_index < info_keys.size )
{
info = level.score_cf_info[ info_keys[ info_index ] ];
info.players[ player_ent_index ] = 0;
player setclientfield( info.cf_field, 0 );
info_index++;
}
player_index++;
}
}
}
player_add_points( event, mod, hit_location, is_dog, zombie_team, damage_weapon )
{
if ( level.intermission )
{
return;
}
if ( !is_player_valid( self ) )
{
return;
}
player_points = 0;
team_points = 0;
multiplier = get_points_multiplier( self );
switch( event )
{
case "death":
player_points = get_zombie_death_player_points();
team_points = get_zombie_death_team_points();
points = self player_add_points_kill_bonus( mod, hit_location );
if ( level.zombie_vars[ self.team ][ "zombie_powerup_insta_kill_on" ] == 1 && mod == "MOD_UNKNOWN" )
{
points *= 2;
}
player_points += points;
if ( team_points > 0 )
{
team_points += points;
}
if ( mod == "MOD_GRENADE" || mod == "MOD_GRENADE_SPLASH" )
{
self maps/mp/zombies/_zm_stats::increment_client_stat( "grenade_kills" );
self maps/mp/zombies/_zm_stats::increment_player_stat( "grenade_kills" );
}
break;
case "ballistic_knife_death":
player_points = get_zombie_death_player_points() + level.zombie_vars[ "zombie_score_bonus_melee" ];
self score_cf_increment_info( "death_melee" );
break;
case "damage_light":
player_points = level.zombie_vars[ "zombie_score_damage_light" ];
self score_cf_increment_info( "damage" );
break;
case "damage":
player_points = level.zombie_vars[ "zombie_score_damage_normal" ];
self score_cf_increment_info( "damage" );
break;
case "damage_ads":
player_points = int( level.zombie_vars[ "zombie_score_damage_normal" ] * 1.25 );
self score_cf_increment_info( "damage" );
break;
case "carpenter_powerup":
case "rebuild_board":
player_points = mod;
break;
case "bonus_points_powerup":
player_points = mod;
break;
case "nuke_powerup":
player_points = mod;
team_points = mod;
break;
case "jetgun_fling":
case "riotshield_fling":
case "thundergun_fling":
player_points = mod;
break;
case "hacker_transfer":
player_points = mod;
break;
case "reviver":
player_points = mod;
break;
case "vulture":
player_points = mod;
break;
case "build_wallbuy":
player_points = mod;
break;
default:
/*
/#
assert( 0, "Unknown point event" );
#/
*/
break;
}
player_points = multiplier * round_up_score( player_points, 5 );
team_points = multiplier * round_up_score( team_points, 5 );
if ( isDefined( self.point_split_receiver ) || event == "death" && event == "ballistic_knife_death" )
{
split_player_points = player_points - round_up_score( player_points * self.point_split_keep_percent, 10 );
self.point_split_receiver add_to_player_score( split_player_points );
player_points -= split_player_points;
}
if ( is_true( level.pers_upgrade_pistol_points ) )
{
player_points = self maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_pistol_points_set_score( player_points, event, mod, damage_weapon );
}
self add_to_player_score( player_points );
self.pers[ "score" ] = self.score;
if ( isDefined( level._game_module_point_adjustment ) )
{
level [[ level._game_module_point_adjustment ]]( self, zombie_team, player_points );
}
}
get_points_multiplier( player )
{
multiplier = level.zombie_vars[ player.team ][ "zombie_point_scalar" ];
if ( isDefined( level.current_game_module ) && level.current_game_module == 2 )
{
if ( isDefined( level._race_team_double_points ) && level._race_team_double_points == player._race_team )
{
return multiplier;
}
else
{
return 1;
}
}
return multiplier;
}
get_zombie_death_player_points()
{
players = get_players();
if ( players.size == 1 )
{
points = level.zombie_vars[ "zombie_score_kill_1player" ];
}
else if ( players.size == 2 )
{
points = level.zombie_vars[ "zombie_score_kill_2player" ];
}
else if ( players.size == 3 )
{
points = level.zombie_vars[ "zombie_score_kill_3player" ];
}
else
{
points = level.zombie_vars[ "zombie_score_kill_4player" ];
}
return points;
}
get_zombie_death_team_points()
{
players = get_players();
if ( players.size == 1 )
{
points = level.zombie_vars[ "zombie_score_kill_1p_team" ];
}
else if ( players.size == 2 )
{
points = level.zombie_vars[ "zombie_score_kill_2p_team" ];
}
else if ( players.size == 3 )
{
points = level.zombie_vars[ "zombie_score_kill_3p_team" ];
}
else
{
points = level.zombie_vars[ "zombie_score_kill_4p_team" ];
}
return points;
}
player_add_points_kill_bonus( mod, hit_location )
{
if ( mod == "MOD_MELEE" )
{
self score_cf_increment_info( "death_melee" );
return level.zombie_vars[ "zombie_score_bonus_melee" ];
}
if ( mod == "MOD_BURNED" )
{
self score_cf_increment_info( "death_torso" );
return level.zombie_vars[ "zombie_score_bonus_burn" ];
}
score = 0;
if ( isDefined( hit_location ) )
{
switch( hit_location )
{
case "head":
case "helmet":
self score_cf_increment_info( "death_head" );
score = level.zombie_vars[ "zombie_score_bonus_head" ];
break;
case "neck":
self score_cf_increment_info( "death_neck" );
score = level.zombie_vars[ "zombie_score_bonus_neck" ];
break;
case "torso_lower":
case "torso_upper":
self score_cf_increment_info( "death_torso" );
score = level.zombie_vars[ "zombie_score_bonus_torso" ];
break;
default:
self score_cf_increment_info( "death_normal" );
break;
}
}
return score;
}
player_reduce_points( event, mod, hit_location )
{
if ( level.intermission )
{
return;
}
points = 0;
switch( event )
{
case "no_revive_penalty":
percent = level.zombie_vars[ "penalty_no_revive" ];
points = self.score * percent;
break;
case "died":
percent = level.zombie_vars[ "penalty_died" ];
points = self.score * percent;
break;
case "downed":
percent = level.zombie_vars[ "penalty_downed" ];
self notify( "I_am_down" );
points = self.score * percent;
self.score_lost_when_downed = round_up_to_ten( int( points ) );
break;
default:
/*
/#
assert( 0, "Unknown point event" );
#/
*/
break;
}
points = self.score - round_up_to_ten( int( points ) );
if ( points < 0 )
{
points = 0;
}
self.score = points;
}
add_to_player_score( points, add_to_total )
{
if ( !isDefined( add_to_total ) )
{
add_to_total = 1;
}
if ( !isDefined( points ) || level.intermission )
{
return;
}
self.score += points;
self.pers[ "score" ] = self.score;
if ( add_to_total )
{
self.score_total += points;
}
self incrementplayerstat( "score", points );
}
minus_to_player_score( points, ignore_double_points_upgrade )
{
if ( !isDefined( points ) || level.intermission )
{
return;
}
if ( !is_true( ignore_double_points_upgrade ) )
{
if ( is_true( level.pers_upgrade_double_points ) )
{
points = maps/mp/zombies/_zm_pers_upgrades_functions::pers_upgrade_double_points_set_score( points );
}
}
self.score -= points;
self.pers[ "score" ] = self.score;
level notify( "spent_points" );
}
add_to_team_score( points )
{
}
minus_to_team_score( points )
{
}
player_died_penalty()
{
players = get_players( self.team );
i = 0;
while ( i < players.size )
{
if ( players[ i ] != self && !players[ i ].is_zombie )
{
players[ i ] player_reduce_points( "no_revive_penalty" );
}
i++;
}
}
player_downed_penalty()
{
/*
/#
println( "ZM >> LAST STAND - player_downed_penalty " );
#/
*/
self player_reduce_points( "downed" );
}

540
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_tombstone.gsc
View File

@ -1,540 +0,0 @@
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_weap_cymbal_monkey;
#include maps/mp/zombies/_zm_melee_weapon;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
onplayerconnect_callback( ::tombstone_player_init );
level.tombstone_laststand_func = ::tombstone_laststand;
level.tombstone_spawn_func = ::tombstone_spawn;
level thread tombstone_hostmigration();
if ( isDefined( level.zombiemode_using_tombstone_perk ) && level.zombiemode_using_tombstone_perk )
{
add_custom_limited_weapon_check( ::is_weapon_available_in_tombstone );
}
}
tombstone_player_init()
{
while ( !isDefined( self.tombstone_index ) )
{
wait 0.1;
}
level.tombstones[ self.tombstone_index ] = spawnstruct();
}
tombstone_spawn()
{
dc = spawn( "script_model", self.origin + vectorScale( ( 0, 0, 1 ), 40 ) );
dc.angles = self.angles;
dc setmodel( "tag_origin" );
dc_icon = spawn( "script_model", self.origin + vectorScale( ( 0, 0, 1 ), 40 ) );
dc_icon.angles = self.angles;
dc_icon setmodel( "ch_tombstone1" );
dc_icon linkto( dc );
dc.icon = dc_icon;
dc.script_noteworthy = "player_tombstone_model";
dc.player = self;
self thread tombstone_clear();
dc thread tombstone_wobble();
dc thread tombstone_revived( self );
result = self waittill_any_return( "player_revived", "spawned_player", "disconnect" );
if ( result == "player_revived" || result == "disconnect" )
{
dc notify( "tombstone_timedout" );
dc_icon unlink();
dc_icon delete();
dc delete();
return;
}
dc thread tombstone_timeout();
dc thread tombstone_grab();
}
tombstone_clear()
{
result = self waittill_any_return( "tombstone_timedout", "tombstone_grabbed" );
level.tombstones[ self.tombstone_index ] = spawnstruct();
}
tombstone_revived( player )
{
self endon( "tombstone_timedout" );
player endon( "disconnect" );
shown = 1;
while ( isDefined( self ) && isDefined( player ) )
{
if ( isDefined( player.revivetrigger ) && isDefined( player.revivetrigger.beingrevived ) && player.revivetrigger.beingrevived )
{
if ( shown )
{
shown = 0;
self.icon hide();
}
}
else
{
if ( !shown )
{
shown = 1;
self.icon show();
}
}
wait 0.05;
}
}
tombstone_laststand()
{
primaries = self getweaponslistprimaries();
currentweapon = self getcurrentweapon();
dc = level.tombstones[ self.tombstone_index ];
dc.player = self;
dc.weapon = [];
dc.current_weapon = -1;
_a134 = primaries;
index = getFirstArrayKey( _a134 );
while ( isDefined( index ) )
{
weapon = _a134[ index ];
dc.weapon[ index ] = weapon;
dc.stockcount[ index ] = self getweaponammostock( weapon );
if ( weapon == currentweapon )
{
dc.current_weapon = index;
}
index = getNextArrayKey( _a134, index );
}
if ( isDefined( self.hasriotshield ) && self.hasriotshield )
{
dc.hasriotshield = 1;
}
dc save_weapons_for_tombstone( self );
if ( self hasweapon( "claymore_zm" ) )
{
dc.hasclaymore = 1;
dc.claymoreclip = self getweaponammoclip( "claymore_zm" );
}
if ( self hasweapon( "emp_grenade_zm" ) )
{
dc.hasemp = 1;
dc.empclip = self getweaponammoclip( "emp_grenade_zm" );
}
dc.perk = tombstone_save_perks( self );
lethal_grenade = self get_player_lethal_grenade();
if ( self hasweapon( lethal_grenade ) )
{
dc.grenade = self getweaponammoclip( lethal_grenade );
}
else
{
dc.grenade = 0;
}
if ( maps/mp/zombies/_zm_weap_cymbal_monkey::cymbal_monkey_exists() )
{
dc.zombie_cymbal_monkey_count = self getweaponammoclip( "cymbal_monkey_zm" );
}
}
tombstone_save_perks( ent )
{
perk_array = [];
if ( ent hasperk( "specialty_armorvest" ) )
{
perk_array[ perk_array.size ] = "specialty_armorvest";
}
if ( ent hasperk( "specialty_deadshot" ) )
{
perk_array[ perk_array.size ] = "specialty_deadshot";
}
if ( ent hasperk( "specialty_fastreload" ) )
{
perk_array[ perk_array.size ] = "specialty_fastreload";
}
if ( ent hasperk( "specialty_flakjacket" ) )
{
perk_array[ perk_array.size ] = "specialty_flakjacket";
}
if ( ent hasperk( "specialty_longersprint" ) )
{
perk_array[ perk_array.size ] = "specialty_longersprint";
}
if ( ent hasperk( "specialty_quickrevive" ) )
{
perk_array[ perk_array.size ] = "specialty_quickrevive";
}
if ( ent hasperk( "specialty_rof" ) )
{
perk_array[ perk_array.size ] = "specialty_rof";
}
return perk_array;
}
tombstone_grab()
{
self endon( "tombstone_timedout" );
wait 1;
while ( isDefined( self ) )
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( players[ i ].is_zombie )
{
i++;
continue;
}
else
{
if ( isDefined( self.player ) && players[ i ] == self.player )
{
tombstone_machine_triggers = getentarray( "specialty_scavenger", "script_noteworthy" );
istombstonepowered = 0;
_a258 = tombstone_machine_triggers;
_k258 = getFirstArrayKey( _a258 );
while ( isDefined( _k258 ) )
{
trigger = _a258[ _k258 ];
if ( isDefined( trigger.power_on ) || trigger.power_on && isDefined( trigger.turbine_power_on ) && trigger.turbine_power_on )
{
istombstonepowered = 1;
}
_k258 = getNextArrayKey( _a258, _k258 );
}
if ( istombstonepowered )
{
dist = distance( players[ i ].origin, self.origin );
if ( dist < 64 )
{
playfx( level._effect[ "powerup_grabbed" ], self.origin );
playfx( level._effect[ "powerup_grabbed_wave" ], self.origin );
players[ i ] tombstone_give();
wait 0.1;
playsoundatposition( "zmb_tombstone_grab", self.origin );
self stoploopsound();
self.icon unlink();
self.icon delete();
self delete();
self notify( "tombstone_grabbed" );
players[ i ] clientnotify( "dc0" );
players[ i ] notify( "dance_on_my_grave" );
}
}
}
}
i++;
}
wait_network_frame();
}
}
tombstone_give()
{
dc = level.tombstones[ self.tombstone_index ];
while ( !flag( "solo_game" ) )
{
primaries = self getweaponslistprimaries();
while ( dc.weapon.size > 1 || primaries.size > 1 )
{
_a310 = primaries;
_k310 = getFirstArrayKey( _a310 );
while ( isDefined( _k310 ) )
{
weapon = _a310[ _k310 ];
self takeweapon( weapon );
_k310 = getNextArrayKey( _a310, _k310 );
}
}
i = 0;
while ( i < dc.weapon.size )
{
if ( !isDefined( dc.weapon[ i ] ) )
{
i++;
continue;
}
else if ( dc.weapon[ i ] == "none" )
{
i++;
continue;
}
else
{
weapon = dc.weapon[ i ];
stock = dc.stockcount[ i ];
if ( !self hasweapon( weapon ) )
{
self giveweapon( weapon, 0, self maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( weapon ) );
self setweaponammoclip( weapon, weaponclipsize( weapon ) );
self setweaponammostock( weapon, stock );
if ( i == dc.current_weapon )
{
self switchtoweapon( weapon );
}
}
}
i++;
}
}
if ( isDefined( dc.hasriotshield ) && dc.hasriotshield )
{
self maps/mp/zombies/_zm_equipment::equipment_give( "riotshield_zm" );
if ( isDefined( self.player_shield_reset_health ) )
{
self [[ self.player_shield_reset_health ]]();
}
}
dc restore_weapons_for_tombstone( self );
if ( isDefined( dc.hasclaymore ) && dc.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", dc.claymoreclip );
}
if ( isDefined( dc.hasemp ) && dc.hasemp )
{
self giveweapon( "emp_grenade_zm" );
self setweaponammoclip( "emp_grenade_zm", dc.empclip );
}
while ( isDefined( dc.perk ) && dc.perk.size > 0 )
{
i = 0;
while ( i < dc.perk.size )
{
if ( self hasperk( dc.perk[ i ] ) )
{
i++;
continue;
}
else if ( dc.perk[ i ] == "specialty_quickrevive" && flag( "solo_game" ) )
{
i++;
continue;
}
else
{
maps/mp/zombies/_zm_perks::give_perk( dc.perk[ i ] );
}
i++;
}
}
if ( dc.grenade > 0 && !flag( "solo_game" ) )
{
curgrenadecount = 0;
if ( self hasweapon( self get_player_lethal_grenade() ) )
{
self getweaponammoclip( self get_player_lethal_grenade() );
}
else
{
self giveweapon( self get_player_lethal_grenade() );
}
self setweaponammoclip( self get_player_lethal_grenade(), dc.grenade + curgrenadecount );
}
if ( maps/mp/zombies/_zm_weap_cymbal_monkey::cymbal_monkey_exists() && !flag( "solo_game" ) )
{
if ( dc.zombie_cymbal_monkey_count )
{
self maps/mp/zombies/_zm_weap_cymbal_monkey::player_give_cymbal_monkey();
self setweaponammoclip( "cymbal_monkey_zm", dc.zombie_cymbal_monkey_count );
}
}
}
tombstone_wobble()
{
self endon( "tombstone_grabbed" );
self endon( "tombstone_timedout" );
if ( isDefined( self ) )
{
wait 1;
playfxontag( level._effect[ "powerup_on" ], self, "tag_origin" );
self playsound( "zmb_tombstone_spawn" );
self playloopsound( "zmb_tombstone_looper" );
}
while ( isDefined( self ) )
{
self rotateyaw( 360, 3 );
wait 2.9;
}
}
tombstone_timeout()
{
self endon( "tombstone_grabbed" );
self thread playtombstonetimeraudio();
wait 48.5;
i = 0;
while ( i < 40 )
{
if ( i % 2 )
{
self.icon ghost();
}
else
{
self.icon show();
}
if ( i < 15 )
{
wait 0.5;
i++;
continue;
}
else if ( i < 25 )
{
wait 0.25;
i++;
continue;
}
else
{
wait 0.1;
}
i++;
}
self notify( "tombstone_timedout" );
self.icon unlink();
self.icon delete();
self delete();
}
playtombstonetimeraudio()
{
self endon( "tombstone_grabbed" );
self endon( "tombstone_timedout" );
player = self.player;
self thread playtombstonetimerout( player );
while ( 1 )
{
player playsoundtoplayer( "zmb_tombstone_timer_count", player );
wait 1;
}
}
playtombstonetimerout( player )
{
self endon( "tombstone_grabbed" );
self waittill( "tombstone_timedout" );
player playsoundtoplayer( "zmb_tombstone_timer_out", player );
}
save_weapons_for_tombstone( player )
{
self.tombstone_melee_weapons = [];
i = 0;
while ( i < level._melee_weapons.size )
{
self save_weapon_for_tombstone( player, level._melee_weapons[ i ].weapon_name );
i++;
}
}
save_weapon_for_tombstone( player, weapon_name )
{
if ( player hasweapon( weapon_name ) )
{
self.tombstone_melee_weapons[ weapon_name ] = 1;
}
}
restore_weapons_for_tombstone( player )
{
i = 0;
while ( i < level._melee_weapons.size )
{
self restore_weapon_for_tombstone( player, level._melee_weapons[ i ].weapon_name );
i++;
}
self.tombstone_melee_weapons = undefined;
}
restore_weapon_for_tombstone( player, weapon_name )
{
if ( isDefined( weapon_name ) || !isDefined( self.tombstone_melee_weapons ) && !isDefined( self.tombstone_melee_weapons[ weapon_name ] ) )
{
return;
}
if ( isDefined( self.tombstone_melee_weapons[ weapon_name ] ) && self.tombstone_melee_weapons[ weapon_name ] )
{
player giveweapon( weapon_name );
player change_melee_weapon( weapon_name, "none" );
self.tombstone_melee_weapons[ weapon_name ] = 0;
}
}
tombstone_hostmigration()
{
level endon( "end_game" );
level notify( "tombstone_hostmigration" );
level endon( "tombstone_hostmigration" );
while ( 1 )
{
level waittill( "host_migration_end" );
tombstones = getentarray( "player_tombstone_model", "script_noteworthy" );
_a580 = tombstones;
_k580 = getFirstArrayKey( _a580 );
while ( isDefined( _k580 ) )
{
model = _a580[ _k580 ];
playfxontag( level._effect[ "powerup_on" ], model, "tag_origin" );
_k580 = getNextArrayKey( _a580, _k580 );
}
}
}
is_weapon_available_in_tombstone( weapon, player_to_check )
{
count = 0;
upgradedweapon = weapon;
if ( isDefined( level.zombie_weapons[ weapon ] ) && isDefined( level.zombie_weapons[ weapon ].upgrade_name ) )
{
upgradedweapon = level.zombie_weapons[ weapon ].upgrade_name;
}
tombstone_index = 0;
while ( tombstone_index < level.tombstones.size )
{
dc = level.tombstones[ tombstone_index ];
if ( !isDefined( dc.weapon ) )
{
tombstone_index++;
continue;
}
else if ( isDefined( player_to_check ) && dc.player != player_to_check )
{
tombstone_index++;
continue;
}
else
{
weapon_index = 0;
while ( weapon_index < dc.weapon.size )
{
if ( !isDefined( dc.weapon[ weapon_index ] ) )
{
weapon_index++;
continue;
}
else
{
tombstone_weapon = dc.weapon[ weapon_index ];
if ( tombstone_weapon == weapon || tombstone_weapon == upgradedweapon )
{
count++;
}
}
weapon_index++;
}
}
tombstone_index++;
}
return count;
}

3058
Fixed Zombies GSCs for compiling/patch_zm/maps/mp/zombies/_zm_weapons.gsc
View File

File diff suppressed because it is too large Load Diff

66
Fixed Zombies GSCs for compiling/readme.md
View File

@ -1,66 +0,0 @@
### The following gscs compile and run successfully with no known errors:
```
patch_zm/maps/mp/zombies/_zm_ai_basic.gsc
patch_zm/maps/mp/zombies/_zm_ai_dogs.gsc
patch_zm/maps/mp/zombies/_zm_ai_faller.gsc
patch_zm/maps/mp/zombies/_zm_bot.gsc
patch_zm/maps/mp/zombies/_zm_equip_hacker.gsc
patch_zm/maps/mp/zombies/_zm_hackables_boards.gsc
patch_zm/maps/mp/zombies/_zm_hackables_box.gsc
patch_zm/maps/mp/zombies/_zm_hackables_doors.gsc
patch_zm/maps/mp/zombies/_zm_hackables_packapunch.gsc
patch_zm/maps/mp/zombies/_zm_hackables_perks.gsc
patch_zm/maps/mp/zombies/_zm_hackables_powerups.gsc
patch_zm/maps/mp/zombies/_zm_hackables_wallbuys.gsc
patch_zm/maps/mp/zombies/_zm_perk_electric_cherry.gsc
patch_zm/maps/mp/zombies/_zm_pers_upgrades.gsc
patch_zm/maps/mp/zombies/_zm_pers_upgrades_functions.gsc
patch_zm/maps/mp/zombies/_zm_pers_upgrades_system.gsc
patch_zm/maps/mp/zombies/_zm_score.gsc
patch_zm/maps/mp/zombies/_zm_tombstone.gsc
```
```
patch_zm/maps/mp/gametypes_zm/_scoreboard.gsc
patch_zm/maps/mp/gametypes_zm/_shellshock.gsc
patch_zm/maps/mp/gametypes_zm/zclassic.gsc
```
```
zm_transit_patch/maps/mp/zm_transit_utility.gsc
```
### The following scripts compile and run successfully with minor errors:
```
zm_transit_patch/maps/mp/gametypes_zm/zgrief.gsc
```
### The following scripts compile and run successfully with major errors:
```
patch_zm/maps/mp/zombies/_zm_magicbox.gsc
patch_zm/maps/mp/zombies/_zm_perks.gsc
patch_zm/maps/mp/zombies/_zm_powerups.gsc
patch_zm/maps/mp/zombies/_zm_weapons.gsc
```
```
patch_zm/maps/mp/gametypes_zm/_zm_gametype.gsc
```
```
zm_transit_patch/maps/mp/zombies/_zm_weap_jetgun.gsc
```
```
zm_highrise_patch/maps/mp/zombies/_zm_weap_slipgun.gsc
```
### The following scripts compile and run serverside but clients cannot join due to exe_client_field_mismatch
```
patch_zm/maps/mp/zombies/_zm.gsc
patch_zm/maps/mp/zombies/_zm_gump.gsc
patch_zm/maps/mp/zombies/_zm_equipment.gsc
```
### The following scripts compile but cause a minidump or other severe error:
```
patch_zm/maps/mp/zombies/_load.gsc
```
### notes:
```
zm_transit_utility.gsc can be recompiled to fix tombstone
```

891
Fixed Zombies GSCs for compiling/zm_highrise_patch/maps/mp/zombies/_zm_weap_slipgun.gsc
View File

@ -1,891 +0,0 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/animscripts/zm_shared;
#include maps/mp/animscripts/zm_utility;
#include maps/mp/zombies/_zm;
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/gametypes_zm/_weaponobjects;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
set_zombie_var_once( var, value, is_float, column, is_team_based )
{
if ( !isDefined( level.zombie_vars ) || !isDefined( level.zombie_vars[ var ] ) )
{
set_zombie_var( var, value, is_float, column, is_team_based );
}
}
init()
{
if ( !maps/mp/zombies/_zm_weapons::is_weapon_included( "slipgun_zm" ) )
{
return;
}
precachemodel( "t5_weapon_crossbow_bolt" );
precacheitem( "slip_bolt_zm" );
precacheitem( "slip_bolt_upgraded_zm" );
if ( is_true( level.slipgun_as_equipment ) )
{
maps/mp/zombies/_zm_equipment::register_equipment( "slipgun_zm", &"ZM_HIGHRISE_EQUIP_SLIPGUN_PICKUP_HINT_STRING", &"ZM_HIGHRISE_EQUIP_SLIPGUN_HOWTO", "jetgun_zm_icon", "slipgun", ::slipgun_activation_watcher_thread, ::transferslipgun, ::dropslipgun, ::pickupslipgun );
maps/mp/zombies/_zm_equipment::enemies_ignore_equipment( "slipgun_zm" );
maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "slipgun", &"ZM_HIGHRISE_EQUIP_SLIPGUN_PICKUP_HINT_STRING" );
}
set_zombie_var_once( "slipgun_reslip_max_spots", 8 );
set_zombie_var_once( "slipgun_reslip_rate", 6 );
set_zombie_var_once( "slipgun_max_kill_chain_depth", 16 );
set_zombie_var_once( "slipgun_max_kill_round", 100 );
set_zombie_var_once( "slipgun_chain_radius", 120 );
set_zombie_var_once( "slipgun_chain_wait_min", 0.75, 1 );
set_zombie_var_once( "slipgun_chain_wait_max", 1.5, 1 );
level.slippery_spot_count = 0;
level.sliquifier_distance_checks = 0;
maps/mp/zombies/_zm_spawner::register_zombie_damage_callback( ::slipgun_zombie_damage_response );
maps/mp/zombies/_zm_spawner::register_zombie_death_animscript_callback( ::slipgun_zombie_death_response );
level._effect[ "slipgun_explode" ] = loadfx( "weapon/liquifier/fx_liquifier_goo_explo" );
level._effect[ "slipgun_splatter" ] = loadfx( "maps/zombie/fx_zmb_goo_splat" );
level._effect[ "slipgun_simmer" ] = loadfx( "weapon/liquifier/fx_liquifier_goo_sizzle" );
level._effect[ "slipgun_viewmodel_eject" ] = loadfx( "weapon/liquifier/fx_liquifier_clip_eject" );
level._effect[ "slipgun_viewmodel_reload" ] = loadfx( "weapon/liquifier/fx_liquifier_reload_steam" );
onplayerconnect_callback( ::slipgun_player_connect );
thread wait_init_damage();
}
wait_init_damage()
{
while ( !isDefined( level.zombie_vars ) || !isDefined( level.zombie_vars[ "zombie_health_start" ] ) )
{
wait 1;
}
wait 1;
level.slipgun_damage = maps/mp/zombies/_zm::ai_zombie_health( level.zombie_vars[ "slipgun_max_kill_round" ] );
level.slipgun_damage_mod = "MOD_PROJECTILE_SPLASH";
}
slipgun_player_connect()
{
self thread watch_for_slip_bolt();
}
watch_for_slip_bolt()
{
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "grenade_fire", grenade, weaponname, parent );
self.num_sliquifier_kills = 0;
switch( weaponname )
{
case "slip_bolt_zm":
grenade thread slip_bolt( self, 0 );
break;
continue;
case "slip_bolt_upgraded_zm":
grenade thread slip_bolt( self, 1 );
break;
continue;
}
}
}
slip_bolt( player, upgraded )
{
startpos = player getweaponmuzzlepoint();
self waittill( "explode", position );
duration = 24;
if ( upgraded )
{
duration = 36;
}
thread add_slippery_spot( position, duration, startpos );
}
dropslipgun()
{
item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "t6_wpn_zmb_slipgun_world", "slipgun_zm", self.origin + vectorScale( ( 0, 0, 1 ), 30 ), self.angles );
if ( isDefined( item ) )
{
item.original_owner = self;
item.owner = undefined;
item.name = "slipgun_zm";
item.requires_pickup = 1;
item.clipammo = self getweaponammoclip( item.name );
item.stockammo = self getweaponammostock( item.name );
}
self takeweapon( "slipgun_zm" );
return item;
}
pickupslipgun( item )
{
item.owner = self;
self giveweapon( item.name );
if ( isDefined( item.clipammo ) && isDefined( item.stockammo ) )
{
self setweaponammoclip( item.name, item.clipammo );
self setweaponammostock( item.name, item.stockammo );
item.clipammo = undefined;
item.stockammo = undefined;
}
}
transferslipgun( fromplayer, toplayer )
{
toplayer notify( "slipgun_zm_taken" );
fromplayer notify( "slipgun_zm_taken" );
}
slipgun_activation_watcher_thread()
{
self endon( "zombified" );
self endon( "disconnect" );
self endon( "slipgun_zm_taken" );
while ( 1 )
{
self waittill_either( "slipgun_zm_activate", "slipgun_zm_deactivate" );
}
}
slipgun_debug_circle( origin, radius, seconds, onslope, parent, start )
{
/*
/#
if ( getDvarInt( #"6136A815" ) )
{
frames = int( 20 * seconds );
if ( isDefined( parent ) )
{
time = seconds;
frames = 1;
while ( time > 0 )
{
morigin = origin + ( parent.origin - start );
if ( isDefined( onslope ) && onslope )
{
circle( morigin, radius, ( 0, 0, 1 ), 0, 1, frames );
}
else
{
circle( morigin, radius, ( 0, 0, 1 ), 0, 1, frames );
}
time -= 0,05;
wait 0,05;
}
}
else if ( isDefined( onslope ) && onslope )
{
circle( origin, radius, ( 0, 0, 1 ), 0, 1, frames );
return;
}
else
{
circle( origin, radius, ( 0, 0, 1 ), 0, 1, frames );
#/
}
}
*/
}
slipgun_debug_line( start, end, color, seconds )
{
/*
/#
if ( getDvarInt( #"6136A815" ) )
{
frames = int( 20 * seconds );
line( start, end, color, 1, 0, frames );
#/
}
*/
}
canzombieongoofall()
{
if ( is_true( self.is_inert ) )
{
return 0;
}
if ( is_true( self.is_traversing ) )
{
return 0;
}
if ( is_true( self.barricade_enter ) )
{
return 0;
}
if ( randomint( 100 ) < 20 )
{
trace = groundtrace( self.origin + vectorScale( ( 0, 0, 1 ), 5 ), self.origin + vectorScale( ( 0, 0, 1 ), 300 ), 0, undefined );
origin = trace[ "position" ];
groundnormal = trace[ "normal" ];
if ( distancesquared( self.origin, origin ) > 256 )
{
return 0;
}
dot = vectordot( ( 0, 0, 1 ), groundnormal );
if ( dot < 0.9 )
{
return 0;
}
trace_origin = self.origin + vectorScale( anglesToForward( self.angles ), 200 );
trace = groundtrace( trace_origin + vectorScale( ( 0, 0, 1 ), 5 ), self.origin + vectorScale( ( 0, 0, 1 ), 300 ), 0, undefined );
origin = trace[ "position" ];
groundnormal = trace[ "normal" ];
if ( distancesquared( trace_origin, origin ) > 256 )
{
return 0;
}
dot = vectordot( ( 0, 0, 1 ), groundnormal );
if ( dot < 0.9 )
{
return 0;
}
return 1;
}
return 0;
}
zombiemoveongoo()
{
self endon( "death" );
self endon( "removed" );
level endon( "intermission" );
if ( is_true( self.sliding_on_goo ) )
{
return;
}
self notify( "endOnGoo" );
self endon( "endOnGoo" );
self notify( "stop_zombie_goto_entrance" );
self notify( "stop_find_flesh" );
self notify( "zombie_acquire_enemy" );
self.goo_last_vel = self getvelocity();
self.goo_last_pos = self.origin;
slide_direction = anglesToForward( self.angles );
self animmode( "slide" );
self orientmode( "face enemy" );
self.forcemovementscriptstate = 1;
self.ai_state = "zombieMoveOnGoo";
self maps/mp/zombies/_zm_spawner::zombie_history( "zombieMoveOnGoo " + getTime() );
self.sliding_on_goo = 0;
self thread zombiemoveongoo_on_killanimscript();
for ( ;; )
{
while ( 1 )
{
if ( isDefined( self.is_on_goo ) )
{
self_on_goo = self.is_on_goo;
}
velocity = self getvelocity();
velocitylength = length( self getvelocity() );
if ( isDefined( self.has_legs ) )
{
iscrawler = !self.has_legs;
}
isleaper = self is_leaper();
while ( is_true( self.is_leaping ) )
{
wait 0.1;
}
if ( !self_on_goo )
{
self animcustom( ::zombie_moveongoo_animcustom_recover );
self waittill( "zombie_MoveOnGoo_animCustom_recover_done" );
break;
}
else
{
if ( velocitylength <= 0.2 )
{
self animmode( "normal" );
wait 0.1;
self animmode( "slide" );
}
if ( !self.sliding_on_goo || !issubstr( self.zombie_move_speed, "slide" ) )
{
if ( !iscrawler && !isleaper && !isDefined( self.fell_while_sliding ) && canzombieongoofall() )
{
self animcustom( ::zombie_moveongoo_animcustom_fall );
self waittill( "zombie_MoveOnGoo_animCustom_fall_done" );
}
}
else self.sliding_on_goo = 1;
if ( velocitylength <= 0.2 )
{
wait 0.1;
}
self animmode( "slide" );
self orientmode( "face enemy" );
if ( self.zombie_move_speed == "sprint" )
{
if ( !isDefined( self.zombie_move_speed ) || isDefined( self.zombie_move_speed ) && self.zombie_move_speed != "sprint_slide" )
{
animstatedef = self maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "sprint_slide" );
self set_zombie_run_cycle( animstatedef );
}
break;
}
else if ( self.zombie_move_speed == "run" )
{
if ( !isDefined( self.zombie_move_speed ) || isDefined( self.zombie_move_speed ) && self.zombie_move_speed != "run_slide" )
{
animstatedef = self maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "run_slide" );
self set_zombie_run_cycle( animstatedef );
}
break;
}
else
{
if ( !isDefined( self.zombie_move_speed ) || isDefined( self.zombie_move_speed ) && self.zombie_move_speed != "walk_slide" )
{
animstatedef = self maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "walk_slide" );
self set_zombie_run_cycle( animstatedef );
}
}
}
wait 0.05;
}
}
zombiemoveongoo_gobacktonormal();
}
zombie_moveongoo_animcustom_fall()
{
self endon( "death" );
self endon( "removed" );
level endon( "intermission" );
self.fell_while_sliding = 1;
self animmode( "normal" );
self orientmode( "face angle", self.angles[ 1 ] );
fallanimstatedef = "zm_move_slide_fall";
self setanimstatefromasd( fallanimstatedef );
maps/mp/animscripts/zm_shared::donotetracks( "slide_fall_anim" );
self notify( "zombie_MoveOnGoo_animCustom_fall_done" );
}
zombie_moveongoo_animcustom_recover()
{
self endon( "death" );
self endon( "removed" );
level endon( "intermission" );
self.recovering_from_goo = 1;
if ( randomint( 100 ) < 50 )
{
animstatedef = maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "zm_move_slide_recover" );
self setanimstatefromasd( animstatedef );
maps/mp/animscripts/zm_shared::donotetracks( "slide_recover_anim" );
}
self.recovering_from_goo = 0;
zombiemoveongoo_gobacktonormal();
self notify( "zombie_MoveOnGoo_animCustom_recover_done" );
}
zombiemoveongoo_on_killanimscript()
{
self endon( "death" );
self endon( "removed" );
level endon( "intermission" );
self notify( "zombieMoveOnGoo_on_killAnimScript_thread" );
self endon( "zombieMoveOnGoo_on_killAnimScript_thread" );
self waittill_any( "endOnGoo", "killanimscript" );
zombiemoveongoo_gobacktonormal();
}
zombiemoveongoo_gobacktonormal()
{
self animmode( "normal" );
self set_zombie_run_cycle();
self.sliding_on_goo = 0;
self.fell_while_sliding = undefined;
self notify( "zombieMoveOnGoo_on_killAnimScript_thread" );
self notify( "endOnGoo" );
self.forcemovementscriptstate = 0;
if ( !is_true( self.completed_emerging_into_playable_area ) )
{
/*
/#
assert( isDefined( self.first_node ) );
#/
*/
self maps/mp/zombies/_zm_spawner::reset_attack_spot();
self orientmode( "face default" );
self thread maps/mp/zombies/_zm_spawner::zombie_goto_entrance( self.first_node );
}
else
{
self orientmode( "face enemy" );
self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
}
}
zombie_can_slip()
{
if ( is_true( self.barricade_enter ) )
{
return 0;
}
if ( is_true( self.is_traversing ) )
{
return 0;
}
if ( !is_true( self.completed_emerging_into_playable_area ) && !isDefined( self.first_node ) )
{
return 0;
}
if ( is_true( self.is_leaping ) )
{
return 0;
}
return 1;
}
zombie_set_slipping( onoff )
{
if ( isDefined( self ) )
{
self.is_on_goo = onoff;
if ( onoff )
{
self thread zombiemoveongoo();
}
}
}
slippery_spot_choke( lifetime )
{
level.sliquifier_distance_checks++;
if ( level.sliquifier_distance_checks >= 32 )
{
level.sliquifier_distance_checks = 0;
lifetime -= 0.05;
wait 0.05;
}
return lifetime;
}
add_slippery_spot( origin, duration, startpos )
{
wait 0.5;
level.slippery_spot_count++;
hit_norm = vectornormalize( startpos - origin );
hit_from = 6 * hit_norm;
trace_height = 120;
trace = bullettrace( origin + hit_from, origin + hit_from + ( 0, 0, trace_height * -1 ), 0, undefined );
if ( isDefined( trace[ "entity" ] ) )
{
parent = trace[ "entity" ];
if ( is_true( parent.can_move ) )
{
return;
}
}
fxorigin = origin + hit_from;
/*
/#
red = ( 0, 0, 1 );
green = ( 0, 0, 1 );
dkgreen = vectorScale( ( 0, 0, 1 ), 0,15 );
blue = ( 0, 0, 1 );
grey = vectorScale( ( 0, 0, 1 ), 0,3 );
black = ( 0, 0, 1 );
slipgun_debug_line( origin, origin + hit_from, red, duration );
if ( trace[ "fraction" ] == 1 )
{
slipgun_debug_line( origin + hit_from, origin + hit_from + ( 0, 0, trace_height * -1 ), grey, duration );
}
else
{
slipgun_debug_line( origin + hit_from, trace[ "position" ], green, duration );
slipgun_debug_line( trace[ "position" ], origin + hit_from + ( 0, 0, trace_height * -1 ), dkgreen, duration );
#/
}
*/
if ( trace[ "fraction" ] == 1 )
{
return;
}
moving_parent = undefined;
moving_parent_start = ( 0, 0, 1 );
if ( isDefined( trace[ "entity" ] ) )
{
parent = trace[ "entity" ];
if ( is_true( parent.can_move ) )
{
return;
}
}
origin = trace[ "position" ];
thread pool_of_goo( fxorigin, duration );
if ( !isDefined( level.slippery_spots ) )
{
level.slippery_spots = [];
}
level.slippery_spots[ level.slippery_spots.size ] = origin;
radius = 60;
height = 48;
/*
/#
thread slipgun_debug_circle( origin, radius, duration, 0, moving_parent, moving_parent_start );
#/
*/
slicked_players = [];
slicked_zombies = [];
lifetime = duration;
radius2 = radius * radius;
while ( lifetime > 0 )
{
oldlifetime = lifetime;
_a612 = get_players();
_k612 = getFirstArrayKey( _a612 );
while ( isDefined( _k612 ) )
{
player = _a612[ _k612 ];
num = player getentitynumber();
morigin = origin;
if ( isDefined( moving_parent ) )
{
morigin = origin + ( moving_parent.origin - moving_parent_start );
}
if ( distance2dsquared( player.origin, morigin ) < radius2 )
{
should_be_slick = abs( player.origin[ 2 ] - morigin[ 2 ] ) < height;
}
is_slick = isDefined( slicked_players[ num ] );
if ( should_be_slick != is_slick )
{
if ( !isDefined( player.slick_count ) )
{
player.slick_count = 0;
}
if ( should_be_slick )
{
player.slick_count++;
slicked_players[ num ] = player;
}
else
{
player.slick_count--;
/*
/#
assert( player.slick_count >= 0 );
#/
*/
}
player forceslick( player.slick_count );
}
lifetime = slippery_spot_choke( lifetime );
_k612 = getNextArrayKey( _a612, _k612 );
}
zombies = get_round_enemy_array();
while ( isDefined( zombies ) )
{
_a645 = zombies;
_k645 = getFirstArrayKey( _a645 );
while ( isDefined( _k645 ) )
{
zombie = _a645[ _k645 ];
if ( isDefined( zombie ) )
{
num = zombie getentitynumber();
morigin = origin;
if ( isDefined( moving_parent ) )
{
morigin = origin + ( moving_parent.origin - moving_parent_start );
}
if ( distance2dsquared( zombie.origin, morigin ) < radius2 )
{
should_be_slick = abs( zombie.origin[ 2 ] - morigin[ 2 ] ) < height;
}
if ( should_be_slick && !zombie zombie_can_slip() )
{
should_be_slick = 0;
}
is_slick = isDefined( slicked_zombies[ num ] );
if ( should_be_slick != is_slick )
{
if ( !isDefined( zombie.slick_count ) )
{
zombie.slick_count = 0;
}
if ( should_be_slick )
{
zombie.slick_count++;
slicked_zombies[ num ] = zombie;
}
else
{
if ( zombie.slick_count > 0 )
{
zombie.slick_count--;
}
}
zombie zombie_set_slipping( zombie.slick_count > 0 );
}
lifetime = slippery_spot_choke( lifetime );
}
_k645 = getNextArrayKey( _a645, _k645 );
}
}
if ( oldlifetime == lifetime )
{
lifetime -= 0.05;
wait 0.05;
}
}
_a684 = slicked_players;
_k684 = getFirstArrayKey( _a684 );
while ( isDefined( _k684 ) )
{
player = _a684[ _k684 ];
player.slick_count--;
/*
/#
assert( player.slick_count >= 0 );
#/
*/
player forceslick( player.slick_count );
_k684 = getNextArrayKey( _a684, _k684 );
}
_a690 = slicked_zombies;
_k690 = getFirstArrayKey( _a690 );
while ( isDefined( _k690 ) )
{
zombie = _a690[ _k690 ];
if ( isDefined( zombie ) )
{
if ( zombie.slick_count > 0 )
{
zombie.slick_count--;
}
zombie zombie_set_slipping( zombie.slick_count > 0 );
}
_k690 = getNextArrayKey( _a690, _k690 );
}
arrayremovevalue( level.slippery_spots, origin, 0 );
level.slippery_spot_count--;
}
pool_of_goo( origin, duration )
{
effect_life = 24;
if ( duration > effect_life )
{
pool_of_goo( origin, duration - effect_life );
duration = effect_life;
}
if ( isDefined( level._effect[ "slipgun_splatter" ] ) )
{
playfx( level._effect[ "slipgun_splatter" ], origin );
}
wait duration;
}
explode_into_goo( player, chain_depth )
{
if ( isDefined( self.marked_for_insta_upgraded_death ) )
{
return;
}
tag = "J_SpineLower";
if ( is_true( self.isdog ) )
{
tag = "tag_origin";
}
self.guts_explosion = 1;
self playsound( "wpn_slipgun_zombie_explode" );
if ( isDefined( level._effect[ "slipgun_explode" ] ) )
{
playfx( level._effect[ "slipgun_explode" ], self gettagorigin( tag ) );
}
if ( !is_true( self.isdog ) )
{
wait 0.1;
}
self ghost();
if ( !isDefined( self.goo_chain_depth ) )
{
self.goo_chain_depth = chain_depth;
}
chain_radius = level.zombie_vars[ "slipgun_chain_radius" ];
level thread explode_to_near_zombies( player, self.origin, chain_radius, self.goo_chain_depth );
}
explode_to_near_zombies( player, origin, radius, chain_depth )
{
if ( level.zombie_vars[ "slipgun_max_kill_chain_depth" ] > 0 && chain_depth > level.zombie_vars[ "slipgun_max_kill_chain_depth" ] )
{
return;
}
enemies = get_round_enemy_array();
enemies = get_array_of_closest( origin, enemies );
minchainwait = level.zombie_vars[ "slipgun_chain_wait_min" ];
maxchainwait = level.zombie_vars[ "slipgun_chain_wait_max" ];
rsquared = radius * radius;
tag = "J_Head";
marked_zombies = [];
while ( isDefined( enemies ) && enemies.size )
{
index = 0;
enemy = enemies[ index ];
while ( distancesquared( enemy.origin, origin ) < rsquared )
{
if ( isalive( enemy ) && !is_true( enemy.guts_explosion ) && !is_true( enemy.nuked ) && !isDefined( enemy.slipgun_sizzle ) )
{
trace = bullettrace( origin + vectorScale( ( 0, 0, 1 ), 50 ), enemy.origin + vectorScale( ( 0, 0, 1 ), 50 ), 0, undefined, 1 );
if ( isDefined( trace[ "fraction" ] ) && trace[ "fraction" ] == 1 )
{
enemy.slipgun_sizzle = playfxontag( level._effect[ "slipgun_simmer" ], enemy, tag );
marked_zombies[ marked_zombies.size ] = enemy;
}
}
index++;
if ( index >= enemies.size )
{
break;
}
else
{
enemy = enemies[ index ];
}
}
}
while ( isDefined( marked_zombies ) && marked_zombies.size )
{
_a799 = marked_zombies;
_k799 = getFirstArrayKey( _a799 );
while ( isDefined( _k799 ) )
{
enemy = _a799[ _k799 ];
if ( isalive( enemy ) && !is_true( enemy.guts_explosion ) && !is_true( enemy.nuked ) )
{
wait randomfloatrange( minchainwait, maxchainwait );
if ( isalive( enemy ) && !is_true( enemy.guts_explosion ) && !is_true( enemy.nuked ) )
{
if ( !isDefined( enemy.goo_chain_depth ) )
{
enemy.goo_chain_depth = chain_depth;
}
if ( enemy.health > 0 )
{
if ( player maps/mp/zombies/_zm_powerups::is_insta_kill_active() )
{
enemy.health = 1;
}
enemy dodamage( level.slipgun_damage, origin, player, player, "none", level.slipgun_damage_mod, 0, "slip_goo_zm" );
}
if ( level.slippery_spot_count < level.zombie_vars[ "slipgun_reslip_max_spots" ] )
{
if ( isDefined( enemy.slick_count ) && enemy.slick_count == 0 && enemy.health <= 0 )
{
if ( level.zombie_vars[ "slipgun_reslip_rate" ] > 0 && randomint( level.zombie_vars[ "slipgun_reslip_rate" ] ) == 0 )
{
startpos = origin;
duration = 24;
thread add_slippery_spot( enemy.origin, duration, startpos );
}
}
}
}
}
_k799 = getNextArrayKey( _a799, _k799 );
}
}
}
slipgun_zombie_1st_hit_response( upgraded, player )
{
self notify( "stop_find_flesh" );
self notify( "zombie_acquire_enemy" );
self orientmode( "face default" );
self.ignoreall = 1;
self.gibbed = 1;
if ( isalive( self ) )
{
if ( !isDefined( self.goo_chain_depth ) )
{
self.goo_chain_depth = 0;
}
if ( self.health > 0 )
{
if ( player maps/mp/zombies/_zm_powerups::is_insta_kill_active() )
{
self.health = 1;
}
self dodamage( level.slipgun_damage, self.origin, player, player, "none", level.slipgun_damage_mod, 0, "slip_goo_zm" );
}
}
}
slipgun_zombie_hit_response_internal( mod, damageweapon, player )
{
if ( !self is_slipgun_damage( mod, damageweapon ) && !is_slipgun_explosive_damage( mod, damageweapon ) )
{
return 0;
}
self playsound( "wpn_slipgun_zombie_impact" );
upgraded = damageweapon == "slipgun_upgraded_zm";
self thread slipgun_zombie_1st_hit_response( upgraded, player );
if ( isDefined( player ) && isplayer( player ) )
{
player thread slipgun_play_zombie_hit_vox();
}
return 1;
}
slipgun_zombie_damage_response( mod, hit_location, hit_origin, player, amount )
{
return slipgun_zombie_hit_response_internal( mod, self.damageweapon, player );
}
slipgun_zombie_death_response()
{
if ( !self is_slipgun_damage( self.damagemod, self.damageweapon ) && !is_slipgun_explosive_damage( self.damagemod, self.damageweapon ) )
{
return 0;
}
level maps/mp/zombies/_zm_spawner::zombie_death_points( self.origin, self.damagemod, self.damagelocation, self.attacker, self );
self explode_into_goo( self.attacker, 0 );
return 1;
}
is_slipgun_explosive_damage( mod, weapon )
{
if ( isDefined( weapon ) )
{
if ( weapon != "slip_goo_zm" && weapon != "slip_bolt_zm" )
{
return weapon == "slip_bolt_upgraded_zm";
}
}
}
is_slipgun_damage( mod, weapon )
{
if ( isDefined( weapon ) )
{
if ( weapon != "slipgun_zm" )
{
return weapon == "slipgun_upgraded_zm";
}
}
}
slipgun_play_zombie_hit_vox()
{
rand = randomintrange( 0, 101 );
if ( rand >= 20 )
{
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "kill", "human" );
}
}

730
Fixed Zombies GSCs for compiling/zm_transit_patch/maps/mp/gametypes_zm/zgrief.gsc
View File

@ -1,730 +0,0 @@
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_audio_announcer;
#include maps/mp/zombies/_zm_zonemgr;
#include maps/mp/_demo;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_weap_cymbal_monkey;
#include maps/mp/zombies/_zm_magicbox;
#include maps/mp/zombies/_zm_game_module;
#include maps/mp/zombies/_zm;
#include maps/mp/zombies/_zm_game_module_meat_utility;
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/gametypes_zm/zmeat;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
#include maps/mp/zombies/_zm_spawner;
main()
{
maps/mp/gametypes_zm/_zm_gametype::main();
level.onprecachegametype = ::onprecachegametype;
level.onstartgametype = ::onstartgametype;
level.custom_spectate_permissions = ::setspectatepermissionsgrief;
level._game_module_custom_spawn_init_func = ::custom_spawn_init_func;
//level._game_module_stat_update_func = ::maps/mp/zombies/_zm_stats::grief_custom_stat_update;
level._game_module_player_damage_callback = ::game_module_player_damage_callback;
level.custom_end_screen = ::custom_end_screen;
level.gamemode_map_postinit[ "zgrief" ] = ::postinit_func;
level._supress_survived_screen = 1;
level.game_module_team_name_override_og_x = 155;
level.prevent_player_damage = ::player_prevent_damage;
level._game_module_player_damage_grief_callback = ::game_module_player_damage_grief_callback;
level._grief_reset_message = ::grief_reset_message;
level._game_module_player_laststand_callback = ::grief_laststand_weapon_save;
level.onplayerspawned_restore_previous_weapons = ::grief_laststand_weapons_return;
level.game_module_onplayerconnect = ::grief_onplayerconnect;
level.game_mode_spawn_player_logic = ::game_mode_spawn_player_logic;
level.game_mode_custom_onplayerdisconnect = ::grief_onplayerdisconnect;
maps/mp/gametypes_zm/_zm_gametype::post_gametype_main( "zgrief" );
}
grief_onplayerconnect()
{
self thread move_team_icons();
self thread zgrief_player_bled_out_msg();
}
grief_onplayerdisconnect( disconnecting_player )
{
level thread update_players_on_bleedout_or_disconnect( disconnecting_player );
}
setspectatepermissionsgrief()
{
self allowspectateteam( "allies", 1 );
self allowspectateteam( "axis", 1 );
self allowspectateteam( "freelook", 0 );
self allowspectateteam( "none", 1 );
}
custom_end_screen()
{
players = get_players();
i = 0;
while ( i < players.size )
{
players[ i ].game_over_hud = newclienthudelem( players[ i ] );
players[ i ].game_over_hud.alignx = "center";
players[ i ].game_over_hud.aligny = "middle";
players[ i ].game_over_hud.horzalign = "center";
players[ i ].game_over_hud.vertalign = "middle";
players[ i ].game_over_hud.y -= 130;
players[ i ].game_over_hud.foreground = 1;
players[ i ].game_over_hud.fontscale = 3;
players[ i ].game_over_hud.alpha = 0;
players[ i ].game_over_hud.color = ( 1, 1, 1 );
players[ i ].game_over_hud.hidewheninmenu = 1;
players[ i ].game_over_hud settext( &"ZOMBIE_GAME_OVER" );
players[ i ].game_over_hud fadeovertime( 1 );
players[ i ].game_over_hud.alpha = 1;
if ( players[ i ] issplitscreen() )
{
players[ i ].game_over_hud.fontscale = 2;
players[ i ].game_over_hud.y += 40;
}
players[ i ].survived_hud = newclienthudelem( players[ i ] );
players[ i ].survived_hud.alignx = "center";
players[ i ].survived_hud.aligny = "middle";
players[ i ].survived_hud.horzalign = "center";
players[ i ].survived_hud.vertalign = "middle";
players[ i ].survived_hud.y -= 100;
players[ i ].survived_hud.foreground = 1;
players[ i ].survived_hud.fontscale = 2;
players[ i ].survived_hud.alpha = 0;
players[ i ].survived_hud.color = ( 1, 1, 1 );
players[ i ].survived_hud.hidewheninmenu = 1;
if ( players[ i ] issplitscreen() )
{
players[ i ].survived_hud.fontscale = 1.5;
players[ i ].survived_hud.y += 40;
}
winner_text = &"ZOMBIE_GRIEF_WIN";
loser_text = &"ZOMBIE_GRIEF_LOSE";
if ( level.round_number < 2 )
{
winner_text = &"ZOMBIE_GRIEF_WIN_SINGLE";
loser_text = &"ZOMBIE_GRIEF_LOSE_SINGLE";
}
if ( isDefined( level.host_ended_game ) && level.host_ended_game )
{
players[ i ].survived_hud settext( &"MP_HOST_ENDED_GAME" );
}
else
{
if ( isDefined( level.gamemodulewinningteam ) && players[ i ]._encounters_team == level.gamemodulewinningteam )
{
players[ i ].survived_hud settext( winner_text, level.round_number );
break;
}
else
{
players[ i ].survived_hud settext( loser_text, level.round_number );
}
}
players[ i ].survived_hud fadeovertime( 1 );
players[ i ].survived_hud.alpha = 1;
i++;
}
}
postinit_func()
{
level.min_humans = 1;
level.zombie_ai_limit = 24;
level.prevent_player_damage = ::player_prevent_damage;
level.lock_player_on_team_score = 1;
level._zombie_spawning = 0;
level._get_game_module_players = undefined;
level.powerup_drop_count = 0;
level.is_zombie_level = 1;
setmatchtalkflag( "DeadChatWithDead", 1 );
setmatchtalkflag( "DeadChatWithTeam", 1 );
setmatchtalkflag( "DeadHearTeamLiving", 1 );
setmatchtalkflag( "DeadHearAllLiving", 1 );
setmatchtalkflag( "EveryoneHearsEveryone", 1 );
}
grief_game_end_check_func()
{
return 0;
}
player_prevent_damage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
{
if ( isDefined( eattacker ) && isplayer( eattacker ) && self != eattacker && !eattacker hasperk( "specialty_noname" ) && isDefined( self.is_zombie ) && !self.is_zombie )
{
return 1;
}
return 0;
}
game_module_player_damage_grief_callback( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
{
penalty = 10;
if ( isDefined( eattacker ) && isplayer( eattacker ) && eattacker != self && eattacker.team != self.team && smeansofdeath == "MOD_MELEE" )
{
self applyknockback( idamage, vdir );
}
}
onprecachegametype()
{
level.playersuicideallowed = 1;
level.suicide_weapon = "death_self_zm";
precacheitem( "death_self_zm" );
precacheshellshock( "grief_stab_zm" );
precacheshader( "faction_cdc" );
precacheshader( "faction_cia" );
precacheshader( "waypoint_revive_cdc_zm" );
precacheshader( "waypoint_revive_cia_zm" );
level._effect[ "butterflies" ] = loadfx( "maps/zombie/fx_zmb_impact_noharm" );
level thread maps/mp/gametypes_zm/_zm_gametype::init();
maps/mp/gametypes_zm/_zm_gametype::rungametypeprecache( "zgrief" );
}
onstartgametype()
{
level.no_end_game_check = 1;
level._game_module_game_end_check = ::grief_game_end_check_func;
level.round_end_custom_logic = ::grief_round_end_custom_logic;
maps/mp/gametypes_zm/_zm_gametype::setup_classic_gametype();
maps/mp/gametypes_zm/_zm_gametype::rungametypemain( "zgrief", ::zgrief_main );
}
zgrief_main()
{
level thread maps/mp/zombies/_zm::round_start();
level thread maps/mp/gametypes_zm/_zm_gametype::kill_all_zombies();
flag_wait( "initial_blackscreen_passed" );
level thread maps/mp/zombies/_zm_game_module::wait_for_team_death_and_round_end();
players = get_players();
_a302 = players;
_k302 = getFirstArrayKey( _a302 );
while ( isDefined( _k302 ) )
{
player = _a302[ _k302 ];
player.is_hotjoin = 0;
_k302 = getNextArrayKey( _a302, _k302 );
}
wait 1;
playsoundatposition( "vox_zmba_grief_intro_0", ( 1, 1, 1 ) );
}
move_team_icons()
{
self endon( "disconnect" );
flag_wait( "initial_blackscreen_passed" );
wait 0.5;
}
kill_start_chest()
{
flag_wait( "initial_blackscreen_passed" );
wait 2;
start_chest = getstruct( "start_chest", "script_noteworthy" );
start_chest maps/mp/zombies/_zm_magicbox::hide_chest();
}
door_close_zombie_think()
{
self endon( "death" );
while ( isalive( self ) )
{
if ( isDefined( self.enemy ) && isplayer( self.enemy ) )
{
insamezone = 0;
keys = getarraykeys( level.zones );
i = 0;
while ( i < keys.size )
{
if ( self maps/mp/zombies/_zm_zonemgr::entity_in_zone( keys[ i ] ) && self.enemy maps/mp/zombies/_zm_zonemgr::entity_in_zone( keys[ i ] ) )
{
insamezone = 1;
}
i++;
}
while ( insamezone )
{
wait 3;
}
nearestzombienode = getnearestnode( self.origin );
nearestplayernode = getnearestnode( self.enemy.origin );
if ( isDefined( nearestzombienode ) && isDefined( nearestplayernode ) )
{
if ( !nodesvisible( nearestzombienode, nearestplayernode ) && !nodescanpath( nearestzombienode, nearestplayernode ) )
{
self silentlyremovezombie();
}
}
}
wait 1;
}
}
silentlyremovezombie()
{
level.zombie_total++;
playfx( level._effect[ "spawn_cloud" ], self.origin );
self.skip_death_notetracks = 1;
self.nodeathragdoll = 1;
self dodamage( self.maxhealth * 2, self.origin, self, self, "none", "MOD_SUICIDE" );
self self_delete();
}
zgrief_player_bled_out_msg()
{
level endon( "end_game" );
self endon( "disconnect" );
while ( 1 )
{
self waittill( "bled_out" );
level thread update_players_on_bleedout_or_disconnect( self );
}
}
show_grief_hud_msg( msg, msg_parm, offset, cleanup_end_game )
{
self endon( "disconnect" );
while ( isDefined( level.hostmigrationtimer ) )
{
wait 0.05;
}
zgrief_hudmsg = newclienthudelem( self );
zgrief_hudmsg.alignx = "center";
zgrief_hudmsg.aligny = "middle";
zgrief_hudmsg.horzalign = "center";
zgrief_hudmsg.vertalign = "middle";
zgrief_hudmsg.y -= 130;
if ( self issplitscreen() )
{
zgrief_hudmsg.y += 70;
}
if ( isDefined( offset ) )
{
zgrief_hudmsg.y += offset;
}
zgrief_hudmsg.foreground = 1;
zgrief_hudmsg.fontscale = 5;
zgrief_hudmsg.alpha = 0;
zgrief_hudmsg.color = ( 1, 1, 1 );
zgrief_hudmsg.hidewheninmenu = 1;
zgrief_hudmsg.font = "default";
if ( isDefined( cleanup_end_game ) && cleanup_end_game )
{
level endon( "end_game" );
zgrief_hudmsg thread show_grief_hud_msg_cleanup();
}
if ( isDefined( msg_parm ) )
{
zgrief_hudmsg settext( msg, msg_parm );
}
else
{
zgrief_hudmsg settext( msg );
}
zgrief_hudmsg changefontscaleovertime( 0.25 );
zgrief_hudmsg fadeovertime( 0.25 );
zgrief_hudmsg.alpha = 1;
zgrief_hudmsg.fontscale = 2;
wait 3.25;
zgrief_hudmsg changefontscaleovertime( 1 );
zgrief_hudmsg fadeovertime( 1 );
zgrief_hudmsg.alpha = 0;
zgrief_hudmsg.fontscale = 5;
wait 1;
zgrief_hudmsg notify( "death" );
if ( isDefined( zgrief_hudmsg ) )
{
zgrief_hudmsg destroy();
}
}
show_grief_hud_msg_cleanup()
{
self endon( "death" );
level waittill( "end_game" );
if ( isDefined( self ) )
{
self destroy();
}
}
grief_reset_message()
{
msg = &"ZOMBIE_GRIEF_RESET";
players = get_players();
if ( isDefined( level.hostmigrationtimer ) )
{
while ( isDefined( level.hostmigrationtimer ) )
{
wait 0.05;
}
wait 4;
}
_a697 = players;
_k697 = getFirstArrayKey( _a697 );
while ( isDefined( _k697 ) )
{
player = _a697[ _k697 ];
player thread show_grief_hud_msg( msg );
_k697 = getNextArrayKey( _a697, _k697 );
}
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "grief_restarted" );
}
grief_laststand_weapon_save( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
{
self.grief_savedweapon_weapons = self getweaponslist();
self.grief_savedweapon_weaponsammo_stock = [];
self.grief_savedweapon_weaponsammo_clip = [];
self.grief_savedweapon_currentweapon = self getcurrentweapon();
self.grief_savedweapon_grenades = self get_player_lethal_grenade();
if ( isDefined( self.grief_savedweapon_grenades ) )
{
self.grief_savedweapon_grenades_clip = self getweaponammoclip( self.grief_savedweapon_grenades );
}
self.grief_savedweapon_tactical = self get_player_tactical_grenade();
if ( isDefined( self.grief_savedweapon_tactical ) )
{
self.grief_savedweapon_tactical_clip = self getweaponammoclip( self.grief_savedweapon_tactical );
}
i = 0;
while ( i < self.grief_savedweapon_weapons.size )
{
self.grief_savedweapon_weaponsammo_clip[ i ] = self getweaponammoclip( self.grief_savedweapon_weapons[ i ] );
self.grief_savedweapon_weaponsammo_stock[ i ] = self getweaponammostock( self.grief_savedweapon_weapons[ i ] );
i++;
}
if ( isDefined( self.hasriotshield ) && self.hasriotshield )
{
self.grief_hasriotshield = 1;
}
if ( self hasweapon( "claymore_zm" ) )
{
self.grief_savedweapon_claymore = 1;
self.grief_savedweapon_claymore_clip = self getweaponammoclip( "claymore_zm" );
}
if ( isDefined( self.current_equipment ) )
{
self.grief_savedweapon_equipment = self.current_equipment;
}
}
grief_laststand_weapons_return()
{
if ( isDefined( level.isresetting_grief ) && !level.isresetting_grief )
{
return 0;
}
if ( !isDefined( self.grief_savedweapon_weapons ) )
{
return 0;
}
primary_weapons_returned = 0;
_a766 = self.grief_savedweapon_weapons;
index = getFirstArrayKey( _a766 );
while ( isDefined( index ) )
{
weapon = _a766[ index ];
if ( isDefined( self.grief_savedweapon_grenades ) || weapon == self.grief_savedweapon_grenades && isDefined( self.grief_savedweapon_tactical ) && weapon == self.grief_savedweapon_tactical )
{
}
else
{
if ( isweaponprimary( weapon ) )
{
if ( primary_weapons_returned >= 2 )
{
break;
}
else primary_weapons_returned++;
}
if ( weapon == "item_meat_zm" )
{
break;
}
else
{
self giveweapon( weapon, 0, self maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( weapon ) );
if ( isDefined( self.grief_savedweapon_weaponsammo_clip[ index ] ) )
{
self setweaponammoclip( weapon, self.grief_savedweapon_weaponsammo_clip[ index ] );
}
if ( isDefined( self.grief_savedweapon_weaponsammo_stock[ index ] ) )
{
self setweaponammostock( weapon, self.grief_savedweapon_weaponsammo_stock[ index ] );
}
}
}
index = getNextArrayKey( _a766, index );
}
if ( isDefined( self.grief_savedweapon_grenades ) )
{
self giveweapon( self.grief_savedweapon_grenades );
if ( isDefined( self.grief_savedweapon_grenades_clip ) )
{
self setweaponammoclip( self.grief_savedweapon_grenades, self.grief_savedweapon_grenades_clip );
}
}
if ( isDefined( self.grief_savedweapon_tactical ) )
{
self giveweapon( self.grief_savedweapon_tactical );
if ( isDefined( self.grief_savedweapon_tactical_clip ) )
{
self setweaponammoclip( self.grief_savedweapon_tactical, self.grief_savedweapon_tactical_clip );
}
}
if ( isDefined( self.current_equipment ) )
{
self maps/mp/zombies/_zm_equipment::equipment_take( self.current_equipment );
}
if ( isDefined( self.grief_savedweapon_equipment ) )
{
self.do_not_display_equipment_pickup_hint = 1;
self maps/mp/zombies/_zm_equipment::equipment_give( self.grief_savedweapon_equipment );
self.do_not_display_equipment_pickup_hint = undefined;
}
if ( isDefined( self.grief_hasriotshield ) && self.grief_hasriotshield )
{
if ( isDefined( self.player_shield_reset_health ) )
{
self [[ self.player_shield_reset_health ]]();
}
}
if ( isDefined( self.grief_savedweapon_claymore ) && self.grief_savedweapon_claymore )
{
self giveweapon( "claymore_zm" );
self set_player_placeable_mine( "claymore_zm" );
self setactionslot( 4, "weapon", "claymore_zm" );
self setweaponammoclip( "claymore_zm", self.grief_savedweapon_claymore_clip );
}
primaries = self getweaponslistprimaries();
_a859 = primaries;
_k859 = getFirstArrayKey( _a859 );
while ( isDefined( _k859 ) )
{
weapon = _a859[ _k859 ];
if ( isDefined( self.grief_savedweapon_currentweapon ) && self.grief_savedweapon_currentweapon == weapon )
{
self switchtoweapon( weapon );
return 1;
}
_k859 = getNextArrayKey( _a859, _k859 );
}
if ( primaries.size > 0 )
{
self switchtoweapon( primaries[ 0 ] );
return 1;
}
return 0;
}
grief_store_player_scores()
{
players = get_players();
_a883 = players;
_k883 = getFirstArrayKey( _a883 );
while ( isDefined( _k883 ) )
{
player = _a883[ _k883 ];
player._pre_round_score = player.score;
_k883 = getNextArrayKey( _a883, _k883 );
}
}
grief_restore_player_score()
{
if ( !isDefined( self._pre_round_score ) )
{
self._pre_round_score = self.score;
}
if ( isDefined( self._pre_round_score ) )
{
self.score = self._pre_round_score;
self.pers[ "score" ] = self._pre_round_score;
}
}
game_mode_spawn_player_logic()
{
if ( flag( "start_zombie_round_logic" ) && !isDefined( self.is_hotjoin ) )
{
self.is_hotjoin = 1;
return 1;
}
return 0;
}
update_players_on_bleedout_or_disconnect( excluded_player )
{
other_team = undefined;
players = get_players();
players_remaining = 0;
_a920 = players;
_k920 = getFirstArrayKey( _a920 );
while ( isDefined( _k920 ) )
{
player = _a920[ _k920 ];
if ( player == excluded_player )
{
}
else if ( player.team == excluded_player.team )
{
if ( is_player_valid( player ) )
{
players_remaining++;
}
break;
}
_k920 = getNextArrayKey( _a920, _k920 );
}
_a937 = players;
_k937 = getFirstArrayKey( _a937 );
while ( isDefined( _k937 ) )
{
player = _a937[ _k937 ];
if ( player == excluded_player )
{
}
else if ( player.team != excluded_player.team )
{
other_team = player.team;
if ( players_remaining < 1 )
{
player thread show_grief_hud_msg( &"ZOMBIE_ZGRIEF_ALL_PLAYERS_DOWN", undefined, undefined, 1 );
player delay_thread_watch_host_migrate( 2, ::show_grief_hud_msg, &"ZOMBIE_ZGRIEF_SURVIVE", undefined, 30, 1 );
break;
}
else
{
player thread show_grief_hud_msg( &"ZOMBIE_ZGRIEF_PLAYER_BLED_OUT", players_remaining );
}
}
_k937 = getNextArrayKey( _a937, _k937 );
}
if ( players_remaining == 1 )
{
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "last_player", excluded_player.team );
}
if ( !isDefined( other_team ) )
{
return;
}
if ( players_remaining < 1 )
{
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "4_player_down", other_team );
}
else
{
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( players_remaining + "_player_left", other_team );
}
}
delay_thread_watch_host_migrate( timer, func, param1, param2, param3, param4, param5, param6 )
{
self thread _delay_thread_watch_host_migrate_proc( func, timer, param1, param2, param3, param4, param5, param6 );
}
_delay_thread_watch_host_migrate_proc( func, timer, param1, param2, param3, param4, param5, param6 )
{
self endon( "death" );
self endon( "disconnect" );
wait timer;
if ( isDefined( level.hostmigrationtimer ) )
{
while ( isDefined( level.hostmigrationtimer ) )
{
wait 0.05;
}
wait timer;
}
single_thread( self, func, param1, param2, param3, param4, param5, param6 );
}
grief_round_end_custom_logic()
{
waittillframeend;
if ( isDefined( level.gamemodulewinningteam ) )
{
level notify( "end_round_think" );
}
}
custom_spawn_init_func()
{
array_thread( level.zombie_spawners, ::add_spawn_function, ::zombie_spawn_init );
array_thread( level.zombie_spawners, ::add_spawn_function, level._zombies_round_spawn_failsafe );
}
game_module_player_damage_callback( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
{
self.last_damage_from_zombie_or_player = 0;
if ( isDefined( eattacker ) )
{
if ( isplayer( eattacker ) && eattacker == self )
{
return;
}
if ( isDefined( eattacker.is_zombie ) || eattacker.is_zombie && isplayer( eattacker ) )
{
self.last_damage_from_zombie_or_player = 1;
}
}
if ( isDefined( self._being_shellshocked ) || self._being_shellshocked && self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
return;
}
if ( isplayer( eattacker ) && isDefined( eattacker._encounters_team ) && eattacker._encounters_team != self._encounters_team )
{
if ( isDefined( self.hasriotshield ) && self.hasriotshield && isDefined( vdir ) )
{
if ( isDefined( self.hasriotshieldequipped ) && self.hasriotshieldequipped )
{
if ( self maps/mp/zombies/_zm::player_shield_facing_attacker( vdir, 0.2 ) && isDefined( self.player_shield_apply_damage ) )
{
return;
}
}
else
{
if ( !isDefined( self.riotshieldentity ) )
{
if ( !self maps/mp/zombies/_zm::player_shield_facing_attacker( vdir, -0.2 ) && isDefined( self.player_shield_apply_damage ) )
{
return;
}
}
}
}
if ( isDefined( level._game_module_player_damage_grief_callback ) )
{
self [[ level._game_module_player_damage_grief_callback ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime );
}
if ( isDefined( level._effect[ "butterflies" ] ) )
{
if ( isDefined( sweapon ) && weapontype( sweapon ) == "grenade" )
{
playfx( level._effect[ "butterflies" ], self.origin + vectorScale( ( 1, 1, 1 ), 40 ) );
}
else
{
playfx( level._effect[ "butterflies" ], vpoint, vdir );
}
}
self thread do_game_mode_shellshock();
self playsound( "zmb_player_hit_ding" );
}
}
do_game_mode_shellshock()
{
self endon( "disconnect" );
self._being_shellshocked = 1;
self shellshock( "grief_stab_zm", 0,75 );
wait 0.75;
self._being_shellshocked = 0;
}

279
Fixed Zombies GSCs for compiling/zm_transit_patch/maps/mp/zm_transit_utility.gsc
View File

@ -1,279 +0,0 @@
#include maps/mp/_compass;
#include maps/mp/zombies/_zm_zonemgr;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
playercanafford( player, cost )
{
if ( !player usebuttonpressed() )
{
return 0;
}
if ( player in_revive_trigger() )
{
return 0;
}
if ( isDefined( cost ) )
{
if ( player.score < cost )
{
return 0;
}
player maps/mp/zombies/_zm_score::minus_to_player_score( cost );
}
return 1;
}
setinvisibletoall()
{
players = get_players();
playerindex = 0;
while ( playerindex < players.size )
{
self setinvisibletoplayer( players[ playerindex ] );
playerindex++;
}
}
spawnandlinkfxtotag( effect, ent, tag )
{
fxent = spawn( "script_model", ent gettagorigin( tag ) );
fxent setmodel( "tag_origin" );
fxent linkto( ent, tag );
wait_network_frame();
playfxontag( effect, fxent, "tag_origin" );
return fxent;
}
spawnandlinkfxtooffset( effect, ent, offsetorigin, offsetangles )
{
fxent = spawn( "script_model", ( 0, 0, 0 ) );
fxent setmodel( "tag_origin" );
fxent linkto( ent, "", offsetorigin, offsetangles );
wait_network_frame();
playfxontag( effect, fxent, "tag_origin" );
return fxent;
}
custom_weapon_wall_prices()
{
if ( !isDefined( level.zombie_include_weapons ) )
{
return;
}
weapon_spawns = [];
weapon_spawns = getentarray( "weapon_upgrade", "targetname" );
i = 0;
while ( i < weapon_spawns.size )
{
if ( !isDefined( level.zombie_weapons[ weapon_spawns[ i ].zombie_weapon_upgrade ] ) )
{
i++;
continue;
}
else
{
if ( isDefined( weapon_spawns[ i ].script_int ) )
{
cost = weapon_spawns[ i ].script_int;
level.zombie_weapons[ weapon_spawns[ i ].zombie_weapon_upgrade ].cost = cost;
}
}
i++;
}
}
pause_zombie_spawning()
{
if ( !isDefined( level.spawnpausecount ) )
{
level.spawnpausecount = 0;
}
level.spawnpausecount++;
flag_clear( "spawn_zombies" );
}
try_resume_zombie_spawning()
{
if ( !isDefined( level.spawnpausecount ) )
{
level.spawnpausecount = 0;
}
level.spawnpausecount--;
if ( level.spawnpausecount <= 0 )
{
level.spawnpausecount = 0;
flag_set( "spawn_zombies" );
}
}
automatonspeak( category, type, response, force_variant, override )
{
if ( isDefined( level.automaton ) && !is_true( level.automaton.disabled_by_emp ) )
{
if ( type != "leaving" && type != "leaving_warning" )
{
level.automaton notify( "want_to_be_speaking" );
level.automaton waittill( "startspeaking" );
}
level.automaton maps/mp/zombies/_zm_audio::create_and_play_dialog( category, type, response, force_variant, override );
}
}
is_thedouche()
{
return self.characterindex == 0;
}
is_theconspiracytheorist()
{
return self.characterindex == 1;
}
is_thefarmersdaughter()
{
return self.characterindex == 2;
}
is_theelectricalengineer()
{
return self.characterindex == 3;
}
get_random_encounter_match( location )
{
match_pool = [];
return random( match_pool );
}
transit_breakable_glass_init()
{
glass = getentarray( "transit_glass", "targetname" );
if ( level.splitscreen && getDvarInt( "splitscreen_playerCount" ) > 2 )
{
array_delete( glass );
return;
}
array_thread( glass, ::transit_breakable_glass );
}
transit_breakable_glass()
{
level endon( "intermission" );
self.health = 99999;
self setcandamage( 1 );
self.damage_state = 0;
while ( 1 )
{
self waittill( "damage", amount, attacker, direction, point, dmg_type );
if ( isplayer( attacker ) )
{
if ( self.damage_state == 0 )
{
self glass_gets_destroyed();
self.damage_state = 1;
self playsound( "fly_glass_break" );
}
}
}
}
glass_gets_destroyed()
{
if ( isDefined( level._effect[ "glass_impact" ] ) )
{
playfx( level._effect[ "glass_impact" ], self.origin, anglesToForward( self.angles ) );
}
wait 0.1;
if ( isDefined( self.model ) && self.damage_state == 0 )
{
self setmodel( self.model + "_broken" );
self.damage_state = 1;
return;
}
else
{
self delete();
return;
}
}
solo_tombstone_removal()
{
if ( getnumexpectedplayers() > 1 )
{
return;
}
level notify( "tombstone_removed" );
level thread maps/mp/zombies/_zm_perks::perk_machine_removal( "specialty_scavenger" );
}
sparking_power_lines()
{
lines = getentarray( "power_line_sparking", "targetname" );
}
disconnect_door_zones( zone_a, zone_b, flag_name )
{
level endon( "intermission" );
level endon( "end_game" );
while ( 1 )
{
flag_wait( flag_name );
azone = level.zones[ zone_a ].adjacent_zones[ zone_b ];
azone maps/mp/zombies/_zm_zonemgr::door_close_disconnect( flag_name );
}
}
enable_morse_code()
{
level clientnotify( "mc1" );
}
disable_morse_code()
{
level clientnotify( "mc0" );
}
transit_pathnode_spawning()
{
precachemodel( "collision_wall_128x128x10_standard" );
precachemodel( "collision_wall_256x256x10_standard" );
precachemodel( "collision_clip_64x64x256" );
minimap_upperl = spawn( "script_origin", ( -12248, 9496, 552 ) );
minimap_upperl.targetname = "minimap_corner";
minimap_lowerr = spawn( "script_origin", ( 14472, -8496, -776 ) );
minimap_lowerr.targetname = "minimap_corner";
maps/mp/_compass::setupminimap( "compass_map_zm_transit" );
flag_wait( "start_zombie_round_logic" );
collision1 = spawn( "script_model", ( 2273, -126, 143 ) );
collision1 setmodel( "collision_wall_128x128x10_standard" );
collision1.angles = ( 0, 0, 0 );
collision1 ghost();
collision2 = spawn( "script_model", ( 2096, -126, 143 ) );
collision2 setmodel( "collision_wall_128x128x10_standard" );
collision2.angles = ( 0, 0, 0 );
collision2 ghost();
collision3 = spawn( "script_model", ( 1959, -126, 143 ) );
collision3 setmodel( "collision_wall_128x128x10_standard" );
collision3.angles = ( 0, 0, 0 );
collision3 ghost();
collision4 = spawn( "script_model", ( 12239, 8509, -688 ) );
collision4 setmodel( "collision_wall_128x128x10_standard" );
collision4.angles = ( 0, 0, 0 );
collision4 ghost();
collision5 = spawn( "script_model", ( 8320, -6679, 362 ) );
collision5 setmodel( "collision_wall_256x256x10_standard" );
collision5.angles = vectorScale( ( 0, 0, 0 ), 300 );
collision5 ghost();
collision5 = spawn( "script_model", ( 10068, 7272, -67 ) );
collision5 setmodel( "collision_clip_64x64x256" );
collision5.angles = ( 0, 0, 0 );
collision5 ghost();
}

935
Fixed Zombies GSCs for compiling/zm_transit_patch/maps/mp/zombies/_zm_weap_jetgun.gsc
View File

@ -1,935 +0,0 @@
#include maps/mp/animscripts/zm_run;
#include maps/mp/animscripts/zm_death;
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/zombies/_zm_buildables;
#include maps/mp/gametypes_zm/_weaponobjects;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_net;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( !maps/mp/zombies/_zm_weapons::is_weapon_included( "jetgun_zm" ) )
{
return;
}
maps/mp/zombies/_zm_equipment::register_equipment( "jetgun_zm", &"ZOMBIE_EQUIP_JETGUN_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_JETGUN_HOWTO", "jetgun_zm_icon", "jetgun", ::jetgun_activation_watcher_thread, undefined, ::dropjetgun, ::pickupjetgun );
maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "jetgun", &"ZOMBIE_EQUIP_JETGUN_PICKUP_HINT_STRING" );
level._effect[ "jetgun_smoke_cloud" ] = loadfx( "weapon/thunder_gun/fx_thundergun_smoke_cloud" );
level._effect[ "jetgun_overheat" ] = loadfx( "weapon/jet_gun/fx_jetgun_overheat" );
level._effect[ "jetgun_vortex" ] = loadfx( "weapon/jet_gun/fx_jetgun_on" );
level._effect[ "jetgun_meat_grinder" ] = loadfx( "weapon/jet_gun/fx_jetgun_kill" );
set_zombie_var( "jetgun_cylinder_radius", 1024 );
set_zombie_var( "jetgun_grind_range", 128 );
set_zombie_var( "jetgun_gib_range", 256 );
set_zombie_var( "jetgun_gib_damage", 50 );
set_zombie_var( "jetgun_knockdown_range", 256 );
set_zombie_var( "jetgun_drag_range", 2048 );
set_zombie_var( "jetgun_knockdown_damage", 15 );
set_zombie_var( "powerup_move_dist", 50 );
set_zombie_var( "powerup_drag_range", 500 );
level.jetgun_pulled_in_range = int( level.zombie_vars[ "jetgun_drag_range" ] / 8 ) * ( level.zombie_vars[ "jetgun_drag_range" ] / 8 );
level.jetgun_pulling_in_range = int( level.zombie_vars[ "jetgun_drag_range" ] / 4 ) * ( level.zombie_vars[ "jetgun_drag_range" ] / 4 );
level.jetgun_inner_range = int( level.zombie_vars[ "jetgun_drag_range" ] / 2 ) * ( level.zombie_vars[ "jetgun_drag_range" ] / 2 );
level.jetgun_outer_edge = int( level.zombie_vars[ "jetgun_drag_range" ] * level.zombie_vars[ "jetgun_drag_range" ] );
level.jetgun_gib_refs = [];
level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "guts";
level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "right_arm";
level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "left_arm";
level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "right_leg";
level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "left_leg";
level.jetgun_gib_refs[ level.jetgun_gib_refs.size ] = "no_legs";
/*
/#
level thread jetgun_devgui_dvar_think();
level.zm_devgui_jetgun_never_overheat = ::never_overheat;
#/
*/
onplayerconnect_callback( ::jetgun_on_player_connect );
}
dropjetgun()
{
item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "t6_wpn_zmb_jet_gun_world", "jetgun_zm", self.origin + vectorScale( ( 1, 0, 1 ), 30 ), self.angles );
if ( isDefined( item ) )
{
item.overheating = self.jetgun_overheating;
item.heatval = self.jetgun_heatval;
item.original_owner = self;
item.owner = undefined;
item.name = "jetgun_zm";
item.requires_pickup = 1;
}
self.jetgun_overheating = undefined;
self.jetgun_heatval = undefined;
self takeweapon( "jetgun_zm" );
return item;
}
pickupjetgun( item )
{
item.owner = self;
if ( isDefined( item.overheating ) && isDefined( item.heatval ) )
{
self.jetgun_overheating = item.overheating;
self.jetgun_heatval = item.heatval;
}
item.overheating = undefined;
item.heatval = undefined;
self setcurrentweaponspinlerp( 0 );
}
jetgun_activation_watcher_thread()
{
self endon( "zombified" );
self endon( "disconnect" );
self endon( "jetgun_zm_taken" );
while ( 1 )
{
self waittill_either( "jetgun_zm_activate", "jetgun_zm_deactivate" );
}
}
jetgun_devgui_dvar_think()
{
/*
/#
if ( !maps/mp/zombies/_zm_weapons::is_weapon_included( "jetgun_zm" ) )
{
return;
}
setdvar( "scr_jetgun_cylinder_radius", level.zombie_vars[ "jetgun_cylinder_radius" ] );
setdvar( "scr_jetgun_grind_range", level.zombie_vars[ "jetgun_grind_range" ] );
setdvar( "scr_jetgun_drag_range", level.zombie_vars[ "jetgun_drag_range" ] );
setdvar( "scr_jetgun_gib_range", level.zombie_vars[ "jetgun_gib_range" ] );
setdvar( "scr_jetgun_gib_damage", level.zombie_vars[ "jetgun_gib_damage" ] );
setdvar( "scr_jetgun_knockdown_range", level.zombie_vars[ "jetgun_knockdown_range" ] );
setdvar( "scr_jetgun_knockdown_damage", level.zombie_vars[ "jetgun_knockdown_damage" ] );
for ( ;; )
{
level.zombie_vars[ "jetgun_cylinder_radius" ] = getDvarInt( "scr_jetgun_cylinder_radius" );
level.zombie_vars[ "jetgun_grind_range" ] = getDvarInt( "scr_jetgun_grind_range" );
level.zombie_vars[ "jetgun_drag_range" ] = getDvarInt( "scr_jetgun_drag_range" );
level.zombie_vars[ "jetgun_gib_range" ] = getDvarInt( "scr_jetgun_gib_range" );
level.zombie_vars[ "jetgun_gib_damage" ] = getDvarInt( "scr_jetgun_gib_damage" );
level.zombie_vars[ "jetgun_knockdown_range" ] = getDvarInt( "scr_jetgun_knockdown_range" );
level.zombie_vars[ "jetgun_knockdown_damage" ] = getDvarInt( "scr_jetgun_knockdown_damage" );
wait 0.5;
}
#/
*/
}
jetgun_on_player_connect()
{
self thread wait_for_jetgun_fired();
self thread watch_weapon_changes();
self thread handle_overheated_jetgun();
}
get_jetgun_engine_direction()
{
return self getcurrentweaponspinlerp();
}
set_jetgun_engine_direction( nv )
{
self setcurrentweaponspinlerp( nv );
}
never_overheat()
{
/*
/#
self notify( "never_overheat" );
self endon( "never_overheat" );
self endon( "death_or_disconnect" );
while ( 1 )
{
if ( self getcurrentweapon() == "jetgun_zm" )
{
self setweaponoverheating( 0, 0 );
}
wait 0.05;
}
#/
*/
}
watch_overheat()
{
self endon( "death_or_disconnect" );
self endon( "weapon_change" );
if ( self getcurrentweapon() == "jetgun_zm" && isDefined( self.jetgun_overheating ) && isDefined( self.jetgun_heatval ) )
{
self setweaponoverheating( self.jetgun_overheating, self.jetgun_heatval );
}
while ( 1 )
{
if ( self getcurrentweapon() == "jetgun_zm" )
{
overheating = self isweaponoverheating( 0 );
heat = self isweaponoverheating( 1 );
self.jetgun_overheating = overheating;
self.jetgun_heatval = heat;
if ( overheating )
{
self notify( "jetgun_overheated" );
}
if ( heat > 75 )
{
self thread play_overheat_fx();
}
}
wait 0.05;
}
}
play_overheat_fx()
{
if ( isDefined( self.overheat_fx_playing ) && !self.overheat_fx_playing )
{
self.overheat_fx_playing = 1;
playfxontag( level._effect[ "jetgun_overheat" ], self, "tag_flash" );
wait 5;
if ( isDefined( self ) )
{
self.overheat_fx_playing = 0;
}
}
}
handle_overheated_jetgun()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "jetgun_overheated" );
if ( self getcurrentweapon() == "jetgun_zm" )
{
if ( isDefined( level.explode_overheated_jetgun ) && level.explode_overheated_jetgun )
{
self thread maps/mp/zombies/_zm_equipment::equipment_release( "jetgun_zm" );
weapon_org = self gettagorigin( "tag_weapon" );
pcount = get_players().size;
pickup_time = 360 / pcount;
maps/mp/zombies/_zm_buildables::player_explode_buildable( "jetgun_zm", weapon_org, 250, 1, pickup_time );
self.jetgun_overheating = undefined;
self.jetgun_heatval = undefined;
self playsound( "wpn_jetgun_explo" );
break;
}
else
{
if ( isDefined( level.unbuild_overheated_jetgun ) && level.unbuild_overheated_jetgun )
{
self thread maps/mp/zombies/_zm_equipment::equipment_release( "jetgun_zm" );
maps/mp/zombies/_zm_buildables::unbuild_buildable( "jetgun_zm", 1 );
self.jetgun_overheating = undefined;
self.jetgun_heatval = undefined;
break;
}
else
{
if ( isDefined( level.take_overheated_jetgun ) && level.take_overheated_jetgun )
{
self thread maps/mp/zombies/_zm_equipment::equipment_release( "jetgun_zm" );
self.jetgun_overheating = undefined;
self.jetgun_heatval = undefined;
}
}
}
}
}
}
watch_weapon_changes()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "weapon_change", weapon );
if ( weapon == "jetgun_zm" )
{
/*
/#
if ( getDvarInt( #"BCDDAAFF" ) > 0 )
{
self thread zombie_drag_radius();
}
#/
*/
self thread watch_overheat();
}
}
}
wait_for_jetgun_fired()
{
self endon( "disconnect" );
self waittill( "spawned_player" );
for ( ;; )
{
self waittill( "weapon_fired" );
currentweapon = self getcurrentweapon();
if ( currentweapon == "jetgun_zm" || currentweapon == "jetgun_upgraded_zm" )
{
self jetgun_firing();
}
}
}
jetgun_network_choke()
{
level.jetgun_network_choke_count++;
if ( level.jetgun_network_choke_count % 10 )
{
wait_network_frame();
wait_network_frame();
wait_network_frame();
}
}
is_jetgun_firing()
{
return abs( self get_jetgun_engine_direction() ) > 0.2;
}
jetgun_firing()
{
if ( !isDefined( self.jetsound_ent ) )
{
self.jetsound_ent = spawn( "script_origin", self.origin );
self.jetsound_ent linkto( self, "tag_origin" );
}
jetgun_fired = 0;
if ( self is_jetgun_firing() && jetgun_fired == 0 )
{
self.jetsound_ent playloopsound( "wpn_jetgun_effect_plr_loop", 0.8 );
self.jetsound_ent playsound( "wpn_jetgun_effect_plr_start" );
self notify( "jgun_snd" );
}
while ( self is_jetgun_firing() )
{
jetgun_fired = 1;
self thread jetgun_fired();
view_pos = self gettagorigin( "tag_flash" );
view_angles = self gettagangles( "tag_flash" );
if ( self get_jetgun_engine_direction() < 0 )
{
playfx( level._effect[ "jetgun_smoke_cloud" ], view_pos - self getplayerviewheight(), anglesToForward( view_angles ), anglesToUp( view_angles ) );
}
else
{
playfx( level._effect[ "jetgun_smoke_cloud" ], view_pos - self getplayerviewheight(), anglesToForward( view_angles ) * -1, anglesToUp( view_angles ) );
}
wait 0.25;
}
if ( jetgun_fired == 1 )
{
self.jetsound_ent stoploopsound( 0.5 );
self.jetsound_ent playsound( "wpn_jetgun_effect_plr_end" );
self.jetsound_ent thread sound_ent_cleanup();
jetgun_fired = 0;
}
}
sound_ent_cleanup()
{
self endon( "jgun_snd" );
wait 4;
if ( isDefined( self.jetsound_ent ) )
{
self delete();
}
}
jetgun_fired()
{
if ( !self is_jetgun_firing() )
{
return;
}
origin = self getweaponmuzzlepoint();
physicsjetthrust( origin, self getweaponforwarddir() * -1, level.zombie_vars[ "jetgun_grind_range" ], self get_jetgun_engine_direction(), 0.85 );
if ( !isDefined( level.jetgun_knockdown_enemies ) )
{
level.jetgun_knockdown_enemies = [];
level.jetgun_knockdown_gib = [];
level.jetgun_drag_enemies = [];
level.jetgun_fling_enemies = [];
level.jetgun_grind_enemies = [];
}
powerups = maps/mp/zombies/_zm_powerups::get_powerups();
if ( isDefined( powerups ) && powerups.size )
{
self thread try_pull_powerups( powerups );
}
self jetgun_get_enemies_in_range( self get_jetgun_engine_direction() );
level.jetgun_network_choke_count = 0;
_a408 = level.jetgun_fling_enemies;
index = getFirstArrayKey( _a408 );
while ( isDefined( index ) )
{
zombie = _a408[ index ];
jetgun_network_choke();
if ( isDefined( zombie ) )
{
zombie thread jetgun_fling_zombie( self, index );
}
index = getNextArrayKey( _a408, index );
}
_a418 = level.jetgun_drag_enemies;
_k418 = getFirstArrayKey( _a418 );
while ( isDefined( _k418 ) )
{
zombie = _a418[ _k418 ];
jetgun_network_choke();
if ( isDefined( zombie ) )
{
zombie.jetgun_owner = self;
zombie thread jetgun_drag_zombie( origin, -1 * self get_jetgun_engine_direction() );
}
_k418 = getNextArrayKey( _a418, _k418 );
}
level.jetgun_knockdown_enemies = [];
level.jetgun_knockdown_gib = [];
level.jetgun_drag_enemies = [];
level.jetgun_fling_enemies = [];
level.jetgun_grind_enemies = [];
}
try_pull_powerups( powerups )
{
powerup_move_dist = level.zombie_vars[ "powerup_move_dist" ] * -1 * self get_jetgun_engine_direction();
powerup_range_squared = level.zombie_vars[ "powerup_drag_range" ] * level.zombie_vars[ "powerup_drag_range" ];
view_pos = self getweaponmuzzlepoint();
forward_view_angles = self getweaponforwarddir();
_a453 = powerups;
_k453 = getFirstArrayKey( _a453 );
while ( isDefined( _k453 ) )
{
powerup = _a453[ _k453 ];
if ( distancesquared( view_pos, powerup.origin ) > powerup_range_squared )
{
}
else normal = vectornormalize( powerup.origin - view_pos );
dot = vectordot( forward_view_angles, normal );
if ( abs( dot ) < 0.7 )
{
}
else
{
powerup notify( "move_powerup" );
}
_k453 = getNextArrayKey( _a453, _k453 );
}
}
jetgun_get_enemies_in_range( invert )
{
view_pos = self getweaponmuzzlepoint();
zombies = get_array_of_closest( view_pos, get_round_enemy_array(), undefined, 3, level.zombie_vars[ "jetgun_drag_range" ] );
if ( !isDefined( zombies ) )
{
}
knockdown_range_squared = level.zombie_vars[ "jetgun_knockdown_range" ] * level.zombie_vars[ "jetgun_knockdown_range" ];
drag_range_squared = level.zombie_vars[ "jetgun_drag_range" ] * level.zombie_vars[ "jetgun_drag_range" ];
gib_range_squared = level.zombie_vars[ "jetgun_gib_range" ] * level.zombie_vars[ "jetgun_gib_range" ];
grind_range_squared = level.zombie_vars[ "jetgun_grind_range" ] * level.zombie_vars[ "jetgun_grind_range" ];
cylinder_radius_squared = level.zombie_vars[ "jetgun_cylinder_radius" ] * level.zombie_vars[ "jetgun_cylinder_radius" ];
forward_view_angles = self getweaponforwarddir();
end_pos = view_pos + vectorScale( forward_view_angles, level.zombie_vars[ "jetgun_knockdown_range" ] );
/*
/#
if ( getDvarInt( #"BCDDAAFF" ) == 2 )
{
near_circle_pos = view_pos + vectorScale( forward_view_angles, 2 );
circle( near_circle_pos, level.zombie_vars[ "jetgun_cylinder_radius" ], ( 1, 0, 1 ), 0, 0, 100 );
line( near_circle_pos, end_pos, ( 1, 0, 1 ), 1, 0, 100 );
circle( end_pos, level.zombie_vars[ "jetgun_cylinder_radius" ], ( 1, 0, 1 ), 0, 0, 100 );
}
#/
*/
i = 0;
while ( i < zombies.size )
{
self jetgun_check_enemies_in_range( zombies[ i ], view_pos, drag_range_squared, gib_range_squared, grind_range_squared, cylinder_radius_squared, forward_view_angles, end_pos, invert );
i++;
}
}
jetgun_check_enemies_in_range( zombie, view_pos, drag_range_squared, gib_range_squared, grind_range_squared, cylinder_radius_squared, forward_view_angles, end_pos, invert )
{
if ( !isDefined( zombie ) )
{
return;
}
if ( !isDefined( zombie ) )
{
return;
}
if ( zombie enemy_killed_by_jetgun() )
{
return;
}
if ( !isDefined( zombie.ai_state ) || zombie.ai_state != "find_flesh" && zombie.ai_state != "zombieMoveOnBus" )
{
return;
}
if ( isDefined( zombie.in_the_ground ) && zombie.in_the_ground )
{
return;
}
if ( isDefined( zombie.is_avogadro ) && zombie.is_avogadro )
{
return;
}
if ( isDefined( zombie.isdog ) && zombie.isdog )
{
return;
}
if ( isDefined( zombie.isscreecher ) && zombie.isscreecher )
{
return;
}
if ( isDefined( self.animname ) && self.animname == "quad_zombie" )
{
return;
}
test_origin = zombie getcentroid();
test_range_squared = distancesquared( view_pos, test_origin );
if ( test_range_squared > drag_range_squared )
{
zombie jetgun_debug_print( "range", ( 1, 0, 1 ) );
return;
}
normal = vectornormalize( test_origin - view_pos );
dot = vectordot( forward_view_angles, normal );
if ( abs( dot ) < 0.7 )
{
zombie jetgun_debug_print( "dot", ( 1, 0, 1 ) );
return;
}
radial_origin = pointonsegmentnearesttopoint( view_pos, end_pos, test_origin );
if ( distancesquared( test_origin, radial_origin ) > cylinder_radius_squared )
{
zombie jetgun_debug_print( "cylinder", ( 1, 0, 1 ) );
return;
}
if ( zombie damageconetrace( view_pos, self ) == 0 )
{
zombie jetgun_debug_print( "cone", ( 1, 0, 1 ) );
return;
}
jetgun_blow_suck = invert;
if ( dot <= 0 )
{
jetgun_blow_suck *= -1;
}
if ( test_range_squared < grind_range_squared )
{
level.jetgun_fling_enemies[ level.jetgun_fling_enemies.size ] = zombie;
level.jetgun_grind_enemies[ level.jetgun_grind_enemies.size ] = dot < 0;
}
else
{
if ( test_range_squared < drag_range_squared && dot > 0 )
{
level.jetgun_drag_enemies[ level.jetgun_drag_enemies.size ] = zombie;
}
}
}
jetgun_debug_print( msg, color )
{
/*
/#
if ( !getDvarInt( #"BCDDAAFF" ) )
{
return;
}
if ( !isDefined( color ) )
{
color = ( 1, 0, 1 );
}
print3d( self.origin + vectorScale( ( 1, 0, 1 ), 60 ), msg, color, 1, 1, 40 );
#/
*/
}
jetgun_debug_print_on_ent( msg, color )
{
/*
/#
if ( !getDvarInt( #"BCDDAAFF" ) )
{
return;
}
if ( !isDefined( color ) )
{
color = ( 1, 0, 1 );
}
self notify( "new_jetgun_debug_print_on_ent" );
self endon( "death" );
self endon( "jetgun_end_drag_state" );
self endon( "new_jetgun_debug_print_on_ent" );
while ( 1 )
{
print3d( self.origin + vectorScale( ( 1, 0, 1 ), 60 ), msg, color, 1, 1 );
wait 0.05;
}
#/
*/
}
try_gibbing()
{
if ( isDefined( self ) && isDefined( self.a ) && isDefined( self.isscreecher ) && !self.isscreecher )
{
self.a.gib_ref = random( level.jetgun_gib_refs );
self thread maps/mp/animscripts/zm_death::do_gib();
}
}
jetgun_handle_death_notetracks( note )
{
if ( note == "jetgunned" )
{
self thread jetgun_grind_death_ending();
}
}
jetgun_grind_death_ending()
{
if ( !isDefined( self ) )
{
return;
}
self hide();
wait 0.1;
self self_delete();
}
jetgun_grind_zombie( player )
{
player endon( "death" );
player endon( "disconnect" );
self endon( "death" );
if ( !isDefined( self.jetgun_grind ) )
{
self.jetgun_grind = 1;
self notify( "grinding" );
player set_jetgun_engine_direction( 0.5 * player get_jetgun_engine_direction() );
if ( is_mature() )
{
if ( isDefined( level._effect[ "zombie_guts_explosion" ] ) )
{
playfx( level._effect[ "zombie_guts_explosion" ], self gettagorigin( "J_SpineLower" ) );
}
}
self.nodeathragdoll = 1;
self.handle_death_notetracks = ::jetgun_handle_death_notetracks;
self dodamage( self.health + 666, player.origin, player );
}
}
jetgun_fling_zombie( player, index )
{
if ( !isDefined( self ) )
{
return;
}
if ( isDefined( self.jetgun_fling_func ) )
{
self [[ self.jetgun_fling_func ]]( player );
return;
}
was_alive = isalive( self );
if ( was_alive )
{
self.jetgun_fling = 1;
self notify( "flinging" );
deathanim = undefined;
if ( is_mature() )
{
player weaponplayejectbrass();
}
if ( isDefined( self.has_legs ) && self.has_legs )
{
if ( isDefined( self.jetgun_drag_state ) && self.jetgun_drag_state == "jetgun_sprint" )
{
deathanim = "zm_jetgun_sprint_death";
}
else
{
deathanim = "zm_jetgun_death";
}
}
else
{
deathanim = "zm_jetgun_death_crawl";
}
self.deathanim = deathanim;
player playsound( "evt_jetgun_zmb_suck" );
}
self thread jetgun_grind_zombie( player );
}
jetgun_drag_zombie( vdir, speed )
{
if ( isDefined( self.jetgun_drag_func ) )
{
self [[ self.jetgun_drag_func ]]( vdir, speed );
return;
}
self zombie_do_drag( vdir, speed );
}
jetgun_knockdown_zombie( player, gib )
{
self endon( "death" );
return;
if ( isDefined( self.jetgun_knockdown_func ) )
{
self [[ self.jetgun_knockdown_func ]]( player, gib );
}
else
{
self dodamage( level.zombie_vars[ "jetgun_knockdown_damage" ], player.origin, player );
}
if ( gib )
{
self.a.gib_ref = random( level.jetgun_gib_refs );
self thread maps/mp/animscripts/zm_death::do_gib();
}
self.jetgun_handle_pain_notetracks = ::handle_jetgun_pain_notetracks;
self dodamage( level.zombie_vars[ "jetgun_knockdown_damage" ], player.origin, player );
}
handle_jetgun_pain_notetracks( note )
{
if ( note == "zombie_knockdown_ground_impact" )
{
playfx( level._effect[ "jetgun_knockdown_ground" ], self.origin, anglesToForward( self.angles ), anglesToUp( self.angles ) );
}
}
is_jetgun_damage()
{
if ( isDefined( self.damageweapon ) && self.damageweapon != "jetgun_zm" && self.damageweapon == "jetgun_upgraded_zm" )
{
if ( self.damagemod != "MOD_GRENADE" )
{
return self.damagemod != "MOD_GRENADE_SPLASH";
}
}
}
enemy_killed_by_jetgun()
{
if ( isDefined( self.jetgun_fling ) && !self.jetgun_fling )
{
if ( isDefined( self.jetgun_grind ) )
{
return self.jetgun_grind;
}
}
}
zombie_do_drag( vdir, speed )
{
if ( !self zombie_is_in_drag_state() )
{
self zombie_enter_drag_state( vdir, speed );
self thread zombie_drag_think();
}
else
{
self zombie_keep_in_drag_state( vdir, speed );
}
}
zombie_is_in_drag_state()
{
if ( isDefined( self.drag_state ) )
{
return self.drag_state;
}
}
zombie_should_stay_in_drag_state()
{
if ( !isDefined( self ) || !isalive( self ) )
{
return 0;
}
if ( isDefined( self.jetgun_owner ) || self.jetgun_owner getcurrentweapon() != "jetgun_zm" && !self.jetgun_owner is_jetgun_firing() )
{
return 0;
}
if ( isDefined( self.drag_state ) && self.drag_state )
{
return 1;
}
return 0;
}
zombie_keep_in_drag_state( vdir, speed )
{
self.drag_start_time = getTime();
self.drag_target = vdir;
}
zombie_enter_drag_state( vdir, speed )
{
self.drag_state = 1;
self.jetgun_drag_state = "unaffected";
if ( isDefined( self.is_traversing ) )
{
self.was_traversing = self.is_traversing;
}
self notify( "killanimscript" );
self zombie_keep_in_drag_state( vdir, speed );
self.zombie_move_speed_pre_jetgun_drag = self.zombie_move_speed;
}
zombie_exit_drag_state()
{
self notify( "jetgun_end_drag_state" );
self.drag_state = 0;
self.jetgun_drag_state = "unaffected";
self.needs_run_update = 1;
if ( isDefined( self.zombie_move_speed_pre_jetgun_drag ) )
{
self set_zombie_run_cycle( self.zombie_move_speed_pre_jetgun_drag );
self.zombie_move_speed_pre_jetgun_drag = undefined;
}
else
{
self set_zombie_run_cycle();
}
if ( isDefined( self.isdog ) && !self.isdog )
{
self maps/mp/animscripts/zm_run::moverun();
}
if ( isDefined( self.was_traversing ) && self.was_traversing )
{
self traversemode( "gravity" );
self.a.nodeath = 0;
self maps/mp/animscripts/zm_run::needsupdate();
if ( !self.isdog )
{
self maps/mp/animscripts/zm_run::moverun();
}
self.is_traversing = 0;
self notify( "zombie_end_traverse" );
if ( is_mature() )
{
if ( isDefined( level._effect[ "zombie_guts_explosion" ] ) )
{
playfx( level._effect[ "zombie_guts_explosion" ], self gettagorigin( "J_SpineLower" ) );
}
}
self.nodeathragdoll = 1;
self dodamage( self.health + 666, self.origin, self );
}
}
aiphysicstrace( start, end )
{
result = physicstrace( start, end, ( 1, 0, 1 ), ( 1, 0, 1 ), self );
return result[ "position" ];
}
zombie_drag_think()
{
self endon( "death" );
self endon( "flinging" );
self endon( "grinding" );
while ( self zombie_should_stay_in_drag_state() )
{
self._distance_to_jetgun_owner = distancesquared( self.origin, self.jetgun_owner.origin );
jetgun_network_choke();
if ( self.zombie_move_speed == "sprint" || self._distance_to_jetgun_owner < level.jetgun_pulled_in_range )
{
self jetgun_drag_set( "jetgun_sprint", "jetgun_walk_fast_crawl" );
}
else
{
if ( self._distance_to_jetgun_owner < level.jetgun_pulling_in_range )
{
self jetgun_drag_set( "jetgun_walk_fast", "jetgun_walk_fast" );
break;
}
else if ( self._distance_to_jetgun_owner < level.jetgun_inner_range )
{
self jetgun_drag_set( "jetgun_walk", "jetgun_walk_slow_crawl" );
break;
}
else
{
if ( self._distance_to_jetgun_owner < level.jetgun_outer_edge )
{
self jetgun_drag_set( "jetgun_walk_slow", "jetgun_walk_slow_crawl" );
}
}
}
wait 0.1;
}
self thread zombie_exit_drag_state();
}
jetgun_drag_set( legsanim, crawlanim )
{
self endon( "death" );
self.needs_run_update = 1;
if ( self.has_legs )
{
self._had_legs = 1;
self set_zombie_run_cycle( legsanim );
}
else
{
self._had_legs = 0;
self set_zombie_run_cycle( crawlanim );
}
/*
/#
if ( self.jetgun_drag_state != legsanim )
{
self thread jetgun_debug_print_on_ent( legsanim, ( 1, 0, 1 ) );
}
self.jetgun_drag_state = legsanim;
#/
*/
}
zombie_drag_radius()
{
/*
/#
self endon( "death_or_disconnect" );
self endon( "weapon_change" );
while ( 1 )
{
circle( self.origin, level.zombie_vars[ "jetgun_grind_range" ], vectorScale( ( 1, 0, 1 ), 0.5 ) );
circle( self.origin, level.zombie_vars[ "jetgun_drag_range" ] / 8, ( 1, 0, 1 ) );
circle( self.origin, level.zombie_vars[ "jetgun_drag_range" ] / 4, ( 1, 0, 1 ) );
circle( self.origin, level.zombie_vars[ "jetgun_drag_range" ] / 2, ( 1, 0, 1 ) );
circle( self.origin, level.zombie_vars[ "jetgun_drag_range" ], ( 1, 0, 1 ) );
wait 0.05;
}
#/
*/
}