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

Added all the remaining scripts not previously included.

Browse Source
This commit is contained in:
JezuzLizard
2021-08-07 11:29:26 -07:00
parent cf8d60b2d0
commit 98bfc67831
1001 changed files with 239603 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

506
zm_transit_dr_patch/maps/mp/zombies/_load.gsc Normal file
View File

@ -0,0 +1,506 @@
#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.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( #"F7B30924" ) == "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()
{
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" ] = vectorToAngle( 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 );
wait 0,05;
}
level.introscreen.alpha = 1;
players = get_players();
i = 0;
while ( i < players.size )
{
players[ i ] freezecontrols( 1 );
i++;
}
wait 1;
}

5649
zm_transit_dr_patch/maps/mp/zombies/_zm.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

566
zm_transit_dr_patch/maps/mp/zombies/_zm_ai_basic.gsc Normal file
View File

@ -0,0 +1,566 @@
#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;
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 );
_a476 = locs;
_k476 = getFirstArrayKey( _a476 );
while ( isDefined( _k476 ) )
{
loc = _a476[ _k476 ];
dist_sq = distancesquared( self.origin, loc.origin );
if ( dist_sq > 90000 )
{
self setgoalpos( loc.origin );
break;
}
_k476 = getNextArrayKey( _a476, _k476 );
}
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();
_a517 = players;
_k517 = getFirstArrayKey( _a517 );
while ( isDefined( _k517 ) )
{
player = _a517[ _k517 ];
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;
}
}
_k517 = getNextArrayKey( _a517, _k517 );
}
wait 0,1;
}
}
inert_bump()
{
self endon( "death" );
self endon( "stop_zombie_inert" );
while ( 1 )
{
zombies = getaiarray( level.zombie_team );
_a557 = zombies;
_k557 = getFirstArrayKey( _a557 );
while ( isDefined( _k557 ) )
{
zombie = _a557[ _k557 ];
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;
}
}
}
_k557 = getNextArrayKey( _a557, _k557 );
}
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;
}
_a628 = zombies;
_k628 = getFirstArrayKey( _a628 );
while ( isDefined( _k628 ) )
{
zombie = _a628[ _k628 ];
zombie stop_inert();
_k628 = getNextArrayKey( _a628, _k628 );
}
}
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;
}
}
}
}

798
zm_transit_dr_patch/maps/mp/zombies/_zm_ai_dogs.gsc Normal file
View File

@ -0,0 +1,798 @@
#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++;
}
/#
assert( level.dog_spawners.size > 0 );
#/
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++;
}
/#
level endon( "kill_round" );
if ( getDvarInt( "zombie_cheat" ) == 2 || getDvarInt( "zombie_cheat" ) >= 4 )
{
return;
#/
}
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;
}
/#
if ( getDvar( "force_dogs" ) != "" )
{
max = getDvarInt( "force_dogs" );
#/
}
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 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 = vectorToAngle( ai.favoriteenemy.origin - ent.origin );
angles = ( ai.angles[ 0 ], angle[ 1 ], ai.angles[ 2 ] );
ai forceteleport( ent.origin, angles );
/#
assert( isDefined( ai ), "Ent isn't defined." );
#/
/#
assert( isalive( ai ), "Ent is dead." );
#/
/#
assert( ai.isdog, "Ent isn't a dog;" );
#/
/#
assert( is_magic_bullet_shield_enabled( ai ), "Ent doesn't have a magic bullet shield." );
#/
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 )
{
/#
assert( dog_array.size > 0, "Dog Spawner array is empty." );
#/
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 ( getDvarInt( "force_dogs" ) > 0 )
{
level.next_dog_round = level.round_number;
#/
}
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 );
/#
get_players()[ 0 ] iprintln( "Next dog round: " + level.next_dog_round );
#/
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 hide();
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" ) );
/#
assert( isDefined( self.fx_dog_eye ) );
#/
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" ) );
/#
assert( isDefined( self.fx_dog_trail ) );
#/
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();
/#
assert( isDefined( self.fx_dog_eye ) );
#/
self.fx_dog_eye delete();
/#
assert( isDefined( self.fx_dog_trail ) );
#/
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 )
{
dogangle = angleClamp180( vectorToAngle( self.origin - players[ i ].origin )[ 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;
}
/#
assert( isDefined( self.fx_dog_eye ) );
#/
maps/mp/zombies/_zm_net::network_safe_play_fx_on_tag( "dog_fx", 2, level._effect[ "dog_eye_glow" ], self.fx_dog_eye, "tag_origin" );
/#
assert( isDefined( self.fx_dog_trail ) );
#/
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 );
}

634
zm_transit_dr_patch/maps/mp/zombies/_zm_ai_faller.gsc Normal file
View File

@ -0,0 +1,634 @@
#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
{
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 = vectorToAngle( 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.in_the_ceiling = 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 = ::maps/mp/zombies/_zm_spawner::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 }
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 );
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 = ::maps/mp/zombies/_zm_spawner::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" );
}

1441
zm_transit_dr_patch/maps/mp/zombies/_zm_audio.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

490
zm_transit_dr_patch/maps/mp/zombies/_zm_audio_announcer.gsc Normal file
View File

@ -0,0 +1,490 @@
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
game[ "zmbdialog" ] = [];
game[ "zmbdialog" ][ "prefix" ] = "vox_zmba";
createvox( "carpenter", "powerup_carpenter" );
createvox( "insta_kill", "powerup_instakill" );
createvox( "double_points", "powerup_doublepoints" );
createvox( "nuke", "powerup_nuke" );
createvox( "full_ammo", "powerup_maxammo" );
createvox( "fire_sale", "powerup_firesale" );
createvox( "minigun", "powerup_death_machine" );
createvox( "boxmove", "event_magicbox" );
createvox( "dogstart", "event_dogstart" );
thread init_gamemodespecificvox( getDvar( "ui_gametype" ), getDvar( "ui_zm_mapstartlocation" ) );
level.allowzmbannouncer = 1;
}
init_gamemodespecificvox( mode, location )
{
switch( mode )
{
case "zmeat":
init_meatvox( "meat" );
break;
case "zrace":
init_racevox( "race", location );
break;
case "zgrief":
init_griefvox( "grief" );
break;
case "zcleansed":
init_cleansed( location );
break;
default:
init_gamemodecommonvox();
break;
}
}
init_gamemodecommonvox( prefix )
{
createvox( "rules", "rules", prefix );
createvox( "countdown", "intro", prefix );
createvox( "side_switch", "side_switch", prefix );
createvox( "round_win", "win_rd", prefix );
createvox( "round_lose", "lose_rd", prefix );
createvox( "round_tied", "tied_rd", prefix );
createvox( "match_win", "win", prefix );
createvox( "match_lose", "lose", prefix );
createvox( "match_tied", "tied", prefix );
}
init_griefvox( prefix )
{
init_gamemodecommonvox( prefix );
createvox( "1_player_down", "1rivdown", prefix );
createvox( "2_player_down", "2rivdown", prefix );
createvox( "3_player_down", "3rivdown", prefix );
createvox( "4_player_down", "4rivdown", prefix );
createvox( "grief_restarted", "restart", prefix );
createvox( "grief_lost", "lose", prefix );
createvox( "grief_won", "win", prefix );
createvox( "1_player_left", "1rivup", prefix );
createvox( "2_player_left", "2rivup", prefix );
createvox( "3_player_left", "3rivup", prefix );
createvox( "last_player", "solo", prefix );
}
init_cleansed( prefix )
{
init_gamemodecommonvox( prefix );
createvox( "dr_start_single_0", "dr_start_0" );
createvox( "dr_start_2", "dr_start_1" );
createvox( "dr_start_3", "dr_start_2" );
createvox( "dr_cure_found_line", "dr_cure_found" );
createvox( "dr_monkey_killer", "dr_monkey_0" );
createvox( "dr_monkey_killee", "dr_monkey_1" );
createvox( "dr_human_killed", "dr_kill_plr" );
createvox( "dr_human_killer", "dr_kill_plr_2" );
createvox( "dr_survival", "dr_plr_survive_0" );
createvox( "dr_zurvival", "dr_zmb_survive_2" );
createvox( "dr_countdown0", "dr_plr_survive_1" );
createvox( "dr_countdown1", "dr_plr_survive_2" );
createvox( "dr_countdown2", "dr_plr_survive_3" );
createvox( "dr_ending", "dr_time_0" );
}
init_meatvox( prefix )
{
init_gamemodecommonvox( prefix );
createvox( "meat_drop", "drop", prefix );
createvox( "meat_grab", "grab", prefix );
createvox( "meat_grab_A", "team_cdc", prefix );
createvox( "meat_grab_B", "team_cia", prefix );
createvox( "meat_land", "land", prefix );
createvox( "meat_hold", "hold", prefix );
createvox( "meat_revive_1", "revive1", prefix );
createvox( "meat_revive_2", "revive2", prefix );
createvox( "meat_revive_3", "revive3", prefix );
createvox( "meat_ring_splitter", "ring_tripple", prefix );
createvox( "meat_ring_minigun", "ring_death", prefix );
createvox( "meat_ring_ammo", "ring_ammo", prefix );
}
init_racevox( prefix, location )
{
init_gamemodecommonvox( prefix );
switch( location )
{
case "tunnel":
createvox( "rules", "rules_" + location, prefix );
createvox( "countdown", "intro_" + location, prefix );
break;
case "power":
createvox( "rules", "rules_" + location, prefix );
createvox( "countdown", "intro_" + location, prefix );
createvox( "lap1", "lap1", prefix );
createvox( "lap2", "lap2", prefix );
createvox( "lap_final", "lap_final", prefix );
break;
case "farm":
createvox( "rules", "rules_" + location, prefix );
createvox( "countdown", "intro_" + location, prefix );
createvox( "hoop_area", "hoop_area", prefix );
createvox( "hoop_miss", "hoop_miss", prefix );
break;
default:
}
createvox( "race_room_2_ally", "room2_ally", prefix );
createvox( "race_room_3_ally", "room3_ally", prefix );
createvox( "race_room_4_ally", "room4_ally", prefix );
createvox( "race_room_5_ally", "room5_ally", prefix );
createvox( "race_room_2_axis", "room2_axis", prefix );
createvox( "race_room_3_axis", "room3_axis", prefix );
createvox( "race_room_4_axis", "room4_axis", prefix );
createvox( "race_room_5_axis", "room5_axis", prefix );
createvox( "race_ahead_1_ally", "ahead1_ally", prefix );
createvox( "race_ahead_2_ally", "ahead2_ally", prefix );
createvox( "race_ahead_3_ally", "ahead3_ally", prefix );
createvox( "race_ahead_4_ally", "ahead4_ally", prefix );
createvox( "race_ahead_1_axis", "ahead1_axis", prefix );
createvox( "race_ahead_2_axis", "ahead2_axis", prefix );
createvox( "race_ahead_3_axis", "ahead3_axis", prefix );
createvox( "race_ahead_4_axis", "ahead4_axis", prefix );
createvox( "race_kill_15", "door15", prefix );
createvox( "race_kill_10", "door10", prefix );
createvox( "race_kill_5", "door5", prefix );
createvox( "race_kill_3", "door3", prefix );
createvox( "race_kill_1", "door1", prefix );
createvox( "race_door_open", "door_open", prefix );
createvox( "race_door_nag", "door_nag", prefix );
createvox( "race_grief_incoming", "grief_income_ammo", prefix );
createvox( "race_grief_land", "grief_land", prefix );
createvox( "race_laststand", "last_stand", prefix );
}
}
createvox( type, alias, gametype )
{
if ( !isDefined( gametype ) )
{
gametype = "";
}
else
{
gametype += "_";
}
game[ "zmbdialog" ][ type ] = gametype + alias;
}
announceroundwinner( winner, delay )
{
if ( isDefined( delay ) && delay > 0 )
{
wait delay;
}
if ( !isDefined( winner ) || isplayer( winner ) )
{
return;
}
if ( winner != "tied" )
{
players = get_players();
_a235 = players;
_k235 = getFirstArrayKey( _a235 );
while ( isDefined( _k235 ) )
{
player = _a235[ _k235 ];
if ( isDefined( player._encounters_team ) && player._encounters_team == winner )
{
winning_team = player.pers[ "team" ];
break;
}
else
{
_k235 = getNextArrayKey( _a235, _k235 );
}
}
losing_team = getotherteam( winning_team );
leaderdialog( "round_win", winning_team, undefined, 1 );
leaderdialog( "round_lose", losing_team, undefined, 1 );
}
else
{
leaderdialog( "round_tied", undefined, undefined, 1 );
}
}
announcematchwinner( winner, delay )
{
if ( isDefined( delay ) && delay > 0 )
{
wait delay;
}
if ( !isDefined( winner ) || isplayer( winner ) )
{
return;
}
if ( winner != "tied" )
{
players = get_players();
_a266 = players;
_k266 = getFirstArrayKey( _a266 );
while ( isDefined( _k266 ) )
{
player = _a266[ _k266 ];
if ( isDefined( player._encounters_team ) && player._encounters_team == winner )
{
winning_team = player.pers[ "team" ];
break;
}
else
{
_k266 = getNextArrayKey( _a266, _k266 );
}
}
losing_team = getotherteam( winning_team );
leaderdialog( "match_win", winning_team, undefined, 1 );
leaderdialog( "match_lose", losing_team, undefined, 1 );
}
else
{
leaderdialog( "match_tied", undefined, undefined, 1 );
}
}
announcegamemoderules()
{
if ( getDvar( "ui_zm_mapstartlocation" ) == "town" )
{
leaderdialog( "rules", undefined, undefined, undefined, 20 );
}
}
leaderdialog( dialog, team, group, queue, waittime )
{
/#
assert( isDefined( level.players ) );
#/
if ( !isDefined( team ) )
{
leaderdialogbothteams( dialog, "allies", dialog, "axis", group, queue, waittime );
return;
}
if ( level.splitscreen )
{
if ( level.players.size )
{
level.players[ 0 ] leaderdialogonplayer( dialog, group, queue, waittime );
}
return;
}
i = 0;
while ( i < level.players.size )
{
player = level.players[ i ];
if ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] == team )
{
player leaderdialogonplayer( dialog, group, queue, waittime );
}
i++;
}
}
leaderdialogbothteams( dialog1, team1, dialog2, team2, group, queue, waittime )
{
/#
assert( isDefined( level.players ) );
#/
if ( level.splitscreen )
{
if ( level.players.size )
{
level.players[ 0 ] leaderdialogonplayer( dialog1, group, queue, waittime );
}
return;
}
i = 0;
while ( i < level.players.size )
{
player = level.players[ i ];
team = player.pers[ "team" ];
if ( !isDefined( team ) )
{
i++;
continue;
}
else if ( team == team1 )
{
player leaderdialogonplayer( dialog1, group, queue, waittime );
i++;
continue;
}
else
{
if ( team == team2 )
{
player leaderdialogonplayer( dialog2, group, queue, waittime );
}
}
i++;
}
}
leaderdialogonplayer( dialog, group, queue, waittime )
{
team = self.pers[ "team" ];
if ( !isDefined( team ) )
{
return;
}
if ( team != "allies" && team != "axis" )
{
return;
}
if ( isDefined( group ) )
{
if ( self.zmbdialoggroup == group )
{
return;
}
hadgroupdialog = isDefined( self.zmbdialoggroups[ group ] );
self.zmbdialoggroups[ group ] = dialog;
dialog = group;
if ( hadgroupdialog )
{
return;
}
}
if ( !self.zmbdialogactive )
{
self thread playleaderdialogonplayer( dialog, team, waittime );
}
else
{
if ( isDefined( queue ) && queue )
{
self.zmbdialogqueue[ self.zmbdialogqueue.size ] = dialog;
}
}
}
playleaderdialogonplayer( dialog, team, waittime )
{
self endon( "disconnect" );
if ( level.allowzmbannouncer )
{
if ( !isDefined( game[ "zmbdialog" ][ dialog ] ) )
{
/#
if ( getDvarInt( #"0AEB127D" ) > 0 )
{
println( "DIALOG DEBUGGER: No VOX created for - " + dialog );
#/
}
return;
}
}
self.zmbdialogactive = 1;
if ( isDefined( self.zmbdialoggroups[ dialog ] ) )
{
group = dialog;
dialog = self.zmbdialoggroups[ group ];
self.zmbdialoggroup = group;
}
if ( level.allowzmbannouncer )
{
alias = game[ "zmbdialog" ][ "prefix" ] + "_" + game[ "zmbdialog" ][ dialog ];
variant = self getleaderdialogvariant( alias );
if ( !isDefined( variant ) )
{
full_alias = alias;
}
else
{
full_alias = ( alias + "_" ) + variant;
}
self playlocalsound( full_alias );
}
if ( isDefined( waittime ) )
{
wait waittime;
}
else
{
wait 4;
}
self.zmbdialogactive = 0;
self.zmbdialoggroup = "";
if ( self.zmbdialogqueue.size > 0 && level.allowzmbannouncer )
{
nextdialog = self.zmbdialogqueue[ 0 ];
i = 1;
while ( i < self.zmbdialogqueue.size )
{
self.zmbdialogqueue[ i - 1 ] = self.zmbdialogqueue[ i ];
i++;
}
self thread playleaderdialogonplayer( nextdialog, team );
}
}
getleaderdialogvariant( alias )
{
if ( !isDefined( alias ) )
{
return;
}
if ( !isDefined( level.announcer_dialog ) )
{
level.announcer_dialog = [];
level.announcer_dialog_available = [];
}
num_variants = maps/mp/zombies/_zm_spawner::get_number_variants( alias );
if ( num_variants <= 0 )
{
/#
if ( getDvarInt( #"0AEB127D" ) > 0 )
{
println( "DIALOG DEBUGGER: No variants found for - " + alias );
#/
}
return undefined;
}
i = 0;
while ( i < num_variants )
{
level.announcer_dialog[ alias ][ i ] = i;
i++;
}
level.announcer_dialog_available[ alias ] = [];
if ( level.announcer_dialog_available[ alias ].size <= 0 )
{
level.announcer_dialog_available[ alias ] = level.announcer_dialog[ alias ];
}
variation = random( level.announcer_dialog_available[ alias ] );
level.announcer_dialog_available[ alias ] = arrayremovevalue( level.announcer_dialog_available[ alias ], variation );
return variation;
}
getroundswitchdialog( switchtype )
{
switch( switchtype )
{
case "halftime":
return "halftime";
case "overtime":
return "overtime";
default:
return "side_switch";
}
}
getotherteam( team )
{
if ( team == "allies" )
{
return "axis";
}
else
{
return "allies";
}
}

2503
zm_transit_dr_patch/maps/mp/zombies/_zm_blockers.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

10
zm_transit_dr_patch/maps/mp/zombies/_zm_bot.gsc Normal file
View File

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

2565
zm_transit_dr_patch/maps/mp/zombies/_zm_buildables.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

837
zm_transit_dr_patch/maps/mp/zombies/_zm_chugabud.gsc Normal file
View File

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

133
zm_transit_dr_patch/maps/mp/zombies/_zm_clone.gsc Normal file
View File

@ -0,0 +1,133 @@
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
#using_animtree( "zm_ally" );
init()
{
init_mover_tree();
}
spawn_player_clone( player, origin, forceweapon, forcemodel )
{
if ( !isDefined( origin ) )
{
origin = player.origin;
}
primaryweapons = player getweaponslistprimaries();
if ( isDefined( forceweapon ) )
{
weapon = forceweapon;
}
else if ( primaryweapons.size )
{
weapon = primaryweapons[ 0 ];
}
else
{
weapon = player getcurrentweapon();
}
weaponmodel = getweaponmodel( weapon );
spawner = getent( "fake_player_spawner", "targetname" );
if ( isDefined( spawner ) )
{
clone = spawner spawnactor();
clone.origin = origin;
clone.isactor = 1;
}
else
{
clone = spawn( "script_model", origin );
clone.isactor = 0;
}
if ( isDefined( forcemodel ) )
{
clone setmodel( forcemodel );
}
else
{
clone setmodel( self.model );
if ( isDefined( player.headmodel ) )
{
clone.headmodel = player.headmodel;
clone attach( clone.headmodel, "", 1 );
}
}
if ( weaponmodel != "" && weaponmodel != "none" )
{
clone attach( weaponmodel, "tag_weapon_right" );
}
clone.team = player.team;
clone.is_inert = 1;
clone.zombie_move_speed = "walk";
clone.script_noteworthy = "corpse_clone";
clone.actor_damage_func = ::clone_damage_func;
return clone;
}
clone_damage_func( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
{
idamage = 0;
if ( sweapon != "knife_ballistic_upgraded_zm" && sweapon != "knife_ballistic_bowie_upgraded_zm" || sweapon == "knife_ballistic_no_melee_upgraded_zm" && sweapon == "knife_ballistic_sickle_upgraded_zm" )
{
self notify( "player_revived" );
}
return idamage;
}
clone_give_weapon( weapon )
{
weaponmodel = getweaponmodel( weapon );
if ( weaponmodel != "" && weaponmodel != "none" )
{
self attach( weaponmodel, "tag_weapon_right" );
}
}
clone_animate( animtype )
{
if ( self.isactor )
{
self thread clone_actor_animate( animtype );
}
else
{
self thread clone_mover_animate( animtype );
}
}
clone_actor_animate( animtype )
{
wait 0,1;
switch( animtype )
{
case "laststand":
self setanimstatefromasd( "laststand" );
break;
case "idle":
default:
self setanimstatefromasd( "idle" );
break;
}
}
init_mover_tree()
{
scriptmodelsuseanimtree( -1 );
}
clone_mover_animate( animtype )
{
self useanimtree( -1 );
switch( animtype )
{
case "laststand":
self setanim( %pb_laststand_idle );
break;
case "idle":
default:
self setanim( %pb_stand_alert );
break;
}
}

1817
zm_transit_dr_patch/maps/mp/zombies/_zm_devgui.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

140
zm_transit_dr_patch/maps/mp/zombies/_zm_electric_cherry.gsc Normal file
View File

@ -0,0 +1,140 @@
#include maps/mp/_visionset_mgr;
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_net;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
level.custom_laststand_func = ::electric_cherry_laststand;
level._effect[ "electric_cherry_explode" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_player" );
level._effect[ "tesla_shock" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock" );
level._effect[ "tesla_shock_secondary" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock_secondary" );
set_zombie_var( "tesla_head_gib_chance", 50 );
}
electric_cherry_player_init()
{
}
electric_cherry_laststand()
{
perk_radius = 500;
perk_dmg = 1000;
perk_points = 40;
perk_delay = 1,5;
self thread electric_cherry_visionset();
wait perk_delay;
visionsetlaststand( "zm_electric_cherry", 1 );
while ( isDefined( self ) )
{
playfx( level._effect[ "electric_cherry_explode" ], self.origin );
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 );
i = 0;
while ( i < a_zombies.size )
{
if ( isDefined( self ) && isalive( self ) )
{
if ( a_zombies[ i ].health <= perk_dmg )
{
a_zombies[ i ] thread electric_cherry_death_fx();
self maps/mp/zombies/_zm_score::add_to_player_score( perk_points );
}
else
{
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 );
}
i++;
}
}
}
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 ( isDefined( self.stun_zombie ) )
{
self thread [[ self.stun_zombie ]]();
return;
}
self thread maps/mp/zombies/_zm_ai_basic::start_inert();
}
electric_cherry_visionset()
{
if ( isDefined( self ) && flag( "solo_game" ) )
{
if ( isDefined( level.vsmgr_prio_visionset_zm_electric_cherry ) )
{
if ( !isDefined( self.electric_cherry_visionset ) || self.electric_cherry_visionset == 0 )
{
maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_electric_cherry", self );
self.electric_cherry_visionset = 1;
}
}
}
wait 5;
if ( isDefined( self ) && isDefined( level.vsmgr_prio_visionset_zm_electric_cherry ) )
{
if ( isDefined( self.electric_cherry_visionset ) && self.electric_cherry_visionset )
{
maps/mp/_visionset_mgr::vsmgr_deactivate( "visionset", "zm_electric_cherry", self );
self.electric_cherry_visionset = 0;
return;
}
else
{
if ( !flag( "solo_game" ) )
{
visionsetlaststand( "zombie_last_stand", 1 );
}
}
}
}

412
zm_transit_dr_patch/maps/mp/zombies/_zm_equip_electrictrap.gsc Normal file
View File

@ -0,0 +1,412 @@
#include maps/mp/zombies/_zm_traps;
#include maps/mp/zombies/_zm_buildables;
#include maps/mp/zombies/_zm_power;
#include maps/mp/zombies/_zm_unitrigger;
#include maps/mp/zombies/_zm;
#include maps/mp/gametypes_zm/_weaponobjects;
#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_electrictrap_zm" ) )
{
return;
}
level.electrictrap_name = "equip_electrictrap_zm";
maps/mp/zombies/_zm_equipment::register_equipment( "equip_electrictrap_zm", &"ZOMBIE_EQUIP_ELECTRICTRAP_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_ELECTRICTRAP_HOWTO", "etrap_zm_icon", "electrictrap", undefined, ::transfertrap, ::droptrap, ::pickuptrap, ::placetrap );
maps/mp/zombies/_zm_equipment::add_placeable_equipment( "equip_electrictrap_zm", "p6_anim_zm_buildable_etrap" );
level thread onplayerconnect();
maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "equip_electrictrap", &"ZOMBIE_EQUIP_ELECTRICTRAP_PICKUP_HINT_STRING" );
level._effect[ "etrap_on" ] = loadfx( "maps/zombie/fx_zmb_tranzit_electric_trap_on" );
thread wait_init_damage();
}
wait_init_damage()
{
while ( !isDefined( level.zombie_vars ) || !isDefined( level.zombie_vars[ "zombie_health_start" ] ) )
{
wait 1;
}
level.etrap_damage = maps/mp/zombies/_zm::ai_zombie_health( 50 );
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player thread onplayerspawned();
}
}
onplayerspawned()
{
self endon( "disconnect" );
self thread setupwatchers();
for ( ;; )
{
self waittill( "spawned_player" );
self thread watchelectrictrapuse();
}
}
setupwatchers()
{
self waittill( "weapon_watchers_created" );
watcher = maps/mp/gametypes_zm/_weaponobjects::getweaponobjectwatcher( "equip_electrictrap" );
watcher.onspawnretrievetriggers = ::maps/mp/zombies/_zm_equipment::equipment_onspawnretrievableweaponobject;
}
watchelectrictrapuse()
{
self notify( "watchElectricTrapUse" );
self endon( "watchElectricTrapUse" );
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "equipment_placed", weapon, weapname );
if ( weapname == level.electrictrap_name )
{
self cleanupoldtrap();
self.buildableelectrictrap = weapon;
self thread startelectrictrapdeploy( weapon );
}
}
}
cleanupoldtrap()
{
if ( isDefined( self.buildableelectrictrap ) )
{
if ( isDefined( self.buildableelectrictrap.stub ) )
{
thread maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.buildableelectrictrap.stub );
self.buildableelectrictrap.stub = undefined;
}
self.buildableelectrictrap delete();
}
if ( isDefined( level.electrap_sound_ent ) )
{
level.electrap_sound_ent delete();
level.electrap_sound_ent = undefined;
}
}
watchforcleanup()
{
self notify( "etrap_cleanup" );
self endon( "etrap_cleanup" );
self waittill_any( "death", "disconnect", "equip_electrictrap_zm_taken", "equip_electrictrap_zm_pickup" );
cleanupoldtrap();
}
placetrap( origin, angles )
{
item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "p6_anim_zm_buildable_etrap", "equip_electrictrap_zm", origin, angles );
if ( isDefined( item ) )
{
item.owner = self;
item.zombie_attack_callback = ::zombie_attacked_trap;
}
return item;
}
droptrap()
{
item = self maps/mp/zombies/_zm_equipment::dropped_equipment_think( "p6_anim_zm_buildable_etrap", "equip_electrictrap_zm", self.origin, self.angles );
if ( isDefined( item ) )
{
item.electrictrap_health = self.electrictrap_health;
}
self.electrictrap_health = undefined;
return item;
}
pickuptrap( item )
{
item.owner = self;
self.electrictrap_health = item.electrictrap_health;
item.electrictrap_health = undefined;
}
transfertrap( fromplayer, toplayer )
{
buildableelectrictrap = toplayer.buildableelectrictrap;
electrictrap_health = toplayer.electrictrap_health;
toplayer.buildableelectrictrap = fromplayer.buildableelectrictrap;
toplayer.buildableelectrictrap.original_owner = toplayer;
toplayer notify( "equip_electrictrap_zm_taken" );
toplayer thread startelectrictrapdeploy( toplayer.buildableelectrictrap );
toplayer.electrictrap_health = fromplayer.electrictrap_health;
fromplayer.buildableelectrictrap = buildableelectrictrap;
fromplayer notify( "equip_electrictrap_zm_taken" );
if ( isDefined( fromplayer.buildableelectrictrap ) )
{
fromplayer thread startelectrictrapdeploy( fromplayer.buildableelectrictrap );
fromplayer.buildableelectrictrap.original_owner = fromplayer;
fromplayer.buildableelectrictrap.owner = fromplayer;
}
else
{
fromplayer maps/mp/zombies/_zm_equipment::equipment_release( "equip_electrictrap_zm" );
}
fromplayer.electrictrap_health = electrictrap_health;
}
startelectrictrapdeploy( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_electrictrap_zm_taken" );
self thread watchforcleanup();
electricradius = 45;
if ( !isDefined( self.electrictrap_health ) )
{
self.electrictrap_health = 60;
}
if ( isDefined( weapon ) )
{
/#
weapon thread debugelectrictrap( electricradius );
#/
if ( isDefined( level.equipment_etrap_needs_power ) && level.equipment_etrap_needs_power )
{
weapon.power_on = 0;
maps/mp/zombies/_zm_power::add_temp_powered_item( ::trap_power_on, ::trap_power_off, ::trap_in_range, ::maps/mp/zombies/_zm_power::cost_high, 1, weapon.power_on, weapon );
}
else
{
weapon.power_on = 1;
}
if ( !weapon.power_on )
{
self iprintlnbold( &"ZOMBIE_NEED_LOCAL_POWER" );
}
self thread electrictrapthink( weapon, electricradius );
if ( isDefined( level.equipment_etrap_needs_power ) && !level.equipment_etrap_needs_power )
{
self thread electrictrapdecay( weapon );
}
self thread maps/mp/zombies/_zm_buildables::delete_on_disconnect( weapon );
weapon waittill( "death" );
if ( isDefined( level.electrap_sound_ent ) )
{
level.electrap_sound_ent playsound( "wpn_zmb_electrap_stop" );
level.electrap_sound_ent delete();
level.electrap_sound_ent = undefined;
}
self notify( "etrap_cleanup" );
}
}
trap_in_range( delta, origin, radius )
{
if ( distancesquared( self.target.origin, origin ) < ( radius * radius ) )
{
return 1;
}
return 0;
}
trap_power_on( origin, radius )
{
/#
println( "^1ZM POWER: trap on\n" );
#/
if ( !isDefined( self.target ) )
{
return;
}
self.target.power_on = 1;
self.target.power_on_time = getTime();
if ( !isDefined( level.electrap_sound_ent ) )
{
level.electrap_sound_ent = spawn( "script_origin", self.target.origin );
}
level.electrap_sound_ent playsound( "wpn_zmb_electrap_start" );
level.electrap_sound_ent playloopsound( "wpn_zmb_electrap_loop", 2 );
self.target thread trapfx();
}
trap_power_off( origin, radius )
{
/#
println( "^1ZM POWER: trap off\n" );
#/
if ( !isDefined( self.target ) )
{
return;
}
self.target.power_on = 0;
if ( isDefined( level.electrap_sound_ent ) )
{
level.electrap_sound_ent playsound( "wpn_zmb_electrap_stop" );
level.electrap_sound_ent delete();
level.electrap_sound_ent = undefined;
}
}
trapfx()
{
self endon( "disconnect" );
while ( isDefined( self ) && isDefined( self.power_on ) && self.power_on )
{
playfxontag( level._effect[ "etrap_on" ], self, "tag_origin" );
wait 0,3;
}
}
zombie_attacked_trap( zombie )
{
if ( isDefined( self.power_on ) && self.power_on )
{
self zap_zombie( zombie );
}
}
electrocution_lockout( time )
{
level.electrocuting_zombie = 1;
wait time;
level.electrocuting_zombie = 0;
}
zap_zombie( zombie )
{
if ( isDefined( zombie.ignore_electric_trap ) && zombie.ignore_electric_trap )
{
return;
}
if ( zombie.health > level.etrap_damage )
{
zombie dodamage( level.etrap_damage, self.origin );
zombie.ignore_electric_trap = 1;
return;
}
self playsound( "wpn_zmb_electrap_zap" );
if ( isDefined( level.electrocuting_zombie ) && !level.electrocuting_zombie )
{
thread electrocution_lockout( 2 );
zombie thread play_elec_vocals();
zombie thread maps/mp/zombies/_zm_traps::electroctute_death_fx();
zombie.is_on_fire = 0;
zombie notify( "stop_flame_damage" );
}
zombie thread electrictrapkill( self );
}
etrap_choke()
{
if ( !isDefined( level.etrap_choke_count ) )
{
level.etrap_choke_count = 0;
}
level.etrap_choke_count++;
if ( level.etrap_choke_count >= 5 )
{
wait 0,05;
level.etrap_choke_count = 0;
}
}
electrictrapthink( weapon, electricradius )
{
weapon endon( "death" );
radiussquared = electricradius * electricradius;
while ( isDefined( weapon ) )
{
while ( weapon.power_on && ( getTime() - weapon.power_on_time ) > 2000 )
{
zombies = getaiarray( level.zombie_team );
_a350 = zombies;
_k350 = getFirstArrayKey( _a350 );
while ( isDefined( _k350 ) )
{
zombie = _a350[ _k350 ];
if ( !isDefined( zombie ) || !isalive( zombie ) )
{
}
else
{
if ( isDefined( zombie.ignore_electric_trap ) && zombie.ignore_electric_trap )
{
break;
}
else
{
if ( distancesquared( weapon.origin, zombie.origin ) < radiussquared )
{
weapon zap_zombie( zombie );
wait 0,15;
}
etrap_choke();
}
}
_k350 = getNextArrayKey( _a350, _k350 );
}
players = get_players();
_a369 = players;
_k369 = getFirstArrayKey( _a369 );
while ( isDefined( _k369 ) )
{
player = _a369[ _k369 ];
if ( is_player_valid( player ) && distancesquared( weapon.origin, player.origin ) < radiussquared )
{
player thread maps/mp/zombies/_zm_traps::player_elec_damage();
etrap_choke();
}
etrap_choke();
_k369 = getNextArrayKey( _a369, _k369 );
}
}
wait 0,1;
}
}
electrictrapkill( weapon )
{
self endon( "death" );
wait randomfloatrange( 0,1, 0,4 );
self dodamage( self.health + 666, self.origin );
}
electrictrapdecay( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_electrictrap_zm_taken" );
while ( isDefined( weapon ) )
{
if ( weapon.power_on )
{
self.electrictrap_health--;
if ( self.electrictrap_health <= 0 )
{
self cleanupoldtrap();
self.electrictrap_health = undefined;
self thread maps/mp/zombies/_zm_equipment::equipment_release( "equip_electrictrap_zm" );
return;
}
}
wait 1;
}
}
debugelectrictrap( radius )
{
/#
while ( isDefined( self ) )
{
if ( getDvarInt( #"EB512CB7" ) )
{
circle( self.origin, radius, ( 1, 1, 1 ), 0, 1, 1 );
}
wait 0,05;
#/
}
}

198
zm_transit_dr_patch/maps/mp/zombies/_zm_equip_gasmask.gsc Normal file
View File

@ -0,0 +1,198 @@
#include maps/mp/zombies/_zm_laststand;
#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_gasmask_zm" ) )
{
return;
}
registerclientfield( "toplayer", "gasmaskoverlay", 7000, 1, "int" );
maps/mp/zombies/_zm_equipment::register_equipment( "equip_gasmask_zm", &"ZOMBIE_EQUIP_GASMASK_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_GASMASK_HOWTO", undefined, "gasmask", ::gasmask_activation_watcher_thread );
level.deathcard_spawn_func = ::remove_gasmask_on_player_bleedout;
precacheitem( "lower_equip_gasmask_zm" );
onplayerconnect_callback( ::gasmask_on_player_connect );
}
gasmask_on_player_connect()
{
}
gasmask_removed_watcher_thread()
{
self notify( "only_one_gasmask_removed_thread" );
self endon( "only_one_gasmask_removed_thread" );
self endon( "disconnect" );
self waittill( "equip_gasmask_zm_taken" );
if ( isDefined( level.zombiemode_gasmask_reset_player_model ) )
{
ent_num = self.characterindex;
if ( isDefined( self.zm_random_char ) )
{
ent_num = self.zm_random_char;
}
self [[ level.zombiemode_gasmask_reset_player_model ]]( ent_num );
}
if ( isDefined( level.zombiemode_gasmask_reset_player_viewmodel ) )
{
ent_num = self.characterindex;
if ( isDefined( self.zm_random_char ) )
{
ent_num = self.zm_random_char;
}
self [[ level.zombiemode_gasmask_reset_player_viewmodel ]]( ent_num );
}
self setclientfieldtoplayer( "gasmaskoverlay", 0 );
}
gasmask_activation_watcher_thread()
{
self endon( "zombified" );
self endon( "disconnect" );
self endon( "equip_gasmask_zm_taken" );
self thread gasmask_removed_watcher_thread();
self thread remove_gasmask_on_game_over();
if ( isDefined( level.zombiemode_gasmask_set_player_model ) )
{
ent_num = self.characterindex;
if ( isDefined( self.zm_random_char ) )
{
ent_num = self.zm_random_char;
}
self [[ level.zombiemode_gasmask_set_player_model ]]( ent_num );
}
if ( isDefined( level.zombiemode_gasmask_set_player_viewmodel ) )
{
ent_num = self.characterindex;
if ( isDefined( self.zm_random_char ) )
{
ent_num = self.zm_random_char;
}
self [[ level.zombiemode_gasmask_set_player_viewmodel ]]( ent_num );
}
for ( ;; )
{
while ( 1 )
{
self waittill_either( "equip_gasmask_zm_activate", "equip_gasmask_zm_deactivate" );
if ( self maps/mp/zombies/_zm_equipment::is_equipment_active( "equip_gasmask_zm" ) )
{
self increment_is_drinking();
self setactionslot( 1, "" );
if ( isDefined( level.zombiemode_gasmask_set_player_model ) )
{
ent_num = self.characterindex;
if ( isDefined( self.zm_random_char ) )
{
ent_num = self.zm_random_char;
}
self [[ level.zombiemode_gasmask_change_player_headmodel ]]( ent_num, 1 );
}
clientnotify( "gmsk2" );
self waittill( "weapon_change_complete" );
self setclientfieldtoplayer( "gasmaskoverlay", 1 );
}
else
{
self increment_is_drinking();
self setactionslot( 1, "" );
if ( isDefined( level.zombiemode_gasmask_set_player_model ) )
{
ent_num = self.characterindex;
if ( isDefined( self.zm_random_char ) )
{
ent_num = self.zm_random_char;
}
self [[ level.zombiemode_gasmask_change_player_headmodel ]]( ent_num, 0 );
}
self takeweapon( "equip_gasmask_zm" );
self giveweapon( "lower_equip_gasmask_zm" );
self switchtoweapon( "lower_equip_gasmask_zm" );
wait 0,05;
self setclientfieldtoplayer( "gasmaskoverlay", 0 );
self waittill( "weapon_change_complete" );
self takeweapon( "lower_equip_gasmask_zm" );
self giveweapon( "equip_gasmask_zm" );
}
if ( !self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
if ( self is_multiple_drinking() )
{
self decrement_is_drinking();
self setactionslot( 1, "weapon", "equip_gasmask_zm" );
self notify( "equipment_select_response_done" );
}
}
else if ( isDefined( self.prev_weapon_before_equipment_change ) && self hasweapon( self.prev_weapon_before_equipment_change ) )
{
if ( self.prev_weapon_before_equipment_change != self getcurrentweapon() )
{
self switchtoweapon( self.prev_weapon_before_equipment_change );
self waittill( "weapon_change_complete" );
}
break;
}
else
{
primaryweapons = self getweaponslistprimaries();
if ( isDefined( primaryweapons ) && primaryweapons.size > 0 )
{
if ( primaryweapons[ 0 ] != self getcurrentweapon() )
{
self switchtoweapon( primaryweapons[ 0 ] );
self waittill( "weapon_change_complete" );
}
break;
}
else
{
self switchtoweapon( get_player_melee_weapon() );
}
}
}
self setactionslot( 1, "weapon", "equip_gasmask_zm" );
if ( !self maps/mp/zombies/_zm_laststand::player_is_in_laststand() && isDefined( self.intermission ) && !self.intermission )
{
self decrement_is_drinking();
}
self notify( "equipment_select_response_done" );
}
}
remove_gasmask_on_player_bleedout()
{
self setclientfieldtoplayer( "gasmaskoverlay", 0 );
wait_network_frame();
wait_network_frame();
self setclientfieldtoplayer( "gasmaskoverlay", 1 );
}
remove_gasmask_on_game_over()
{
self endon( "equip_gasmask_zm_taken" );
level waittill( "pre_end_game" );
self setclientfieldtoplayer( "gasmaskoverlay", 0 );
}
gasmask_active()
{
return self maps/mp/zombies/_zm_equipment::is_equipment_active( "equip_gasmask_zm" );
}
gasmask_debug_print( msg, color )
{
/#
if ( !getDvarInt( #"4D1BCA99" ) )
{
return;
}
if ( !isDefined( color ) )
{
color = ( 0, 0, 1 );
}
print3d( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), msg, color, 1, 1, 40 );
#/
}

880
zm_transit_dr_patch/maps/mp/zombies/_zm_equip_hacker.gsc Normal file
View File

@ -0,0 +1,880 @@
#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
{
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( self.height ) )
{
height = candidate.height;
}
trigger = spawn( "trigger_radius_use", candidate.origin, 0, radius, height );
trigger usetriggerrequirelookat();
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++;
}
}
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 ) )
{
self._trigger sethintstring( "" );
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 );
#/
}

772
zm_transit_dr_patch/maps/mp/zombies/_zm_equip_turbine.gsc Normal file
View File

@ -0,0 +1,772 @@
#include maps/mp/zombies/_zm_buildables;
#include maps/mp/zombies/_zm_unitrigger;
#include maps/mp/zombies/_zm_power;
#include maps/mp/gametypes_zm/_weaponobjects;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
#using_animtree( "zombie_turbine" );
init()
{
if ( !maps/mp/zombies/_zm_equipment::is_equipment_included( "equip_turbine_zm" ) )
{
return;
}
level.turbine_name = "equip_turbine_zm";
maps/mp/zombies/_zm_equipment::register_equipment( "equip_turbine_zm", &"ZOMBIE_EQUIP_TURBINE_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_TURBINE_HOWTO", "turbine_zm_icon", "turbine", undefined, ::transferturbine, ::dropturbine, ::pickupturbine, ::placeturbine );
maps/mp/zombies/_zm_equipment::add_placeable_equipment( "equip_turbine_zm", "p6_anim_zm_buildable_turbine", ::destroy_placed_turbine );
level thread onplayerconnect();
maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "equip_turbine", &"ZOMBIE_EQUIP_TURBINE_PICKUP_HINT_STRING" );
level._effect[ "turbine_on" ] = loadfx( "maps/zombie/fx_zmb_tranzit_wind_turbine_on" );
level._effect[ "turbine_med" ] = loadfx( "maps/zombie/fx_zmb_tranzit_wind_turbine_med" );
level._effect[ "turbine_low" ] = loadfx( "maps/zombie/fx_zmb_tranzit_wind_turbine_low" );
level._effect[ "turbine_aoe" ] = loadfx( "maps/zombie/fx_zmb_tranzit_wind_turbine_aoe" );
level._turbine_disappear_fx = loadfx( "maps/zombie/fx_zmb_tranzit_turbine_explo" );
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player thread onplayerspawned();
}
}
onplayerspawned()
{
self endon( "disconnect" );
self thread setupwatchers();
for ( ;; )
{
self waittill( "spawned_player" );
self thread watchturbineuse();
}
}
setupwatchers()
{
self waittill( "weapon_watchers_created" );
watcher = maps/mp/gametypes_zm/_weaponobjects::getweaponobjectwatcher( "equip_turbine" );
watcher.onspawnretrievetriggers = ::maps/mp/zombies/_zm_equipment::equipment_onspawnretrievableweaponobject;
}
watchturbineuse()
{
self notify( "watchTurbineUse" );
self endon( "watchTurbineUse" );
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "equipment_placed", weapon, weapname );
if ( weapname == level.turbine_name )
{
self cleanupoldturbine();
self.buildableturbine = weapon;
self thread startturbinedeploy( weapon );
level notify( "turbine_deployed" );
}
}
}
cleanupoldturbine( preserve_state )
{
if ( isDefined( self.localpower ) )
{
maps/mp/zombies/_zm_power::end_local_power( self.localpower );
self notify( "depower_on_disconnect" );
self.localpower = undefined;
self.turbine_power_is_on = 0;
}
self.turbine_is_powering_on = 0;
if ( isDefined( self.buildableturbine ) )
{
if ( isDefined( self.buildableturbine.stub ) )
{
thread maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.buildableturbine.stub );
self.buildableturbine.stub = undefined;
}
self.buildableturbine stoploopsound();
self.buildableturbine delete();
if ( isDefined( preserve_state ) && !preserve_state )
{
self.turbine_health = undefined;
self.turbine_emped = undefined;
self.turbine_emp_time = undefined;
}
}
}
watchforcleanup()
{
self notify( "turbine_cleanup" );
self endon( "turbine_cleanup" );
evt = self waittill_any_return( "death", "disconnect", "equip_turbine_zm_taken", "equip_turbine_zm_pickup" );
if ( isDefined( self ) )
{
self cleanupoldturbine( evt == "equip_turbine_zm_pickup" );
}
}
depower_on_disconnect( localpower )
{
self notify( "depower_on_disconnect" );
self endon( "depower_on_disconnect" );
self waittill( "disconnect" );
if ( isDefined( localpower ) )
{
maps/mp/zombies/_zm_power::end_local_power( localpower );
}
}
placeturbine( origin, angles )
{
item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "p6_anim_zm_buildable_turbine", "equip_turbine_zm", origin, angles );
return item;
}
dropturbine()
{
item = thread maps/mp/zombies/_zm_equipment::dropped_equipment_think( "p6_anim_zm_buildable_turbine", "equip_turbine_zm", self.origin, self.angles );
if ( isDefined( item ) )
{
item.turbine_power_on = self.turbine_power_on;
item.turbine_power_level = self.turbine_power_level;
item.turbine_round_start = self.turbine_round_start;
item.turbine_health = self.turbine_health;
item.turbine_emped = self.turbine_emped;
item.turbine_emp_time = self.turbine_emp_time;
}
self.turbine_is_powering_on = undefined;
self.turbine_power_on = undefined;
self.turbine_power_level = undefined;
self.turbine_round_start = undefined;
self.turbine_health = undefined;
self.turbine_emped = undefined;
self.turbine_emp_time = undefined;
return item;
}
pickupturbine( item )
{
item.owner = self;
self.turbine_power_on = item.turbine_power_on;
item.turbine_power_on = undefined;
self.turbine_power_level = item.turbine_power_level;
self.turbine_round_start = item.turbine_round_start;
self.turbine_health = item.turbine_health;
item.turbine_health = undefined;
item.turbine_power_level = undefined;
item.turbine_round_start = undefined;
self.turbine_emped = item.turbine_emped;
self.turbine_emp_time = item.turbine_emp_time;
item.turbine_emped = undefined;
item.turbine_emp_time = undefined;
self.turbine_is_powering_on = undefined;
}
transferturbine( fromplayer, toplayer )
{
while ( isDefined( toplayer.turbine_is_powering_on ) || toplayer.turbine_is_powering_on && isDefined( fromplayer.turbine_is_powering_on ) && fromplayer.turbine_is_powering_on )
{
wait 0,05;
}
if ( isDefined( fromplayer.buildableturbine ) && isDefined( fromplayer.buildableturbine.dying ) && fromplayer.buildableturbine.dying )
{
fromplayer cleanupoldturbine( 0 );
}
if ( isDefined( toplayer.buildableturbine ) && isDefined( toplayer.buildableturbine.dying ) && toplayer.buildableturbine.dying )
{
toplayer cleanupoldturbine( 0 );
}
buildableturbine = toplayer.buildableturbine;
localpower = toplayer.localpower;
turbine_power_on = toplayer.turbine_power_on;
turbine_power_is_on = toplayer.turbine_power_is_on;
turbine_power_level = toplayer.turbine_power_level;
turbine_round_start = toplayer.turbine_round_start;
turbine_health = toplayer.turbine_health;
turbine_emped = toplayer.turbine_emped;
turbine_emp_time = toplayer.turbine_emp_time;
toplayer.buildableturbine = fromplayer.buildableturbine;
fromplayer.buildableturbine = buildableturbine;
toplayer.localpower = fromplayer.localpower;
fromplayer.localpower = localpower;
toplayer.turbine_power_on = fromplayer.turbine_power_on;
fromplayer.turbine_power_on = turbine_power_on;
toplayer.turbine_power_is_on = fromplayer.turbine_power_is_on;
fromplayer.turbine_power_is_on = turbine_power_is_on;
toplayer.turbine_power_level = fromplayer.turbine_power_level;
toplayer.turbine_round_start = fromplayer.turbine_round_start;
fromplayer.turbine_power_level = turbine_power_level;
fromplayer.turbine_round_start = turbine_round_start;
toplayer.turbine_health = fromplayer.turbine_health;
fromplayer.turbine_health = turbine_health;
toplayer.turbine_emped = fromplayer.turbine_emped;
fromplayer.turbine_emped = turbine_emped;
toplayer.turbine_emp_time = fromplayer.turbine_emp_time;
fromplayer.turbine_emp_time = turbine_emp_time;
toplayer.turbine_is_powering_on = undefined;
fromplayer.turbine_is_powering_on = undefined;
toplayer notify( "equip_turbine_zm_taken" );
toplayer.buildableturbine.original_owner = toplayer;
toplayer thread startturbinedeploy( toplayer.buildableturbine );
fromplayer notify( "equip_turbine_zm_taken" );
if ( isDefined( fromplayer.buildableturbine ) )
{
fromplayer thread startturbinedeploy( fromplayer.buildableturbine );
fromplayer.buildableturbine.original_owner = fromplayer;
fromplayer.buildableturbine.owner = fromplayer;
}
else
{
fromplayer maps/mp/zombies/_zm_equipment::equipment_release( "equip_turbine_zm" );
}
}
startturbinedeploy( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turbine_zm_taken" );
self thread watchforcleanup();
origin = weapon.origin;
powerradius = 335;
if ( !isDefined( self.turbine_health ) )
{
self.turbine_health = 1200;
self.turbine_power_level = 4;
self.turbine_power_on = 1;
self.turbine_is_powering_on = undefined;
}
if ( !isDefined( self.turbine_round_start ) )
{
self.turbine_round_start = level.round_number;
self.turbine_power_on = 1;
}
self thread turbinedecay();
self thread turbinepowerdiminish( origin, powerradius );
if ( isDefined( weapon ) )
{
/#
self thread debugturbine( powerradius );
#/
self thread turbineaudio();
self thread turbineanim();
self thread turbinepowerthink( weapon, powerradius );
if ( isDefined( weapon.equipment_can_move ) && weapon.equipment_can_move )
{
self thread turbinepowermove( weapon );
}
self thread maps/mp/zombies/_zm_buildables::delete_on_disconnect( weapon );
weapon waittill( "death" );
self thread turbinepoweroff( origin, powerradius );
self notify( "turbine_cleanup" );
}
}
turbine_watch_for_emp( weapon, powerradius )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turbine_zm_taken" );
self.buildableturbine endon( "death" );
while ( 1 )
{
level waittill( "emp_detonate", origin, radius );
if ( distancesquared( origin, self.buildableturbine.origin ) < ( radius * radius ) )
{
break;
}
else
{
}
}
self.turbine_emped = 1;
self.turbine_emp_time = getTime();
self notify( "turbine_power_change" );
}
turbinepowerthink( weapon, powerradius )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turbine_zm_taken" );
self.buildableturbine endon( "death" );
origin = weapon.origin;
self thread turbine_watch_for_emp( weapon, powerradius );
if ( isDefined( self.turbine_power_on ) || self.turbine_power_on && isDefined( self.turbine_emped ) && self.turbine_emped )
{
self thread turbinepoweron( origin, powerradius );
}
while ( isDefined( self.buildableturbine ) )
{
self waittill( "turbine_power_change" );
if ( isDefined( self.turbine_emped ) && self.turbine_emped )
{
self thread turbinepoweroff( origin, powerradius );
if ( isDefined( weapon ) )
{
origin = weapon.origin;
}
self thread turbinepoweron( origin, powerradius );
continue;
}
else
{
if ( isDefined( self.turbine_power_is_on ) && !self.turbine_power_is_on )
{
self thread turbinepoweroff( origin, powerradius );
break;
}
else
{
if ( isDefined( weapon ) )
{
origin = weapon.origin;
}
self thread turbinepoweron( origin, powerradius );
}
}
}
}
turbinepowermove( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turbine_zm_taken" );
self.buildableturbine endon( "death" );
origin = weapon.origin;
while ( 1 )
{
if ( origin != weapon.origin )
{
if ( isDefined( self.localpower ) )
{
self.localpower = maps/mp/zombies/_zm_power::move_local_power( self.localpower, origin );
}
origin = weapon.origin;
}
wait 0,5;
}
}
turbinewarmup()
{
if ( isDefined( self.turbine_emped ) && self.turbine_emped )
{
emp_time = level.zombie_vars[ "emp_perk_off_time" ];
now = getTime();
emp_time_left = emp_time - ( ( now - self.turbine_emp_time ) / 1000 );
if ( emp_time_left > 0 )
{
wait emp_time_left;
}
self.turbine_emped = undefined;
self.turbine_emp_time = undefined;
}
playfxontag( level._effect[ "turbine_low" ], self.buildableturbine, "tag_animate" );
wait 0,5;
playfxontag( level._effect[ "turbine_med" ], self.buildableturbine, "tag_animate" );
wait 0,5;
playfxontag( level._effect[ "turbine_on" ], self.buildableturbine, "tag_animate" );
wait 0,5;
}
turbinepoweron( origin, powerradius )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turbine_zm_taken" );
self.buildableturbine endon( "death" );
if ( isDefined( self.turbine_power_is_on ) && !self.turbine_power_is_on && isDefined( self.turbine_is_powering_on ) && !self.turbine_is_powering_on && isDefined( self.buildableturbine.dying ) && !self.buildableturbine.dying )
{
self.turbine_is_powering_on = 1;
self.buildableturbine playloopsound( "zmb_turbine_loop", 2 );
self turbinewarmup();
if ( isDefined( self.localpower ) )
{
maps/mp/zombies/_zm_power::end_local_power( self.localpower );
}
self.localpower = undefined;
self.turbine_power_is_on = 0;
if ( isDefined( self.turbine_emped ) && !self.turbine_emped )
{
self.localpower = maps/mp/zombies/_zm_power::add_local_power( origin, powerradius );
self thread depower_on_disconnect( self.localpower );
self.turbine_power_is_on = 1;
self thread turbineaudio();
}
self.turbine_is_powering_on = 0;
self thread turbinefx();
self thread turbinedecay();
}
}
turbinepoweroff( origin, powerradius )
{
if ( isDefined( self.turbine_power_is_on ) && self.turbine_power_is_on )
{
if ( isDefined( self.localpower ) )
{
maps/mp/zombies/_zm_power::end_local_power( self.localpower );
}
self notify( "depower_on_disconnect" );
self.localpower = undefined;
self.turbine_power_is_on = 0;
self thread turbineaudio();
if ( isDefined( self.buildableturbine.dying ) && !self.buildableturbine.dying )
{
self thread turbineanim();
}
}
}
turbine_disappear_fx( origin, waittime )
{
if ( isDefined( waittime ) && waittime > 0 )
{
wait waittime;
}
playfx( level._turbine_disappear_fx, origin );
if ( isDefined( self.buildableturbine ) )
{
playsoundatposition( "zmb_turbine_explo", self.buildableturbine.origin );
}
}
turbinefxonce( withaoe )
{
if ( isDefined( self ) && isDefined( self.buildableturbine ) && isDefined( self.turbine_power_is_on ) && self.turbine_power_is_on )
{
switch( self.turbine_power_level )
{
case 3:
case 4:
playfxontag( level._effect[ "turbine_on" ], self.buildableturbine, "tag_animate" );
break;
case 2:
playfxontag( level._effect[ "turbine_med" ], self.buildableturbine, "tag_animate" );
break;
case 1:
playfxontag( level._effect[ "turbine_low" ], self.buildableturbine, "tag_animate" );
break;
}
if ( withaoe )
{
if ( isDefined( self.buildableturbine.equipment_can_move ) && self.buildableturbine.equipment_can_move && isDefined( self.buildableturbine.move_parent.ismoving ) && self.buildableturbine.move_parent.ismoving )
{
playfxontag( level._effect[ "turbine_aoe" ], self.buildableturbine, "tag_animate" );
}
else
{
playfx( level._effect[ "turbine_aoe" ], self.buildableturbine.origin );
}
self.buildableturbine playsound( "zmb_turbine_pulse" );
}
}
}
turbinefx()
{
self endon( "disconnect" );
while ( isDefined( self ) && isDefined( self.buildableturbine ) && isDefined( self.turbine_power_is_on ) && self.turbine_power_is_on )
{
self turbinefxonce( 1 );
wait 0,5;
self turbinefxonce( 0 );
wait 0,5;
}
}
turbineaudio()
{
if ( !isDefined( self.buildableturbine ) )
{
return;
}
if ( isDefined( self.turbine_power_is_on ) || !self.turbine_power_is_on && isDefined( self.turbine_emped ) && self.turbine_emped )
{
self.buildableturbine stoploopsound();
return;
}
self.buildableturbine playloopsound( "zmb_turbine_loop", 2 );
}
init_animtree()
{
scriptmodelsuseanimtree( -1 );
}
turbineanim( wait_for_end )
{
if ( !isDefined( self.buildableturbine ) )
{
return;
}
animlength = 0;
self.buildableturbine useanimtree( -1 );
if ( isDefined( self.buildableturbine.dying ) && self.buildableturbine.dying )
{
animlength = getanimlength( %o_zombie_buildable_turbine_death );
self.buildableturbine setanim( %o_zombie_buildable_turbine_death );
break;
}
else
{
if ( isDefined( self.turbine_emped ) && self.turbine_emped )
{
self.buildableturbine clearanim( %o_zombie_buildable_turbine_fullpower, 0 );
return;
break;
}
else
{
switch( self.turbine_power_level )
{
case 3:
case 4:
animlength = getanimlength( %o_zombie_buildable_turbine_fullpower );
self.buildableturbine setanim( %o_zombie_buildable_turbine_fullpower );
break;
case 2:
animlength = getanimlength( %o_zombie_buildable_turbine_halfpower );
self.buildableturbine setanim( %o_zombie_buildable_turbine_halfpower );
break;
case 1:
animlength = getanimlength( %o_zombie_buildable_turbine_neardeath );
self.buildableturbine setanim( %o_zombie_buildable_turbine_neardeath );
break;
}
}
}
if ( isDefined( wait_for_end ) && wait_for_end )
{
wait animlength;
}
}
turbinedecay()
{
self notify( "turbineDecay" );
self endon( "turbineDecay" );
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turbine_zm_taken" );
self.buildableturbine endon( "death" );
roundlives = 4;
if ( !isDefined( self.turbine_power_level ) )
{
self.turbine_power_level = roundlives;
}
while ( self.turbine_health > 0 )
{
old_power_level = self.turbine_power_level;
if ( isDefined( self.turbine_emped ) && self.turbine_emped && isDefined( self.turbine_is_powering_on ) && self.turbine_is_powering_on )
{
emp_time = level.zombie_vars[ "emp_perk_off_time" ];
now = getTime();
emp_time_left = emp_time - ( ( now - self.turbine_emp_time ) / 1000 );
if ( emp_time_left <= 0 )
{
self.turbine_emped = undefined;
self.turbine_emp_time = undefined;
self.turbine_power_is_on = 0;
old_power_level = -1;
}
}
if ( isDefined( self.turbine_emped ) && self.turbine_emped )
{
self.turbine_power_level = 0;
}
else
{
if ( isDefined( self.turbine_power_is_on ) && self.turbine_power_is_on )
{
cost = 1;
if ( isDefined( self.localpower ) )
{
cost += maps/mp/zombies/_zm_power::get_local_power_cost( self.localpower );
}
self.turbine_health -= cost;
if ( self.turbine_health < 200 )
{
self.turbine_power_level = 1;
break;
}
else if ( self.turbine_health < 600 )
{
self.turbine_power_level = 2;
break;
}
else
{
self.turbine_power_level = 4;
}
}
}
if ( old_power_level != self.turbine_power_level )
{
self notify( "turbine_power_change" );
self thread turbineaudio();
if ( isDefined( self.buildableturbine.dying ) && !self.buildableturbine.dying )
{
self thread turbineanim();
}
}
wait 1;
}
self destroy_placed_turbine();
if ( isDefined( self.buildableturbine ) )
{
turbine_disappear_fx( self.buildableturbine.origin );
}
self thread wait_and_take_equipment();
self.turbine_health = undefined;
self.turbine_power_level = undefined;
self.turbine_round_start = undefined;
self.turbine_power_on = undefined;
self.turbine_emped = undefined;
self.turbine_emp_time = undefined;
self cleanupoldturbine();
}
destroy_placed_turbine()
{
if ( isDefined( self.buildableturbine ) )
{
if ( isDefined( self.buildableturbine.dying ) && self.buildableturbine.dying )
{
while ( isDefined( self.buildableturbine ) )
{
wait 0,05;
}
return;
}
if ( isDefined( self.buildableturbine.stub ) )
{
thread maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.buildableturbine.stub );
}
thread turbine_disappear_fx( self.buildableturbine.origin, 0,75 );
self.buildableturbine.dying = 1;
self turbineanim( 1 );
}
}
wait_and_take_equipment()
{
wait 0,05;
self thread maps/mp/zombies/_zm_equipment::equipment_release( "equip_turbine_zm" );
}
turbinepowerdiminish( origin, powerradius )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turbine_zm_taken" );
self.buildableturbine endon( "death" );
while ( isDefined( self.buildableturbine.dying ) && !self.buildableturbine.dying )
{
if ( isDefined( self.turbine_power_level ) && isDefined( self.buildableturbine ) )
{
switch( self.turbine_power_level )
{
case 4:
break;
case 3:
case 2:
self.turbine_power_on = 1;
wait randomintrange( 12, 20 );
self turbinepoweroff( origin, powerradius );
self.turbine_power_on = 0;
wait randomintrange( 3, 8 );
self turbinepoweron( origin, powerradius );
break;
case 1:
self.turbine_power_on = 1;
wait randomintrange( 3, 7 );
self turbinepoweroff( origin, powerradius );
self.turbine_power_on = 0;
wait randomintrange( 6, 12 );
self turbinepoweron( origin, powerradius );
break;
}
}
wait 0,05;
}
}
}
debugturbine( radius )
{
/#
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turbine_zm_taken" );
self.buildableturbine endon( "death" );
while ( isDefined( self.buildableturbine ) )
{
if ( getDvarInt( #"EB512CB7" ) )
{
color = ( 0, 0, 1 );
text = "";
if ( isDefined( self.turbine_health ) )
{
text = "" + self.turbine_health + "";
}
if ( isDefined( self.buildableturbine.dying ) && self.buildableturbine.dying )
{
text = "dying";
color = ( 0, 0, 1 );
}
else
{
if ( isDefined( self.turbine_emped ) && self.turbine_emped )
{
color = ( 0, 0, 1 );
emp_time = level.zombie_vars[ "emp_perk_off_time" ];
now = getTime();
emp_time_left = int( emp_time - ( ( now - self.turbine_emp_time ) / 1000 ) );
text = ( text + " emp(" ) + emp_time_left + ")";
break;
}
else
{
if ( isDefined( self.turbine_is_powering_on ) && self.turbine_is_powering_on )
{
text += " warmup";
break;
}
else
{
if ( isDefined( self.turbine_power_is_on ) && self.turbine_power_is_on )
{
if ( self.turbine_health < 200 )
{
color = ( 0, 0, 1 );
break;
}
else if ( self.turbine_health < 600 )
{
color = ( 1, 0,7, 0 );
break;
}
else
{
color = ( 0, 0, 1 );
}
}
}
}
}
print3d( self.buildableturbine.origin + vectorScale( ( 0, 0, 1 ), 60 ), text, color, 1, 0,5, 1 );
}
wait 0,05;
#/
}
}

350
zm_transit_dr_patch/maps/mp/zombies/_zm_equip_turret.gsc Normal file
View File

@ -0,0 +1,350 @@
#include maps/mp/zombies/_zm_buildables;
#include maps/mp/zombies/_zm_mgturret;
#include maps/mp/zombies/_zm_power;
#include maps/mp/zombies/_zm_unitrigger;
#include maps/mp/gametypes_zm/_weaponobjects;
#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_turret_zm" ) )
{
return;
}
precachemodel( "p6_anim_zm_buildable_turret" );
precacheturret( "zombie_bullet_crouch_zm" );
level.turret_name = "equip_turret_zm";
maps/mp/zombies/_zm_equipment::register_equipment( "equip_turret_zm", &"ZOMBIE_EQUIP_TURRET_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_TURRET_HOWTO", "turret_zm_icon", "turret", undefined, ::transferturret, ::dropturret, ::pickupturret, ::placeturret );
maps/mp/zombies/_zm_equipment::add_placeable_equipment( "equip_turret_zm", "p6_anim_zm_buildable_turret" );
level thread onplayerconnect();
maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "equip_turret", &"ZOMBIE_EQUIP_TURRET_PICKUP_HINT_STRING" );
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player thread onplayerspawned();
}
}
onplayerspawned()
{
self endon( "disconnect" );
self thread setupwatchers();
for ( ;; )
{
self waittill( "spawned_player" );
self thread watchturretuse();
}
}
setupwatchers()
{
self waittill( "weapon_watchers_created" );
watcher = maps/mp/gametypes_zm/_weaponobjects::getweaponobjectwatcher( "equip_turret" );
watcher.onspawnretrievetriggers = ::maps/mp/zombies/_zm_equipment::equipment_onspawnretrievableweaponobject;
}
watchturretuse()
{
self notify( "watchTurretUse" );
self endon( "watchTurretUse" );
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "equipment_placed", weapon, weapname );
if ( weapname == level.turret_name )
{
self cleanupoldturret();
self.buildableturret = weapon;
self thread startturretdeploy( weapon );
}
}
}
cleanupoldturret()
{
if ( isDefined( self.buildableturret ) )
{
if ( isDefined( self.buildableturret.stub ) )
{
thread maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.buildableturret.stub );
self.buildableturret.stub = undefined;
}
if ( isDefined( self.buildableturret.turret ) )
{
if ( isDefined( self.buildableturret.turret.sound_ent ) )
{
self.buildableturret.turret.sound_ent delete();
}
self.buildableturret.turret delete();
}
if ( isDefined( self.buildableturret.sound_ent ) )
{
self.buildableturret.sound_ent delete();
self.buildableturret.sound_ent = undefined;
}
self.buildableturret delete();
self.turret_health = undefined;
}
else
{
if ( isDefined( self.turret ) )
{
self.turret notify( "stop_burst_fire_unmanned" );
self.turret delete();
}
}
self.turret = undefined;
self notify( "turret_cleanup" );
}
watchforcleanup()
{
self notify( "turret_cleanup" );
self endon( "turret_cleanup" );
self waittill_any( "death", "disconnect", "equip_turret_zm_taken", "equip_turret_zm_pickup" );
cleanupoldturret();
}
placeturret( origin, angles )
{
item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "p6_anim_zm_buildable_turret", "equip_turret_zm", origin, angles );
if ( isDefined( item ) )
{
item.owner = self;
}
return item;
}
dropturret()
{
item = self maps/mp/zombies/_zm_equipment::dropped_equipment_think( "p6_anim_zm_buildable_turret", "equip_turret_zm", self.origin, self.angles );
if ( isDefined( item ) )
{
item.turret_health = self.turret_health;
}
self.turret_health = undefined;
return item;
}
pickupturret( item )
{
item.owner = self;
self.turret_health = item.turret_health;
item.turret_health = undefined;
}
transferturret( fromplayer, toplayer )
{
buildableturret = toplayer.buildableturret;
turret = toplayer.turret;
toplayer.buildableturret = fromplayer.buildableturret;
toplayer.turret = fromplayer.turret;
fromplayer.buildableturret = buildableturret;
fromplayer.turret = turret;
toplayer.buildableturret.original_owner = toplayer;
toplayer notify( "equip_turret_zm_taken" );
toplayer thread startturretdeploy( toplayer.buildableturret );
fromplayer notify( "equip_turret_zm_taken" );
if ( isDefined( fromplayer.buildableturret ) )
{
fromplayer thread startturretdeploy( fromplayer.buildableturret );
fromplayer.buildableturret.original_owner = fromplayer;
fromplayer.buildableturret.owner = fromplayer;
}
else
{
fromplayer maps/mp/zombies/_zm_equipment::equipment_release( "equip_turret_zm" );
}
turret_health = toplayer.turret_health;
toplayer.turret_health = fromplayer.turret_health;
fromplayer.turret_health = turret_health;
}
startturretdeploy( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "equip_turret_zm_taken" );
self thread watchforcleanup();
if ( !isDefined( self.turret_health ) )
{
self.turret_health = 60;
}
if ( isDefined( weapon ) )
{
weapon hide();
wait 0,1;
if ( isDefined( weapon.power_on ) && weapon.power_on )
{
weapon.turret notify( "stop_burst_fire_unmanned" );
}
if ( !isDefined( weapon ) )
{
return;
}
if ( isDefined( self.turret ) )
{
self.turret notify( "stop_burst_fire_unmanned" );
self.turret notify( "turret_deactivated" );
self.turret delete();
}
turret = spawnturret( "misc_turret", weapon.origin, "zombie_bullet_crouch_zm" );
turret.turrettype = "sentry";
turret setturrettype( turret.turrettype );
turret setmodel( "p6_anim_zm_buildable_turret" );
turret.origin = weapon.origin;
turret.angles = weapon.angles;
turret linkto( weapon );
turret makeunusable();
turret.owner = self;
turret setowner( turret.owner );
turret maketurretunusable();
turret setmode( "auto_nonai" );
turret setdefaultdroppitch( 45 );
turret setconvergencetime( 0,3 );
turret setturretteam( self.team );
turret.team = self.team;
turret.damage_own_team = 1;
turret.turret_active = 1;
weapon.turret = turret;
self.turret = turret;
if ( isDefined( level.equipment_turret_needs_power ) && level.equipment_turret_needs_power )
{
weapon.power_on = 0;
maps/mp/zombies/_zm_power::add_temp_powered_item( ::turret_power_on, ::turret_power_off, ::turret_in_range, ::maps/mp/zombies/_zm_power::cost_high, 1, weapon.power_on, weapon );
}
else
{
weapon.power_on = 1;
}
if ( weapon.power_on )
{
turret thread maps/mp/zombies/_zm_mgturret::burst_fire_unmanned();
}
else
{
self iprintlnbold( &"ZOMBIE_NEED_LOCAL_POWER" );
}
if ( isDefined( level.equipment_turret_needs_power ) && !level.equipment_turret_needs_power )
{
self thread turretdecay( weapon );
}
self thread maps/mp/zombies/_zm_buildables::delete_on_disconnect( weapon );
while ( isDefined( weapon ) )
{
if ( !is_true( weapon.power_on ) )
{
if ( isDefined( self.buildableturret.sound_ent ) )
{
self.buildableturret.sound_ent playsound( "wpn_zmb_turret_stop" );
self.buildableturret.sound_ent delete();
self.buildableturret.sound_ent = undefined;
}
}
wait 0,1;
}
if ( isDefined( self.buildableturret.sound_ent ) )
{
self.buildableturret.sound_ent playsound( "wpn_zmb_turret_stop" );
self.buildableturret.sound_ent delete();
self.buildableturret.sound_ent = undefined;
}
if ( isDefined( turret ) )
{
turret notify( "stop_burst_fire_unmanned" );
turret notify( "turret_deactivated" );
turret delete();
}
self.turret = undefined;
self notify( "turret_cleanup" );
}
}
turret_in_range( delta, origin, radius )
{
if ( distancesquared( self.target.origin, origin ) < ( radius * radius ) )
{
return 1;
}
return 0;
}
turret_power_on( origin, radius )
{
/#
println( "^1ZM POWER: turret on\n" );
#/
if ( !isDefined( self.target ) )
{
return;
}
self.target.power_on = 1;
self.target.turret thread maps/mp/zombies/_zm_mgturret::burst_fire_unmanned();
player = self.target.turret.owner;
if ( !isDefined( player.buildableturret.sound_ent ) )
{
player.buildableturret.sound_ent = spawn( "script_origin", self.target.turret.origin );
}
player.buildableturret.sound_ent playsound( "wpn_zmb_turret_start" );
player.buildableturret.sound_ent playloopsound( "wpn_zmb_turret_loop", 2 );
}
turret_power_off( origin, radius )
{
/#
println( "^1ZM POWER: turret off\n" );
#/
if ( !isDefined( self.target ) )
{
return;
}
self.target.power_on = 0;
self.target.turret notify( "stop_burst_fire_unmanned" );
player = self.target.turret.owner;
if ( isDefined( player.buildableturret.sound_ent ) )
{
player.buildableturret.sound_ent playsound( "wpn_zmb_turret_stop" );
player.buildableturret.sound_ent delete();
player.buildableturret.sound_ent = undefined;
}
}
turretdecay( weapon )
{
self endon( "death" );
self endon( "disconnect" );
while ( isDefined( weapon ) )
{
if ( weapon.power_on )
{
self.turret_health--;
if ( self.turret_health <= 0 )
{
self cleanupoldturret();
self thread maps/mp/zombies/_zm_equipment::equipment_release( "equip_turret_zm" );
return;
}
}
wait 1;
}
}
debugturret( radius )
{
/#
while ( isDefined( self ) )
{
circle( self.origin, radius, ( 1, 1, 1 ), 0, 1, 1 );
wait 0,05;
#/
}
}

1659
zm_transit_dr_patch/maps/mp/zombies/_zm_equipment.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

77
zm_transit_dr_patch/maps/mp/zombies/_zm_ffotd.gsc Normal file
View File

@ -0,0 +1,77 @@
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
main_start()
{
}
main_end()
{
}
player_in_exploit_area( player_trigger_origin, player_trigger_radius )
{
if ( distancesquared( player_trigger_origin, self.origin ) < ( player_trigger_radius * player_trigger_radius ) )
{
/#
iprintlnbold( "player exploit detectect" );
#/
return 1;
}
return 0;
}
path_exploit_fix( zombie_trigger_origin, zombie_trigger_radius, zombie_trigger_height, player_trigger_origin, player_trigger_radius, zombie_goto_point )
{
spawnflags = 9;
zombie_trigger = spawn( "trigger_radius", zombie_trigger_origin, spawnflags, zombie_trigger_radius, zombie_trigger_height );
zombie_trigger setteamfortrigger( level.zombie_team );
/#
thread debug_exploit( zombie_trigger_origin, zombie_trigger_radius, player_trigger_origin, player_trigger_radius, zombie_goto_point );
#/
while ( 1 )
{
zombie_trigger waittill( "trigger", who );
if ( !is_true( who.reroute ) )
{
who thread exploit_reroute( zombie_trigger, player_trigger_origin, player_trigger_radius, zombie_goto_point );
}
}
}
exploit_reroute( zombie_trigger, player_trigger_origin, player_trigger_radius, zombie_goto_point )
{
self endon( "death" );
self.reroute = 1;
while ( 1 )
{
if ( self istouching( zombie_trigger ) )
{
player = self.favoriteenemy;
if ( isDefined( player ) && player player_in_exploit_area( player_trigger_origin, player_trigger_radius ) )
{
self.reroute_origin = zombie_goto_point;
}
else
{
}
}
else wait 0,2;
}
self.reroute = 0;
}
debug_exploit( player_origin, player_radius, enemy_origin, enemy_radius, zombie_goto_point )
{
/#
while ( isDefined( self ) )
{
circle( player_origin, player_radius, ( 1, 1, 0 ), 0, 1, 1 );
circle( enemy_origin, enemy_radius, ( 1, 1, 0 ), 0, 1, 1 );
line( player_origin, enemy_origin, ( 1, 1, 0 ), 1 );
line( enemy_origin, zombie_goto_point, ( 1, 1, 0 ), 1 );
wait 0,05;
#/
}
}

491
zm_transit_dr_patch/maps/mp/zombies/_zm_game_module.gsc Normal file
View File

@ -0,0 +1,491 @@
#include maps/mp/gametypes_zm/_zm_gametype;
#include maps/mp/zombies/_zm_audio_announcer;
#include maps/mp/zombies/_zm;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
register_game_module( index, module_name, pre_init_func, post_init_func, pre_init_zombie_spawn_func, post_init_zombie_spawn_func, hub_start_func )
{
if ( !isDefined( level._game_modules ) )
{
level._game_modules = [];
level._num_registered_game_modules = 0;
}
i = 0;
while ( i < level._num_registered_game_modules )
{
if ( !isDefined( level._game_modules[ i ] ) )
{
i++;
continue;
}
else
{
if ( isDefined( level._game_modules[ i ].index ) && level._game_modules[ i ].index == index )
{
/#
assert( level._game_modules[ i ].index != index, "A Game module is already registered for index (" + index + ")" );
#/
}
}
i++;
}
level._game_modules[ level._num_registered_game_modules ] = spawnstruct();
level._game_modules[ level._num_registered_game_modules ].index = index;
level._game_modules[ level._num_registered_game_modules ].module_name = module_name;
level._game_modules[ level._num_registered_game_modules ].pre_init_func = pre_init_func;
level._game_modules[ level._num_registered_game_modules ].post_init_func = post_init_func;
level._game_modules[ level._num_registered_game_modules ].pre_init_zombie_spawn_func = pre_init_zombie_spawn_func;
level._game_modules[ level._num_registered_game_modules ].post_init_zombie_spawn_func = post_init_zombie_spawn_func;
level._game_modules[ level._num_registered_game_modules ].hub_start_func = hub_start_func;
level._num_registered_game_modules++;
}
set_current_game_module( game_module_index )
{
if ( !isDefined( game_module_index ) )
{
level.current_game_module = level.game_module_classic_index;
level.scr_zm_game_module = level.game_module_classic_index;
return;
}
game_module = get_game_module( game_module_index );
if ( !isDefined( game_module ) )
{
/#
assert( isDefined( game_module ), "unknown game module (" + game_module_index + ")" );
#/
return;
}
level.current_game_module = game_module_index;
}
get_current_game_module()
{
return get_game_module( level.current_game_module );
}
get_game_module( game_module_index )
{
if ( !isDefined( game_module_index ) )
{
return undefined;
}
i = 0;
while ( i < level._game_modules.size )
{
if ( level._game_modules[ i ].index == game_module_index )
{
return level._game_modules[ i ];
}
i++;
}
return undefined;
}
game_module_pre_zombie_spawn_init()
{
current_module = get_current_game_module();
if ( !isDefined( current_module ) || !isDefined( current_module.pre_init_zombie_spawn_func ) )
{
return;
}
self [[ current_module.pre_init_zombie_spawn_func ]]();
}
game_module_post_zombie_spawn_init()
{
current_module = get_current_game_module();
if ( !isDefined( current_module ) || !isDefined( current_module.post_init_zombie_spawn_func ) )
{
return;
}
self [[ current_module.post_init_zombie_spawn_func ]]();
}
kill_all_zombies()
{
ai = get_round_enemy_array();
_a115 = ai;
_k115 = getFirstArrayKey( _a115 );
while ( isDefined( _k115 ) )
{
zombie = _a115[ _k115 ];
if ( isDefined( zombie ) )
{
zombie dodamage( zombie.maxhealth * 2, zombie.origin, zombie, zombie, "none", "MOD_SUICIDE" );
wait 0,05;
}
_k115 = getNextArrayKey( _a115, _k115 );
}
}
freeze_players( freeze )
{
players = get_players();
i = 0;
while ( i < players.size )
{
players[ i ] freeze_player_controls( freeze );
i++;
}
}
turn_power_on_and_open_doors()
{
level.local_doors_stay_open = 1;
level.power_local_doors_globally = 1;
flag_set( "power_on" );
level setclientfield( "zombie_power_on", 1 );
zombie_doors = getentarray( "zombie_door", "targetname" );
_a144 = zombie_doors;
_k144 = getFirstArrayKey( _a144 );
while ( isDefined( _k144 ) )
{
door = _a144[ _k144 ];
if ( isDefined( door.script_noteworthy ) && door.script_noteworthy == "electric_door" )
{
door notify( "power_on" );
}
else
{
if ( isDefined( door.script_noteworthy ) && door.script_noteworthy == "local_electric_door" )
{
door notify( "local_power_on" );
}
}
_k144 = getNextArrayKey( _a144, _k144 );
}
}
respawn_spectators_and_freeze_players()
{
players = get_players();
_a161 = players;
_k161 = getFirstArrayKey( _a161 );
while ( isDefined( _k161 ) )
{
player = _a161[ _k161 ];
if ( player.sessionstate == "spectator" )
{
if ( isDefined( player.spectate_hud ) )
{
player.spectate_hud destroy();
}
player [[ level.spawnplayer ]]();
}
player freeze_player_controls( 1 );
_k161 = getNextArrayKey( _a161, _k161 );
}
}
damage_callback_no_pvp_damage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
{
if ( isDefined( eattacker ) && isplayer( eattacker ) && eattacker == self )
{
return idamage;
}
if ( isDefined( eattacker ) && !isplayer( eattacker ) )
{
return idamage;
}
if ( !isDefined( eattacker ) )
{
return idamage;
}
return 0;
}
respawn_players()
{
players = get_players();
_a196 = players;
_k196 = getFirstArrayKey( _a196 );
while ( isDefined( _k196 ) )
{
player = _a196[ _k196 ];
player [[ level.spawnplayer ]]();
player freeze_player_controls( 1 );
_k196 = getNextArrayKey( _a196, _k196 );
}
}
zombie_goto_round( target_round )
{
level notify( "restart_round" );
if ( target_round < 1 )
{
target_round = 1;
}
level.zombie_total = 0;
maps/mp/zombies/_zm::ai_calculate_health( target_round );
zombies = get_round_enemy_array();
while ( isDefined( zombies ) )
{
i = 0;
while ( i < zombies.size )
{
zombies[ i ] dodamage( zombies[ i ].health + 666, zombies[ i ].origin );
i++;
}
}
respawn_players();
wait 1;
}
wait_for_team_death_and_round_end()
{
level endon( "game_module_ended" );
level endon( "end_game" );
checking_for_round_end = 0;
level.isresetting_grief = 0;
while ( 1 )
{
cdc_alive = 0;
cia_alive = 0;
players = get_players();
_a244 = players;
_k244 = getFirstArrayKey( _a244 );
while ( isDefined( _k244 ) )
{
player = _a244[ _k244 ];
if ( !isDefined( player._encounters_team ) )
{
}
else if ( player._encounters_team == "A" )
{
if ( is_player_valid( player ) )
{
cia_alive++;
}
}
else
{
if ( is_player_valid( player ) )
{
cdc_alive++;
}
}
_k244 = getNextArrayKey( _a244, _k244 );
}
if ( cia_alive == 0 && cdc_alive == 0 && !level.isresetting_grief && isDefined( level.host_ended_game ) && !level.host_ended_game )
{
wait 0,5;
if ( isDefined( level._grief_reset_message ) )
{
level thread [[ level._grief_reset_message ]]();
}
level.isresetting_grief = 1;
level notify( "end_round_think" );
level.zombie_vars[ "spectators_respawn" ] = 1;
level notify( "keep_griefing" );
checking_for_round_end = 0;
zombie_goto_round( level.round_number );
level thread reset_grief();
level thread maps/mp/zombies/_zm::round_think( 1 );
}
else
{
if ( !checking_for_round_end )
{
if ( cia_alive == 0 )
{
level thread check_for_round_end( "B" );
checking_for_round_end = 1;
break;
}
else
{
if ( cdc_alive == 0 )
{
level thread check_for_round_end( "A" );
checking_for_round_end = 1;
}
}
}
}
if ( cia_alive > 0 && cdc_alive > 0 )
{
level notify( "stop_round_end_check" );
checking_for_round_end = 0;
}
wait 0,05;
}
}
reset_grief()
{
wait 1;
level.isresetting_grief = 0;
}
check_for_round_end( winner )
{
level endon( "keep_griefing" );
level endon( "stop_round_end_check" );
level waittill( "end_of_round" );
level.gamemodulewinningteam = winner;
level.zombie_vars[ "spectators_respawn" ] = 0;
players = get_players();
i = 0;
while ( i < players.size )
{
players[ i ] freezecontrols( 1 );
if ( players[ i ]._encounters_team == winner )
{
players[ i ] thread maps/mp/zombies/_zm_audio_announcer::leaderdialogonplayer( "grief_won" );
i++;
continue;
}
else
{
players[ i ] thread maps/mp/zombies/_zm_audio_announcer::leaderdialogonplayer( "grief_lost" );
}
i++;
}
level notify( "game_module_ended" );
level._game_module_game_end_check = undefined;
maps/mp/gametypes_zm/_zm_gametype::track_encounters_win_stats( level.gamemodulewinningteam );
level notify( "end_game" );
}
wait_for_team_death()
{
wait 15;
winner = undefined;
while ( !isDefined( winner ) )
{
cdc_alive = 0;
cia_alive = 0;
players = get_players();
_a418 = players;
_k418 = getFirstArrayKey( _a418 );
while ( isDefined( _k418 ) )
{
player = _a418[ _k418 ];
if ( player._encounters_team == "A" )
{
if ( is_player_valid( player ) || isDefined( level.force_solo_quick_revive ) && level.force_solo_quick_revive && isDefined( player.lives ) && player.lives > 0 )
{
cia_alive++;
}
}
else
{
if ( is_player_valid( player ) || isDefined( level.force_solo_quick_revive ) && level.force_solo_quick_revive && isDefined( player.lives ) && player.lives > 0 )
{
cdc_alive++;
}
}
_k418 = getNextArrayKey( _a418, _k418 );
}
if ( cia_alive == 0 )
{
winner = "B";
}
else
{
if ( cdc_alive == 0 )
{
winner = "A";
}
}
wait 0,05;
}
level notify( "game_module_ended" );
}
make_supersprinter()
{
self set_zombie_run_cycle( "super_sprint" );
}
game_module_custom_intermission( intermission_struct )
{
self closemenu();
self closeingamemenu();
level endon( "stop_intermission" );
self endon( "disconnect" );
self endon( "death" );
self notify( "_zombie_game_over" );
self.score = self.score_total;
self.sessionstate = "intermission";
self.spectatorclient = -1;
self.killcamentity = -1;
self.archivetime = 0;
self.psoffsettime = 0;
self.friendlydamage = undefined;
s_point = getstruct( intermission_struct, "targetname" );
if ( !isDefined( level.intermission_cam_model ) )
{
level.intermission_cam_model = spawn( "script_model", s_point.origin );
level.intermission_cam_model.angles = s_point.angles;
level.intermission_cam_model setmodel( "tag_origin" );
}
self.game_over_bg = newclienthudelem( self );
self.game_over_bg.horzalign = "fullscreen";
self.game_over_bg.vertalign = "fullscreen";
self.game_over_bg setshader( "black", 640, 480 );
self.game_over_bg.alpha = 1;
self spawn( level.intermission_cam_model.origin, level.intermission_cam_model.angles );
self camerasetposition( level.intermission_cam_model );
self camerasetlookat();
self cameraactivate( 1 );
self linkto( level.intermission_cam_model );
level.intermission_cam_model moveto( getstruct( s_point.target, "targetname" ).origin, 12 );
if ( isDefined( level.intermission_cam_model.angles ) )
{
level.intermission_cam_model rotateto( getstruct( s_point.target, "targetname" ).angles, 12 );
}
self.game_over_bg fadeovertime( 2 );
self.game_over_bg.alpha = 0;
wait 2;
self.game_over_bg thread maps/mp/zombies/_zm::fade_up_over_time( 1 );
}
create_fireworks( launch_spots, min_wait, max_wait, randomize )
{
level endon( "stop_fireworks" );
while ( 1 )
{
if ( isDefined( randomize ) && randomize )
{
launch_spots = array_randomize( launch_spots );
}
_a516 = launch_spots;
_k516 = getFirstArrayKey( _a516 );
while ( isDefined( _k516 ) )
{
spot = _a516[ _k516 ];
level thread fireworks_launch( spot );
wait randomfloatrange( min_wait, max_wait );
_k516 = getNextArrayKey( _a516, _k516 );
}
wait randomfloatrange( min_wait, max_wait );
}
}
fireworks_launch( launch_spot )
{
firework = spawn( "script_model", launch_spot.origin + ( randomintrange( -60, 60 ), randomintrange( -60, 60 ), 0 ) );
firework setmodel( "tag_origin" );
wait_network_frame();
playfxontag( level._effect[ "fw_trail_cheap" ], firework, "tag_origin" );
firework playloopsound( "zmb_souls_loop", 0,75 );
dest = launch_spot;
while ( isDefined( dest ) && isDefined( dest.target ) )
{
random_offset = ( randomintrange( -60, 60 ), randomintrange( -60, 60 ), 0 );
new_dests = getstructarray( dest.target, "targetname" );
new_dest = random( new_dests );
dest = new_dest;
dist = distance( new_dest.origin + random_offset, firework.origin );
time = dist / 700;
firework moveto( new_dest.origin + random_offset, time );
firework waittill( "movedone" );
}
firework playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_pre_burst" ], firework.origin );
firework delete();
}

17
zm_transit_dr_patch/maps/mp/zombies/_zm_game_module_cleansed.gsc Normal file
View File

@ -0,0 +1,17 @@
#include maps/mp/zombies/_zm_turned;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
register_game_module()
{
}
onstartgametype( name )
{
}
onstartcleansedgametype()
{
}

11
zm_transit_dr_patch/maps/mp/zombies/_zm_game_module_grief.gsc Normal file
View File

@ -0,0 +1,11 @@
#include maps/mp/zombies/_zm_game_module_utility;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
register_game_module()
{
level.game_module_grief_index = 9;
maps/mp/zombies/_zm_game_module::register_game_module( level.game_module_grief_index, "zgrief", ::onpreinitgametype, ::onpostinitgametype, undefined, ::onspawnzombie, ::onstartgametype );
}

6
zm_transit_dr_patch/maps/mp/zombies/_zm_game_module_meat.gsc Normal file
View File

@ -0,0 +1,6 @@
#include maps/mp/zombies/_zm_game_module_utility;
#include maps/mp/zombies/_zm_game_module_meat_utility;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;

685
zm_transit_dr_patch/maps/mp/zombies/_zm_game_module_meat_utility.gsc Normal file
View File

@ -0,0 +1,685 @@
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/gametypes_zm/zmeat;
#include maps/mp/zombies/_zm_audio_announcer;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_game_module_utility;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
award_grenades_for_team( team )
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ]._meat_team ) || players[ i ]._meat_team != team )
{
i++;
continue;
}
else
{
lethal_grenade = players[ i ] get_player_lethal_grenade();
players[ i ] giveweapon( lethal_grenade );
players[ i ] setweaponammoclip( lethal_grenade, 4 );
}
i++;
}
}
get_players_on_meat_team( team )
{
players = get_players();
players_on_team = [];
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ]._meat_team ) || players[ i ]._meat_team != team )
{
i++;
continue;
}
else
{
players_on_team[ players_on_team.size ] = players[ i ];
}
i++;
}
return players_on_team;
}
get_alive_players_on_meat_team( team )
{
players = get_players();
players_on_team = [];
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ]._meat_team ) || players[ i ]._meat_team != team )
{
i++;
continue;
}
else
{
if ( players[ i ].sessionstate == "spectator" || players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
i++;
continue;
}
else
{
players_on_team[ players_on_team.size ] = players[ i ];
}
}
i++;
}
return players_on_team;
}
init_minigun_ring()
{
if ( isDefined( level._minigun_ring ) )
{
return;
}
ring_pos = getstruct( level._meat_location + "_meat_minigun", "script_noteworthy" );
if ( !isDefined( ring_pos ) )
{
return;
}
level._minigun_ring = spawn( "script_model", ring_pos.origin );
level._minigun_ring.angles = ring_pos.angles;
level._minigun_ring setmodel( ring_pos.script_parameters );
level._minigun_ring_clip = getent( level._meat_location + "_meat_minigun_clip", "script_noteworthy" );
if ( isDefined( level._minigun_ring_clip ) )
{
level._minigun_ring_clip linkto( level._minigun_ring );
}
else
{
iprintlnbold( "BUG: no level._minigun_ring_clip" );
}
level._minigun_ring_trig = getent( level._meat_location + "_meat_minigun_trig", "targetname" );
if ( isDefined( level._minigun_ring_trig ) )
{
level._minigun_ring_trig enablelinkto();
level._minigun_ring_trig linkto( level._minigun_ring );
level._minigun_icon = spawn( "script_model", level._minigun_ring_trig.origin );
level._minigun_icon setmodel( getweaponmodel( "minigun_zm" ) );
level._minigun_icon linkto( level._minigun_ring );
level._minigun_icon setclientfield( "ring_glowfx", 1 );
level thread ring_toss( level._minigun_ring_trig, "minigun" );
}
else
{
iprintlnbold( "BUG: no level._minigun_ring_trig" );
}
level._minigun_ring thread move_ring( ring_pos );
level._minigun_ring thread rotate_ring( 1 );
}
init_ammo_ring()
{
if ( isDefined( level._ammo_ring ) )
{
return;
}
name = level._meat_location + "_meat_ammo";
ring_pos = getstruct( name, "script_noteworthy" );
if ( !isDefined( ring_pos ) )
{
return;
}
level._ammo_ring = spawn( "script_model", ring_pos.origin );
level._ammo_ring.angles = ring_pos.angles;
level._ammo_ring setmodel( ring_pos.script_parameters );
name = level._meat_location + "_meat_ammo_clip";
level._ammo_ring_clip = getent( name, "script_noteworthy" );
if ( isDefined( level._ammo_ring_clip ) )
{
level._ammo_ring_clip linkto( level._ammo_ring );
}
else
{
iprintlnbold( "BUG: no level._ammo_ring_clip" );
}
name = level._meat_location + "_meat_ammo_trig";
level._ammo_ring_trig = getent( name, "targetname" );
if ( isDefined( level._ammo_ring_clip ) )
{
level._ammo_ring_trig enablelinkto();
level._ammo_ring_trig linkto( level._ammo_ring );
level._ammo_icon = spawn( "script_model", level._ammo_ring_trig.origin );
level._ammo_icon setmodel( "zombie_ammocan" );
level._ammo_icon linkto( level._ammo_ring );
level._ammo_icon setclientfield( "ring_glowfx", 1 );
level thread ring_toss( level._ammo_ring_trig, "ammo" );
}
else
{
iprintlnbold( "BUG: no level._ammo_ring_trig" );
}
level._ammo_ring thread move_ring( ring_pos );
level._ammo_ring thread rotate_ring( 1 );
}
init_splitter_ring()
{
if ( isDefined( level._splitter_ring ) )
{
return;
}
ring_pos = getstruct( level._meat_location + "_meat_splitter", "script_noteworthy" );
if ( !isDefined( ring_pos ) )
{
return;
}
level._splitter_ring = spawn( "script_model", ring_pos.origin );
level._splitter_ring.angles = ring_pos.angles;
level._splitter_ring setmodel( ring_pos.script_parameters );
level._splitter_ring_trig1 = getent( level._meat_location + "_meat_splitter_trig_1", "targetname" );
level._splitter_ring_trig2 = getent( level._meat_location + "_meat_splitter_trig_2", "targetname" );
if ( isDefined( level._splitter_ring_trig1 ) && isDefined( level._splitter_ring_trig2 ) )
{
level._splitter_ring_trig1 enablelinkto();
level._splitter_ring_trig2 enablelinkto();
}
else
{
iprintlnbold( "BUG: missing at least one level._splitter_ring_trig" );
}
level._splitter_ring notsolid();
level._meat_icon = spawn( "script_model", level._splitter_ring.origin );
level._meat_icon setmodel( getweaponmodel( get_gamemode_var( "item_meat_name" ) ) );
level._meat_icon linkto( level._splitter_ring );
level._meat_icon setclientfield( "ring_glow_meatfx", 1 );
if ( isDefined( level._splitter_ring_trig1 ) && isDefined( level._splitter_ring_trig2 ) )
{
level._splitter_ring_trig1 linkto( level._splitter_ring );
level._splitter_ring_trig2 linkto( level._splitter_ring );
level thread ring_toss( level._splitter_ring_trig1, "splitter" );
level thread ring_toss( level._splitter_ring_trig2, "splitter" );
}
level._splitter_ring thread move_ring( ring_pos );
}
ring_toss( trig, type )
{
level endon( "end_game" );
while ( 1 )
{
while ( isDefined( level._ring_triggered ) && level._ring_triggered )
{
wait 0,05;
}
if ( isDefined( level.item_meat ) && isDefined( level.item_meat.meat_is_moving ) && level.item_meat.meat_is_moving )
{
if ( level.item_meat istouching( trig ) )
{
level thread ring_toss_prize( type, trig );
level._ring_triggered = 1;
level thread ring_cooldown();
}
}
wait 0,05;
}
}
ring_cooldown()
{
wait 3;
level._ring_triggered = 0;
}
ring_toss_prize( type, trig )
{
switch( type )
{
case "splitter":
level thread meat_splitter( trig );
break;
case "minigun":
level thread minigun_prize( trig );
break;
case "ammo":
level thread ammo_prize( trig );
break;
}
}
meat_splitter( trig )
{
level endon( "meat_grabbed" );
level endon( "meat_kicked" );
while ( isDefined( level.item_meat ) && level.item_meat istouching( trig ) )
{
wait 0,05;
}
exit_trig = getent( trig.target, "targetname" );
exit_struct = getstruct( trig.target, "targetname" );
while ( isDefined( level.item_meat ) && !level.item_meat istouching( exit_trig ) )
{
wait 0,05;
}
while ( isDefined( level.item_meat ) && level.item_meat istouching( exit_trig ) )
{
wait 0,05;
}
if ( !isDefined( level.item_meat ) )
{
return;
}
playfx( level._effect[ "fw_burst" ], exit_trig.origin );
flare_dir = vectornormalize( anglesToForward( exit_struct.angles ) );
velocity = vectorScale( flare_dir, randomintrange( 400, 600 ) );
velocity1 = ( velocity[ 0 ] + 75, velocity[ 1 ] + 75, randomintrange( 75, 125 ) );
velocity2 = ( velocity[ 0 ] - 75, velocity[ 1 ] - 75, randomintrange( 75, 125 ) );
velocity3 = ( velocity[ 0 ], velocity[ 1 ], 100 );
level._fake_meats = [];
level._meat_splitter_activated = 1;
org = exit_trig.origin;
player = get_players()[ 0 ];
player._spawning_meat = 1;
player endon( "disconnect" );
thread split_meat( player, org, velocity1, velocity2, velocity );
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "meat_ring_splitter", undefined, undefined, 1 );
wait 0,1;
while ( isDefined( level.splitting_meat ) && level.splitting_meat )
{
wait 0,05;
}
player._spawning_meat = 0;
}
split_meat( player, org, vel1, vel2, vel3 )
{
level.splitting_meat = 1;
level.item_meat cleanup_meat();
wait_network_frame();
level._fake_meats[ level._fake_meats.size ] = player magicgrenadetype( get_gamemode_var( "item_meat_name" ), org, vel1 );
wait_network_frame();
level._fake_meats[ level._fake_meats.size ] = player magicgrenadetype( get_gamemode_var( "item_meat_name" ), org, vel2 );
wait_network_frame();
level._fake_meats[ level._fake_meats.size ] = player magicgrenadetype( get_gamemode_var( "item_meat_name" ), org, vel3 );
real_meat = random( level._fake_meats );
_a330 = level._fake_meats;
_k330 = getFirstArrayKey( _a330 );
while ( isDefined( _k330 ) )
{
meat = _a330[ _k330 ];
if ( real_meat != meat )
{
meat._fake_meat = 1;
meat thread maps/mp/gametypes_zm/zmeat::delete_on_real_meat_pickup();
}
else
{
meat._fake_meat = 0;
level.item_meat = meat;
}
_k330 = getNextArrayKey( _a330, _k330 );
}
level.splitting_meat = 0;
}
minigun_prize( trig )
{
while ( isDefined( level.item_meat ) && level.item_meat istouching( trig ) )
{
wait 0,05;
}
if ( !isDefined( level.item_meat ) )
{
return;
}
if ( isDefined( level._minigun_toss_cooldown ) && level._minigun_toss_cooldown )
{
return;
}
level thread minigun_toss_cooldown();
if ( !is_player_valid( level._last_person_to_throw_meat ) )
{
return;
}
level._last_person_to_throw_meat thread maps/mp/zombies/_zm_powerups::powerup_vo( "minigun" );
level thread maps/mp/zombies/_zm_powerups::minigun_weapon_powerup( level._last_person_to_throw_meat );
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "meat_ring_minigun", undefined, undefined, 1 );
}
ammo_prize( trig )
{
while ( isDefined( level.item_meat ) && level.item_meat istouching( trig ) )
{
wait 0,05;
}
if ( !isDefined( level.item_meat ) )
{
return;
}
if ( isDefined( level._ammo_toss_cooldown ) && level._ammo_toss_cooldown )
{
return;
}
playfx( level._effect[ "poltergeist" ], trig.origin );
level thread ammo_toss_cooldown();
level._last_person_to_throw_meat thread maps/mp/zombies/_zm_powerups::powerup_vo( "full_ammo" );
level thread maps/mp/zombies/_zm_powerups::full_ammo_powerup( undefined, level._last_person_to_throw_meat );
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "meat_ring_ammo", undefined, undefined, 1 );
}
minigun_toss_cooldown()
{
level._minigun_toss_cooldown = 1;
if ( isDefined( level._minigun_icon ) )
{
level._minigun_icon delete();
}
waittill_any_or_timeout( 120, "meat_end" );
playfx( level._effect[ "poltergeist" ], level._minigun_ring_trig.origin );
level._minigun_icon = spawn( "script_model", level._minigun_ring_trig.origin );
level._minigun_icon setmodel( getweaponmodel( "minigun_zm" ) );
level._minigun_icon linkto( level._minigun_ring );
level._minigun_icon setclientfield( "ring_glowfx", 1 );
level._minigun_toss_cooldown = 0;
}
ammo_toss_cooldown()
{
level._ammo_toss_cooldown = 1;
if ( isDefined( level._ammo_icon ) )
{
level._ammo_icon delete();
}
waittill_any_or_timeout( 60, "meat_end" );
playfx( level._effect[ "poltergeist" ], level._ammo_ring_trig.origin );
level._ammo_icon = spawn( "script_model", level._ammo_ring_trig.origin );
level._ammo_icon setmodel( "zombie_ammocan" );
level._ammo_icon linkto( level._ammo_ring );
level._ammo_icon setclientfield( "ring_glowfx", 1 );
level._ammo_toss_cooldown = 0;
}
wait_for_team_death( team )
{
level endon( "meat_end" );
encounters_team = undefined;
while ( 1 )
{
wait 1;
while ( isDefined( level._checking_for_save ) && level._checking_for_save )
{
wait 0,1;
}
alive_team_players = get_alive_players_on_meat_team( team );
while ( alive_team_players.size > 0 )
{
encounters_team = alive_team_players[ 0 ]._encounters_team;
}
}
if ( !isDefined( encounters_team ) )
{
return;
}
winning_team = "A";
if ( encounters_team == "A" )
{
winning_team = "B";
}
level notify( "meat_end" );
}
check_should_save_player( team )
{
if ( !isDefined( level._meat_on_team ) )
{
return 0;
}
level._checking_for_save = 1;
players = get_players_on_meat_team( team );
i = 0;
while ( i < players.size )
{
player = players[ i ];
if ( isDefined( level._last_person_to_throw_meat ) && level._last_person_to_throw_meat == player )
{
while ( isDefined( level.item_meat.meat_is_moving ) && !level.item_meat.meat_is_moving && isDefined( level._meat_splitter_activated ) || level._meat_splitter_activated && isDefined( level.item_meat.meat_is_flying ) && level.item_meat.meat_is_flying )
{
if ( level._meat_on_team != player._meat_team )
{
break;
}
else if ( isDefined( level.item_meat.meat_is_rolling ) && level.item_meat.meat_is_rolling && level._meat_on_team == player._meat_team )
{
break;
}
else
{
wait 0,05;
}
}
if ( !isDefined( player ) )
{
level._checking_for_save = 0;
return 0;
}
if ( isDefined( player.last_damage_from_zombie_or_player ) && !player.last_damage_from_zombie_or_player )
{
level._checking_for_save = 0;
return 0;
}
if ( level._meat_on_team != player._meat_team && isDefined( level._last_person_to_throw_meat ) && level._last_person_to_throw_meat == player )
{
if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
level thread revive_saved_player( player );
return 1;
}
}
}
i++;
}
level._checking_for_save = 0;
return 0;
}
watch_save_player()
{
if ( !isDefined( level._meat_on_team ) )
{
return 0;
}
if ( !isDefined( level._last_person_to_throw_meat ) || level._last_person_to_throw_meat != self )
{
return 0;
}
level._checking_for_save = 1;
while ( isDefined( level.splitting_meat ) || level.splitting_meat && isDefined( level.item_meat ) && isDefined( level.item_meat.meat_is_moving ) || level.item_meat.meat_is_moving && isDefined( level.item_meat.meat_is_flying ) && level.item_meat.meat_is_flying )
{
if ( level._meat_on_team != self._meat_team )
{
}
else if ( isDefined( level.item_meat ) && isDefined( level.item_meat.meat_is_rolling ) && level.item_meat.meat_is_rolling && level._meat_on_team == self._meat_team )
{
}
else
{
wait 0,05;
}
}
if ( level._meat_on_team != self._meat_team && isDefined( level._last_person_to_throw_meat ) && level._last_person_to_throw_meat == self )
{
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
level thread revive_saved_player( self );
return 1;
}
}
level._checking_for_save = 0;
return 0;
}
revive_saved_player( player )
{
player endon( "disconnect" );
player iprintlnbold( &"ZOMBIE_PLAYER_SAVED" );
player playsound( level.zmb_laugh_alias );
wait 0,25;
playfx( level._effect[ "poltergeist" ], player.origin );
playsoundatposition( "zmb_bolt", player.origin );
earthquake( 0,5, 0,75, player.origin, 1000 );
player thread maps/mp/zombies/_zm_laststand::auto_revive( player );
player._saved_by_throw++;
level._checking_for_save = 0;
}
get_game_module_players( player )
{
return get_players_on_meat_team( player._meat_team );
}
item_meat_spawn( origin )
{
org = origin;
player = get_players()[ 0 ];
player._spawning_meat = 1;
player magicgrenadetype( get_gamemode_var( "item_meat_name" ), org, ( 0, 0, 1 ) );
playsoundatposition( "zmb_spawn_powerup", org );
wait 0,1;
player._spawning_meat = undefined;
}
init_item_meat( gametype )
{
if ( gametype == "zgrief" )
{
set_gamemode_var_once( "item_meat_name", "item_meat_zm" );
set_gamemode_var_once( "item_meat_model", "t6_wpn_zmb_meat_world" );
}
else
{
set_gamemode_var_once( "item_meat_name", "item_head_zm" );
set_gamemode_var_once( "item_meat_model", "t6_wpn_zmb_severedhead_world" );
}
precacheitem( get_gamemode_var( "item_meat_name" ) );
set_gamemode_var_once( "start_item_meat_name", get_gamemode_var( "item_meat_name" ) );
level.meat_weaponidx = getweaponindexfromname( get_gamemode_var( "item_meat_name" ) );
level.meat_pickupsound = getweaponpickupsound( level.meat_weaponidx );
level.meat_pickupsoundplayer = getweaponpickupsoundplayer( level.meat_weaponidx );
}
meat_intro( launch_spot )
{
flag_wait( "start_encounters_match_logic" );
wait 3;
level thread multi_launch( launch_spot );
launch_meat( launch_spot );
drop_meat( level._meat_start_point );
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "meat_drop", undefined, undefined, 1 );
}
launch_meat( launch_spot )
{
level waittill( "launch_meat" );
spots = getstructarray( launch_spot, "targetname" );
if ( isDefined( spots ) && spots.size > 0 )
{
spot = random( spots );
meat = spawn( "script_model", spot.origin );
meat setmodel( "tag_origin" );
wait_network_frame();
playfxontag( level._effect[ "fw_trail" ], meat, "tag_origin" );
meat playloopsound( "zmb_souls_loop", 0,75 );
dest = spot;
while ( isDefined( dest ) && isDefined( dest.target ) )
{
new_dest = getstruct( dest.target, "targetname" );
dest = new_dest;
dist = distance( new_dest.origin, meat.origin );
time = dist / 700;
meat moveto( new_dest.origin, time );
meat waittill( "movedone" );
}
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_burst" ], meat.origin );
wait randomfloatrange( 0,2, 0,5 );
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_burst" ], meat.origin + ( randomintrange( 50, 150 ), randomintrange( 50, 150 ), randomintrange( -20, 20 ) ) );
wait randomfloatrange( 0,5, 0,75 );
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_burst" ], meat.origin + ( randomintrange( -150, -50 ), randomintrange( -150, 50 ), randomintrange( -20, 20 ) ) );
wait randomfloatrange( 0,5, 0,75 );
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_burst" ], meat.origin );
meat delete();
}
}
multi_launch( launch_spot )
{
spots = getstructarray( launch_spot, "targetname" );
if ( isDefined( spots ) && spots.size > 0 )
{
x = 0;
while ( x < 3 )
{
i = 0;
while ( i < spots.size )
{
delay = randomfloatrange( 0,1, 0,25 );
level thread fake_launch( spots[ i ], delay );
i++;
}
wait randomfloatrange( 0,25, 0,75 );
if ( x > 1 )
{
level notify( "launch_meat" );
}
x++;
}
}
else wait randomfloatrange( 0,25, 0,75 );
level notify( "launch_meat" );
}
fake_launch( launch_spot, delay )
{
wait delay;
wait randomfloatrange( 0,1, 4 );
meat = spawn( "script_model", launch_spot.origin + ( randomintrange( -60, 60 ), randomintrange( -60, 60 ), 0 ) );
meat setmodel( "tag_origin" );
wait_network_frame();
playfxontag( level._effect[ "fw_trail_cheap" ], meat, "tag_origin" );
meat playloopsound( "zmb_souls_loop", 0,75 );
dest = launch_spot;
while ( isDefined( dest ) && isDefined( dest.target ) )
{
random_offset = ( randomintrange( -60, 60 ), randomintrange( -60, 60 ), 0 );
new_dest = getstruct( dest.target, "targetname" );
dest = new_dest;
dist = distance( new_dest.origin + random_offset, meat.origin );
time = dist / 700;
meat moveto( new_dest.origin + random_offset, time );
meat waittill( "movedone" );
}
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_pre_burst" ], meat.origin );
meat delete();
}
drop_meat( drop_spot )
{
meat = spawn( "script_model", drop_spot + vectorScale( ( 0, 0, 1 ), 600 ) );
meat setmodel( "tag_origin" );
dist = distance( meat.origin, drop_spot );
time = dist / 400;
wait 2;
meat moveto( drop_spot, time );
wait_network_frame();
playfxontag( level._effect[ "fw_drop" ], meat, "tag_origin" );
meat waittill( "movedone" );
playfx( level._effect[ "fw_impact" ], drop_spot );
level notify( "reset_meat" );
meat delete();
}

0
zm_transit_dr_patch/maps/mp/zombies/_zm_game_module_standard.gsc Normal file
View File

64
zm_transit_dr_patch/maps/mp/zombies/_zm_game_module_turned.gsc Normal file
View File

@ -0,0 +1,64 @@
#include maps/mp/zombies/_zm_game_module_cleansed;
#include maps/mp/zombies/_zm_turned;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
register_game_module()
{
level.game_module_turned_index = 6;
maps/mp/zombies/_zm_game_module::register_game_module( level.game_module_turned_index, "zturned", ::maps/mp/zombies/_zm_game_module_cleansed::onpreinitgametype, ::onpostinitgametype, undefined, ::maps/mp/zombies/_zm_game_module_cleansed::onspawnzombie, ::maps/mp/zombies/_zm_game_module_cleansed::onstartgametype );
}
register_turned_match( start_func, end_func, name )
{
if ( !isDefined( level._registered_turned_matches ) )
{
level._registered_turned_matches = [];
}
match = spawnstruct();
match.match_name = name;
match.match_start_func = start_func;
match.match_end_func = end_func;
level._registered_turned_matches[ level._registered_turned_matches.size ] = match;
}
get_registered_turned_match( name )
{
_a41 = level._registered_turned_matches;
_k41 = getFirstArrayKey( _a41 );
while ( isDefined( _k41 ) )
{
struct = _a41[ _k41 ];
if ( struct.match_name == name )
{
return struct;
}
_k41 = getNextArrayKey( _a41, _k41 );
}
}
set_current_turned_match( name )
{
level._current_turned_match = name;
}
get_current_turned_match()
{
return level._current_turned_match;
}
init_zombie_weapon()
{
maps/mp/zombies/_zm_turned::init();
}
onpostinitgametype()
{
if ( level.scr_zm_game_module != level.game_module_turned_index )
{
return;
}
level thread init_zombie_weapon();
}

46
zm_transit_dr_patch/maps/mp/zombies/_zm_game_module_utility.gsc Normal file
View File

@ -0,0 +1,46 @@
#include maps/mp/zombies/_zm_game_module_meat;
#include maps/mp/zombies/_zm_game_module_meat_utility;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
init_item_meat()
{
level.item_meat_name = "item_meat_zm";
precacheitem( level.item_meat_name );
}
move_ring( ring )
{
positions = getstructarray( ring.target, "targetname" );
positions = array_randomize( positions );
level endon( "end_game" );
while ( 1 )
{
_a23 = positions;
_k23 = getFirstArrayKey( _a23 );
while ( isDefined( _k23 ) )
{
position = _a23[ _k23 ];
self moveto( position.origin, randomintrange( 30, 45 ) );
self waittill( "movedone" );
_k23 = getNextArrayKey( _a23, _k23 );
}
}
}
rotate_ring( forward )
{
level endon( "end_game" );
dir = -360;
if ( forward )
{
dir = 360;
}
while ( 1 )
{
self rotateyaw( dir, 9 );
wait 9;
}
}

67
zm_transit_dr_patch/maps/mp/zombies/_zm_gump.gsc Normal file
View File

@ -0,0 +1,67 @@
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
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.uses_gumps ) && level.uses_gumps )
{
self setclientfieldtoplayer( "blackscreen", 1 );
wait 0,05;
self setclientfieldtoplayer( "blackscreen", 0 );
}
}
player_connect_gump()
{
}
player_watch_spectate_change()
{
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 );
#/
}
}

118
zm_transit_dr_patch/maps/mp/zombies/_zm_hackables_boards.gsc Normal file
View File

@ -0,0 +1,118 @@
#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.barrier_chunks ) )
{
break;
}
else chunk = get_random_destroyed_chunk( self, self.window.barrier_chunks );
if ( !isDefined( chunk ) )
{
break;
}
else self.window thread maps/mp/zombies/_zm_blockers::replace_chunk( self, 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
{
}
}
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 );
}
board_qualifier( player )
{
if ( all_chunks_intact( self.window.barrier_chunks ) || no_valid_repairable_boards( self, self.window.barrier_chunks ) )
{
return 0;
}
return 1;
}

363
zm_transit_dr_patch/maps/mp/zombies/_zm_hackables_box.gsc Normal file
View File

@ -0,0 +1,363 @@
#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 ( self.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.chest_origin.weapon_model ) )
{
self.chest.chest_origin.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.chest_origin.origin );
play_sound_at_pos( "music_chest", self.chest.chest_origin.origin );
maps/mp/zombies/_zm_weapons::unacquire_weapon_toggle( self.chest.chest_origin.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.chest_origin.origin;
if ( isDefined( self.chest.chest_origin.weapon_model ) )
{
self.chest.chest_origin.weapon_model notify( "kill_respin_respin_think_thread" );
self.chest.chest_origin.weapon_model notify( "kill_weapon_movement" );
self.chest.chest_origin.weapon_model moveto( org + vectorScale( ( 0, 0, 1 ), 40 ), 0,5 );
}
if ( isDefined( self.chest.chest_origin.weapon_model_dw ) )
{
self.chest.chest_origin.weapon_model_dw notify( "kill_weapon_movement" );
self.chest.chest_origin.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.chest_origin.weapon_model, self.chest.chest_origin.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 = getentarray( "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.chest_lid waittill( "lid_closed" );
self.chest.chest_lid waittill( "rotatedone" );
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;
}

107
zm_transit_dr_patch/maps/mp/zombies/_zm_hackables_doors.gsc Normal file
View File

@ -0,0 +1,107 @@
#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
zm_transit_dr_patch/maps/mp/zombies/_zm_hackables_packapunch.gsc Normal file
View File

@ -0,0 +1,46 @@
#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" );
}

72
zm_transit_dr_patch/maps/mp/zombies/_zm_hackables_perks.gsc Normal file
View File

@ -0,0 +1,72 @@
#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();
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 ];
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 ( 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
zm_transit_dr_patch/maps/mp/zombies/_zm_hackables_powerups.gsc Normal file
View File

@ -0,0 +1,79 @@
#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
zm_transit_dr_patch/maps/mp/zombies/_zm_hackables_wallbuys.gsc Normal file
View File

@ -0,0 +1,55 @@
#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 = getentarray( "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;
model = getent( self.wallbuy.target, "targetname" );
model rotateroll( 180, 0,5 );
maps/mp/zombies/_zm_equip_hacker::deregister_hackable_struct( self );
}

557
zm_transit_dr_patch/maps/mp/zombies/_zm_jump_pad.gsc Normal file
View File

@ -0,0 +1,557 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( is_true( level._uses_jump_pads ) )
{
level jump_pad_init();
}
}
jump_pad_init()
{
level._jump_pad_override = [];
jump_pad_triggers = getentarray( "trig_jump_pad", "targetname" );
if ( !isDefined( jump_pad_triggers ) )
{
return;
}
i = 0;
while ( i < jump_pad_triggers.size )
{
jump_pad_triggers[ i ].start = getstruct( jump_pad_triggers[ i ].target, "targetname" );
jump_pad_triggers[ i ].destination = getstructarray( jump_pad_triggers[ i ].start.target, "targetname" );
if ( isDefined( jump_pad_triggers[ i ].script_string ) )
{
jump_pad_triggers[ i ].overrides = strtok( jump_pad_triggers[ i ].script_string, "," );
}
jump_pad_triggers[ i ] thread jump_pad_think();
i++;
}
onplayerconnect_callback( ::jump_pad_player_variables );
}
jump_pad_player_variables()
{
self._padded = 0;
self.lander = 0;
}
jump_pad_think()
{
self endon( "destroyed" );
end_point = undefined;
start_point = undefined;
z_velocity = undefined;
z_dist = undefined;
fling_this_way = undefined;
jump_time = undefined;
world_gravity = getDvarInt( "bg_gravity" );
gravity_pulls = -13,3;
top_velocity_sq = 810000;
forward_scaling = 1;
if ( isDefined( self.script_flag_wait ) )
{
if ( !isDefined( level.flag[ self.script_flag_wait ] ) )
{
flag_init( self.script_flag_wait );
}
flag_wait( self.script_flag_wait );
}
while ( isDefined( self ) )
{
self waittill( "trigger", who );
if ( isplayer( who ) )
{
self thread trigger_thread( who, ::jump_pad_start, ::jump_pad_cancel );
}
}
}
jump_pad_start( ent_player, endon_condition )
{
self endon( "endon_condition" );
ent_player endon( "left_jump_pad" );
ent_player endon( "death" );
ent_player endon( "disconnect" );
end_point = undefined;
start_point = undefined;
z_velocity = undefined;
z_dist = undefined;
fling_this_way = undefined;
jump_time = undefined;
world_gravity = getDvarInt( "bg_gravity" );
gravity_pulls = -13,3;
top_velocity_sq = 810000;
forward_scaling = 1;
start_point = self.start;
while ( isDefined( self.name ) )
{
self._action_overrides = strtok( self.name, "," );
while ( isDefined( self._action_overrides ) )
{
i = 0;
while ( i < self._action_overrides.size )
{
ent_player jump_pad_player_overrides( self._action_overrides[ i ] );
i++;
}
}
}
if ( isDefined( self.script_wait ) )
{
if ( self.script_wait < 1 )
{
self playsound( "evt_jump_pad_charge_short" );
}
else
{
self playsound( "evt_jump_pad_charge" );
}
wait self.script_wait;
}
else
{
self playsound( "evt_jump_pad_charge" );
wait 1;
}
if ( isDefined( self.script_parameters ) && isDefined( level._jump_pad_override[ self.script_parameters ] ) )
{
end_point = self [[ level._jump_pad_override[ self.script_parameters ] ]]( ent_player );
}
if ( !isDefined( end_point ) )
{
end_point = self.destination[ randomint( self.destination.size ) ];
}
if ( isDefined( self.script_string ) && isDefined( level._jump_pad_override[ self.script_string ] ) )
{
info_array = self [[ level._jump_pad_override[ self.script_string ] ]]( start_point, end_point );
fling_this_way = info_array[ 0 ];
jump_time = info_array[ 1 ];
}
else
{
end_spot = end_point.origin;
if ( !is_true( self.script_airspeed ) )
{
rand_end = ( randomfloat( -1, 1 ), randomfloat( -1, 1 ), 0 );
rand_scale = randomint( 100 );
rand_spot = vectorScale( rand_end, rand_scale );
end_spot = end_point.origin + rand_spot;
}
pad_dist = distance( start_point.origin, end_spot );
z_dist = end_spot[ 2 ] - start_point.origin[ 2 ];
jump_velocity = end_spot - start_point.origin;
if ( z_dist > 40 && z_dist < 135 )
{
z_dist *= 2,5;
forward_scaling = 1,1;
/#
if ( getDvarInt( #"D5FD01C3" ) )
{
if ( getDvar( #"E2494021" ) != "" )
{
z_dist *= getDvarFloat( #"E2494021" );
}
if ( getDvar( #"4E3BC729" ) != "" )
{
forward_scaling = getDvarFloat( #"4E3BC729" );
#/
}
}
}
else
{
if ( z_dist >= 135 )
{
z_dist *= 2,7;
forward_scaling = 1,3;
/#
if ( getDvarInt( #"D5FD01C3" ) )
{
if ( getDvar( #"E2494021" ) != "" )
{
z_dist *= getDvarFloat( #"E2494021" );
}
if ( getDvar( #"4E3BC729" ) != "" )
{
forward_scaling = getDvarFloat( #"4E3BC729" );
#/
}
}
}
else
{
if ( z_dist < 0 )
{
z_dist *= 2,4;
forward_scaling = 1;
/#
if ( getDvarInt( #"D5FD01C3" ) )
{
if ( getDvar( #"E2494021" ) != "" )
{
z_dist *= getDvarFloat( #"E2494021" );
}
if ( getDvar( #"4E3BC729" ) != "" )
{
forward_scaling = getDvarFloat( #"4E3BC729" );
#/
}
}
}
}
}
z_velocity = 2 * z_dist * world_gravity;
if ( z_velocity < 0 )
{
z_velocity *= -1;
}
if ( z_dist < 0 )
{
z_dist *= -1;
}
jump_time = sqrt( ( 2 * pad_dist ) / world_gravity );
jump_time_2 = sqrt( ( 2 * z_dist ) / world_gravity );
jump_time += jump_time_2;
if ( jump_time < 0 )
{
jump_time *= -1;
}
x = ( jump_velocity[ 0 ] * forward_scaling ) / jump_time;
y = ( jump_velocity[ 1 ] * forward_scaling ) / jump_time;
z = z_velocity / jump_time;
fling_this_way = ( x, y, z );
}
if ( isDefined( end_point.target ) )
{
poi_spot = getstruct( end_point.target, "targetname" );
}
else
{
poi_spot = end_point;
}
if ( !isDefined( self.script_index ) )
{
ent_player.script_index = undefined;
}
else
{
ent_player.script_index = self.script_index;
}
if ( isDefined( self.script_start ) && self.script_start == 1 )
{
if ( !is_true( ent_player._padded ) )
{
self playsound( "evt_jump_pad_launch" );
playfx( level._effect[ "jump_pad_jump" ], self.origin );
ent_player thread jump_pad_move( fling_this_way, jump_time, poi_spot, self );
if ( isDefined( self.script_label ) )
{
level notify( self.script_label );
}
return;
}
}
else
{
if ( ent_player isonground() && !is_true( ent_player._padded ) )
{
self playsound( "evt_jump_pad_launch" );
playfx( level._effect[ "jump_pad_jump" ], self.origin );
ent_player thread jump_pad_move( fling_this_way, jump_time, poi_spot, self );
if ( isDefined( self.script_label ) )
{
level notify( self.script_label );
}
return;
}
}
wait 0,5;
if ( ent_player istouching( self ) )
{
self jump_pad_start( ent_player, endon_condition );
}
}
jump_pad_cancel( ent_player )
{
ent_player notify( "left_jump_pad" );
if ( isDefined( ent_player.poi_spot ) && !is_true( ent_player._padded ) )
{
}
while ( isDefined( self.name ) )
{
self._action_overrides = strtok( self.name, "," );
while ( isDefined( self._action_overrides ) )
{
i = 0;
while ( i < self._action_overrides.size )
{
ent_player jump_pad_player_overrides( self._action_overrides[ i ] );
i++;
}
}
}
}
jump_pad_move( vec_direction, flt_time, struct_poi, trigger )
{
self endon( "death" );
self endon( "disconnect" );
start_time = getTime();
jump_time = flt_time * 500;
attract_dist = undefined;
num_attractors = 30;
added_poi_value = 0;
start_turned_on = 1;
poi_start_func = undefined;
while ( is_true( self.divetoprone ) || is_true( self._padded ) )
{
wait 0,05;
}
self._padded = 1;
self.lander = 1;
self setstance( "stand" );
wait 0,1;
if ( isDefined( trigger.script_label ) )
{
if ( issubstr( trigger.script_label, "low" ) )
{
self.jump_pad_current = undefined;
self.jump_pad_previous = undefined;
}
else if ( !isDefined( self.jump_pad_current ) )
{
self.jump_pad_current = trigger;
}
else
{
self.jump_pad_previous = self.jump_pad_current;
self.jump_pad_current = trigger;
}
}
if ( isDefined( self.poi_spot ) )
{
level jump_pad_ignore_poi_cleanup( self.poi_spot );
self.poi_spot deactivate_zombie_point_of_interest();
self.poi_spot delete();
}
if ( isDefined( struct_poi ) )
{
self.poi_spot = spawn( "script_origin", struct_poi.origin );
if ( isDefined( level._pad_poi_ignore ) )
{
level [[ level._pad_poi_ignore ]]( self.poi_spot );
}
self thread jump_pad_enemy_follow_or_ignore( self.poi_spot );
if ( isDefined( level._jump_pad_poi_start_override ) && !is_true( self.script_index ) )
{
poi_start_func = level._jump_pad_poi_start_override;
}
if ( isDefined( level._jump_pad_poi_end_override ) )
{
poi_end_func = level._jump_pad_poi_end_override;
}
self.poi_spot create_zombie_point_of_interest( attract_dist, num_attractors, added_poi_value, start_turned_on, poi_start_func );
self thread disconnect_failsafe_pad_poi_clean();
}
self setorigin( self.origin + ( 0, 0, 1 ) );
if ( randomintrange( 0, 101 ) < 20 )
{
self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "jumppad" );
}
while ( ( getTime() - start_time ) < jump_time )
{
self setvelocity( vec_direction );
wait 0,05;
}
while ( !self isonground() )
{
wait 0,05;
}
self._padded = 0;
self.lander = 0;
jump_pad_triggers = getentarray( "trig_jump_pad", "targetname" );
i = 0;
while ( i < jump_pad_triggers.size )
{
if ( self istouching( jump_pad_triggers[ i ] ) )
{
level thread failsafe_pad_poi_clean( jump_pad_triggers[ i ], self.poi_spot );
return;
}
i++;
}
if ( isDefined( self.poi_spot ) )
{
level jump_pad_ignore_poi_cleanup( self.poi_spot );
self.poi_spot delete();
}
}
disconnect_failsafe_pad_poi_clean()
{
self notify( "kill_disconnect_failsafe_pad_poi_clean" );
self endon( "kill_disconnect_failsafe_pad_poi_clean" );
self.poi_spot endon( "death" );
self waittill( "disconnect" );
if ( isDefined( self.poi_spot ) )
{
level jump_pad_ignore_poi_cleanup( self.poi_spot );
self.poi_spot deactivate_zombie_point_of_interest();
self.poi_spot delete();
}
}
failsafe_pad_poi_clean( ent_trig, ent_poi )
{
if ( isDefined( ent_trig.script_wait ) )
{
wait ent_trig.script_wait;
}
else
{
wait 0,5;
}
if ( isDefined( ent_poi ) )
{
level jump_pad_ignore_poi_cleanup( ent_poi );
ent_poi deactivate_zombie_point_of_interest();
ent_poi delete();
}
}
jump_pad_enemy_follow_or_ignore( ent_poi )
{
self endon( "death" );
self endon( "disconnect" );
zombies = getaiarray( level.zombie_team );
players = getplayers();
valid_players = 0;
p = 0;
while ( p < players.size )
{
if ( is_player_valid( players[ p ] ) )
{
valid_players++;
}
p++;
}
i = 0;
while ( i < zombies.size )
{
ignore_poi = 0;
if ( !isDefined( zombies[ i ] ) )
{
i++;
continue;
}
else enemy = zombies[ i ].favoriteenemy;
if ( isDefined( enemy ) )
{
if ( players.size > 1 && valid_players > 1 )
{
if ( enemy != self || isDefined( enemy.jump_pad_previous ) && enemy.jump_pad_previous == enemy.jump_pad_current )
{
ignore_poi = 1;
}
}
}
if ( is_true( ignore_poi ) )
{
zombies[ i ] thread add_poi_to_ignore_list( ent_poi );
i++;
continue;
}
else
{
zombies[ i ].ignore_distance_tracking = 1;
zombies[ i ]._pad_follow = 1;
zombies[ i ] thread stop_chasing_the_sky( ent_poi );
}
i++;
}
}
jump_pad_ignore_poi_cleanup( ent_poi )
{
zombies = getaiarray( level.zombie_team );
i = 0;
while ( i < zombies.size )
{
if ( isDefined( zombies[ i ] ) )
{
if ( is_true( zombies[ i ]._pad_follow ) )
{
zombies[ i ]._pad_follow = 0;
zombies[ i ] notify( "stop_chasing_the_sky" );
zombies[ i ].ignore_distance_tracking = 0;
}
if ( isDefined( ent_poi ) )
{
zombies[ i ] thread remove_poi_from_ignore_list( ent_poi );
}
}
i++;
}
}
stop_chasing_the_sky( ent_poi )
{
self endon( "death" );
self endon( "stop_chasing_the_sky" );
while ( is_true( self._pad_follow ) )
{
while ( isDefined( self.favoriteenemy ) )
{
players = getplayers();
i = 0;
while ( i < players.size )
{
if ( is_player_valid( players[ i ] ) && players[ i ] != self.favoriteenemy )
{
if ( distance2dsquared( players[ i ].origin, self.origin ) < 10000 )
{
self add_poi_to_ignore_list( ent_poi );
return;
}
}
i++;
}
}
wait 0,1;
}
self._pad_follow = 0;
self.ignore_distance_tracking = 0;
self notify( "stop_chasing_the_sky" );
}
jump_pad_player_overrides( st_behavior, int_clean )
{
if ( !isDefined( st_behavior ) || !isstring( st_behavior ) )
{
return;
}
if ( !isDefined( int_clean ) )
{
int_clean = 0;
}
switch( st_behavior )
{
case "no_sprint":
if ( !int_clean )
{
}
default:
if ( isDefined( level._jump_pad_level_behavior ) )
{
self [[ level._jump_pad_level_behavior ]]( st_behavior, int_clean );
}
}
}
}
}

1445
zm_transit_dr_patch/maps/mp/zombies/_zm_laststand.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

1484
zm_transit_dr_patch/maps/mp/zombies/_zm_magicbox.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

84
zm_transit_dr_patch/maps/mp/zombies/_zm_magicbox_lock.gsc Normal file
View File

@ -0,0 +1,84 @@
#include maps/mp/zombies/_zm_unitrigger;
#include maps/mp/zombies/_zm_magicbox_lock;
#include maps/mp/zombies/_zm_magicbox;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
precachemodel( "p6_anim_strongbox_lock" );
level.locked_magic_box_cost = 2000;
level.custom_magicbox_state_handler = ::set_locked_magicbox_state;
add_zombie_hint( "locked_magic_box_cost", &"ZOMBIE_LOCKED_BOX_COST" );
}
watch_for_lock()
{
self endon( "user_grabbed_weapon" );
self endon( "chest_accessed" );
self waittill( "box_locked" );
self notify( "kill_chest_think" );
self.grab_weapon_hint = 0;
wait 0,1;
self thread maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( self.unitrigger_stub, ::magicbox_unitrigger_think );
self.unitrigger_stub run_visibility_function_for_all_triggers();
self thread treasure_chest_think();
}
clean_up_locked_box()
{
self endon( "box_spin_done" );
self.owner waittill( "box_locked" );
if ( isDefined( self.weapon_model ) )
{
self.weapon_model delete();
self.weapon_model = undefined;
}
if ( isDefined( self.weapon_model_dw ) )
{
self.weapon_model_dw delete();
self.weapon_model_dw = undefined;
}
self hidezbarrierpiece( 3 );
self hidezbarrierpiece( 4 );
self setzbarrierpiecestate( 3, "closed" );
self setzbarrierpiecestate( 4, "closed" );
}
magic_box_locks()
{
self.owner.is_locked = 1;
self.owner notify( "box_locked" );
if ( !isDefined( self.angles ) )
{
self.angles = ( 0, 0, 1 );
}
forward = anglesToRight( self.angles );
self.lock_model = spawn( "script_model", self.origin + ( -15 * forward ) + vectorScale( ( 0, 0, 1 ), 8 ) );
self.lock_model.angles = self.angles;
self.lock_model setmodel( "p6_anim_strongbox_lock" );
}
magic_box_unlocks()
{
self.owner.is_locked = 0;
self.lock_model delete();
}
set_locked_magicbox_state( state )
{
switch( state )
{
case "locking":
self showzbarrierpiece( 1 );
self thread magic_box_locks();
self.state = "locking";
break;
case "unlocking":
self showzbarrierpiece( 1 );
self thread magic_box_unlocks();
self.state = "close";
break;
}
}

503
zm_transit_dr_patch/maps/mp/zombies/_zm_melee_weapon.gsc Normal file
View File

@ -0,0 +1,503 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, has_weapon, give_weapon, take_weapon, flourish_fn )
{
precacheitem( weapon_name );
precacheitem( flourish_weapon_name );
add_melee_weapon( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, has_weapon, give_weapon, take_weapon );
melee_weapon_triggers = getentarray( wallbuy_targetname, "targetname" );
i = 0;
while ( i < melee_weapon_triggers.size )
{
knife_model = getent( melee_weapon_triggers[ i ].target, "targetname" );
if ( isDefined( knife_model ) )
{
knife_model hide();
}
melee_weapon_triggers[ i ] thread melee_weapon_think( weapon_name, cost, has_weapon, give_weapon, flourish_fn, vo_dialog_id, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name );
melee_weapon_triggers[ i ] sethintstring( hint_string, cost );
melee_weapon_triggers[ i ] setcursorhint( "HINT_NOICON" );
melee_weapon_triggers[ i ] usetriggerrequirelookat();
i++;
}
melee_weapon_structs = getstructarray( wallbuy_targetname, "targetname" );
i = 0;
while ( i < melee_weapon_structs.size )
{
if ( isDefined( melee_weapon_structs[ i ].trigger_stub ) )
{
melee_weapon_structs[ i ].trigger_stub.hint_string = hint_string;
melee_weapon_structs[ i ].trigger_stub.cost = cost;
melee_weapon_structs[ i ].trigger_stub.weapon_name = weapon_name;
melee_weapon_structs[ i ].trigger_stub.has_weapon = has_weapon;
melee_weapon_structs[ i ].trigger_stub.give_weapon = give_weapon;
melee_weapon_structs[ i ].trigger_stub.vo_dialog_id = vo_dialog_id;
melee_weapon_structs[ i ].trigger_stub.flourish_weapon_name = flourish_weapon_name;
melee_weapon_structs[ i ].trigger_stub.ballistic_weapon_name = ballistic_weapon_name;
melee_weapon_structs[ i ].trigger_stub.ballistic_upgraded_weapon_name = ballistic_upgraded_weapon_name;
melee_weapon_structs[ i ].trigger_stub.trigger_func = ::melee_weapon_think;
melee_weapon_structs[ i ].trigger_stub.flourish_fn = flourish_fn;
}
i++;
}
register_melee_weapon_for_level( weapon_name );
if ( !isDefined( level.ballistic_weapon_name ) )
{
level.ballistic_weapon_name = [];
}
level.ballistic_weapon_name[ weapon_name ] = ballistic_weapon_name;
if ( !isDefined( level.ballistic_upgraded_weapon_name ) )
{
level.ballistic_upgraded_weapon_name = [];
}
level.ballistic_upgraded_weapon_name[ weapon_name ] = ballistic_upgraded_weapon_name;
}
add_melee_weapon( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, has_weapon, give_weapon, take_weapon, flourish_fn )
{
melee_weapon = spawnstruct();
melee_weapon.weapon_name = weapon_name;
melee_weapon.flourish_weapon_name = flourish_weapon_name;
melee_weapon.ballistic_weapon_name = ballistic_weapon_name;
melee_weapon.ballistic_upgraded_weapon_name = ballistic_upgraded_weapon_name;
melee_weapon.cost = cost;
melee_weapon.wallbuy_targetname = wallbuy_targetname;
melee_weapon.hint_string = hint_string;
melee_weapon.vo_dialog_id = vo_dialog_id;
melee_weapon.has_weapon = has_weapon;
melee_weapon.give_weapon = give_weapon;
melee_weapon.take_weapon = take_weapon;
melee_weapon.flourish_fn = flourish_fn;
if ( !isDefined( level._melee_weapons ) )
{
level._melee_weapons = [];
}
level._melee_weapons[ level._melee_weapons.size ] = melee_weapon;
}
spectator_respawn_all()
{
i = 0;
while ( i < level._melee_weapons.size )
{
self [[ level._melee_weapons[ i ].take_weapon ]]();
i++;
}
i = 0;
while ( i < level._melee_weapons.size )
{
self spectator_respawn( level._melee_weapons[ i ].wallbuy_targetname, level._melee_weapons[ i ].take_weapon, level._melee_weapons[ i ].has_weapon );
i++;
}
}
spectator_respawn( wallbuy_targetname, take_weapon, has_weapon )
{
melee_triggers = getentarray( wallbuy_targetname, "targetname" );
players = get_players();
i = 0;
while ( i < melee_triggers.size )
{
melee_triggers[ i ] setvisibletoall();
while ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
{
j = 0;
while ( j < players.size )
{
if ( players[ j ] [[ has_weapon ]]() )
{
melee_triggers[ i ] setinvisibletoplayer( players[ j ] );
}
j++;
}
}
i++;
}
}
trigger_hide_all()
{
i = 0;
while ( i < level._melee_weapons.size )
{
self trigger_hide( level._melee_weapons[ i ].wallbuy_targetname );
i++;
}
}
trigger_hide( wallbuy_targetname )
{
melee_triggers = getentarray( wallbuy_targetname, "targetname" );
i = 0;
while ( i < melee_triggers.size )
{
melee_triggers[ i ] setinvisibletoplayer( self );
i++;
}
}
has_any_ballistic_knife()
{
if ( self hasweapon( "knife_ballistic_zm" ) )
{
return 1;
}
if ( self hasweapon( "knife_ballistic_upgraded_zm" ) )
{
return 1;
}
i = 0;
while ( i < level._melee_weapons.size )
{
if ( self hasweapon( level._melee_weapons[ i ].ballistic_weapon_name ) )
{
return 1;
}
if ( self hasweapon( level._melee_weapons[ i ].ballistic_upgraded_weapon_name ) )
{
return 1;
}
i++;
}
return 0;
}
has_upgraded_ballistic_knife()
{
if ( self hasweapon( "knife_ballistic_upgraded_zm" ) )
{
return 1;
}
i = 0;
while ( i < level._melee_weapons.size )
{
if ( self hasweapon( level._melee_weapons[ i ].ballistic_upgraded_weapon_name ) )
{
return 1;
}
i++;
}
return 0;
}
give_ballistic_knife( weapon_string, upgraded )
{
current_melee_weapon = self get_player_melee_weapon();
if ( isDefined( current_melee_weapon ) )
{
if ( upgraded && isDefined( level.ballistic_upgraded_weapon_name ) && isDefined( level.ballistic_upgraded_weapon_name[ current_melee_weapon ] ) )
{
weapon_string = level.ballistic_upgraded_weapon_name[ current_melee_weapon ];
}
if ( !upgraded && isDefined( level.ballistic_weapon_name ) && isDefined( level.ballistic_weapon_name[ current_melee_weapon ] ) )
{
weapon_string = level.ballistic_weapon_name[ current_melee_weapon ];
}
}
return weapon_string;
}
change_melee_weapon( weapon_name, current_weapon )
{
current_melee_weapon = self get_player_melee_weapon();
if ( isDefined( current_melee_weapon ) )
{
self takeweapon( current_melee_weapon );
unacquire_weapon_toggle( current_melee_weapon );
}
self set_player_melee_weapon( weapon_name );
had_ballistic = 0;
had_ballistic_upgraded = 0;
ballistic_was_primary = 0;
primaryweapons = self getweaponslistprimaries();
i = 0;
while ( i < primaryweapons.size )
{
primary_weapon = primaryweapons[ i ];
if ( issubstr( primary_weapon, "knife_ballistic_" ) )
{
had_ballistic = 1;
if ( primary_weapon == current_weapon )
{
ballistic_was_primary = 1;
}
self notify( "zmb_lost_knife" );
self takeweapon( primary_weapon );
unacquire_weapon_toggle( primary_weapon );
if ( issubstr( primary_weapon, "upgraded" ) )
{
had_ballistic_upgraded = 1;
}
}
i++;
}
if ( had_ballistic )
{
if ( had_ballistic_upgraded )
{
new_ballistic = level.ballistic_upgraded_weapon_name[ weapon_name ];
if ( ballistic_was_primary )
{
current_weapon = new_ballistic;
}
self giveweapon( new_ballistic, 0, self maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( new_ballistic ) );
}
else
{
new_ballistic = level.ballistic_weapon_name[ weapon_name ];
if ( ballistic_was_primary )
{
current_weapon = new_ballistic;
}
self giveweapon( new_ballistic, 0 );
}
}
return current_weapon;
}
melee_weapon_think( weapon_name, cost, has_weapon, give_weapon, flourish_fn, vo_dialog_id, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name )
{
self.first_time_triggered = 0;
while ( isDefined( self.stub ) )
{
self endon( "kill_trigger" );
if ( isDefined( self.stub.first_time_triggered ) )
{
self.first_time_triggered = self.stub.first_time_triggered;
}
weapon_name = self.stub.weapon_name;
cost = self.stub.cost;
has_weapon = self.stub.has_weapon;
give_weapon = self.stub.give_weapon;
flourish_fn = self.stub.flourish_fn;
vo_dialog_id = self.stub.vo_dialog_id;
flourish_weapon_name = self.stub.flourish_weapon_name;
ballistic_weapon_name = self.stub.ballistic_weapon_name;
ballistic_upgraded_weapon_name = self.stub.ballistic_upgraded_weapon_name;
players = getplayers();
while ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
{
i = 0;
while ( i < players.size )
{
if ( players[ i ] [[ has_weapon ]]() )
{
self setinvisibletoplayer( players[ i ] );
}
i++;
}
}
}
for ( ;; )
{
self waittill( "trigger", player );
if ( !is_player_valid( player ) )
{
player thread ignore_triggers( 0,5 );
continue;
}
else if ( player in_revive_trigger() )
{
wait 0,1;
continue;
}
else if ( player isthrowinggrenade() )
{
wait 0,1;
continue;
}
else if ( player.is_drinking > 0 )
{
wait 0,1;
continue;
}
else if ( player hasweapon( weapon_name ) || player has_powerup_weapon() )
{
wait 0,1;
continue;
}
else
{
if ( player isswitchingweapons() )
{
wait 0,1;
break;
}
else current_weapon = player getcurrentweapon();
if ( !is_placeable_mine( current_weapon ) || is_equipment( current_weapon ) && player has_powerup_weapon() )
{
wait 0,1;
break;
}
else
{
if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( player.intermission ) && player.intermission )
{
wait 0,1;
break;
}
else
{
player_has_weapon = player [[ has_weapon ]]();
if ( !player_has_weapon )
{
if ( player.score >= cost )
{
if ( self.first_time_triggered == 0 )
{
model = getent( self.target, "targetname" );
if ( isDefined( model ) )
{
model thread melee_weapon_show( player );
}
else
{
if ( isDefined( self.clientfieldname ) )
{
level setclientfield( self.clientfieldname, 1 );
}
}
self.first_time_triggered = 1;
if ( isDefined( self.stub ) )
{
self.stub.first_time_triggered = 1;
}
}
player maps/mp/zombies/_zm_score::minus_to_player_score( cost );
bbprint( "zombie_uses", "playername %s playerscore %d round %d cost %d name %s x %f y %f z %f type %s", player.name, player.score, level.round_number, cost, weapon_name, self.origin, "weapon" );
player thread give_melee_weapon( vo_dialog_id, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, give_weapon, flourish_fn, self );
}
else
{
play_sound_on_ent( "no_purchase" );
player maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "no_money_weapon", undefined, 1 );
}
break;
}
else
{
if ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
{
self setinvisibletoplayer( player );
}
}
}
}
}
}
}
melee_weapon_show( player )
{
player_angles = vectorToAngle( player.origin - self.origin );
player_yaw = player_angles[ 1 ];
weapon_yaw = self.angles[ 1 ];
yaw_diff = angleClamp180( player_yaw - weapon_yaw );
if ( yaw_diff > 0 )
{
yaw = weapon_yaw - 90;
}
else
{
yaw = weapon_yaw + 90;
}
self.og_origin = self.origin;
self.origin += anglesToForward( ( 0, yaw, 0 ) ) * 8;
wait 0,05;
self show();
play_sound_at_pos( "weapon_show", self.origin, self );
time = 1;
self moveto( self.og_origin, time );
}
give_melee_weapon( vo_dialog_id, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, give_weapon, flourish_fn, trigger )
{
if ( isDefined( flourish_fn ) )
{
self thread [[ flourish_fn ]]();
}
gun = self do_melee_weapon_flourish_begin( flourish_weapon_name );
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", vo_dialog_id );
self waittill_any( "fake_death", "death", "player_downed", "weapon_change_complete" );
self do_melee_weapon_flourish_end( gun, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name );
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( self.intermission ) && self.intermission )
{
return;
}
self [[ give_weapon ]]();
if ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
{
trigger setinvisibletoplayer( self );
self trigger_hide_all();
}
}
do_melee_weapon_flourish_begin( flourish_weapon_name )
{
self increment_is_drinking();
self disable_player_move_states( 1 );
gun = self getcurrentweapon();
weapon = flourish_weapon_name;
self giveweapon( weapon );
self switchtoweapon( weapon );
return gun;
}
do_melee_weapon_flourish_end( gun, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name )
{
/#
assert( !is_zombie_perk_bottle( gun ) );
#/
/#
assert( gun != level.revive_tool );
#/
self enable_player_move_states();
weapon = flourish_weapon_name;
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( self.intermission ) && self.intermission )
{
self takeweapon( weapon );
self.lastactiveweapon = "none";
return;
}
self takeweapon( weapon );
self giveweapon( weapon_name );
gun = change_melee_weapon( weapon_name, gun );
if ( self hasweapon( "knife_zm" ) )
{
self takeweapon( "knife_zm" );
}
if ( self is_multiple_drinking() )
{
self decrement_is_drinking();
return;
}
else if ( gun == "knife_zm" )
{
self switchtoweapon( weapon_name );
self decrement_is_drinking();
return;
}
else if ( gun != "none" && !is_placeable_mine( gun ) && !is_equipment( gun ) )
{
self switchtoweapon( gun );
}
else
{
primaryweapons = self getweaponslistprimaries();
if ( isDefined( primaryweapons ) && primaryweapons.size > 0 )
{
self switchtoweapon( primaryweapons[ 0 ] );
}
}
self waittill( "weapon_change_complete" );
if ( !self maps/mp/zombies/_zm_laststand::player_is_in_laststand() && isDefined( self.intermission ) && !self.intermission )
{
self decrement_is_drinking();
}
}

339
zm_transit_dr_patch/maps/mp/zombies/_zm_mgturret.gsc Normal file
View File

@ -0,0 +1,339 @@
#include common_scripts/utility;
#include maps/mp/_utility;
main()
{
if ( getDvar( #"7C9A91DF" ) == "" )
{
setdvar( "mgTurret", "off" );
}
level.magic_distance = 24;
turretinfos = getentarray( "turretInfo", "targetname" );
index = 0;
while ( index < turretinfos.size )
{
turretinfos[ index ] delete();
index++;
}
}
set_difficulty( difficulty )
{
init_turret_difficulty_settings();
turrets = getentarray( "misc_turret", "classname" );
index = 0;
while ( index < turrets.size )
{
if ( isDefined( turrets[ index ].script_skilloverride ) )
{
switch( turrets[ index ].script_skilloverride )
{
case "easy":
difficulty = "easy";
break;
break;
case "medium":
difficulty = "medium";
break;
break;
case "hard":
difficulty = "hard";
break;
break;
case "fu":
difficulty = "fu";
break;
break;
default:
}
}
turret_set_difficulty( turrets[ index ], difficulty );
index++;
}
}
}
init_turret_difficulty_settings()
{
level.mgturretsettings[ "easy" ][ "convergenceTime" ] = 2,5;
level.mgturretsettings[ "easy" ][ "suppressionTime" ] = 3;
level.mgturretsettings[ "easy" ][ "accuracy" ] = 0,38;
level.mgturretsettings[ "easy" ][ "aiSpread" ] = 2;
level.mgturretsettings[ "easy" ][ "playerSpread" ] = 0,5;
level.mgturretsettings[ "medium" ][ "convergenceTime" ] = 1,5;
level.mgturretsettings[ "medium" ][ "suppressionTime" ] = 3;
level.mgturretsettings[ "medium" ][ "accuracy" ] = 0,38;
level.mgturretsettings[ "medium" ][ "aiSpread" ] = 2;
level.mgturretsettings[ "medium" ][ "playerSpread" ] = 0,5;
level.mgturretsettings[ "hard" ][ "convergenceTime" ] = 0,8;
level.mgturretsettings[ "hard" ][ "suppressionTime" ] = 3;
level.mgturretsettings[ "hard" ][ "accuracy" ] = 0,38;
level.mgturretsettings[ "hard" ][ "aiSpread" ] = 2;
level.mgturretsettings[ "hard" ][ "playerSpread" ] = 0,5;
level.mgturretsettings[ "fu" ][ "convergenceTime" ] = 0,4;
level.mgturretsettings[ "fu" ][ "suppressionTime" ] = 3;
level.mgturretsettings[ "fu" ][ "accuracy" ] = 0,38;
level.mgturretsettings[ "fu" ][ "aiSpread" ] = 2;
level.mgturretsettings[ "fu" ][ "playerSpread" ] = 0,5;
}
turret_set_difficulty( turret, difficulty )
{
turret.convergencetime = level.mgturretsettings[ difficulty ][ "convergenceTime" ];
turret.suppressiontime = level.mgturretsettings[ difficulty ][ "suppressionTime" ];
turret.accuracy = level.mgturretsettings[ difficulty ][ "accuracy" ];
turret.aispread = level.mgturretsettings[ difficulty ][ "aiSpread" ];
turret.playerspread = level.mgturretsettings[ difficulty ][ "playerSpread" ];
}
turret_suppression_fire( targets )
{
self endon( "death" );
self endon( "stop_suppression_fire" );
if ( !isDefined( self.suppresionfire ) )
{
self.suppresionfire = 1;
}
for ( ;; )
{
while ( self.suppresionfire )
{
self settargetentity( targets[ randomint( targets.size ) ] );
wait ( 2 + randomfloat( 2 ) );
}
self cleartargetentity();
while ( !self.suppresionfire )
{
wait 1;
}
}
}
burst_fire_settings( setting )
{
if ( setting == "delay" )
{
return 0,2;
}
else
{
if ( setting == "delay_range" )
{
return 0,5;
}
else
{
if ( setting == "burst" )
{
return 0,5;
}
else
{
if ( setting == "burst_range" )
{
return 4;
}
}
}
}
}
burst_fire( turret, manual_target )
{
turret endon( "death" );
turret endon( "stopfiring" );
self endon( "stop_using_built_in_burst_fire" );
if ( isDefined( turret.script_delay_min ) )
{
turret_delay = turret.script_delay_min;
}
else
{
turret_delay = burst_fire_settings( "delay" );
}
if ( isDefined( turret.script_delay_max ) )
{
turret_delay_range = turret.script_delay_max - turret_delay;
}
else
{
turret_delay_range = burst_fire_settings( "delay_range" );
}
if ( isDefined( turret.script_burst_min ) )
{
turret_burst = turret.script_burst_min;
}
else
{
turret_burst = burst_fire_settings( "burst" );
}
if ( isDefined( turret.script_burst_max ) )
{
turret_burst_range = turret.script_burst_max - turret_burst;
}
else
{
turret_burst_range = burst_fire_settings( "burst_range" );
}
while ( 1 )
{
turret startfiring();
if ( isDefined( manual_target ) )
{
turret thread random_spread( manual_target );
}
turret do_shoot();
wait ( turret_burst + randomfloat( turret_burst_range ) );
turret stopshootturret();
turret stopfiring();
wait ( turret_delay + randomfloat( turret_delay_range ) );
}
}
burst_fire_unmanned()
{
self notify( "stop_burst_fire_unmanned" );
self endon( "stop_burst_fire_unmanned" );
self endon( "death" );
self endon( "remote_start" );
level endon( "game_ended" );
if ( isDefined( self.controlled ) && self.controlled )
{
return;
}
if ( isDefined( self.script_delay_min ) )
{
turret_delay = self.script_delay_min;
}
else
{
turret_delay = burst_fire_settings( "delay" );
}
if ( isDefined( self.script_delay_max ) )
{
turret_delay_range = self.script_delay_max - turret_delay;
}
else
{
turret_delay_range = burst_fire_settings( "delay_range" );
}
if ( isDefined( self.script_burst_min ) )
{
turret_burst = self.script_burst_min;
}
else
{
turret_burst = burst_fire_settings( "burst" );
}
if ( isDefined( self.script_burst_max ) )
{
turret_burst_range = self.script_burst_max - turret_burst;
}
else
{
turret_burst_range = burst_fire_settings( "burst_range" );
}
pauseuntiltime = getTime();
turretstate = "start";
self.script_shooting = 0;
for ( ;; )
{
if ( isDefined( self.manual_targets ) )
{
self cleartargetentity();
self settargetentity( self.manual_targets[ randomint( self.manual_targets.size ) ] );
}
duration = ( pauseuntiltime - getTime() ) * 0,001;
if ( self isfiringturret() && duration <= 0 )
{
if ( turretstate != "fire" )
{
turretstate = "fire";
self playsound( "mpl_turret_alert" );
self thread do_shoot();
self.script_shooting = 1;
}
duration = turret_burst + randomfloat( turret_burst_range );
self thread turret_timer( duration );
self waittill( "turretstatechange" );
self.script_shooting = 0;
duration = turret_delay + randomfloat( turret_delay_range );
pauseuntiltime = getTime() + int( duration * 1000 );
continue;
}
else
{
if ( turretstate != "aim" )
{
turretstate = "aim";
}
self thread turret_timer( duration );
self waittill( "turretstatechange" );
}
}
}
avoid_synchronization( time )
{
if ( !isDefined( level._zm_mgturret_firing ) )
{
level._zm_mgturret_firing = 0;
}
level._zm_mgturret_firing++;
wait time;
level._zm_mgturret_firing--;
}
do_shoot()
{
self endon( "death" );
self endon( "turretstatechange" );
for ( ;; )
{
while ( is_true( level._zm_mgturret_firing ) )
{
wait 0,1;
}
thread avoid_synchronization( 0,1 );
self shootturret();
wait 0,112;
}
}
turret_timer( duration )
{
if ( duration <= 0 )
{
return;
}
self endon( "turretstatechange" );
wait duration;
if ( isDefined( self ) )
{
self notify( "turretstatechange" );
}
}
random_spread( ent )
{
self endon( "death" );
self notify( "stop random_spread" );
self endon( "stop random_spread" );
self endon( "stopfiring" );
self settargetentity( ent );
self.manual_target = ent;
while ( 1 )
{
if ( isplayer( ent ) )
{
ent.origin = self.manual_target getorigin();
}
else
{
ent.origin = self.manual_target.origin;
}
ent.origin += ( 20 - randomfloat( 40 ), 20 - randomfloat( 40 ), 20 - randomfloat( 60 ) );
wait 0,2;
}
}

100
zm_transit_dr_patch/maps/mp/zombies/_zm_net.gsc Normal file
View File

@ -0,0 +1,100 @@
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
network_choke_init( id, max )
{
if ( !isDefined( level.zombie_network_choke_ids_max ) )
{
level.zombie_network_choke_ids_max = [];
level.zombie_network_choke_ids_count = [];
}
level.zombie_network_choke_ids_max[ id ] = max;
level.zombie_network_choke_ids_count[ id ] = 0;
level thread network_choke_thread( id );
}
network_choke_thread( id )
{
while ( 1 )
{
wait_network_frame();
wait_network_frame();
level.zombie_network_choke_ids_count[ id ] = 0;
}
}
network_choke_safe( id )
{
return level.zombie_network_choke_ids_count[ id ] < level.zombie_network_choke_ids_max[ id ];
}
network_choke_action( id, choke_action, arg1, arg2, arg3 )
{
/#
assert( isDefined( level.zombie_network_choke_ids_max[ id ] ), "Network Choke: " + id + " undefined" );
#/
while ( !network_choke_safe( id ) )
{
wait 0,05;
}
level.zombie_network_choke_ids_count[ id ]++;
if ( !isDefined( arg1 ) )
{
return [[ choke_action ]]();
}
if ( !isDefined( arg2 ) )
{
return [[ choke_action ]]( arg1 );
}
if ( !isDefined( arg3 ) )
{
return [[ choke_action ]]( arg1, arg2 );
}
return [[ choke_action ]]( arg1, arg2, arg3 );
}
network_entity_valid( entity )
{
if ( !isDefined( entity ) )
{
return 0;
}
return 1;
}
network_safe_init( id, max )
{
if ( !isDefined( level.zombie_network_choke_ids_max ) || !isDefined( level.zombie_network_choke_ids_max[ id ] ) )
{
network_choke_init( id, max );
}
/#
assert( max == level.zombie_network_choke_ids_max[ id ] );
#/
}
_network_safe_spawn( classname, origin )
{
return spawn( classname, origin );
}
network_safe_spawn( id, max, classname, origin )
{
network_safe_init( id, max );
return network_choke_action( id, ::_network_safe_spawn, classname, origin );
}
_network_safe_play_fx_on_tag( fx, entity, tag )
{
if ( network_entity_valid( entity ) )
{
playfxontag( fx, entity, tag );
}
}
network_safe_play_fx_on_tag( id, max, fx, entity, tag )
{
network_safe_init( id, max );
network_choke_action( id, ::_network_safe_play_fx_on_tag, fx, entity, tag );
}

3844
zm_transit_dr_patch/maps/mp/zombies/_zm_perks.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

359
zm_transit_dr_patch/maps/mp/zombies/_zm_pers_upgrades.gsc Normal file
View File

@ -0,0 +1,359 @@
#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_system;
#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();
level thread pers_upgrades_monitor();
}
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 );
}
}
pers_upgrade_jugg_player_death_stat()
{
if ( isDefined( level.pers_upgrade_jugg ) && level.pers_upgrade_jugg )
{
if ( maps/mp/zombies/_zm_utility::is_classic() )
{
if ( isDefined( self.pers_upgrades_awarded[ "jugg" ] ) && !self.pers_upgrades_awarded[ "jugg" ] )
{
if ( level.round_number <= level.pers_jugg_hit_and_die_round_limit )
{
self maps/mp/zombies/_zm_stats::increment_client_stat( "pers_jugg", 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 );
}
}
pers_upgrade_boards_active()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "pers_stats_end_of_round" );
if ( self.rebuild_barrier_reward == 0 )
{
self maps/mp/zombies/_zm_stats::zero_client_stat( "pers_boarding", 0 );
return;
}
}
}
pers_upgrade_revive_active()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "player_failed_revive" );
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" );
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;
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;
self waittill( "pers_melee_swipe" );
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;
}
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 ( is_classic() )
{
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 ( 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 ( !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 ( !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,01;
}
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 ( isDefined( level.pers_upgrade_carpenter ) && level.pers_upgrade_carpenter )
{
if ( is_classic() )
{
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" );
}

242
zm_transit_dr_patch/maps/mp/zombies/_zm_pers_upgrades_system.gsc Normal file
View File

@ -0,0 +1,242 @@
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm;
#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 );
}
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 ] ] )
{
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 ) )
{
player playsoundtoplayer( "evt_player_upgrade", player );
player delay_thread( 1, ::play_vox_to_player, "general", "upgrade" );
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 * 10 ) ) + ( v_up * 10 );
}
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" );
}

583
zm_transit_dr_patch/maps/mp/zombies/_zm_playerhealth.gsc Normal file
View File

@ -0,0 +1,583 @@
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( !isDefined( level.script ) )
{
level.script = tolower( getDvar( "mapname" ) );
}
precacheshader( "overlay_low_health" );
level.global_damage_func_ads = ::empty_kill_func;
level.global_damage_func = ::empty_kill_func;
level.difficultytype[ 0 ] = "easy";
level.difficultytype[ 1 ] = "normal";
level.difficultytype[ 2 ] = "hardened";
level.difficultytype[ 3 ] = "veteran";
level.difficultystring[ "easy" ] = &"GAMESKILL_EASY";
level.difficultystring[ "normal" ] = &"GAMESKILL_NORMAL";
level.difficultystring[ "hardened" ] = &"GAMESKILL_HARDENED";
level.difficultystring[ "veteran" ] = &"GAMESKILL_VETERAN";
/#
thread playerhealthdebug();
#/
level.gameskill = 1;
switch( level.gameskill )
{
case 0:
setdvar( "currentDifficulty", "easy" );
break;
case 1:
setdvar( "currentDifficulty", "normal" );
break;
case 2:
setdvar( "currentDifficulty", "hardened" );
break;
case 3:
setdvar( "currentDifficulty", "veteran" );
break;
}
logstring( "difficulty: " + level.gameskill );
level.player_deathinvulnerabletime = 1700;
level.longregentime = 5000;
level.healthoverlaycutoff = 0,2;
level.invultime_preshield = 0,35;
level.invultime_onshield = 0,5;
level.invultime_postshield = 0,3;
level.playerhealth_regularregendelay = 2400;
level.worthydamageratio = 0,1;
setdvar( "player_meleeDamageMultiplier", 0,4 );
onplayerconnect_callback( ::onplayerconnect );
}
onplayerconnect()
{
self thread onplayerspawned();
}
onplayerspawned()
{
for ( ;; )
{
self waittill( "spawned_player" );
self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "health_reboot", 1, 0 );
if ( level.createfx_enabled )
{
continue;
}
else
{
self notify( "noHealthOverlay" );
self thread playerhealthregen();
}
}
}
playerhurtcheck()
{
self endon( "noHealthOverlay" );
self.hurtagain = 0;
for ( ;; )
{
self waittill( "damage", amount, attacker, dir, point, mod );
if ( isDefined( attacker ) && isplayer( attacker ) && attacker.team == self.team )
{
continue;
}
else
{
self.hurtagain = 1;
self.damagepoint = point;
self.damageattacker = attacker;
}
}
}
playerhealthregen()
{
self notify( "playerHealthRegen" );
self endon( "playerHealthRegen" );
self endon( "death" );
self endon( "disconnect" );
if ( !isDefined( self.flag ) )
{
self.flag = [];
self.flags_lock = [];
}
if ( !isDefined( self.flag[ "player_has_red_flashing_overlay" ] ) )
{
self player_flag_init( "player_has_red_flashing_overlay" );
self player_flag_init( "player_is_invulnerable" );
}
self player_flag_clear( "player_has_red_flashing_overlay" );
self player_flag_clear( "player_is_invulnerable" );
self thread healthoverlay();
oldratio = 1;
health_add = 0;
regenrate = 0,1;
veryhurt = 0;
playerjustgotredflashing = 0;
invultime = 0;
hurttime = 0;
newhealth = 0;
lastinvulratio = 1;
self thread playerhurtcheck();
if ( !isDefined( self.veryhurt ) )
{
self.veryhurt = 0;
}
self.bolthit = 0;
if ( getDvar( "scr_playerInvulTimeScale" ) == "" )
{
setdvar( "scr_playerInvulTimeScale", 1 );
}
playerinvultimescale = getDvarFloat( "scr_playerInvulTimeScale" );
for ( ;; )
{
wait 0,05;
waittillframeend;
if ( self.health == self.maxhealth )
{
if ( self player_flag( "player_has_red_flashing_overlay" ) )
{
player_flag_clear( "player_has_red_flashing_overlay" );
}
lastinvulratio = 1;
playerjustgotredflashing = 0;
veryhurt = 0;
continue;
}
else if ( self.health <= 0 )
{
/#
showhitlog();
#/
return;
}
wasveryhurt = veryhurt;
health_ratio = self.health / self.maxhealth;
if ( health_ratio <= level.healthoverlaycutoff )
{
veryhurt = 1;
if ( !wasveryhurt )
{
hurttime = getTime();
self startfadingblur( 3,6, 2 );
self player_flag_set( "player_has_red_flashing_overlay" );
playerjustgotredflashing = 1;
}
}
if ( self.hurtagain )
{
hurttime = getTime();
self.hurtagain = 0;
}
if ( health_ratio >= oldratio )
{
if ( ( getTime() - hurttime ) < level.playerhealth_regularregendelay )
{
continue;
}
else if ( veryhurt )
{
self.veryhurt = 1;
newhealth = health_ratio;
if ( getTime() > ( hurttime + level.longregentime ) )
{
newhealth += regenrate;
}
}
else
{
newhealth = 1;
self.veryhurt = 0;
}
if ( newhealth > 1 )
{
newhealth = 1;
}
if ( newhealth <= 0 )
{
return;
}
/#
if ( newhealth > health_ratio )
{
logregen( newhealth );
#/
}
self setnormalhealth( newhealth );
oldratio = self.health / self.maxhealth;
continue;
}
else invulworthyhealthdrop = ( lastinvulratio - health_ratio ) > level.worthydamageratio;
if ( self.health <= 1 )
{
self setnormalhealth( 2 / self.maxhealth );
invulworthyhealthdrop = 1;
/#
if ( !isDefined( level.player_deathinvulnerabletimeout ) )
{
level.player_deathinvulnerabletimeout = 0;
}
if ( level.player_deathinvulnerabletimeout < getTime() )
{
level.player_deathinvulnerabletimeout = getTime() + getDvarInt( "player_deathInvulnerableTime" );
#/
}
}
oldratio = self.health / self.maxhealth;
level notify( "hit_again" );
health_add = 0;
hurttime = getTime();
self startfadingblur( 3, 0,8 );
if ( !invulworthyhealthdrop || playerinvultimescale <= 0 )
{
/#
loghit( self.health, 0 );
#/
continue;
}
else
{
if ( self player_flag( "player_is_invulnerable" ) )
{
break;
}
else
{
self player_flag_set( "player_is_invulnerable" );
level notify( "player_becoming_invulnerable" );
if ( playerjustgotredflashing )
{
invultime = level.invultime_onshield;
playerjustgotredflashing = 0;
}
else if ( veryhurt )
{
invultime = level.invultime_postshield;
}
else
{
invultime = level.invultime_preshield;
}
invultime *= playerinvultimescale;
/#
loghit( self.health, invultime );
#/
lastinvulratio = self.health / self.maxhealth;
self thread playerinvul( invultime );
}
}
}
}
playerinvul( timer )
{
self endon( "death" );
self endon( "disconnect" );
if ( timer > 0 )
{
/#
level.playerinvultimeend = getTime() + ( timer * 1000 );
#/
wait timer;
}
self player_flag_clear( "player_is_invulnerable" );
}
healthoverlay()
{
self endon( "disconnect" );
self endon( "noHealthOverlay" );
if ( !isDefined( self._health_overlay ) )
{
self._health_overlay = newclienthudelem( self );
self._health_overlay.x = 0;
self._health_overlay.y = 0;
self._health_overlay setshader( "overlay_low_health", 640, 480 );
self._health_overlay.alignx = "left";
self._health_overlay.aligny = "top";
self._health_overlay.horzalign = "fullscreen";
self._health_overlay.vertalign = "fullscreen";
self._health_overlay.alpha = 0;
}
overlay = self._health_overlay;
self thread healthoverlay_remove( overlay );
self thread watchhideredflashingoverlay( overlay );
pulsetime = 0,8;
for ( ;; )
{
if ( overlay.alpha > 0 )
{
overlay fadeovertime( 0,5 );
}
overlay.alpha = 0;
self player_flag_wait( "player_has_red_flashing_overlay" );
self redflashingoverlay( overlay );
}
}
fadefunc( overlay, severity, mult, hud_scaleonly )
{
pulsetime = 0,8;
scalemin = 0,5;
fadeintime = pulsetime * 0,1;
stayfulltime = pulsetime * ( 0,1 + ( severity * 0,2 ) );
fadeouthalftime = pulsetime * ( 0,1 + ( severity * 0,1 ) );
fadeoutfulltime = pulsetime * 0,3;
remainingtime = pulsetime - fadeintime - stayfulltime - fadeouthalftime - fadeoutfulltime;
/#
assert( remainingtime >= -0,001 );
#/
if ( remainingtime < 0 )
{
remainingtime = 0;
}
halfalpha = 0,8 + ( severity * 0,1 );
leastalpha = 0,5 + ( severity * 0,3 );
overlay fadeovertime( fadeintime );
overlay.alpha = mult * 1;
wait ( fadeintime + stayfulltime );
overlay fadeovertime( fadeouthalftime );
overlay.alpha = mult * halfalpha;
wait fadeouthalftime;
overlay fadeovertime( fadeoutfulltime );
overlay.alpha = mult * leastalpha;
wait fadeoutfulltime;
wait remainingtime;
}
watchhideredflashingoverlay( overlay )
{
self endon( "death_or_disconnect" );
while ( isDefined( overlay ) )
{
self waittill( "clear_red_flashing_overlay" );
self player_flag_clear( "player_has_red_flashing_overlay" );
overlay fadeovertime( 0,05 );
overlay.alpha = 0;
setclientsysstate( "levelNotify", "rfo3", self );
self notify( "hit_again" );
}
}
redflashingoverlay( overlay )
{
self endon( "hit_again" );
self endon( "damage" );
self endon( "death" );
self endon( "disconnect" );
self endon( "clear_red_flashing_overlay" );
self.stopflashingbadlytime = getTime() + level.longregentime;
if ( isDefined( self.is_in_process_of_zombify ) && !self.is_in_process_of_zombify && isDefined( self.is_zombie ) && !self.is_zombie )
{
fadefunc( overlay, 1, 1, 0 );
while ( getTime() < self.stopflashingbadlytime && isalive( self ) && isDefined( self.is_in_process_of_zombify ) && !self.is_in_process_of_zombify && isDefined( self.is_zombie ) && !self.is_zombie )
{
fadefunc( overlay, 0,9, 1, 0 );
}
if ( isDefined( self.is_in_process_of_zombify ) && !self.is_in_process_of_zombify && isDefined( self.is_zombie ) && !self.is_zombie )
{
if ( isalive( self ) )
{
fadefunc( overlay, 0,65, 0,8, 0 );
}
fadefunc( overlay, 0, 0,6, 1 );
}
}
overlay fadeovertime( 0,5 );
overlay.alpha = 0;
self player_flag_clear( "player_has_red_flashing_overlay" );
setclientsysstate( "levelNotify", "rfo3", self );
wait 0,5;
self notify( "hit_again" );
}
healthoverlay_remove( overlay )
{
self endon( "disconnect" );
self waittill_any( "noHealthOverlay", "death" );
overlay fadeovertime( 3,5 );
overlay.alpha = 0;
}
empty_kill_func( type, loc, point, attacker, amount )
{
}
loghit( newhealth, invultime )
{
/#
#/
}
logregen( newhealth )
{
/#
#/
}
showhitlog()
{
/#
#/
}
playerhealthdebug()
{
/#
if ( getDvar( "scr_health_debug" ) == "" )
{
setdvar( "scr_health_debug", "0" );
}
waittillframeend;
while ( 1 )
{
while ( 1 )
{
if ( getDvar( "scr_health_debug" ) != "0" )
{
break;
}
else
{
wait 0,5;
}
}
thread printhealthdebug();
while ( 1 )
{
if ( getDvar( "scr_health_debug" ) == "0" )
{
break;
}
else
{
wait 0,5;
}
}
level notify( "stop_printing_grenade_timers" );
destroyhealthdebug();
#/
}
}
printhealthdebug()
{
/#
level notify( "stop_printing_health_bars" );
level endon( "stop_printing_health_bars" );
x = 40;
y = 40;
level.healthbarhudelems = [];
level.healthbarkeys[ 0 ] = "Health";
level.healthbarkeys[ 1 ] = "No Hit Time";
level.healthbarkeys[ 2 ] = "No Die Time";
if ( !isDefined( level.playerinvultimeend ) )
{
level.playerinvultimeend = 0;
}
if ( !isDefined( level.player_deathinvulnerabletimeout ) )
{
level.player_deathinvulnerabletimeout = 0;
}
i = 0;
while ( i < level.healthbarkeys.size )
{
key = level.healthbarkeys[ i ];
textelem = newhudelem();
textelem.x = x;
textelem.y = y;
textelem.alignx = "left";
textelem.aligny = "top";
textelem.horzalign = "fullscreen";
textelem.vertalign = "fullscreen";
textelem settext( key );
bgbar = newhudelem();
bgbar.x = x + 79;
bgbar.y = y + 1;
bgbar.alignx = "left";
bgbar.aligny = "top";
bgbar.horzalign = "fullscreen";
bgbar.vertalign = "fullscreen";
bgbar.maxwidth = 3;
bgbar setshader( "white", bgbar.maxwidth, 10 );
bgbar.color = vectorScale( ( 1, 1, 1 ), 0,5 );
bar = newhudelem();
bar.x = x + 80;
bar.y = y + 2;
bar.alignx = "left";
bar.aligny = "top";
bar.horzalign = "fullscreen";
bar.vertalign = "fullscreen";
bar setshader( "black", 1, 8 );
textelem.bar = bar;
textelem.bgbar = bgbar;
textelem.key = key;
y += 10;
level.healthbarhudelems[ key ] = textelem;
i++;
}
flag_wait( "start_zombie_round_logic" );
while ( 1 )
{
wait 0,05;
players = get_players();
i = 0;
while ( i < level.healthbarkeys.size && players.size > 0 )
{
key = level.healthbarkeys[ i ];
player = players[ 0 ];
width = 0;
if ( i == 0 )
{
width = ( player.health / player.maxhealth ) * 300;
}
else if ( i == 1 )
{
width = ( ( level.playerinvultimeend - getTime() ) / 1000 ) * 40;
}
else
{
if ( i == 2 )
{
width = ( ( level.player_deathinvulnerabletimeout - getTime() ) / 1000 ) * 40;
}
}
width = int( max( width, 1 ) );
width = int( min( width, 300 ) );
bar = level.healthbarhudelems[ key ].bar;
bar setshader( "black", width, 8 );
bgbar = level.healthbarhudelems[ key ].bgbar;
if ( ( width + 2 ) > bgbar.maxwidth )
{
bgbar.maxwidth = width + 2;
bgbar setshader( "white", bgbar.maxwidth, 10 );
bgbar.color = vectorScale( ( 1, 1, 1 ), 0,5 );
}
i++;
}
#/
}
}
destroyhealthdebug()
{
/#
if ( !isDefined( level.healthbarhudelems ) )
{
return;
}
i = 0;
while ( i < level.healthbarkeys.size )
{
level.healthbarhudelems[ level.healthbarkeys[ i ] ].bgbar destroy();
level.healthbarhudelems[ level.healthbarkeys[ i ] ].bar destroy();
level.healthbarhudelems[ level.healthbarkeys[ i ] ] destroy();
i++;
#/
}
}

740
zm_transit_dr_patch/maps/mp/zombies/_zm_power.gsc Normal file
View File

@ -0,0 +1,740 @@
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/_demo;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( !isDefined( level.powered_items ) )
{
level.powered_items = [];
}
if ( !isDefined( level.local_power ) )
{
level.local_power = [];
}
thread standard_powered_items();
/#
thread debug_powered_items();
#/
}
debug_powered_items()
{
/#
while ( 1 )
{
while ( getDvarInt( #"EB512CB7" ) )
{
while ( isDefined( level.local_power ) )
{
_a32 = level.local_power;
_k32 = getFirstArrayKey( _a32 );
while ( isDefined( _k32 ) )
{
localpower = _a32[ _k32 ];
circle( localpower.origin, localpower.radius, ( 0, 0, 1 ), 0, 1, 1 );
_k32 = getNextArrayKey( _a32, _k32 );
}
}
}
wait 0,05;
#/
}
}
watch_global_power()
{
while ( 1 )
{
flag_wait( "power_on" );
set_global_power( 1 );
flag_waitopen( "power_on" );
set_global_power( 0 );
}
}
standard_powered_items()
{
flag_wait( "start_zombie_round_logic" );
vending_triggers = getentarray( "zombie_vending", "targetname" );
_a67 = vending_triggers;
_k67 = getFirstArrayKey( _a67 );
while ( isDefined( _k67 ) )
{
trigger = _a67[ _k67 ];
if ( trigger.script_noteworthy == "specialty_weapupgrade" )
{
}
else
{
powered_on = maps/mp/zombies/_zm_perks::get_perk_machine_start_state( trigger.script_noteworthy );
add_powered_item( ::perk_power_on, ::perk_power_off, ::perk_range, ::cost_low_if_local, 0, powered_on, trigger );
}
_k67 = getNextArrayKey( _a67, _k67 );
}
pack_a_punch = getentarray( "specialty_weapupgrade", "script_noteworthy" );
_a77 = pack_a_punch;
_k77 = getFirstArrayKey( _a77 );
while ( isDefined( _k77 ) )
{
trigger = _a77[ _k77 ];
powered_on = maps/mp/zombies/_zm_perks::get_perk_machine_start_state( trigger.script_noteworthy );
trigger.powered = add_powered_item( ::pap_power_on, ::pap_power_off, ::pap_range, ::cost_low_if_local, 0, powered_on, trigger );
_k77 = getNextArrayKey( _a77, _k77 );
}
zombie_doors = getentarray( "zombie_door", "targetname" );
_a86 = zombie_doors;
_k86 = getFirstArrayKey( _a86 );
while ( isDefined( _k86 ) )
{
door = _a86[ _k86 ];
if ( isDefined( door.script_noteworthy ) && door.script_noteworthy == "electric_door" )
{
add_powered_item( ::door_power_on, ::door_power_off, ::door_range, ::cost_door, 0, 0, door );
}
else
{
if ( isDefined( door.script_noteworthy ) && door.script_noteworthy == "local_electric_door" )
{
power_sources = 0;
if ( isDefined( level.power_local_doors_globally ) && !level.power_local_doors_globally )
{
power_sources = 1;
}
add_powered_item( ::door_local_power_on, ::door_local_power_off, ::door_range, ::cost_door, power_sources, 0, door );
}
}
_k86 = getNextArrayKey( _a86, _k86 );
}
thread watch_global_power();
}
add_powered_item( power_on_func, power_off_func, range_func, cost_func, power_sources, self_powered, target )
{
powered = spawnstruct();
powered.power_on_func = power_on_func;
powered.power_off_func = power_off_func;
powered.range_func = range_func;
powered.power_sources = power_sources;
powered.self_powered = self_powered;
powered.target = target;
powered.cost_func = cost_func;
powered.power = self_powered;
powered.powered_count = self_powered;
powered.depowered_count = 0;
if ( !isDefined( level.powered_items ) )
{
level.powered_items = [];
}
level.powered_items[ level.powered_items.size ] = powered;
return powered;
}
remove_powered_item( powered )
{
arrayremovevalue( level.powered_items, powered, 0 );
}
add_temp_powered_item( power_on_func, power_off_func, range_func, cost_func, power_sources, self_powered, target )
{
powered = add_powered_item( power_on_func, power_off_func, range_func, cost_func, power_sources, self_powered, target );
while ( isDefined( level.local_power ) )
{
_a140 = level.local_power;
_k140 = getFirstArrayKey( _a140 );
while ( isDefined( _k140 ) )
{
localpower = _a140[ _k140 ];
if ( powered [[ powered.range_func ]]( 1, localpower.origin, localpower.radius ) )
{
powered change_power( 1, localpower.origin, localpower.radius );
if ( !isDefined( localpower.added_list ) )
{
localpower.added_list = [];
}
localpower.added_list[ localpower.added_list.size ] = powered;
}
_k140 = getNextArrayKey( _a140, _k140 );
}
}
thread watch_temp_powered_item( powered );
return powered;
}
watch_temp_powered_item( powered )
{
powered.target waittill( "death" );
remove_powered_item( powered );
while ( isDefined( level.local_power ) )
{
_a161 = level.local_power;
_k161 = getFirstArrayKey( _a161 );
while ( isDefined( _k161 ) )
{
localpower = _a161[ _k161 ];
if ( isDefined( localpower.added_list ) )
{
arrayremovevalue( localpower.added_list, powered, 0 );
}
if ( isDefined( localpower.enabled_list ) )
{
arrayremovevalue( localpower.enabled_list, powered, 0 );
}
_k161 = getNextArrayKey( _a161, _k161 );
}
}
}
change_power_in_radius( delta, origin, radius )
{
changed_list = [];
i = 0;
while ( i < level.powered_items.size )
{
powered = level.powered_items[ i ];
if ( powered.power_sources != 2 )
{
if ( powered [[ powered.range_func ]]( delta, origin, radius ) )
{
powered change_power( delta, origin, radius );
changed_list[ changed_list.size ] = powered;
}
}
i++;
}
return changed_list;
}
change_power( delta, origin, radius )
{
if ( delta > 0 )
{
if ( !self.power )
{
self.power = 1;
self [[ self.power_on_func ]]( origin, radius );
}
self.powered_count++;
}
else
{
if ( delta < 0 )
{
if ( self.power )
{
self.power = 0;
self [[ self.power_off_func ]]( origin, radius );
}
self.depowered_count++;
}
}
}
revert_power_to_list( delta, origin, radius, powered_list )
{
i = 0;
while ( i < powered_list.size )
{
powered = powered_list[ i ];
powered revert_power( delta, origin, radius );
i++;
}
}
revert_power( delta, origin, radius, powered_list )
{
if ( delta > 0 )
{
self.depowered_count--;
/#
assert( self.depowered_count >= 0, "Depower underflow in power system" );
#/
if ( self.depowered_count == 0 && self.powered_count > 0 && !self.power )
{
self.power = 1;
self [[ self.power_on_func ]]( origin, radius );
}
}
else
{
if ( delta < 0 )
{
self.powered_count--;
/#
assert( self.powered_count >= 0, "Repower underflow in power system" );
#/
if ( self.powered_count == 0 && self.power )
{
self.power = 0;
self [[ self.power_off_func ]]( origin, radius );
}
}
}
}
add_local_power( origin, radius )
{
localpower = spawnstruct();
/#
println( "ZM POWER: local power on at " + origin + " radius " + radius + "\n" );
#/
localpower.origin = origin;
localpower.radius = radius;
localpower.enabled_list = change_power_in_radius( 1, origin, radius );
if ( !isDefined( level.local_power ) )
{
level.local_power = [];
}
level.local_power[ level.local_power.size ] = localpower;
return localpower;
}
move_local_power( localpower, origin )
{
changed_list = [];
i = 0;
while ( i < level.powered_items.size )
{
powered = level.powered_items[ i ];
if ( powered.power_sources == 2 )
{
i++;
continue;
}
else waspowered = isinarray( localpower.enabled_list, powered );
ispowered = powered [[ powered.range_func ]]( 1, origin, localpower.radius );
if ( ispowered && !waspowered )
{
powered change_power( 1, origin, localpower.radius );
localpower.enabled_list[ localpower.enabled_list.size ] = powered;
i++;
continue;
}
else
{
if ( !ispowered && waspowered )
{
powered revert_power( -1, localpower.origin, localpower.radius, localpower.enabled_list );
arrayremovevalue( localpower.enabled_list, powered, 0 );
}
}
i++;
}
localpower.origin = origin;
return localpower;
}
end_local_power( localpower )
{
/#
println( "ZM POWER: local power off at " + localpower.origin + " radius " + localpower.radius + "\n" );
#/
if ( isDefined( localpower.enabled_list ) )
{
revert_power_to_list( -1, localpower.origin, localpower.radius, localpower.enabled_list );
}
localpower.enabled_list = undefined;
if ( isDefined( localpower.added_list ) )
{
revert_power_to_list( -1, localpower.origin, localpower.radius, localpower.added_list );
}
localpower.added_list = undefined;
arrayremovevalue( level.local_power, localpower, 0 );
}
has_local_power( origin )
{
while ( isDefined( level.local_power ) )
{
_a309 = level.local_power;
_k309 = getFirstArrayKey( _a309 );
while ( isDefined( _k309 ) )
{
localpower = _a309[ _k309 ];
if ( distancesquared( localpower.origin, origin ) < ( localpower.radius * localpower.radius ) )
{
return 1;
}
_k309 = getNextArrayKey( _a309, _k309 );
}
}
return 0;
}
get_powered_item_cost()
{
if ( isDefined( self.power ) && !self.power )
{
return 0;
}
if ( isDefined( level._power_global ) && level._power_global && self.power_sources != 1 )
{
return 0;
}
cost = [[ self.cost_func ]]();
power_sources = self.powered_count;
if ( power_sources < 1 )
{
power_sources = 1;
}
return cost / power_sources;
}
get_local_power_cost( localpower )
{
cost = 0;
while ( isDefined( localpower ) && isDefined( localpower.enabled_list ) )
{
_a340 = localpower.enabled_list;
_k340 = getFirstArrayKey( _a340 );
while ( isDefined( _k340 ) )
{
powered = _a340[ _k340 ];
cost += powered get_powered_item_cost();
_k340 = getNextArrayKey( _a340, _k340 );
}
}
while ( isDefined( localpower ) && isDefined( localpower.added_list ) )
{
_a345 = localpower.added_list;
_k345 = getFirstArrayKey( _a345 );
while ( isDefined( _k345 ) )
{
powered = _a345[ _k345 ];
cost += powered get_powered_item_cost();
_k345 = getNextArrayKey( _a345, _k345 );
}
}
return cost;
}
set_global_power( on_off )
{
maps/mp/_demo::bookmark( "zm_power", getTime(), undefined, undefined, 1 );
level._power_global = on_off;
i = 0;
while ( i < level.powered_items.size )
{
powered = level.powered_items[ i ];
if ( isDefined( powered.target ) && powered.power_sources != 1 )
{
powered global_power( on_off );
}
i++;
}
}
global_power( on_off )
{
if ( on_off )
{
/#
println( "ZM POWER: global power on\n" );
#/
if ( !self.power )
{
self.power = 1;
self [[ self.power_on_func ]]();
}
self.powered_count++;
}
else
{
/#
println( "ZM POWER: global power off\n" );
#/
self.powered_count--;
/#
assert( self.powered_count >= 0, "Repower underflow in power system" );
#/
if ( self.powered_count == 0 && self.power )
{
self.power = 0;
self [[ self.power_off_func ]]();
}
}
}
never_power_on( origin, radius )
{
}
never_power_off( origin, radius )
{
}
cost_negligible()
{
if ( isDefined( self.one_time_cost ) )
{
cost = self.one_time_cost;
self.one_time_cost = undefined;
return cost;
}
return 0;
}
cost_low_if_local()
{
if ( isDefined( self.one_time_cost ) )
{
cost = self.one_time_cost;
self.one_time_cost = undefined;
return cost;
}
if ( isDefined( level._power_global ) && level._power_global )
{
return 0;
}
if ( isDefined( self.self_powered ) && self.self_powered )
{
return 0;
}
return 1;
}
cost_high()
{
if ( isDefined( self.one_time_cost ) )
{
cost = self.one_time_cost;
self.one_time_cost = undefined;
return cost;
}
return 10;
}
door_range( delta, origin, radius )
{
if ( delta < 0 )
{
return 0;
}
if ( distancesquared( self.target.origin, origin ) < ( radius * radius ) )
{
return 1;
}
return 0;
}
door_power_on( origin, radius )
{
/#
println( "^1ZM POWER: door on\n" );
#/
self.target.power_on = 1;
self.target notify( "power_on" );
}
door_power_off( origin, radius )
{
/#
println( "^1ZM POWER: door off\n" );
#/
self.target notify( "power_off" );
self.target.power_on = 0;
}
door_local_power_on( origin, radius )
{
/#
println( "^1ZM POWER: door on (local)\n" );
#/
self.target.local_power_on = 1;
self.target notify( "local_power_on" );
}
door_local_power_off( origin, radius )
{
/#
println( "^1ZM POWER: door off (local)\n" );
#/
self.target notify( "local_power_off" );
self.target.local_power_on = 0;
}
cost_door()
{
if ( isDefined( self.target.power_cost ) )
{
if ( !isDefined( self.one_time_cost ) )
{
self.one_time_cost = 0;
}
self.one_time_cost += self.target.power_cost;
self.target.power_cost = 0;
}
if ( isDefined( self.one_time_cost ) )
{
cost = self.one_time_cost;
self.one_time_cost = undefined;
return cost;
}
return 0;
}
zombie_range( delta, origin, radius )
{
if ( delta > 0 )
{
return 0;
}
self.zombies = get_array_of_closest( origin, get_round_enemy_array(), undefined, undefined, radius );
if ( !isDefined( self.zombies ) )
{
return 0;
}
self.power = 1;
return 1;
}
zombie_power_off( origin, radius )
{
/#
println( "^1ZM POWER: zombies off\n" );
#/
i = 0;
while ( i < self.zombies.size )
{
self.zombies[ i ] thread stun_zombie();
wait 0,05;
i++;
}
}
stun_zombie()
{
self endon( "death" );
self notify( "stun_zombie" );
self endon( "stun_zombie" );
if ( self.health <= 0 )
{
/#
iprintln( "trying to stun a dead zombie" );
#/
return;
}
if ( isDefined( self.ignore_inert ) && self.ignore_inert )
{
return;
}
if ( isDefined( self.stun_zombie ) )
{
self thread [[ self.stun_zombie ]]();
return;
}
self thread maps/mp/zombies/_zm_ai_basic::start_inert();
}
perk_range( delta, origin, radius )
{
if ( isDefined( self.target ) )
{
perkorigin = self.target.origin;
if ( isDefined( self.target.trigger_off ) && self.target.trigger_off )
{
perkorigin = self.target.realorigin;
}
else
{
if ( isDefined( self.target.disabled ) && self.target.disabled )
{
perkorigin += vectorScale( ( 0, 0, 1 ), 10000 );
}
}
if ( distancesquared( perkorigin, origin ) < ( radius * radius ) )
{
return 1;
}
}
return 0;
}
perk_power_on( origin, radius )
{
/#
println( "^1ZM POWER: perk " + self.target maps/mp/zombies/_zm_perks::getvendingmachinenotify() + " on\n" );
#/
level notify( self.target maps/mp/zombies/_zm_perks::getvendingmachinenotify() + "_on" );
maps/mp/zombies/_zm_perks::perk_unpause( self.target.script_noteworthy );
}
perk_power_off( origin, radius )
{
notify_name = self.target maps/mp/zombies/_zm_perks::getvendingmachinenotify();
if ( isDefined( notify_name ) && notify_name == "revive" )
{
if ( level flag_exists( "solo_game" ) && flag( "solo_game" ) )
{
return;
}
}
/#
println( "^1ZM POWER: perk " + self.target.script_noteworthy + " off\n" );
#/
self.target notify( "death" );
self.target thread maps/mp/zombies/_zm_perks::vending_trigger_think();
if ( isDefined( self.target.perk_hum ) )
{
self.target.perk_hum delete();
}
maps/mp/zombies/_zm_perks::perk_pause( self.target.script_noteworthy );
level notify( self.target maps/mp/zombies/_zm_perks::getvendingmachinenotify() + "_off" );
}
pap_range( delta, origin, radius )
{
if ( isDefined( self.target ) )
{
paporigin = self.target.origin;
if ( isDefined( self.target.trigger_off ) && self.target.trigger_off )
{
paporigin = self.target.realorigin;
}
else
{
if ( isDefined( self.target.disabled ) && self.target.disabled )
{
paporigin += vectorScale( ( 0, 0, 1 ), 10000 );
}
}
if ( distancesquared( paporigin, origin ) < ( radius * radius ) )
{
return 1;
}
}
return 0;
}
pap_power_on( origin, radius )
{
/#
println( "^1ZM POWER: PaP on\n" );
#/
level notify( "Pack_A_Punch_on" );
}
pap_power_off( origin, radius )
{
/#
println( "^1ZM POWER: PaP off\n" );
#/
level notify( "Pack_A_Punch_off" );
self.target notify( "death" );
self.target thread maps/mp/zombies/_zm_perks::vending_weapon_upgrade();
}
pap_is_on()
{
if ( isDefined( self.powered ) )
{
return self.powered.power;
}
return 0;
}

3004
zm_transit_dr_patch/maps/mp/zombies/_zm_powerups.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

647
zm_transit_dr_patch/maps/mp/zombies/_zm_riotshield.gsc Normal file
View File

@ -0,0 +1,647 @@
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_buildables;
#include maps/mp/zombies/_zm_weap_riotshield;
#include common_scripts/utility;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
init()
{
level.riotshield_name = "riotshield_zm";
level.deployedshieldmodel = [];
level.stowedshieldmodel = [];
level.carriedshieldmodel = [];
level.deployedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_world";
level.deployedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dmg1_world";
level.deployedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dmg2_world";
level.stowedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_stow";
level.stowedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dmg1_stow";
level.stowedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dmg2_stow";
level.carriedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_world";
level.carriedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dmg1_world";
level.carriedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dmg2_world";
level.viewshieldmodel[ 0 ] = "t6_wpn_zmb_shield_view";
level.viewshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dmg1_view";
level.viewshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dmg2_view";
precachemodel( level.stowedshieldmodel[ 0 ] );
precachemodel( level.stowedshieldmodel[ 2 ] );
precachemodel( level.stowedshieldmodel[ 3 ] );
precachemodel( level.carriedshieldmodel[ 0 ] );
precachemodel( level.carriedshieldmodel[ 2 ] );
precachemodel( level.carriedshieldmodel[ 3 ] );
precachemodel( level.viewshieldmodel[ 0 ] );
precachemodel( level.viewshieldmodel[ 2 ] );
precachemodel( level.viewshieldmodel[ 3 ] );
level.riotshield_placement_zoffset = 26;
}
attachriotshield( model, tag )
{
if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
{
self detachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
}
self.prev_shield_model = model;
self.prev_shield_tag = tag;
if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
{
self attachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
}
}
removeriotshield()
{
if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
{
self detachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
}
self.prev_shield_model = undefined;
self.prev_shield_tag = undefined;
if ( self getcurrentweapon() != level.riotshield_name )
{
return;
}
self setheldweaponmodel( 0 );
}
setriotshieldviewmodel( modelnum )
{
self.prev_shield_viewmodel = modelnum;
if ( self getcurrentweapon() != level.riotshield_name )
{
return;
}
if ( isDefined( self.prev_shield_viewmodel ) )
{
self setheldweaponmodel( self.prev_shield_viewmodel );
}
else
{
self setheldweaponmodel( 0 );
}
}
specialriotshieldviewmodel()
{
if ( self getcurrentweapon() != level.riotshield_name )
{
return;
}
self setheldweaponmodel( 3 );
}
restoreriotshieldviewmodel()
{
if ( self getcurrentweapon() != level.riotshield_name )
{
return;
}
if ( isDefined( self.prev_shield_viewmodel ) )
{
self setheldweaponmodel( self.prev_shield_viewmodel );
}
else
{
self setheldweaponmodel( 0 );
}
}
updateriotshieldmodel()
{
if ( !isDefined( self.shield_damage_level ) )
{
if ( isDefined( self.player_shield_reset_health ) )
{
self [[ self.player_shield_reset_health ]]();
}
}
update = 0;
if ( !isDefined( self.prev_shield_damage_level ) || self.prev_shield_damage_level != self.shield_damage_level )
{
self.prev_shield_damage_level = self.shield_damage_level;
update = 1;
}
if ( !isDefined( self.prev_shield_placement ) || self.prev_shield_placement != self.shield_placement )
{
self.prev_shield_placement = self.shield_placement;
update = 1;
}
if ( update )
{
if ( self.prev_shield_placement == 0 )
{
self attachriotshield();
return;
}
else if ( self.prev_shield_placement == 1 )
{
self attachriotshield( level.carriedshieldmodel[ self.prev_shield_damage_level ], "tag_weapon_left" );
self setriotshieldviewmodel( self.prev_shield_damage_level );
return;
}
else if ( self.prev_shield_placement == 2 )
{
self attachriotshield( level.stowedshieldmodel[ self.prev_shield_damage_level ], "tag_stowed_back" );
return;
}
else
{
if ( self.prev_shield_placement == 3 )
{
self attachriotshield();
if ( isDefined( self.shield_ent ) )
{
self.shield_ent setmodel( level.deployedshieldmodel[ self.prev_shield_damage_level ] );
}
}
}
}
}
updatestandaloneriotshieldmodel()
{
update = 0;
if ( !isDefined( self.prev_shield_damage_level ) || self.prev_shield_damage_level != self.shield_damage_level )
{
self.prev_shield_damage_level = self.shield_damage_level;
update = 1;
}
if ( update )
{
self setmodel( level.deployedshieldmodel[ self.prev_shield_damage_level ] );
}
}
watchshieldlaststand()
{
self endon( "death" );
self endon( "disconnect" );
self notify( "watchShieldLastStand" );
self endon( "watchShieldLastStand" );
while ( 1 )
{
self waittill( "weapons_taken_for_last_stand" );
self.riotshield_hidden = 0;
if ( isDefined( self.hasriotshield ) && self.hasriotshield )
{
if ( self.prev_shield_placement == 1 || self.prev_shield_placement == 2 )
{
self.riotshield_hidden = 2;
self.shield_placement = 0;
self updateriotshieldmodel();
}
}
str_notify = self waittill_any_return( "player_revived", "bled_out" );
if ( str_notify == "player_revived" )
{
if ( isDefined( self.riotshield_hidden ) && self.riotshield_hidden > 0 )
{
self.shield_placement = self.riotshield_hidden;
self updateriotshieldmodel();
}
}
else
{
self maps/mp/zombies/_zm_weap_riotshield::player_take_riotshield();
}
self.riotshield_hidden = undefined;
}
}
trackriotshield()
{
self endon( "death" );
self endon( "disconnect" );
self.hasriotshield = self hasweapon( level.riotshield_name );
self.hasriotshieldequipped = self getcurrentweapon() == level.riotshield_name;
self.shield_placement = 0;
if ( self.hasriotshield )
{
if ( self.hasriotshieldequipped )
{
self.shield_placement = 1;
self updateriotshieldmodel();
}
else
{
self.shield_placement = 2;
self updateriotshieldmodel();
}
}
for ( ;; )
{
self waittill( "weapon_change", newweapon );
if ( newweapon == level.riotshield_name )
{
if ( self.hasriotshieldequipped )
{
continue;
}
else if ( isDefined( self.riotshieldentity ) )
{
self notify( "destroy_riotshield" );
}
self.shield_placement = 1;
self updateriotshieldmodel();
if ( self.hasriotshield )
{
break;
}
self.hasriotshield = 1;
self.hasriotshieldequipped = 1;
continue;
}
else if ( self ismantling() && newweapon == "none" )
{
continue;
}
else
{
if ( self.hasriotshieldequipped )
{
/#
assert( self.hasriotshield );
#/
self.hasriotshield = self hasweapon( level.riotshield_name );
if ( isDefined( self.riotshield_hidden ) && self.riotshield_hidden )
{
}
else
{
if ( self.hasriotshield )
{
self.shield_placement = 2;
break;
}
else if ( isDefined( self.shield_ent ) )
{
/#
assert( self.shield_placement == 3 );
#/
break;
}
else
{
self.shield_placement = 0;
}
}
self updateriotshieldmodel();
self.hasriotshieldequipped = 0;
break;
}
else
{
if ( self.hasriotshield )
{
if ( !self hasweapon( level.riotshield_name ) )
{
self.shield_placement = 0;
self updateriotshieldmodel();
self.hasriotshield = 0;
}
}
}
}
}
}
updateriotshieldplacement()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "deploy_riotshield" );
self endon( "start_riotshield_deploy" );
self endon( "weapon_change" );
while ( 1 )
{
placement = self canplaceriotshield( "raise_riotshield" );
if ( placement[ "result" ] && riotshielddistancetest( placement[ "origin" ] ) )
{
self restoreriotshieldviewmodel();
self setplacementhint( 1 );
}
else
{
self specialriotshieldviewmodel();
self setplacementhint( 0 );
}
wait 0,05;
}
}
startriotshielddeploy()
{
self notify( "start_riotshield_deploy" );
self thread updateriotshieldplacement();
self thread watchriotshielddeploy();
}
spawnriotshieldcover( origin, angles )
{
shield_ent = spawn( "script_model", origin, 1 );
shield_ent.angles = angles;
shield_ent setowner( self );
shield_ent.owner = self;
shield_ent.owner.shield_ent = shield_ent;
shield_ent.isriotshield = 1;
self.shield_placement = 3;
self updateriotshieldmodel();
shield_ent setscriptmoverflag( 0 );
self thread maps/mp/zombies/_zm_buildables::delete_on_disconnect( shield_ent, "destroy_riotshield", 1 );
maps/mp/zombies/_zm_equipment::destructible_equipment_list_add( shield_ent );
return shield_ent;
}
watchriotshielddeploy()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "start_riotshield_deploy" );
self waittill( "deploy_riotshield", deploy_attempt );
self restoreriotshieldviewmodel();
self setplacementhint( 1 );
placement_hint = 0;
if ( deploy_attempt )
{
placement = self canplaceriotshield( "deploy_riotshield" );
if ( placement[ "result" ] && riotshielddistancetest( placement[ "origin" ] ) && self check_plant_position( placement[ "origin" ], placement[ "angles" ] ) )
{
self doriotshielddeploy( placement[ "origin" ], placement[ "angles" ] );
}
else
{
placement_hint = 1;
clip_max_ammo = weaponclipsize( level.riotshield_name );
self setweaponammoclip( level.riotshield_name, clip_max_ammo );
}
}
else
{
placement_hint = 1;
}
if ( placement_hint )
{
self setriotshieldfailhint();
}
}
check_plant_position( origin, angles )
{
if ( isDefined( level.equipment_safe_to_drop ) )
{
ret = 1;
test_ent = spawn( "script_model", origin );
test_ent setmodel( level.deployedshieldmodel[ 0 ] );
test_ent.angles = angles;
if ( !( self [[ level.equipment_safe_to_drop ]]( test_ent ) ) )
{
ret = 0;
}
test_ent delete();
return ret;
}
return 1;
}
doriotshielddeploy( origin, angles )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "start_riotshield_deploy" );
self notify( "deployed_riotshield" );
self maps/mp/zombies/_zm_buildables::track_placed_buildables( level.riotshield_name );
if ( isDefined( self.current_equipment ) && self.current_equipment == level.riotshield_name )
{
self maps/mp/zombies/_zm_equipment::equipment_to_deployed( level.riotshield_name );
}
zoffset = level.riotshield_placement_zoffset;
shield_ent = self spawnriotshieldcover( origin + ( 0, 0, zoffset ), angles );
item_ent = deployriotshield( self, shield_ent );
primaries = self getweaponslistprimaries();
/#
assert( isDefined( item_ent ) );
assert( !isDefined( self.riotshieldretrievetrigger ) );
assert( !isDefined( self.riotshieldentity ) );
#/
self maps/mp/zombies/_zm_weapons::switch_back_primary_weapon( primaries[ 0 ] );
if ( isDefined( level.equipment_planted ) )
{
self [[ level.equipment_planted ]]( shield_ent, level.riotshield_name, self );
}
if ( isDefined( level.equipment_safe_to_drop ) )
{
if ( !( self [[ level.equipment_safe_to_drop ]]( shield_ent ) ) )
{
self notify( "destroy_riotshield" );
shield_ent delete();
item_ent delete();
return;
}
}
self.riotshieldretrievetrigger = item_ent;
self.riotshieldentity = shield_ent;
self thread watchdeployedriotshieldents();
self thread deleteshieldondamage( self.riotshieldentity );
self thread deleteshieldmodelonweaponpickup( self.riotshieldretrievetrigger );
self thread deleteriotshieldonplayerdeath();
self thread watchshieldtriggervisibility( self.riotshieldretrievetrigger );
self.riotshieldentity thread watchdeployedriotshielddamage();
return shield_ent;
}
riotshielddistancetest( origin )
{
/#
assert( isDefined( origin ) );
#/
min_dist_squared = getDvarFloat( "riotshield_deploy_limit_radius" );
min_dist_squared *= min_dist_squared;
i = 0;
while ( i < level.players.size )
{
if ( isDefined( level.players[ i ].riotshieldentity ) )
{
dist_squared = distancesquared( level.players[ i ].riotshieldentity.origin, origin );
if ( min_dist_squared > dist_squared )
{
/#
println( "Shield placement denied! Failed distance check to other riotshields." );
#/
return 0;
}
}
i++;
}
return 1;
}
watchdeployedriotshieldents()
{
/#
assert( isDefined( self.riotshieldretrievetrigger ) );
assert( isDefined( self.riotshieldentity ) );
#/
riotshieldretrievetrigger = self.riotshieldretrievetrigger;
riotshieldentity = self.riotshieldentity;
self waittill_any( "destroy_riotshield", "disconnect", "riotshield_zm_taken" );
if ( isDefined( self ) )
{
self.shield_placement = 0;
self updateriotshieldmodel();
}
if ( isDefined( riotshieldretrievetrigger ) )
{
riotshieldretrievetrigger delete();
}
if ( isDefined( riotshieldentity ) )
{
riotshieldentity delete();
}
}
watchdeployedriotshielddamage()
{
self endon( "death" );
damagemax = getDvarInt( "riotshield_deployed_health" );
self.damagetaken = 0;
while ( 1 )
{
self.maxhealth = 100000;
self.health = self.maxhealth;
self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname, idflags );
if ( isDefined( level.players_can_damage_riotshields ) && !level.players_can_damage_riotshields )
{
continue;
}
if ( !isDefined( attacker ) || !isplayer( attacker ) )
{
continue;
}
/#
if ( isDefined( self.owner ) )
{
assert( isDefined( self.owner.team ) );
}
#/
while ( is_encounter() && attacker.team == self.owner.team && attacker != self.owner )
{
continue;
}
if ( isDefined( level.riotshield_damage_callback ) )
{
self.owner [[ level.riotshield_damage_callback ]]( damage, 0 );
continue;
}
else
{
if ( type == "MOD_MELEE" )
{
damage *= getDvarFloat( "riotshield_melee_damage_scale" );
}
else if ( type == "MOD_PISTOL_BULLET" || type == "MOD_RIFLE_BULLET" )
{
damage *= getDvarFloat( "riotshield_bullet_damage_scale" );
}
else
{
if ( type != "MOD_GRENADE" && type != "MOD_GRENADE_SPLASH" && type != "MOD_EXPLOSIVE" && type != "MOD_EXPLOSIVE_SPLASH" || type == "MOD_PROJECTILE" && type == "MOD_PROJECTILE_SPLASH" )
{
damage *= getDvarFloat( "riotshield_explosive_damage_scale" );
break;
}
else
{
if ( type == "MOD_IMPACT" )
{
damage *= getDvarFloat( "riotshield_projectile_damage_scale" );
}
}
}
self.damagetaken += damage;
if ( self.damagetaken >= damagemax )
{
self damagethendestroyriotshield();
}
}
}
}
damagethendestroyriotshield()
{
self endon( "death" );
self.owner.riotshieldretrievetrigger delete();
self notsolid();
self setclientflag( 14 );
wait getDvarFloat( "riotshield_destroyed_cleanup_time" );
self.owner notify( "destroy_riotshield" );
}
deleteshieldondamage( shield_ent )
{
shield_ent waittill( "death" );
self notify( "destroy_riotshield" );
}
deleteshieldmodelonweaponpickup( shield_trigger )
{
shield_trigger waittill( "trigger", player );
self maps/mp/zombies/_zm_equipment::equipment_from_deployed( level.riotshield_name );
self notify( "destroy_riotshield" );
if ( self != player )
{
if ( isDefined( level.transferriotshield ) )
{
[[ level.transferriotshield ]]( self, player );
}
}
}
watchshieldtriggervisibility( trigger )
{
self endon( "death" );
trigger endon( "death" );
while ( isDefined( trigger ) )
{
players = get_players();
_a740 = players;
_k740 = getFirstArrayKey( _a740 );
while ( isDefined( _k740 ) )
{
player = _a740[ _k740 ];
pickup = 1;
if ( !isDefined( player ) )
{
}
else
{
if ( isDefined( level.cantransferriotshield ) )
{
pickup = [[ level.cantransferriotshield ]]( self, player );
}
if ( !isDefined( trigger ) )
{
return;
}
if ( pickup )
{
trigger setvisibletoplayer( player );
}
else
{
trigger setinvisibletoplayer( player );
}
wait 0,05;
}
_k740 = getNextArrayKey( _a740, _k740 );
}
wait 0,05;
}
}
deleteriotshieldonplayerdeath()
{
self.riotshieldentity endon( "death" );
self waittill( "death" );
self notify( "destroy_riotshield" );
}

374
zm_transit_dr_patch/maps/mp/zombies/_zm_score.gsc Normal file
View File

@ -0,0 +1,374 @@
#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 )
{
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;
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;
}
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 )
{
if ( !isDefined( points ) || level.intermission )
{
return;
}
self.score -= points;
self.pers[ "score" ] = self.score;
}
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" );
}

95
zm_transit_dr_patch/maps/mp/zombies/_zm_server_throttle.gsc Normal file
View File

@ -0,0 +1,95 @@
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
server_choke_init( id, max )
{
if ( !isDefined( level.zombie_server_choke_ids_max ) )
{
level.zombie_server_choke_ids_max = [];
level.zombie_server_choke_ids_count = [];
}
level.zombie_server_choke_ids_max[ id ] = max;
level.zombie_server_choke_ids_count[ id ] = 0;
level thread server_choke_thread( id );
}
server_choke_thread( id )
{
while ( 1 )
{
wait 0,05;
level.zombie_server_choke_ids_count[ id ] = 0;
}
}
server_choke_safe( id )
{
return level.zombie_server_choke_ids_count[ id ] < level.zombie_server_choke_ids_max[ id ];
}
server_choke_action( id, choke_action, arg1, arg2, arg3 )
{
/#
assert( isDefined( level.zombie_server_choke_ids_max[ id ] ), "server Choke: " + id + " undefined" );
#/
while ( !server_choke_safe( id ) )
{
wait 0,05;
}
level.zombie_server_choke_ids_count[ id ]++;
if ( !isDefined( arg1 ) )
{
return [[ choke_action ]]();
}
if ( !isDefined( arg2 ) )
{
return [[ choke_action ]]( arg1 );
}
if ( !isDefined( arg3 ) )
{
return [[ choke_action ]]( arg1, arg2 );
}
return [[ choke_action ]]( arg1, arg2, arg3 );
}
server_entity_valid( entity )
{
if ( !isDefined( entity ) )
{
return 0;
}
return 1;
}
server_safe_init( id, max )
{
if ( !isDefined( level.zombie_server_choke_ids_max ) || !isDefined( level.zombie_server_choke_ids_max[ id ] ) )
{
server_choke_init( id, max );
}
/#
assert( max == level.zombie_server_choke_ids_max[ id ] );
#/
}
_server_safe_ground_trace( pos )
{
return groundpos( pos );
}
server_safe_ground_trace( id, max, origin )
{
server_safe_init( id, max );
return server_choke_action( id, ::_server_safe_ground_trace, origin );
}
_server_safe_ground_trace_ignore_water( pos )
{
return groundpos_ignore_water( pos );
}
server_safe_ground_trace_ignore_water( id, max, origin )
{
server_safe_init( id, max );
return server_choke_action( id, ::_server_safe_ground_trace_ignore_water, origin );
}

1106
zm_transit_dr_patch/maps/mp/zombies/_zm_sidequests.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

3264
zm_transit_dr_patch/maps/mp/zombies/_zm_spawner.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

768
zm_transit_dr_patch/maps/mp/zombies/_zm_stats.gsc Normal file
View File

@ -0,0 +1,768 @@
#include maps/mp/gametypes_zm/_globallogic;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/gametypes_zm/_globallogic_score;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
level.player_stats_init = ::player_stats_init;
level.add_client_stat = ::add_client_stat;
level.increment_client_stat = ::increment_client_stat;
level.track_gibs = ::do_stats_for_gibs;
}
player_stats_init()
{
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "kills", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "suicides", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "downs", 0 );
self.downs = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "downs" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "revives", 0 );
self.revives = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "revives" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "perks_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "headshots", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "gibs", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "head_gibs", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "right_arm_gibs", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "left_arm_gibs", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "right_leg_gibs", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "left_leg_gibs", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "melee_kills", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "grenade_kills", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "doors_purchased", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "distance_traveled", 0 );
self.distance_traveled = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "distance_traveled" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "total_shots", 0 );
self.total_shots = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "total_shots" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "hits", 0 );
self.hits = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "hits" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "deaths", 0 );
self.deaths = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "deaths" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "boards", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "wins", 0 );
self.totalwins = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "totalwins" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "losses", 0 );
self.totallosses = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "totallosses" );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "failed_revives", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "sacrifices", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "failed_sacrifices", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "drops", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "nuke_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "insta_kill_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "full_ammo_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "double_points_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "meat_stink_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "carpenter_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "fire_sale_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "use_magicbox", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "grabbed_from_magicbox", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "use_pap", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pap_weapon_grabbed", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pap_weapon_not_grabbed", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_armorvest_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_quickrevive_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_rof_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_fastreload_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_flakjacket_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_additionalprimaryweapon_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_longersprint_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_deadshot_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_scavenger_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_finalstand_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_grenadepulldeath_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "specialty_nomotionsensor" + "_drank", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "claymores_planted", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "claymores_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "ballistic_knives_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "wallbuy_weapons_purchased", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "ammo_purchased", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "upgraded_ammo_purchased", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "power_turnedon", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "power_turnedoff", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "planted_buildables_pickedup", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "buildables_built", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "time_played_total", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "weighted_rounds_played", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "contaminations_received", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "contaminations_given", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zdogs_killed", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zdog_rounds_finished", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zdog_rounds_lost", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "killed_by_zdog", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "screecher_minigames_won", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "screecher_minigames_lost", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "screechers_killed", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "screecher_teleporters_used", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "avogadro_defeated", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "killed_by_avogadro", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "cheat_too_many_weapons", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "cheat_out_of_playable", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "cheat_too_friendly", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "cheat_total", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_boarding", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_revivenoperk", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_multikill_headshots", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_cash_back_bought", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_cash_back_prone", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_insta_kill", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_insta_kill_stabs", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_jugg", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_jugg_downgrade_count", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_carpenter", 0, 1 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "pers_carpenter_downgrade_count", 0, 1 );
self.successful_revives = 0;
self.failed_revives = 0;
self.failed_cash_back_prones = 0;
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "score", 0 );
if ( level.resetplayerscoreeveryround )
{
self.pers[ "score" ] = 0;
}
self.pers[ "score" ] = level.player_starting_points;
self.score = self.pers[ "score" ];
self incrementplayerstat( "score", self.score );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zteam", 0 );
if ( isDefined( level.level_specific_stats_init ) )
{
[[ level.level_specific_stats_init ]]();
}
if ( !isDefined( self.stats_this_frame ) )
{
self.pers_upgrade_force_test = 1;
self.stats_this_frame = [];
self.pers_upgrades_awarded = [];
}
self.pers[ "last_headshot_kill_time" ] = getTime();
self.pers[ "zombies_multikilled" ] = 0;
self.non_headshot_kill_counter = 0;
}
update_players_stats_at_match_end( players )
{
game_mode = getDvar( "ui_gametype" );
game_mode_group = level.scr_zm_ui_gametype_group;
map_location_name = level.scr_zm_map_start_location;
if ( map_location_name == "" )
{
map_location_name = "default";
}
if ( isDefined( level.gamemodulewinningteam ) )
{
if ( level.gamemodulewinningteam == "B" )
{
matchrecorderincrementheaderstat( "winningTeam", 1 );
}
else
{
if ( level.gamemodulewinningteam == "A" )
{
matchrecorderincrementheaderstat( "winningTeam", 2 );
}
}
}
recordmatchsummaryzombieendgamedata( game_mode, game_mode_group, map_location_name, level.round_number );
newtime = getTime();
i = 0;
while ( i < players.size )
{
player = players[ i ];
if ( player is_bot() )
{
i++;
continue;
}
else
{
distance = player get_stat_distance_traveled();
player addplayerstatwithgametype( "distance_traveled", distance );
player add_location_gametype_stat( level.scr_zm_map_start_location, level.scr_zm_ui_gametype, "time_played_total", player.pers[ "time_played_total" ] );
recordplayermatchend( player );
recordplayerstats( player, "presentAtEnd", 1 );
player maps/mp/zombies/_zm_weapons::updateweapontimingszm( newtime );
if ( isDefined( level._game_module_stat_update_func ) )
{
player [[ level._game_module_stat_update_func ]]();
}
old_high_score = player get_game_mode_stat( game_mode, "score" );
if ( player.score_total > old_high_score )
{
player set_game_mode_stat( game_mode, "score", player.score_total );
}
if ( gamemodeismode( level.gamemode_public_match ) )
{
player gamehistoryfinishmatch( 4, 0, 0, 0, 0, 0 );
if ( isDefined( player.pers[ "matchesPlayedStatsTracked" ] ) )
{
gamemode = maps/mp/gametypes_zm/_globallogic::getcurrentgamemode();
player maps/mp/gametypes_zm/_globallogic::incrementmatchcompletionstat( gamemode, "played", "completed" );
if ( isDefined( player.pers[ "matchesHostedStatsTracked" ] ) )
{
player maps/mp/gametypes_zm/_globallogic::incrementmatchcompletionstat( gamemode, "hosted", "completed" );
}
}
}
if ( !isDefined( player.pers[ "previous_distance_traveled" ] ) )
{
player.pers[ "previous_distance_traveled" ] = 0;
}
distancethisround = int( player.pers[ "distance_traveled" ] - player.pers[ "previous_distance_traveled" ] );
player.pers[ "previous_distance_traveled" ] = player.pers[ "distance_traveled" ];
player incrementplayerstat( "distance_traveled", distancethisround );
}
i++;
}
}
update_playing_utc_time( matchendutctime )
{
current_days = int( matchendutctime / 86400 );
last_days = self get_global_stat( "TIMESTAMPLASTDAY1" );
last_days = int( last_days / 86400 );
diff_days = current_days - last_days;
timestamp_name = "";
if ( diff_days > 0 )
{
i = 5;
while ( i > diff_days )
{
timestamp_name = "TIMESTAMPLASTDAY" + ( i - diff_days );
timestamp_name_to = "TIMESTAMPLASTDAY" + i;
timestamp_value = self get_global_stat( timestamp_name );
self set_global_stat( timestamp_name_to, timestamp_value );
i--;
}
i = 2;
while ( i <= diff_days && i < 6 )
{
timestamp_name = "TIMESTAMPLASTDAY" + i;
self set_global_stat( timestamp_name, 0 );
i++;
}
self set_global_stat( "TIMESTAMPLASTDAY1", matchendutctime );
}
}
survival_classic_custom_stat_update()
{
}
grief_custom_stat_update()
{
}
add_game_mode_group_stat( game_mode, stat_name, value )
{
self adddstat( "PlayerStatsByGameTypeGroup", game_mode, stat_name, "statValue", value );
}
set_game_mode_group_stat( game_mode, stat_name, value )
{
self setdstat( "PlayerStatsByGameTypeGroup", game_mode, stat_name, "statValue", value );
}
get_game_mode_group_stat( game_mode, stat_name )
{
return self getdstat( "PlayerStatsByGameTypeGroup", game_mode, stat_name, "statValue" );
}
add_game_mode_stat( game_mode, stat_name, value )
{
self adddstat( "PlayerStatsByGameType", game_mode, stat_name, "statValue", value );
}
set_game_mode_stat( game_mode, stat_name, value )
{
self setdstat( "PlayerStatsByGameType", game_mode, stat_name, "statValue", value );
}
get_game_mode_stat( game_mode, stat_name )
{
return self getdstat( "PlayerStatsByGameType", game_mode, stat_name, "statValue" );
}
get_global_stat( stat_name )
{
return self getdstat( "PlayerStatsList", stat_name, "StatValue" );
}
set_global_stat( stat_name, value )
{
self setdstat( "PlayerStatsList", stat_name, "StatValue", value );
}
add_global_stat( stat_name, value )
{
self adddstat( "PlayerStatsList", stat_name, "StatValue", value );
}
get_map_stat( stat_name )
{
return self getdstat( "PlayerStatsByMap", level.script, stat_name );
}
set_map_stat( stat_name, value )
{
self setdstat( "PlayerStatsByMap", level.script, stat_name, value );
}
add_map_stat( stat_name, value )
{
self adddstat( "PlayerStatsByMap", level.script, stat_name, value );
}
get_location_gametype_stat( start_location, game_type, stat_name )
{
return self getdstat( "PlayerStatsByStartLocation", start_location, "startLocationGameTypeStats", game_type, "stats", stat_name, "StatValue" );
}
set_location_gametype_stat( start_location, game_type, stat_name, value )
{
self setdstat( "PlayerStatsByStartLocation", start_location, "startLocationGameTypeStats", game_type, "stats", stat_name, "StatValue", value );
}
add_location_gametype_stat( start_location, game_type, stat_name, value )
{
self adddstat( "PlayerStatsByStartLocation", start_location, "startLocationGameTypeStats", game_type, "stats", stat_name, "StatValue", value );
}
get_map_weaponlocker_stat( stat_name )
{
return self getdstat( "PlayerStatsByMap", level.script, "weaponLocker", stat_name );
}
set_map_weaponlocker_stat( stat_name, value )
{
if ( isDefined( value ) )
{
self setdstat( "PlayerStatsByMap", level.script, "weaponLocker", stat_name, value );
}
else
{
self setdstat( "PlayerStatsByMap", level.script, "weaponLocker", stat_name, 0 );
}
}
add_map_weaponlocker_stat( stat_name, value )
{
self adddstat( "PlayerStatsByMap", level.script, "weaponLocker", stat_name, value );
}
has_stored_weapondata()
{
storedweapon = self get_map_weaponlocker_stat( "name" );
if ( isDefined( storedweapon ) && isstring( storedweapon ) || storedweapon == "" && isint( storedweapon ) && storedweapon == 0 )
{
return 0;
}
return 1;
}
get_stored_weapondata()
{
if ( self has_stored_weapondata() )
{
weapondata = [];
weapondata[ "name" ] = self get_map_weaponlocker_stat( "name" );
weapondata[ "lh_clip" ] = self get_map_weaponlocker_stat( "lh_clip" );
weapondata[ "clip" ] = self get_map_weaponlocker_stat( "clip" );
weapondata[ "stock" ] = self get_map_weaponlocker_stat( "stock" );
weapondata[ "alt_clip" ] = self get_map_weaponlocker_stat( "alt_clip" );
weapondata[ "alt_stock" ] = self get_map_weaponlocker_stat( "alt_stock" );
return weapondata;
}
return undefined;
}
clear_stored_weapondata()
{
self set_map_weaponlocker_stat( "name", "" );
self set_map_weaponlocker_stat( "lh_clip", 0 );
self set_map_weaponlocker_stat( "clip", 0 );
self set_map_weaponlocker_stat( "stock", 0 );
self set_map_weaponlocker_stat( "alt_clip", 0 );
self set_map_weaponlocker_stat( "alt_stock", 0 );
}
set_stored_weapondata( weapondata )
{
self set_map_weaponlocker_stat( "name", weapondata[ "name" ] );
self set_map_weaponlocker_stat( "lh_clip", weapondata[ "lh_clip" ] );
self set_map_weaponlocker_stat( "clip", weapondata[ "clip" ] );
self set_map_weaponlocker_stat( "stock", weapondata[ "stock" ] );
self set_map_weaponlocker_stat( "alt_clip", weapondata[ "alt_clip" ] );
self set_map_weaponlocker_stat( "alt_stock", weapondata[ "alt_stock" ] );
}
add_client_stat( stat_name, stat_value, include_gametype )
{
if ( getDvar( "ui_zm_mapstartlocation" ) == "" )
{
return;
}
if ( !isDefined( include_gametype ) )
{
include_gametype = 1;
}
self maps/mp/gametypes_zm/_globallogic_score::incpersstat( stat_name, stat_value, 0, include_gametype );
self.stats_this_frame[ stat_name ] = 1;
}
increment_player_stat( stat_name )
{
if ( getDvar( "ui_zm_mapstartlocation" ) == "" )
{
return;
}
self incrementplayerstat( stat_name, 1 );
}
increment_root_stat( stat_name, stat_value )
{
self adddstat( stat_name, stat_value );
}
increment_client_stat( stat_name, include_gametype )
{
add_client_stat( stat_name, 1, include_gametype );
}
zero_client_stat( stat_name, include_gametype )
{
current_stat_count = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( stat_name );
self maps/mp/gametypes_zm/_globallogic_score::incpersstat( stat_name, current_stat_count * -1, 0, include_gametype );
self.stats_this_frame[ stat_name ] = 1;
}
increment_map_cheat_stat( stat_name )
{
self adddstat( "PlayerStatsByMap", level.script, "cheats", stat_name, 1 );
}
get_stat_distance_traveled()
{
miles = int( self.pers[ "distance_traveled" ] / 63360 );
remainder = ( self.pers[ "distance_traveled" ] / 63360 ) - miles;
if ( miles < 1 && remainder < 0,5 )
{
miles = 1;
}
else
{
if ( remainder >= 0,5 )
{
miles++;
}
}
return miles;
}
get_stat_round_number()
{
return level.round_number;
}
get_stat_combined_rank_value_survival_classic()
{
rounds = get_stat_round_number();
kills = self.pers[ "kills" ];
if ( rounds > 99 )
{
rounds = 99;
}
result = ( rounds * 10000000 ) + kills;
return result;
}
get_stat_combined_rank_value_grief()
{
wins = self.pers[ "wins" ];
losses = self.pers[ "losses" ];
if ( wins > 9999 )
{
wins = 9999;
}
if ( losses > 9999 )
{
losses = 9999;
}
losses_value = 9999 - losses;
result = ( wins * 10000 ) + losses_value;
return result;
}
update_global_counters_on_match_end()
{
deaths = 0;
kills = 0;
melee_kills = 0;
headshots = 0;
suicides = 0;
downs = 0;
revives = 0;
perks_drank = 0;
gibs = 0;
doors_purchased = 0;
distance_traveled = 0;
total_shots = 0;
boards = 0;
sacrifices = 0;
drops = 0;
nuke_pickedup = 0;
insta_kill_pickedup = 0;
full_ammo_pickedup = 0;
double_points_pickedup = 0;
meat_stink_pickedup = 0;
carpenter_pickedup = 0;
fire_sale_pickedup = 0;
use_magicbox = 0;
grabbed_from_magicbox = 0;
use_pap = 0;
pap_weapon_grabbed = 0;
specialty_armorvest_drank = 0;
specialty_quickrevive_drank = 0;
specialty_fastreload_drank = 0;
specialty_longersprint_drank = 0;
specialty_scavenger_drank = 0;
specialty_rof_drank = 0;
specialty_deadshot_drank = 0;
specialty_flakjacket_drank = 0;
specialty_additionalprimaryweapon_drank = 0;
specialty_finalstand_drank = 0;
specialty_grenadepulldeath_drank = 0;
perk_vulture_drank = 0;
claymores_planted = 0;
claymores_pickedup = 0;
ballistic_knives_pickedup = 0;
wallbuy_weapons_purchased = 0;
power_turnedon = 0;
power_turnedoff = 0;
planted_buildables_pickedup = 0;
ammo_purchased = 0;
upgraded_ammo_purchased = 0;
buildables_built = 0;
time_played = 0;
contaminations_received = 0;
contaminations_given = 0;
cheat_too_many_weapons = 0;
cheat_out_of_playable_area = 0;
cheat_too_friendly = 0;
cheat_total = 0;
players = get_players();
_a631 = players;
_k631 = getFirstArrayKey( _a631 );
while ( isDefined( _k631 ) )
{
player = _a631[ _k631 ];
deaths += player.pers[ "deaths" ];
kills += player.pers[ "kills" ];
headshots += player.pers[ "headshots" ];
suicides += player.pers[ "suicides" ];
melee_kills += player.pers[ "melee_kills" ];
downs += player.pers[ "downs" ];
revives += player.pers[ "revives" ];
perks_drank += player.pers[ "perks_drank" ];
specialty_armorvest_drank += player.pers[ "specialty_armorvest_drank" ];
specialty_quickrevive_drank += player.pers[ "specialty_quickrevive_drank" ];
specialty_fastreload_drank += player.pers[ "specialty_fastreload_drank" ];
specialty_longersprint_drank += player.pers[ "specialty_longersprint_drank" ];
specialty_rof_drank += player.pers[ "specialty_rof_drank" ];
specialty_deadshot_drank += player.pers[ "specialty_deadshot_drank" ];
specialty_scavenger_drank += player.pers[ "specialty_scavenger_drank" ];
specialty_flakjacket_drank += player.pers[ "specialty_flakjacket_drank" ];
specialty_additionalprimaryweapon_drank += player.pers[ "specialty_additionalprimaryweapon_drank" ];
specialty_finalstand_drank += player.pers[ "specialty_finalstand_drank" ];
specialty_grenadepulldeath_drank += player.pers[ "specialty_grenadepulldeath_drank" ];
perk_vulture_drank += player.pers[ "specialty_nomotionsensor" + "_drank" ];
gibs += player.pers[ "gibs" ];
doors_purchased += player.pers[ "doors_purchased" ];
distance_traveled += player get_stat_distance_traveled();
boards += player.pers[ "boards" ];
sacrifices += player.pers[ "sacrifices" ];
drops += player.pers[ "drops" ];
nuke_pickedup += player.pers[ "nuke_pickedup" ];
insta_kill_pickedup += player.pers[ "insta_kill_pickedup" ];
full_ammo_pickedup += player.pers[ "full_ammo_pickedup" ];
double_points_pickedup += player.pers[ "double_points_pickedup" ];
meat_stink_pickedup += player.pers[ "meat_stink_pickedup" ];
carpenter_pickedup += player.pers[ "carpenter_pickedup" ];
fire_sale_pickedup += player.pers[ "fire_sale_pickedup" ];
use_magicbox += player.pers[ "use_magicbox" ];
grabbed_from_magicbox += player.pers[ "grabbed_from_magicbox" ];
use_pap += player.pers[ "use_pap" ];
pap_weapon_grabbed += player.pers[ "pap_weapon_grabbed" ];
claymores_planted += player.pers[ "claymores_planted" ];
claymores_pickedup += player.pers[ "claymores_pickedup" ];
ballistic_knives_pickedup += player.pers[ "ballistic_knives_pickedup" ];
wallbuy_weapons_purchased += player.pers[ "wallbuy_weapons_purchased" ];
power_turnedon += player.pers[ "power_turnedon" ];
power_turnedoff += player.pers[ "power_turnedoff" ];
planted_buildables_pickedup += player.pers[ "planted_buildables_pickedup" ];
buildables_built += player.pers[ "buildables_built" ];
ammo_purchased += player.pers[ "ammo_purchased" ];
upgraded_ammo_purchased += player.pers[ "upgraded_ammo_purchased" ];
total_shots += player.total_shots;
time_played += player.pers[ "time_played_total" ];
contaminations_received += player.pers[ "contaminations_received" ];
contaminations_given += player.pers[ "contaminations_given" ];
cheat_too_many_weapons += player.pers[ "cheat_too_many_weapons" ];
cheat_out_of_playable_area += player.pers[ "cheat_out_of_playable" ];
cheat_too_friendly += player.pers[ "cheat_too_friendly" ];
cheat_total += player.pers[ "cheat_total" ];
_k631 = getNextArrayKey( _a631, _k631 );
}
game_mode = getDvar( "ui_gametype" );
incrementcounter( "global_zm_" + game_mode, 1 );
incrementcounter( "global_zm_games", 1 );
if ( game_mode == "zclassic" || level.script == "zm_nuked" )
{
incrementcounter( "global_zm_games_" + level.script, 1 );
}
incrementcounter( "global_zm_killed", level.global_zombies_killed );
incrementcounter( "global_zm_killed_by_players", kills );
incrementcounter( "global_zm_killed_by_traps", level.zombie_trap_killed_count );
spacer = "";
if ( level.round_number < 10 )
{
spacer = "0";
}
incrementcounter( "global_zm_players_reached_round_" + spacer + level.round_number, players.size );
incrementcounter( "global_zm_headshots", headshots );
incrementcounter( "global_zm_suicides", suicides );
incrementcounter( "global_zm_melee_kills", melee_kills );
incrementcounter( "global_zm_downs", downs );
incrementcounter( "global_zm_deaths", deaths );
incrementcounter( "global_zm_revives", revives );
incrementcounter( "global_zm_perks_drank", perks_drank );
incrementcounter( "global_zm_specialty_armorvest_drank", specialty_armorvest_drank );
incrementcounter( "global_zm_specialty_quickrevive_drank", specialty_quickrevive_drank );
incrementcounter( "global_zm_specialty_fastreload_drank", specialty_fastreload_drank );
incrementcounter( "global_zm_specialty_longersprint_drank", specialty_longersprint_drank );
incrementcounter( "global_zm_specialty_rof_drank", specialty_rof_drank );
incrementcounter( "global_zm_specialty_deadshot_drank", specialty_deadshot_drank );
incrementcounter( "global_zm_specialty_scavenger_drank", specialty_scavenger_drank );
incrementcounter( "global_zm_specialty_flakjacket_drank", specialty_flakjacket_drank );
incrementcounter( "global_zm_specialty_additionalprimaryweapon_drank", specialty_additionalprimaryweapon_drank );
incrementcounter( "global_zm_specialty_finalstand_drank", specialty_finalstand_drank );
incrementcounter( "global_zm_specialty_grenadepulldeath_drank", specialty_grenadepulldeath_drank );
incrementcounter( "global_zm_" + "specialty_nomotionsensor", perk_vulture_drank );
incrementcounter( "global_zm_gibs", gibs );
incrementcounter( "global_zm_distance_traveled", int( distance_traveled ) );
incrementcounter( "global_zm_doors_purchased", doors_purchased );
incrementcounter( "global_zm_boards", boards );
incrementcounter( "global_zm_sacrifices", sacrifices );
incrementcounter( "global_zm_drops", drops );
incrementcounter( "global_zm_total_nuke_pickedup", nuke_pickedup );
incrementcounter( "global_zm_total_insta_kill_pickedup", insta_kill_pickedup );
incrementcounter( "global_zm_total_full_ammo_pickedup", full_ammo_pickedup );
incrementcounter( "global_zm_total_double_points_pickedup", double_points_pickedup );
incrementcounter( "global_zm_total_meat_stink_pickedup", double_points_pickedup );
incrementcounter( "global_zm_total_carpenter_pickedup", carpenter_pickedup );
incrementcounter( "global_zm_total_fire_sale_pickedup", fire_sale_pickedup );
incrementcounter( "global_zm_use_magicbox", use_magicbox );
incrementcounter( "global_zm_grabbed_from_magicbox", grabbed_from_magicbox );
incrementcounter( "global_zm_use_pap", use_pap );
incrementcounter( "global_zm_pap_weapon_grabbed", pap_weapon_grabbed );
incrementcounter( "global_zm_claymores_planted", claymores_planted );
incrementcounter( "global_zm_claymores_pickedup", claymores_pickedup );
incrementcounter( "global_zm_ballistic_knives_pickedup", ballistic_knives_pickedup );
incrementcounter( "global_zm_wallbuy_weapons_purchased", wallbuy_weapons_purchased );
incrementcounter( "global_zm_power_turnedon", power_turnedon );
incrementcounter( "global_zm_power_turnedoff", power_turnedoff );
incrementcounter( "global_zm_planted_buildables_pickedup", planted_buildables_pickedup );
incrementcounter( "global_zm_buildables_built", buildables_built );
incrementcounter( "global_zm_ammo_purchased", ammo_purchased );
incrementcounter( "global_zm_upgraded_ammo_purchased", upgraded_ammo_purchased );
incrementcounter( "global_zm_total_shots", total_shots );
incrementcounter( "global_zm_time_played", time_played );
incrementcounter( "global_zm_contaminations_received", contaminations_received );
incrementcounter( "global_zm_contaminations_given", contaminations_given );
incrementcounter( "global_zm_cheat_players_too_friendly", cheat_too_friendly );
incrementcounter( "global_zm_cheats_cheat_too_many_weapons", cheat_too_many_weapons );
incrementcounter( "global_zm_cheats_out_of_playable", cheat_out_of_playable_area );
incrementcounter( "global_zm_total_cheats", cheat_total );
}
get_specific_stat( stat_category, stat_name )
{
return self getdstat( stat_category, stat_name, "StatValue" );
}
do_stats_for_gibs( zombie, limb_tags_array )
{
while ( isDefined( zombie ) && isDefined( zombie.attacker ) && isplayer( zombie.attacker ) )
{
_a780 = limb_tags_array;
_k780 = getFirstArrayKey( _a780 );
while ( isDefined( _k780 ) )
{
limb = _a780[ _k780 ];
stat_name = undefined;
if ( limb == level._zombie_gib_piece_index_right_arm )
{
stat_name = "right_arm_gibs";
}
else if ( limb == level._zombie_gib_piece_index_left_arm )
{
stat_name = "left_arm_gibs";
}
else if ( limb == level._zombie_gib_piece_index_right_leg )
{
stat_name = "right_leg_gibs";
}
else if ( limb == level._zombie_gib_piece_index_left_leg )
{
stat_name = "left_leg_gibs";
}
else
{
if ( limb == level._zombie_gib_piece_index_head )
{
stat_name = "head_gibs";
}
}
if ( !isDefined( stat_name ) )
{
}
else
{
zombie.attacker increment_client_stat( stat_name, 0 );
zombie.attacker increment_client_stat( "gibs" );
}
_k780 = getNextArrayKey( _a780, _k780 );
}
}
}
initializematchstats()
{
if ( !level.onlinegame || !gamemodeismode( level.gamemode_public_match ) )
{
return;
}
self.pers[ "lastHighestScore" ] = self getdstat( "HighestStats", "highest_score" );
currgametype = level.gametype;
self gamehistorystartmatch( getgametypeenumfromname( currgametype, 0 ) );
}
adjustrecentstats()
{
/#
if ( getDvarInt( "scr_writeConfigStrings" ) == 1 || getDvarInt( "scr_hostmigrationtest" ) == 1 )
{
return;
#/
}
initializematchstats();
}
uploadstatssoon()
{
self notify( "upload_stats_soon" );
self endon( "upload_stats_soon" );
self endon( "disconnect" );
wait 1;
uploadstats( self );
}

79
zm_transit_dr_patch/maps/mp/zombies/_zm_timer.gsc Normal file
View File

@ -0,0 +1,79 @@
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
precacheshader( "zombie_stopwatchneedle" );
precacheshader( "zombie_stopwatch" );
precacheshader( "zombie_stopwatch_glass" );
if ( !isDefined( level.stopwatch_length_width ) )
{
level.stopwatch_length_width = 96;
}
}
start_timer( time, stop_notify )
{
self notify( "stop_prev_timer" );
self endon( "stop_prev_timer" );
if ( !isDefined( self.stopwatch_elem ) )
{
self.stopwatch_elem = newclienthudelem( self );
self.stopwatch_elem.horzalign = "left";
self.stopwatch_elem.vertalign = "top";
self.stopwatch_elem.alignx = "left";
self.stopwatch_elem.aligny = "top";
self.stopwatch_elem.x = 10;
self.stopwatch_elem.alpha = 0;
self.stopwatch_elem.sort = 2;
self.stopwatch_elem_glass = newclienthudelem( self );
self.stopwatch_elem_glass.horzalign = "left";
self.stopwatch_elem_glass.vertalign = "top";
self.stopwatch_elem_glass.alignx = "left";
self.stopwatch_elem_glass.aligny = "top";
self.stopwatch_elem_glass.x = 10;
self.stopwatch_elem_glass.alpha = 0;
self.stopwatch_elem_glass.sort = 3;
self.stopwatch_elem_glass setshader( "zombie_stopwatch_glass", level.stopwatch_length_width, level.stopwatch_length_width );
}
self thread update_hud_position();
if ( isDefined( stop_notify ) )
{
self thread wait_for_stop_notify( stop_notify );
}
if ( time > 60 )
{
time = 0;
}
self.stopwatch_elem setclock( time, 60, "zombie_stopwatch", level.stopwatch_length_width, level.stopwatch_length_width );
self.stopwatch_elem.alpha = 1;
self.stopwatch_elem_glass.alpha = 1;
wait time;
self notify( "countdown_finished" );
wait 1;
self.stopwatch_elem.alpha = 0;
self.stopwatch_elem_glass.alpha = 0;
}
wait_for_stop_notify( stop_notify )
{
self endon( "stop_prev_timer" );
self endon( "countdown_finished" );
self waittill( stop_notify );
self.stopwatch_elem.alpha = 0;
self.stopwatch_elem_glass.alpha = 0;
}
update_hud_position()
{
self endon( "disconnect" );
self endon( "stop_prev_timer" );
self endon( "countdown_finished" );
while ( 1 )
{
self.stopwatch_elem.y = 20;
self.stopwatch_elem_glass.y = 20;
wait 0,05;
}
}

479
zm_transit_dr_patch/maps/mp/zombies/_zm_tombstone.gsc Normal file
View File

@ -0,0 +1,479 @@
#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_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();
}
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;
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_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;
_a118 = primaries;
index = getFirstArrayKey( _a118 );
while ( isDefined( index ) )
{
weapon = _a118[ index ];
dc.weapon[ index ] = weapon;
dc.stockcount[ index ] = self getweaponammostock( weapon );
if ( weapon == currentweapon )
{
dc.current_weapon = index;
}
index = getNextArrayKey( _a118, 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;
_a242 = tombstone_machine_triggers;
_k242 = getFirstArrayKey( _a242 );
while ( isDefined( _k242 ) )
{
trigger = _a242[ _k242 ];
if ( isDefined( trigger.power_on ) || trigger.power_on && isDefined( trigger.turbine_power_on ) && trigger.turbine_power_on )
{
istombstonepowered = 1;
}
_k242 = getNextArrayKey( _a242, _k242 );
}
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 )
{
_a294 = primaries;
_k294 = getFirstArrayKey( _a294 );
while ( isDefined( _k294 ) )
{
weapon = _a294[ _k294 ];
self takeweapon( weapon );
_k294 = getNextArrayKey( _a294, _k294 );
}
}
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 set_player_melee_weapon( weapon_name );
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" );
_a564 = tombstones;
_k564 = getFirstArrayKey( _a564 );
while ( isDefined( _k564 ) )
{
model = _a564[ _k564 ];
playfxontag( level._effect[ "powerup_on" ], model, "tag_origin" );
_k564 = getNextArrayKey( _a564, _k564 );
}
}
}

897
zm_transit_dr_patch/maps/mp/zombies/_zm_traps.gsc Normal file
View File

@ -0,0 +1,897 @@
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/animscripts/zm_death;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_net;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
level.trap_kills = 0;
traps = getentarray( "zombie_trap", "targetname" );
array_thread( traps, ::trap_init );
level.burning_zombies = [];
level.elec_trap_time = 40;
level.elec_trap_cooldown_time = 60;
}
trap_init()
{
self ent_flag_init( "flag_active" );
self ent_flag_init( "flag_cooldown" );
self._trap_type = "";
if ( isDefined( self.script_noteworthy ) )
{
self._trap_type = self.script_noteworthy;
if ( isDefined( level._zombiemode_trap_activate_funcs ) && isDefined( level._zombiemode_trap_activate_funcs[ self._trap_type ] ) )
{
self._trap_activate_func = level._zombiemode_trap_activate_funcs[ self._trap_type ];
break;
}
else
{
switch( self.script_noteworthy )
{
case "rotating":
self._trap_activate_func = ::trap_activate_rotating;
break;
case "electric":
self._trap_activate_func = ::trap_activate_electric;
break;
case "flipper":
self._trap_activate_func = ::trap_activate_flipper;
break;
case "fire":
default:
self._trap_activate_func = ::trap_activate_fire;
}
}
if ( isDefined( level._zombiemode_trap_use_funcs ) && isDefined( level._zombiemode_trap_use_funcs[ self._trap_type ] ) )
{
self._trap_use_func = level._zombiemode_trap_use_funcs[ self._trap_type ];
}
else
{
self._trap_use_func = ::trap_use_think;
}
}
self trap_model_type_init();
self._trap_use_trigs = [];
self._trap_lights = [];
self._trap_movers = [];
self._trap_switches = [];
components = getentarray( self.target, "targetname" );
i = 0;
while ( i < components.size )
{
if ( isDefined( components[ i ].script_noteworthy ) )
{
switch( components[ i ].script_noteworthy )
{
case "counter_1s":
self.counter_1s = components[ i ];
break;
i++;
continue;
case "counter_10s":
self.counter_10s = components[ i ];
break;
i++;
continue;
case "counter_100s":
self.counter_100s = components[ i ];
break;
i++;
continue;
case "mover":
self._trap_movers[ self._trap_movers.size ] = components[ i ];
break;
i++;
continue;
case "switch":
self._trap_switches[ self._trap_switches.size ] = components[ i ];
break;
i++;
continue;
case "light":
self._trap_lightes[ self._trap_lightes.size ] = components[ i ];
break;
i++;
continue;
}
}
if ( isDefined( components[ i ].script_string ) )
{
switch( components[ i ].script_string )
{
case "flipper1":
self.flipper1 = components[ i ];
break;
i++;
continue;
case "flipper2":
self.flipper2 = components[ i ];
break;
i++;
continue;
case "flipper1_radius_check":
self.flipper1_radius_check = components[ i ];
break;
i++;
continue;
case "flipper2_radius_check":
self.flipper2_radius_check = components[ i ];
break;
i++;
continue;
case "target1":
self.target1 = components[ i ];
break;
i++;
continue;
case "target2":
self.target2 = components[ i ];
break;
i++;
continue;
case "target3":
self.target3 = components[ i ];
break;
i++;
continue;
}
}
switch( components[ i ].classname )
{
case "trigger_use":
self._trap_use_trigs[ self._trap_use_trigs.size ] = components[ i ];
break;
i++;
continue;
case "script_model":
if ( components[ i ].model == self._trap_light_model_off )
{
self._trap_lights[ self._trap_lights.size ] = components[ i ];
}
else if ( components[ i ].model == self._trap_switch_model )
{
self._trap_switches[ self._trap_switches.size ] = components[ i ];
}
}
i++;
}
self._trap_fx_structs = [];
components = getstructarray( self.target, "targetname" );
i = 0;
while ( i < components.size )
{
if ( isDefined( components[ i ].script_string ) && components[ i ].script_string == "use_this_angle" )
{
self.use_this_angle = components[ i ];
i++;
continue;
}
else
{
self._trap_fx_structs[ self._trap_fx_structs.size ] = components[ i ];
}
i++;
}
/#
assert( self._trap_use_trigs.size > 0, "_zm_traps::init no use triggers found for " + self.target );
#/
if ( !isDefined( self.zombie_cost ) )
{
self.zombie_cost = 1000;
}
self._trap_in_use = 0;
self._trap_cooling_down = 0;
self thread trap_dialog();
flag_wait( "start_zombie_round_logic" );
self trap_lights_red();
i = 0;
while ( i < self._trap_use_trigs.size )
{
self._trap_use_trigs[ i ] setcursorhint( "HINT_NOICON" );
i++;
}
if ( !isDefined( self.script_flag_wait ) )
{
self trap_set_string( &"ZOMBIE_NEED_POWER" );
flag_wait( "power_on" );
}
else
{
if ( !isDefined( level.flag[ self.script_flag_wait ] ) )
{
flag_init( self.script_flag_wait );
}
flag_wait( self.script_flag_wait );
}
self trap_set_string( &"ZOMBIE_BUTTON_BUY_TRAP", self.zombie_cost );
self trap_lights_green();
i = 0;
while ( i < self._trap_use_trigs.size )
{
self._trap_use_trigs[ i ] thread [[ self._trap_use_func ]]( self );
i++;
}
}
trap_use_think( trap )
{
for ( ;; )
{
while ( 1 )
{
self waittill( "trigger", who );
while ( who in_revive_trigger() )
{
continue;
}
if ( is_player_valid( who ) && !trap._trap_in_use )
{
players = get_players();
if ( players.size == 1 && who.score >= trap.zombie_cost )
{
who maps/mp/zombies/_zm_score::minus_to_player_score( trap.zombie_cost );
break;
}
else
{
if ( level.team_pool[ who.team_num ].score >= trap.zombie_cost )
{
who maps/mp/zombies/_zm_score::minus_to_team_score( trap.zombie_cost );
break;
}
else if ( ( level.team_pool[ who.team_num ].score + who.score ) >= trap.zombie_cost )
{
team_points = level.team_pool[ who.team_num ].score;
who maps/mp/zombies/_zm_score::minus_to_player_score( trap.zombie_cost - team_points );
who maps/mp/zombies/_zm_score::minus_to_team_score( team_points );
break;
}
else
{
}
}
}
trap._trap_in_use = 1;
trap trap_set_string( &"ZOMBIE_TRAP_ACTIVE" );
play_sound_at_pos( "purchase", who.origin );
if ( trap._trap_switches.size )
{
trap thread trap_move_switches();
trap waittill( "switch_activated" );
}
trap trigger_on();
trap thread [[ trap._trap_activate_func ]]();
trap waittill( "trap_done" );
trap trigger_off();
trap._trap_cooling_down = 1;
trap trap_set_string( &"ZOMBIE_TRAP_COOLDOWN" );
/#
if ( getDvarInt( "zombie_cheat" ) >= 1 )
{
trap._trap_cooldown_time = 5;
#/
}
wait trap._trap_cooldown_time;
trap._trap_cooling_down = 0;
trap notify( "available" );
trap._trap_in_use = 0;
trap trap_set_string( &"ZOMBIE_BUTTON_BUY_TRAP", trap.zombie_cost );
}
}
}
trap_lights_red()
{
i = 0;
while ( i < self._trap_lights.size )
{
light = self._trap_lights[ i ];
light setmodel( self._trap_light_model_red );
if ( isDefined( light.fx ) )
{
light.fx delete();
}
light.fx = maps/mp/zombies/_zm_net::network_safe_spawn( "trap_lights_red", 2, "script_model", light.origin );
light.fx setmodel( "tag_origin" );
light.fx.angles = light.angles;
playfxontag( level._effect[ "zapper_light_notready" ], light.fx, "tag_origin" );
i++;
}
}
trap_lights_green()
{
i = 0;
while ( i < self._trap_lights.size )
{
light = self._trap_lights[ i ];
if ( isDefined( light._switch_disabled ) )
{
i++;
continue;
}
else
{
light setmodel( self._trap_light_model_green );
if ( isDefined( light.fx ) )
{
light.fx delete();
}
light.fx = maps/mp/zombies/_zm_net::network_safe_spawn( "trap_lights_green", 2, "script_model", light.origin );
light.fx setmodel( "tag_origin" );
light.fx.angles = light.angles;
playfxontag( level._effect[ "zapper_light_ready" ], light.fx, "tag_origin" );
}
i++;
}
}
trap_set_string( string, param1, param2 )
{
i = 0;
while ( i < self._trap_use_trigs.size )
{
if ( !isDefined( param1 ) )
{
self._trap_use_trigs[ i ] sethintstring( string );
i++;
continue;
}
else if ( !isDefined( param2 ) )
{
self._trap_use_trigs[ i ] sethintstring( string, param1 );
i++;
continue;
}
else
{
self._trap_use_trigs[ i ] sethintstring( string, param1, param2 );
}
i++;
}
}
trap_move_switches()
{
self trap_lights_red();
i = 0;
while ( i < self._trap_switches.size )
{
self._trap_switches[ i ] rotatepitch( 180, 0,5 );
self._trap_switches[ i ] playsound( "amb_sparks_l_b" );
i++;
}
self._trap_switches[ 0 ] waittill( "rotatedone" );
self notify( "switch_activated" );
self waittill( "available" );
i = 0;
while ( i < self._trap_switches.size )
{
self._trap_switches[ i ] rotatepitch( -180, 0,5 );
i++;
}
self._trap_switches[ 0 ] waittill( "rotatedone" );
self trap_lights_green();
}
trap_activate_electric()
{
self._trap_duration = 40;
self._trap_cooldown_time = 60;
self notify( "trap_activate" );
if ( isDefined( self.script_string ) )
{
number = int( self.script_string );
if ( number != 0 )
{
exploder( number );
}
else
{
clientnotify( self.script_string + "1" );
}
}
fx_points = getstructarray( self.target, "targetname" );
i = 0;
while ( i < fx_points.size )
{
wait_network_frame();
fx_points[ i ] thread trap_audio_fx( self );
i++;
}
self thread trap_damage();
wait self._trap_duration;
self notify( "trap_done" );
if ( isDefined( self.script_string ) )
{
clientnotify( self.script_string + "0" );
}
}
trap_activate_fire()
{
self._trap_duration = 40;
self._trap_cooldown_time = 60;
clientnotify( self.script_string + "1" );
clientnotify( self.script_parameters );
fx_points = getstructarray( self.target, "targetname" );
i = 0;
while ( i < fx_points.size )
{
wait_network_frame();
fx_points[ i ] thread trap_audio_fx( self );
i++;
}
self thread trap_damage();
wait self._trap_duration;
self notify( "trap_done" );
clientnotify( self.script_string + "0" );
clientnotify( self.script_parameters );
}
trap_activate_rotating()
{
self endon( "trap_done" );
self._trap_duration = 30;
self._trap_cooldown_time = 60;
self thread trap_damage();
self thread trig_update( self._trap_movers[ 0 ] );
old_angles = self._trap_movers[ 0 ].angles;
i = 0;
while ( i < self._trap_movers.size )
{
self._trap_movers[ i ] rotateyaw( 360, 5, 4,5 );
i++;
}
wait 5;
step = 1,5;
t = 0;
while ( t < self._trap_duration )
{
i = 0;
while ( i < self._trap_movers.size )
{
self._trap_movers[ i ] rotateyaw( 360, step );
i++;
}
wait step;
t += step;
}
i = 0;
while ( i < self._trap_movers.size )
{
self._trap_movers[ i ] rotateyaw( 360, 5, 0, 4,5 );
i++;
}
wait 5;
i = 0;
while ( i < self._trap_movers.size )
{
self._trap_movers[ i ].angles = old_angles;
i++;
}
self notify( "trap_done" );
}
trap_activate_flipper()
{
}
trap_audio_fx( trap )
{
sound_origin = undefined;
if ( trap.script_noteworthy == "electric" )
{
sound_origin = spawn( "script_origin", self.origin );
sound_origin playsound( "zmb_elec_start" );
sound_origin playloopsound( "zmb_elec_loop" );
self thread play_electrical_sound( trap );
}
else
{
if ( trap.script_noteworthy == "fire" )
{
sound_origin = spawn( "script_origin", self.origin );
sound_origin playsound( "zmb_firetrap_start" );
sound_origin playloopsound( "zmb_firetrap_loop" );
}
}
trap waittill_any_or_timeout( trap._trap_duration, "trap_done" );
if ( isDefined( sound_origin ) )
{
if ( trap.script_noteworthy == "fire" )
{
playsoundatposition( "zmb_firetrap_end", sound_origin.origin );
}
sound_origin stoploopsound();
wait 0,05;
sound_origin delete();
}
}
play_electrical_sound( trap )
{
trap endon( "trap_done" );
while ( 1 )
{
wait randomfloatrange( 0,1, 0,5 );
playsoundatposition( "zmb_elec_arc", self.origin );
}
}
trap_damage()
{
self endon( "trap_done" );
while ( 1 )
{
self waittill( "trigger", ent );
if ( isplayer( ent ) )
{
switch( self._trap_type )
{
case "electric":
ent thread player_elec_damage();
break;
case "fire":
case "rocket":
ent thread player_fire_damage();
break;
case "rotating":
if ( ent getstance() == "stand" )
{
ent dodamage( 50, ent.origin + vectorScale( ( 0, 0, 1 ), 20 ) );
ent setstance( "crouch" );
}
break;
}
break;
continue;
}
else if ( !isDefined( ent.marked_for_death ) )
{
switch( self._trap_type )
{
case "rocket":
ent thread zombie_trap_death( self, 100 );
break;
break;
case "rotating":
ent thread zombie_trap_death( self, 200 );
break;
break;
case "electric":
case "fire":
default:
ent thread zombie_trap_death( self, randomint( 100 ) );
break;
break;
}
}
}
}
trig_update( parent )
{
self endon( "trap_done" );
start_angles = self.angles;
while ( 1 )
{
self.angles = parent.angles;
wait 0,05;
}
}
player_elec_damage()
{
self endon( "death" );
self endon( "disconnect" );
if ( !isDefined( level.elec_loop ) )
{
level.elec_loop = 0;
}
if ( !isDefined( self.is_burning ) && is_player_valid( self ) )
{
self.is_burning = 1;
self setelectrified( 1,25 );
shocktime = 2,5;
self shellshock( "electrocution", shocktime );
if ( level.elec_loop == 0 )
{
elec_loop = 1;
self playsound( "zmb_zombie_arc" );
}
if ( !self hasperk( "specialty_armorvest" ) || ( self.health - 100 ) < 1 )
{
radiusdamage( self.origin, 10, self.health + 100, self.health + 100 );
self.is_burning = undefined;
return;
}
else
{
self dodamage( 50, self.origin );
wait 0,1;
self.is_burning = undefined;
}
}
}
player_fire_damage()
{
self endon( "death" );
self endon( "disconnect" );
if ( !isDefined( self.is_burning ) && !self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
self.is_burning = 1;
self setburn( 1,25 );
self notify( "burned" );
if ( !self hasperk( "specialty_armorvest" ) || ( self.health - 100 ) < 1 )
{
radiusdamage( self.origin, 10, self.health + 100, self.health + 100 );
self.is_burning = undefined;
return;
}
else
{
self dodamage( 50, self.origin );
wait 0,1;
self.is_burning = undefined;
}
}
}
zombie_trap_death( trap, param )
{
self endon( "death" );
self.marked_for_death = 1;
switch( trap._trap_type )
{
case "electric":
case "fire":
case "rocket":
if ( isDefined( self.animname ) && self.animname != "zombie_dog" )
{
if ( param > 90 && level.burning_zombies.size < 6 )
{
level.burning_zombies[ level.burning_zombies.size ] = self;
self thread zombie_flame_watch();
self playsound( "ignite" );
self thread maps/mp/animscripts/zm_death::flame_death_fx();
playfxontag( level._effect[ "character_fire_death_torso" ], self, "J_SpineLower" );
wait randomfloat( 1,25 );
}
else
{
refs[ 0 ] = "guts";
refs[ 1 ] = "right_arm";
refs[ 2 ] = "left_arm";
refs[ 3 ] = "right_leg";
refs[ 4 ] = "left_leg";
refs[ 5 ] = "no_legs";
refs[ 6 ] = "head";
self.a.gib_ref = refs[ randomint( refs.size ) ];
playsoundatposition( "zmb_zombie_arc", self.origin );
if ( trap._trap_type == "electric" )
{
if ( randomint( 100 ) > 50 )
{
self thread electroctute_death_fx();
self thread play_elec_vocals();
}
}
wait randomfloat( 1,25 );
self playsound( "zmb_zombie_arc" );
}
}
if ( isDefined( self.fire_damage_func ) )
{
self [[ self.fire_damage_func ]]( trap );
}
else
{
level notify( "trap_kill" );
self dodamage( self.health + 666, self.origin, trap );
}
break;
case "centrifuge":
case "rotating":
ang = vectorToAngle( trap.origin - self.origin );
direction_vec = vectorScale( anglesToRight( ang ), param );
if ( isDefined( self.trap_reaction_func ) )
{
self [[ self.trap_reaction_func ]]( trap );
}
level notify( "trap_kill" );
self startragdoll();
self launchragdoll( direction_vec );
wait_network_frame();
self.a.gib_ref = "head";
self dodamage( self.health, self.origin, trap );
break;
}
}
zombie_flame_watch()
{
self waittill( "death" );
self stoploopsound();
arrayremovevalue( level.burning_zombies, self );
}
play_elec_vocals()
{
if ( isDefined( self ) )
{
org = self.origin;
wait 0,15;
playsoundatposition( "zmb_elec_vocals", org );
playsoundatposition( "zmb_zombie_arc", org );
playsoundatposition( "zmb_exp_jib_zombie", org );
}
}
electroctute_death_fx()
{
self endon( "death" );
if ( isDefined( self.is_electrocuted ) && self.is_electrocuted )
{
return;
}
self.is_electrocuted = 1;
self thread electrocute_timeout();
if ( self.team == level.zombie_team )
{
level.bconfiretime = getTime();
level.bconfireorg = self.origin;
}
if ( isDefined( level._effect[ "elec_torso" ] ) )
{
playfxontag( level._effect[ "elec_torso" ], self, "J_SpineLower" );
}
self playsound( "zmb_elec_jib_zombie" );
wait 1;
tagarray = [];
tagarray[ 0 ] = "J_Elbow_LE";
tagarray[ 1 ] = "J_Elbow_RI";
tagarray[ 2 ] = "J_Knee_RI";
tagarray[ 3 ] = "J_Knee_LE";
tagarray = array_randomize( tagarray );
if ( isDefined( level._effect[ "elec_md" ] ) )
{
playfxontag( level._effect[ "elec_md" ], self, tagarray[ 0 ] );
}
self playsound( "zmb_elec_jib_zombie" );
wait 1;
self playsound( "zmb_elec_jib_zombie" );
tagarray[ 0 ] = "J_Wrist_RI";
tagarray[ 1 ] = "J_Wrist_LE";
if ( !isDefined( self.a.gib_ref ) || self.a.gib_ref != "no_legs" )
{
tagarray[ 2 ] = "J_Ankle_RI";
tagarray[ 3 ] = "J_Ankle_LE";
}
tagarray = array_randomize( tagarray );
if ( isDefined( level._effect[ "elec_sm" ] ) )
{
playfxontag( level._effect[ "elec_sm" ], self, tagarray[ 0 ] );
playfxontag( level._effect[ "elec_sm" ], self, tagarray[ 1 ] );
}
}
electrocute_timeout()
{
self endon( "death" );
self playloopsound( "fire_manager_0" );
wait 12;
self stoploopsound();
if ( isDefined( self ) && isalive( self ) )
{
self.is_electrocuted = 0;
self notify( "stop_flame_damage" );
}
}
trap_dialog()
{
self endon( "warning_dialog" );
level endon( "switch_flipped" );
timer = 0;
while ( 1 )
{
wait 0,5;
players = get_players();
i = 0;
while ( i < players.size )
{
dist = distancesquared( players[ i ].origin, self.origin );
if ( dist > 4900 )
{
timer = 0;
i++;
continue;
}
else
{
if ( dist < 4900 && timer < 3 )
{
wait 0,5;
timer++;
}
if ( dist < 4900 && timer == 3 )
{
index = maps/mp/zombies/_zm_weapons::get_player_index( players[ i ] );
plr = "plr_" + index + "_";
wait 3;
self notify( "warning_dialog" );
}
}
i++;
}
}
}
get_trap_array( trap_type )
{
ents = getentarray( "zombie_trap", "targetname" );
traps = [];
i = 0;
while ( i < ents.size )
{
if ( ents[ i ].script_noteworthy == trap_type )
{
traps[ traps.size ] = ents[ i ];
}
i++;
}
return traps;
}
trap_disable()
{
cooldown = self._trap_cooldown_time;
if ( self._trap_in_use )
{
self notify( "trap_done" );
self._trap_cooldown_time = 0,05;
self waittill( "available" );
}
array_thread( self._trap_use_trigs, ::trigger_off );
self trap_lights_red();
self._trap_cooldown_time = cooldown;
}
trap_enable()
{
array_thread( self._trap_use_trigs, ::trigger_on );
self trap_lights_green();
}
trap_model_type_init()
{
if ( !isDefined( self.script_parameters ) )
{
self.script_parameters = "default";
}
switch( self.script_parameters )
{
case "pentagon_electric":
self._trap_light_model_off = "zombie_trap_switch_light";
self._trap_light_model_green = "zombie_trap_switch_light_on_green";
self._trap_light_model_red = "zombie_trap_switch_light_on_red";
self._trap_switch_model = "zombie_trap_switch_handle";
break;
case "default":
default:
self._trap_light_model_off = "zombie_zapper_cagelight";
self._trap_light_model_green = "zombie_zapper_cagelight_green";
self._trap_light_model_red = "zombie_zapper_cagelight_red";
self._trap_switch_model = "zombie_zapper_handle";
break;
}
}

431
zm_transit_dr_patch/maps/mp/zombies/_zm_turned.gsc Normal file
View File

@ -0,0 +1,431 @@
#include maps/mp/gametypes_zm/_spawnlogic;
#include maps/mp/zombies/_zm_audio;
#include maps/mp/gametypes_zm/_zm_gametype;
#include maps/mp/_visionset_mgr;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
level.turnedmeleeweapon = "zombiemelee_zm";
level.turnedmeleeweapon_dw = "zombiemelee_dw";
precacheitem( level.turnedmeleeweapon );
precacheitem( level.turnedmeleeweapon_dw );
precachemodel( "c_zom_player_zombie_fb" );
precachemodel( "c_zom_zombie_viewhands" );
if ( !isDefined( level.vsmgr_prio_visionset_zombie_turned ) )
{
level.vsmgr_prio_visionset_zombie_turned = 123;
}
maps/mp/_visionset_mgr::vsmgr_register_info( "visionset", "zm_turned", 3000, level.vsmgr_prio_visionset_zombie_turned, 1, 1 );
registerclientfield( "toplayer", "turned_ir", 3000, 1, "int" );
registerclientfield( "allplayers", "player_has_eyes", 3000, 1, "int" );
registerclientfield( "allplayers", "player_eyes_special", 5000, 1, "int" );
level._effect[ "player_eye_glow" ] = loadfx( "maps/zombie/fx_zombie_eye_returned_blue" );
level._effect[ "player_eye_glow_orng" ] = loadfx( "maps/zombie/fx_zombie_eye_returned_orng" );
thread setup_zombie_exerts();
}
setup_zombie_exerts()
{
wait 0,05;
level.exert_sounds[ 1 ][ "burp" ] = "null";
level.exert_sounds[ 1 ][ "hitmed" ] = "null";
level.exert_sounds[ 1 ][ "hitlrg" ] = "null";
}
delay_turning_on_eyes()
{
self endon( "death" );
self endon( "disconnect" );
wait_network_frame();
wait 0,1;
self setclientfield( "player_has_eyes", 1 );
}
turn_to_zombie()
{
if ( self.sessionstate == "playing" && isDefined( self.is_zombie ) && self.is_zombie && isDefined( self.laststand ) && !self.laststand )
{
return;
}
if ( isDefined( self.is_in_process_of_zombify ) && self.is_in_process_of_zombify )
{
return;
}
while ( isDefined( self.is_in_process_of_humanify ) && self.is_in_process_of_humanify )
{
wait 0,1;
}
if ( !flag( "pregame" ) )
{
self playsoundtoplayer( "evt_spawn", self );
playsoundatposition( "evt_disappear_3d", self.origin );
if ( !self.is_zombie )
{
playsoundatposition( "vox_plr_" + randomintrange( 0, 4 ) + "_exert_death_high_" + randomintrange( 0, 4 ), self.origin );
}
}
self._can_score = 1;
self setclientfield( "player_has_eyes", 0 );
self ghost();
self turned_disable_player_weapons();
self notify( "clear_red_flashing_overlay" );
self notify( "zombify" );
self.is_in_process_of_zombify = 1;
self.team = level.zombie_team;
self.pers[ "team" ] = level.zombie_team;
self.sessionteam = level.zombie_team;
wait_network_frame();
self maps/mp/gametypes_zm/_zm_gametype::onspawnplayer();
self freezecontrols( 1 );
self.is_zombie = 1;
self setburn( 0 );
if ( isDefined( self.turned_visionset ) && self.turned_visionset )
{
maps/mp/_visionset_mgr::vsmgr_deactivate( "visionset", "zm_turned", self );
wait_network_frame();
wait_network_frame();
if ( !isDefined( self ) )
{
return;
}
}
maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_turned", self );
self.turned_visionset = 1;
self setclientfieldtoplayer( "turned_ir", 1 );
self maps/mp/zombies/_zm_audio::setexertvoice( 1 );
self.laststand = undefined;
wait_network_frame();
if ( !isDefined( self ) )
{
return;
}
self enableweapons();
self show();
playsoundatposition( "evt_appear_3d", self.origin );
playsoundatposition( "zmb_zombie_spawn", self.origin );
self thread delay_turning_on_eyes();
self thread turned_player_buttons();
self setperk( "specialty_noname" );
self setperk( "specialty_unlimitedsprint" );
self setperk( "specialty_fallheight" );
self turned_give_melee_weapon();
self setmovespeedscale( 1 );
self.animname = "zombie";
self disableoffhandweapons();
self allowstand( 1 );
self allowprone( 0 );
self allowcrouch( 0 );
self allowads( 0 );
self allowjump( 0 );
self disableweaponcycling();
self setmovespeedscale( 1 );
self setsprintduration( 4 );
self setsprintcooldown( 0 );
self stopshellshock();
self.maxhealth = 256;
self.health = 256;
self.meleedamage = 1000;
self detachall();
self setmodel( "c_zom_player_zombie_fb" );
self.voice = "american";
self.skeleton = "base";
self setviewmodel( "c_zom_zombie_viewhands" );
self.shock_onpain = 0;
self disableinvulnerability();
if ( isDefined( level.player_movement_suppressed ) )
{
self freezecontrols( level.player_movement_suppressed );
}
else
{
self freezecontrols( 0 );
}
self.is_in_process_of_zombify = 0;
}
turn_to_human()
{
if ( self.sessionstate == "playing" && isDefined( self.is_zombie ) && !self.is_zombie && isDefined( self.laststand ) && !self.laststand )
{
return;
}
if ( isDefined( self.is_in_process_of_humanify ) && self.is_in_process_of_humanify )
{
return;
}
while ( isDefined( self.is_in_process_of_zombify ) && self.is_in_process_of_zombify )
{
wait 0,1;
}
self playsoundtoplayer( "evt_spawn", self );
playsoundatposition( "evt_disappear_3d", self.origin );
self setclientfield( "player_has_eyes", 0 );
self ghost();
self notify( "humanify" );
self.is_in_process_of_humanify = 1;
self.is_zombie = 0;
self notify( "clear_red_flashing_overlay" );
self.team = self.prevteam;
self.pers[ "team" ] = self.prevteam;
self.sessionteam = self.prevteam;
wait_network_frame();
self maps/mp/gametypes_zm/_zm_gametype::onspawnplayer();
self.maxhealth = 100;
self.health = 100;
self freezecontrols( 1 );
if ( self hasweapon( "death_throe_zm" ) )
{
self takeweapon( "death_throe_zm" );
}
self unsetperk( "specialty_noname" );
self unsetperk( "specialty_unlimitedsprint" );
self unsetperk( "specialty_fallheight" );
self turned_enable_player_weapons();
self maps/mp/zombies/_zm_audio::setexertvoice( 0 );
self.turned_visionset = 0;
maps/mp/_visionset_mgr::vsmgr_deactivate( "visionset", "zm_turned", self );
self setclientfieldtoplayer( "turned_ir", 0 );
self setmovespeedscale( 1 );
self.ignoreme = 0;
self.shock_onpain = 1;
self enableweaponcycling();
self allowstand( 1 );
self allowprone( 1 );
self allowcrouch( 1 );
self allowads( 1 );
self allowjump( 1 );
self turnedhuman();
self enableoffhandweapons();
self stopshellshock();
self.laststand = undefined;
self.is_burning = undefined;
self.meleedamage = undefined;
self detachall();
self [[ level.givecustomcharacters ]]();
if ( !self hasweapon( "knife_zm" ) )
{
self giveweapon( "knife_zm" );
}
wait_network_frame();
if ( !isDefined( self ) )
{
return;
}
self disableinvulnerability();
if ( isDefined( level.player_movement_suppressed ) )
{
self freezecontrols( level.player_movement_suppressed );
}
else
{
self freezecontrols( 0 );
}
self show();
playsoundatposition( "evt_appear_3d", self.origin );
self.is_in_process_of_humanify = 0;
}
deletezombiesinradius( origin )
{
zombies = get_round_enemy_array();
maxradius = 128;
_a301 = zombies;
_k301 = getFirstArrayKey( _a301 );
while ( isDefined( _k301 ) )
{
zombie = _a301[ _k301 ];
if ( isDefined( zombie ) && isalive( zombie ) && isDefined( zombie.is_being_used_as_spawner ) && !zombie.is_being_used_as_spawner )
{
if ( distancesquared( zombie.origin, origin ) < ( maxradius * maxradius ) )
{
playfx( level._effect[ "wood_chunk_destory" ], zombie.origin );
zombie thread silentlyremovezombie();
}
wait 0,05;
}
_k301 = getNextArrayKey( _a301, _k301 );
}
}
turned_give_melee_weapon()
{
/#
assert( isDefined( self.turnedmeleeweapon ) );
#/
/#
assert( self.turnedmeleeweapon != "none" );
#/
self.turned_had_knife = self hasweapon( "knife_zm" );
if ( isDefined( self.turned_had_knife ) && self.turned_had_knife )
{
self takeweapon( "knife_zm" );
}
self giveweapon( self.turnedmeleeweapon_dw );
self givemaxammo( self.turnedmeleeweapon_dw );
self giveweapon( self.turnedmeleeweapon );
self givemaxammo( self.turnedmeleeweapon );
self switchtoweapon( self.turnedmeleeweapon_dw );
self switchtoweapon( self.turnedmeleeweapon );
}
turned_player_buttons()
{
self endon( "disconnect" );
self endon( "humanify" );
level endon( "end_game" );
while ( isDefined( self.is_zombie ) && self.is_zombie )
{
while ( !self attackbuttonpressed() || self adsbuttonpressed() && self meleebuttonpressed() )
{
if ( cointoss() )
{
self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "attack", undefined );
}
while ( !self attackbuttonpressed() || self adsbuttonpressed() && self meleebuttonpressed() )
{
wait 0,05;
}
}
while ( self usebuttonpressed() )
{
self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "taunt", undefined );
while ( self usebuttonpressed() )
{
wait 0,05;
}
}
while ( self issprinting() )
{
while ( self issprinting() )
{
self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "sprint", undefined );
wait 0,05;
}
}
wait 0,05;
}
}
turned_disable_player_weapons()
{
if ( isDefined( self.is_zombie ) && self.is_zombie )
{
return;
}
weaponinventory = self getweaponslist();
self.lastactiveweapon = self getcurrentweapon();
self setlaststandprevweap( self.lastactiveweapon );
self.laststandpistol = undefined;
self.hadpistol = 0;
if ( !isDefined( self.turnedmeleeweapon ) )
{
self.turnedmeleeweapon = level.turnedmeleeweapon;
}
if ( !isDefined( self.turnedmeleeweapon_dw ) )
{
self.turnedmeleeweapon_dw = level.turnedmeleeweapon_dw;
}
self takeallweapons();
self disableweaponcycling();
}
turned_enable_player_weapons()
{
self takeallweapons();
self enableweaponcycling();
self enableoffhandweapons();
self.turned_had_knife = undefined;
if ( isDefined( level.humanify_custom_loadout ) )
{
self thread [[ level.humanify_custom_loadout ]]();
return;
}
else
{
if ( !self hasweapon( "rottweil72_zm" ) )
{
self giveweapon( "rottweil72_zm" );
self switchtoweapon( "rottweil72_zm" );
}
}
if ( isDefined( self.is_zombie ) && !self.is_zombie && !self hasweapon( level.start_weapon ) )
{
if ( !self hasweapon( "knife_zm" ) )
{
self giveweapon( "knife_zm" );
}
self give_start_weapon( 0 );
}
if ( self hasweapon( "rottweil72_zm" ) )
{
self setweaponammoclip( "rottweil72_zm", 2 );
self setweaponammostock( "rottweil72_zm", 0 );
}
if ( self hasweapon( level.start_weapon ) )
{
self givemaxammo( level.start_weapon );
}
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(), 2 );
}
get_farthest_available_zombie( player )
{
while ( 1 )
{
zombies = get_array_of_closest( player.origin, getaiarray( level.zombie_team ) );
x = 0;
while ( x < zombies.size )
{
zombie = zombies[ x ];
if ( isDefined( zombie ) && isalive( zombie ) && isDefined( zombie.in_the_ground ) && !zombie.in_the_ground && isDefined( zombie.gibbed ) && !zombie.gibbed && isDefined( zombie.head_gibbed ) && !zombie.head_gibbed && isDefined( zombie.is_being_used_as_spawnpoint ) && !zombie.is_being_used_as_spawnpoint && zombie in_playable_area() )
{
zombie.is_being_used_as_spawnpoint = 1;
return zombie;
}
x++;
}
wait 0,05;
}
}
get_available_human()
{
players = get_players();
_a512 = players;
_k512 = getFirstArrayKey( _a512 );
while ( isDefined( _k512 ) )
{
player = _a512[ _k512 ];
if ( isDefined( player.is_zombie ) && !player.is_zombie )
{
return player;
}
_k512 = getNextArrayKey( _a512, _k512 );
}
}
silentlyremovezombie()
{
self.skip_death_notetracks = 1;
self.nodeathragdoll = 1;
self dodamage( self.maxhealth * 2, self.origin, self, self, "none", "MOD_SUICIDE" );
self self_delete();
}
getspawnpoint()
{
spawnpoint = self maps/mp/gametypes_zm/_spawnlogic::getspawnpoint_dm( level._turned_zombie_respawnpoints );
return spawnpoint;
}

684
zm_transit_dr_patch/maps/mp/zombies/_zm_unitrigger.gsc Normal file
View File

@ -0,0 +1,684 @@
#include maps/mp/zombies/_zm_zonemgr;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
level._unitriggers = spawnstruct();
level._unitriggers._deferredinitlist = [];
level._unitriggers.trigger_pool = [];
level._unitriggers.trigger_stubs = [];
level._unitriggers.dynamic_stubs = [];
level._unitriggers.system_trigger_funcs = [];
stubs_keys = array( "unitrigger_radius", "unitrigger_radius_use", "unitrigger_box", "unitrigger_box_use" );
stubs = [];
i = 0;
while ( i < stubs_keys.size )
{
stubs = arraycombine( stubs, getstructarray( stubs_keys[ i ], "script_unitrigger_type" ), 1, 0 );
i++;
}
i = 0;
while ( i < stubs.size )
{
register_unitrigger( stubs[ i ] );
i++;
}
}
register_unitrigger_system_func( system, trigger_func )
{
level._unitriggers.system_trigger_funcs[ system ] = trigger_func;
}
unitrigger_force_per_player_triggers( unitrigger_stub, opt_on_off )
{
if ( !isDefined( opt_on_off ) )
{
opt_on_off = 1;
}
unitrigger_stub.trigger_per_player = opt_on_off;
}
unitrigger_trigger( player )
{
if ( self.trigger_per_player )
{
return self.playertrigger[ player getentitynumber() ];
}
else
{
return self.trigger;
}
}
unitrigger_origin()
{
if ( isDefined( self.originfunc ) )
{
origin = self [[ self.originfunc ]]();
}
else
{
origin = self.origin;
}
return origin;
}
register_unitrigger_internal( unitrigger_stub, trigger_func )
{
if ( !isDefined( unitrigger_stub.script_unitrigger_type ) )
{
/#
println( "Cannot register a unitrigger with no script_unitrigger_type. Ignoring." );
#/
return;
}
if ( isDefined( trigger_func ) )
{
unitrigger_stub.trigger_func = trigger_func;
}
else
{
if ( isDefined( unitrigger_stub.unitrigger_system ) && isDefined( level._unitriggers.system_trigger_funcs[ unitrigger_stub.unitrigger_system ] ) )
{
unitrigger_stub.trigger_func = level._unitriggers.system_trigger_funcs[ unitrigger_stub.unitrigger_system ];
}
}
switch( unitrigger_stub.script_unitrigger_type )
{
case "unitrigger_radius":
case "unitrigger_radius_use":
if ( !isDefined( unitrigger_stub.radius ) )
{
unitrigger_stub.radius = 32;
}
if ( !isDefined( unitrigger_stub.script_height ) )
{
unitrigger_stub.script_height = 64;
}
unitrigger_stub.test_radius_sq = ( unitrigger_stub.radius + 15 ) * ( unitrigger_stub.radius + 15 );
break;
case "unitrigger_box":
case "unitrigger_box_use":
if ( !isDefined( unitrigger_stub.script_width ) )
{
unitrigger_stub.script_width = 64;
}
if ( !isDefined( unitrigger_stub.script_height ) )
{
unitrigger_stub.script_height = 64;
}
if ( !isDefined( unitrigger_stub.script_length ) )
{
unitrigger_stub.script_length = 64;
}
box_radius = length( ( unitrigger_stub.script_width / 2, unitrigger_stub.script_length / 2, unitrigger_stub.script_height / 2 ) );
if ( !isDefined( unitrigger_stub.radius ) || unitrigger_stub.radius < box_radius )
{
unitrigger_stub.radius = box_radius;
}
unitrigger_stub.test_radius_sq = ( box_radius + 15 ) * ( box_radius + 15 );
break;
default:
/#
println( "Unknown unitrigger type registered : " + unitrigger_stub.targetname + " - ignoring." );
#/
return;
}
level._unitriggers.trigger_stubs[ level._unitriggers.trigger_stubs.size ] = unitrigger_stub;
unitrigger_stub.registered = 1;
}
register_unitrigger( unitrigger_stub, trigger_func )
{
register_unitrigger_internal( unitrigger_stub, trigger_func );
level._unitriggers.dynamic_stubs[ level._unitriggers.dynamic_stubs.size ] = unitrigger_stub;
}
unregister_unitrigger( unitrigger_stub )
{
if ( !isDefined( unitrigger_stub ) )
{
return;
}
unitrigger_stub.registered = 0;
if ( isDefined( unitrigger_stub.trigger_per_player ) && unitrigger_stub.trigger_per_player )
{
if ( isDefined( unitrigger_stub.playertrigger ) && unitrigger_stub.playertrigger.size > 0 )
{
keys = getarraykeys( unitrigger_stub.playertrigger );
_a160 = keys;
_k160 = getFirstArrayKey( _a160 );
while ( isDefined( _k160 ) )
{
key = _a160[ _k160 ];
trigger = unitrigger_stub.playertrigger[ key ];
trigger notify( "kill_trigger" );
if ( isDefined( trigger ) )
{
trigger delete();
}
_k160 = getNextArrayKey( _a160, _k160 );
}
unitrigger_stub.playertrigger = [];
}
}
else
{
if ( isDefined( unitrigger_stub.trigger ) )
{
trigger = unitrigger_stub.trigger;
trigger notify( "kill_trigger" );
trigger.stub.trigger = undefined;
trigger delete();
}
}
if ( isDefined( unitrigger_stub.in_zone ) )
{
arrayremovevalue( level.zones[ unitrigger_stub.in_zone ].unitrigger_stubs, unitrigger_stub );
}
arrayremovevalue( level._unitriggers.trigger_stubs, unitrigger_stub );
arrayremovevalue( level._unitriggers.dynamic_stubs, unitrigger_stub );
}
delay_delete_contact_ent()
{
self.last_used_time = 0;
while ( 1 )
{
wait 1;
if ( ( getTime() - self.last_used_time ) > 1000 )
{
self delete();
level._unitriggers.contact_ent = undefined;
return;
}
}
}
register_static_unitrigger( unitrigger_stub, trigger_func, recalculate_zone )
{
if ( level.zones.size == 0 )
{
unitrigger_stub.trigger_func = trigger_func;
level._unitriggers._deferredinitlist[ level._unitriggers._deferredinitlist.size ] = unitrigger_stub;
return;
}
if ( !isDefined( level._unitriggers.contact_ent ) )
{
level._unitriggers.contact_ent = spawn( "script_origin", ( 0, 0, 1 ) );
level._unitriggers.contact_ent thread delay_delete_contact_ent();
}
register_unitrigger_internal( unitrigger_stub, trigger_func );
while ( !isDefined( level._no_static_unitriggers ) )
{
level._unitriggers.contact_ent.last_used_time = getTime();
level._unitriggers.contact_ent.origin = unitrigger_stub.origin;
if ( isDefined( unitrigger_stub.in_zone ) && !isDefined( recalculate_zone ) )
{
level.zones[ unitrigger_stub.in_zone ].unitrigger_stubs[ level.zones[ unitrigger_stub.in_zone ].unitrigger_stubs.size ] = unitrigger_stub;
return;
}
keys = getarraykeys( level.zones );
i = 0;
while ( i < keys.size )
{
if ( level._unitriggers.contact_ent maps/mp/zombies/_zm_zonemgr::entity_in_zone( keys[ i ], 1 ) )
{
if ( !isDefined( level.zones[ keys[ i ] ].unitrigger_stubs ) )
{
level.zones[ keys[ i ] ].unitrigger_stubs = [];
}
level.zones[ keys[ i ] ].unitrigger_stubs[ level.zones[ keys[ i ] ].unitrigger_stubs.size ] = unitrigger_stub;
unitrigger_stub.in_zone = keys[ i ];
return;
}
i++;
}
}
level._unitriggers.dynamic_stubs[ level._unitriggers.dynamic_stubs.size ] = unitrigger_stub;
unitrigger_stub.registered = 1;
}
reregister_unitrigger_as_dynamic( unitrigger_stub )
{
unregister_unitrigger( unitrigger_stub );
register_unitrigger( unitrigger_stub, unitrigger_stub.trigger_func );
}
debug_unitriggers()
{
/#
while ( 1 )
{
while ( getDvar( #"D256F24B" ) != "" )
{
i = 0;
while ( i < level._unitriggers.trigger_stubs.size )
{
triggerstub = level._unitriggers.trigger_stubs[ i ];
color = vectorScale( ( 0, 0, 1 ), 0,75 );
if ( !isDefined( triggerstub.in_zone ) )
{
color = vectorScale( ( 0, 0, 1 ), 0,65 );
}
else
{
if ( level.zones[ triggerstub.in_zone ].is_active )
{
color = ( 0, 0, 1 );
}
}
if ( isDefined( triggerstub.trigger ) || isDefined( triggerstub.playertrigger ) && triggerstub.playertrigger.size > 0 )
{
color = ( 0, 0, 1 );
if ( isDefined( triggerstub.playertrigger ) && triggerstub.playertrigger.size > 0 )
{
print3d( triggerstub.origin, triggerstub.playertrigger.size, color, 1, 1, 1 );
}
}
origin = triggerstub unitrigger_origin();
switch( triggerstub.script_unitrigger_type )
{
case "unitrigger_radius":
case "unitrigger_radius_use":
if ( triggerstub.radius )
{
circle( origin, triggerstub.radius, color, 0, 0, 1 );
}
if ( triggerstub.script_height )
{
line( origin, origin + ( 0, 0, triggerstub.script_height ), color, 0, 1 );
}
break;
i++;
continue;
case "unitrigger_box":
case "unitrigger_box_use":
vec = ( triggerstub.script_width / 2, triggerstub.script_length / 2, triggerstub.script_height / 2 );
box( origin, vec * -1, vec, triggerstub.angles[ 1 ], color, 1, 0, 1 );
break;
i++;
continue;
}
i++;
}
}
wait 0,05;
#/
}
}
cleanup_trigger( trigger, player )
{
trigger notify( "kill_trigger" );
if ( isDefined( trigger.stub.trigger_per_player ) && trigger.stub.trigger_per_player )
{
}
else
{
trigger.stub.trigger = undefined;
}
trigger delete();
}
main()
{
level thread debug_unitriggers();
if ( level._unitriggers._deferredinitlist.size )
{
i = 0;
while ( i < level._unitriggers._deferredinitlist.size )
{
register_static_unitrigger( level._unitriggers._deferredinitlist[ i ], level._unitriggers._deferredinitlist[ i ].trigger_func );
i++;
}
i = 0;
while ( i < level._unitriggers._deferredinitlist.size )
{
i++;
}
level._unitriggers._deferredinitlist = undefined;
}
valid_range = 128;
valid_range_sq = valid_range * valid_range;
while ( !isDefined( level.active_zone_names ) )
{
wait 0,1;
}
while ( 1 )
{
active_zone_names = level.active_zone_names;
candidate_list = [];
j = 0;
while ( j < active_zone_names.size )
{
if ( isDefined( level.zones[ active_zone_names[ j ] ].unitrigger_stubs ) )
{
candidate_list = arraycombine( candidate_list, level.zones[ active_zone_names[ j ] ].unitrigger_stubs, 1, 0 );
}
j++;
}
candidate_list = arraycombine( candidate_list, level._unitriggers.dynamic_stubs, 1, 0 );
players = getplayers();
i = 0;
while ( i < players.size )
{
player = players[ i ];
if ( !is_player_valid( player ) )
{
i++;
continue;
}
else player_origin = player.origin + vectorScale( ( 0, 0, 1 ), 35 );
trigger = level._unitriggers.trigger_pool[ player getentitynumber() ];
if ( isDefined( trigger ) )
{
dst = valid_range_sq;
origin = trigger unitrigger_origin();
dst = trigger.stub.test_radius_sq;
if ( distance2dsquared( player_origin, origin ) < dst )
{
if ( isDefined( trigger.reassess_time ) )
{
trigger.reassess_time -= 0,05;
if ( trigger.reassess_time > 0 )
{
i++;
continue;
}
else }
else }
else cleanup_trigger( trigger, player );
}
closest = get_closest_unitriggers( player_origin, candidate_list, valid_range );
index = 0;
last_trigger = undefined;
while ( index < closest.size )
{
while ( isDefined( closest[ index ].registered ) && !closest[ index ].registered )
{
index++;
}
if ( isDefined( last_trigger ) )
{
cleanup_trigger( last_trigger, player );
}
if ( isDefined( closest[ index ].trigger_per_player ) && closest[ index ].trigger_per_player )
{
if ( !isDefined( closest[ index ].playertrigger ) )
{
closest[ index ].playertrigger = [];
}
if ( !isDefined( closest[ index ].playertrigger[ player getentitynumber() ] ) )
{
level._unitriggers.trigger_pool[ player getentitynumber() ] = build_trigger_from_unitrigger_stub( closest[ index ], player );
level._unitriggers.trigger_pool[ player getentitynumber() ].parent_player = player;
if ( !isDefined( closest[ index ].prompt_and_visibility_func ) || level._unitriggers.trigger_pool[ player getentitynumber() ] [[ closest[ index ].prompt_and_visibility_func ]]( player ) )
{
level._unitriggers.trigger_pool[ player getentitynumber() ] thread trigger_thread( closest[ index ].trigger_func );
break;
}
else last_trigger = level._unitriggers.trigger_pool[ player getentitynumber() ];
level._unitriggers.trigger_pool[ player getentitynumber() ].reassess_time = 1;
}
index++;
continue;
}
else
{
if ( !isDefined( closest[ index ].trigger ) )
{
level._unitriggers.trigger_pool[ player getentitynumber() ] = build_trigger_from_unitrigger_stub( closest[ index ] );
level._unitriggers.trigger_pool[ player getentitynumber() ].parent_player = player;
if ( !isDefined( closest[ index ].prompt_and_visibility_func ) || level._unitriggers.trigger_pool[ player getentitynumber() ] [[ closest[ index ].prompt_and_visibility_func ]]( player ) )
{
level._unitriggers.trigger_pool[ player getentitynumber() ] thread trigger_thread( closest[ index ].trigger_func );
break;
}
else last_trigger = level._unitriggers.trigger_pool[ player getentitynumber() ];
level._unitriggers.trigger_pool[ player getentitynumber() ].reassess_time = 1;
}
}
index++;
wait 0,05;
}
wait 0,05;
i++;
}
wait 0,05;
}
}
run_visibility_function_for_all_triggers()
{
if ( !isDefined( self.prompt_and_visibility_func ) )
{
return;
}
if ( isDefined( self.trigger_per_player ) && self.trigger_per_player )
{
if ( !isDefined( self.playertrigger ) )
{
return;
}
players = getplayers();
i = 0;
while ( i < players.size )
{
if ( isDefined( self.playertrigger[ players[ i ] getentitynumber() ] ) )
{
self.playertrigger[ players[ i ] getentitynumber() ] [[ self.prompt_and_visibility_func ]]( players[ i ] );
}
i++;
}
}
else if ( isDefined( self.trigger ) )
{
self.trigger [[ self.prompt_and_visibility_func ]]( getplayers()[ 0 ] );
}
}
build_trigger_from_unitrigger_stub( stub, player )
{
radius = stub.radius;
if ( !isDefined( radius ) )
{
radius = 64;
}
script_height = stub.script_height;
if ( !isDefined( script_height ) )
{
script_height = 64;
}
script_width = stub.script_width;
if ( !isDefined( script_width ) )
{
script_width = 64;
}
script_length = stub.script_length;
if ( !isDefined( script_length ) )
{
script_length = 64;
}
trigger = undefined;
origin = stub unitrigger_origin();
switch( stub.script_unitrigger_type )
{
case "unitrigger_radius":
trigger = spawn( "trigger_radius", origin, 0, radius, script_height );
break;
case "unitrigger_radius_use":
trigger = spawn( "trigger_radius_use", origin, 0, radius, script_height );
break;
case "unitrigger_box":
trigger = spawn( "trigger_box", origin, 0, script_width, script_length, script_height );
break;
case "unitrigger_box_use":
trigger = spawn( "trigger_box_use", origin, 0, script_width, script_length, script_height );
break;
}
if ( isDefined( trigger ) )
{
if ( isDefined( stub.angles ) )
{
trigger.angles = stub.angles;
}
if ( isDefined( stub.onspawnfunc ) )
{
stub [[ stub.onspawnfunc ]]( trigger );
}
if ( isDefined( stub.cursor_hint ) )
{
trigger setcursorhint( stub.cursor_hint );
}
trigger triggerignoreteam();
if ( isDefined( stub.require_look_at ) && stub.require_look_at )
{
trigger usetriggerrequirelookat();
}
if ( isDefined( stub.hint_string ) )
{
if ( isDefined( stub.cost ) )
{
trigger sethintstring( stub.hint_string, stub.cost );
}
else
{
trigger sethintstring( stub.hint_string );
}
}
trigger.stub = stub;
}
copy_zombie_keys_onto_trigger( trigger, stub );
if ( isDefined( stub.trigger_per_player ) && stub.trigger_per_player )
{
if ( isDefined( trigger ) )
{
trigger setinvisibletoall();
trigger setvisibletoplayer( player );
}
if ( !isDefined( stub.playertrigger ) )
{
stub.playertrigger = [];
}
stub.playertrigger[ player getentitynumber() ] = trigger;
}
else
{
stub.trigger = trigger;
}
return trigger;
}
copy_zombie_keys_onto_trigger( trig, stub )
{
trig.script_noteworthy = stub.script_noteworthy;
trig.targetname = stub.targetname;
trig.target = stub.target;
trig.zombie_weapon_upgrade = stub.zombie_weapon_upgrade;
trig.clientfieldname = stub.clientfieldname;
trig.usetime = stub.usetime;
}
trigger_thread( trigger_func )
{
self endon( "kill_trigger" );
if ( isDefined( trigger_func ) )
{
self [[ trigger_func ]]();
}
}
get_closest_unitrigger_index( org, array, dist )
{
if ( !isDefined( dist ) )
{
dist = 9999999;
}
distsq = dist * dist;
if ( array.size < 1 )
{
return;
}
index = undefined;
i = 0;
while ( i < array.size )
{
origin = array[ i ] unitrigger_origin();
radius_sq = array[ i ].test_radius_sq;
newdistsq = distance2dsquared( origin, org );
if ( newdistsq >= radius_sq )
{
i++;
continue;
}
else if ( newdistsq >= distsq )
{
i++;
continue;
}
else
{
distsq = newdistsq;
index = i;
}
i++;
}
return index;
}
get_closest_unitriggers( org, array, dist )
{
triggers = [];
if ( !isDefined( dist ) )
{
dist = 9999999;
}
distsq = dist * dist;
if ( array.size < 1 )
{
return triggers;
}
index = undefined;
i = 0;
while ( i < array.size )
{
if ( !isDefined( array[ i ] ) )
{
i++;
continue;
}
else origin = array[ i ] unitrigger_origin();
radius_sq = array[ i ].test_radius_sq;
newdistsq = distance2dsquared( origin, org );
if ( newdistsq >= radius_sq )
{
i++;
continue;
}
else if ( abs( origin[ 2 ] - org[ 2 ] ) > 42 )
{
i++;
continue;
}
else
{
array[ i ].dsquared = newdistsq;
j = 0;
while ( j < triggers.size && newdistsq > triggers[ j ].dsquared )
{
j++;
}
arrayinsert( triggers, array[ i ], j );
if ( ( i % 10 ) == 9 )
{
wait 0,05;
}
}
i++;
}
return triggers;
}

5510
zm_transit_dr_patch/maps/mp/zombies/_zm_utility.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

195
zm_transit_dr_patch/maps/mp/zombies/_zm_vulture.gsc Normal file
View File

@ -0,0 +1,195 @@
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init_vulture()
{
setdvarint( "zombies_debug_vulture_perk", 1 );
setdvarint( "zombies_perk_vulture_pickup_time", 12 );
setdvarint( "zombies_perk_vulture_drop_chance", 25 );
setdvarint( "zombies_perk_vulture_ammo_chance", 40 );
setdvarint( "zombies_perk_vulture_points_chance", 50 );
setdvarint( "zombies_perk_vulture_stink_chance", 10 );
}
enable_vulture_perk_for_level()
{
level.zombiemode_using_vulture_perk = 1;
}
give_vulture_perk()
{
iprintln( "player " + self getentitynumber() + " has vulture perk!" );
self.hasperkspecialtyvulture = 1;
}
take_vulture_perk()
{
iprintln( "player " + self getentitynumber() + " has lost vulture perk!" );
self.hasperkspecialtyvulture = undefined;
}
do_vulture_death( player )
{
if ( isDefined( self ) )
{
self thread _do_vulture_death( player );
}
}
_do_vulture_death( player )
{
if ( should_do_vulture_drop() )
{
str_bonus = get_vulture_drop_type();
str_identifier = "_" + self getentitynumber() + "_" + getTime();
player thread show_debug_info( self.origin, str_identifier, str_bonus );
self thread check_vulture_drop_pickup( self.origin, player, str_identifier, str_bonus );
}
}
should_do_vulture_drop()
{
n_roll = randomint( 100 );
b_should_drop = n_roll > ( 100 - getDvarInt( #"70E3B3FA" ) );
return b_should_drop;
}
get_vulture_drop_type()
{
n_chance_ammo = getDvarInt( #"F75E07AF" );
n_chance_points = getDvarInt( #"D7BCDBE2" );
n_chance_stink = getDvarInt( #"4918C38E" );
n_total_weight = n_chance_ammo + n_chance_points + n_chance_stink;
n_cutoff_ammo = n_chance_ammo;
n_cutoff_points = n_chance_ammo + n_chance_points;
n_roll = randomint( n_total_weight );
if ( n_roll < n_cutoff_ammo )
{
str_bonus = "ammo";
}
else if ( n_roll > n_cutoff_ammo && n_roll < n_cutoff_points )
{
str_bonus = "points";
}
else
{
str_bonus = "stink";
}
return str_bonus;
}
show_debug_info( v_drop_point, str_identifier, str_bonus )
{
/#
while ( getDvarInt( #"38E68F2B" ) )
{
self endon( str_identifier );
iprintln( "zombie dropped " + str_bonus );
i = 0;
while ( i < ( getDvarInt( #"34FA67DE" ) * 20 ) )
{
circle( v_drop_point, 32, get_debug_circle_color( str_bonus ), 0, 1, 1 );
wait 0,05;
i++;
#/
}
}
}
get_debug_circle_color( str_bonus )
{
switch( str_bonus )
{
case "ammo":
v_color = ( 1, 1, 1 );
break;
case "points":
v_color = ( 1, 1, 1 );
break;
case "stink":
v_color = ( 1, 1, 1 );
break;
default:
v_color = ( 1, 1, 1 );
break;
}
return v_color;
}
check_vulture_drop_pickup( v_drop_origin, player, str_identifier, str_bonus )
{
player endon( "death" );
player endon( "disconnect" );
b_collected_vulture = 0;
n_times_to_check = int( getDvarInt( #"34FA67DE" ) / 0,25 );
i = 0;
while ( i < n_times_to_check )
{
if ( distancesquared( v_drop_origin, player.origin ) < 1024 )
{
b_collected_vulture = 1;
player notify( str_identifier );
break;
}
else
{
wait 0,25;
i++;
}
}
if ( b_collected_vulture )
{
player give_vulture_bonus( str_bonus );
}
}
give_vulture_bonus( str_bonus )
{
switch( str_bonus )
{
case "ammo":
self give_bonus_ammo();
break;
case "points":
self give_bonus_points();
break;
case "stink":
self give_bonus_stink();
break;
default:
/#
assert( "invalid bonus string '" + str_bonus + "' used in give_vulture_bonus()!" );
#/
break;
}
}
give_bonus_ammo()
{
str_weapon_current = self getcurrentweapon();
if ( str_weapon_current != "none" )
{
n_ammo_count_current = self getweaponammostock( str_weapon_current );
n_ammo_count_max = weaponmaxammo( str_weapon_current );
n_bullets_refunded = int( n_ammo_count_max * 0,05 );
self setweaponammostock( str_weapon_current, n_ammo_count_current + n_bullets_refunded );
/#
if ( getDvarInt( #"38E68F2B" ) )
{
iprintln( ( str_weapon_current + " bullets given: " ) + n_bullets_refunded );
#/
}
}
}
give_bonus_points()
{
self maps/mp/zombies/_zm_score::player_add_points( "vulture", 5 );
}
give_bonus_stink()
{
iprintln( "zombie stink" );
}

278
zm_transit_dr_patch/maps/mp/zombies/_zm_weap_ballistic_knife.gsc Normal file
View File

@ -0,0 +1,278 @@
#include maps/mp/zombies/_zm_stats;
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
if ( isDefined( level._uses_retrievable_ballisitic_knives ) && level._uses_retrievable_ballisitic_knives == 1 )
{
precachemodel( "t5_weapon_ballistic_knife_projectile" );
precachemodel( "t5_weapon_ballistic_knife_blade_retrieve" );
}
}
on_spawn( watcher, player )
{
player endon( "death" );
player endon( "disconnect" );
player endon( "zmb_lost_knife" );
level endon( "game_ended" );
self waittill( "stationary", endpos, normal, angles, attacker, prey, bone );
isfriendly = 0;
if ( isDefined( endpos ) )
{
retrievable_model = spawn( "script_model", endpos );
retrievable_model setmodel( "t5_weapon_ballistic_knife_blade_retrieve" );
retrievable_model setowner( player );
retrievable_model.owner = player;
retrievable_model.angles = angles;
retrievable_model.name = watcher.weapon;
if ( isDefined( prey ) )
{
if ( isplayer( prey ) && player.team == prey.team )
{
isfriendly = 1;
}
else
{
if ( isai( prey ) && player.team == prey.team )
{
isfriendly = 1;
}
}
if ( !isfriendly )
{
retrievable_model linkto( prey, bone );
retrievable_model thread force_drop_knives_to_ground_on_death( player, prey );
}
else
{
if ( isfriendly )
{
retrievable_model physicslaunch( normal, ( randomint( 10 ), randomint( 10 ), randomint( 10 ) ) );
normal = ( 0, 0, 1 );
}
}
}
watcher.objectarray[ watcher.objectarray.size ] = retrievable_model;
if ( isfriendly )
{
retrievable_model waittill( "stationary" );
}
retrievable_model thread drop_knives_to_ground( player );
if ( isfriendly )
{
player notify( "ballistic_knife_stationary" );
}
else
{
player notify( "ballistic_knife_stationary" );
}
retrievable_model thread wait_to_show_glowing_model( prey );
}
}
wait_to_show_glowing_model( prey )
{
level endon( "game_ended" );
self endon( "death" );
wait 2;
self setmodel( "t5_weapon_ballistic_knife_blade_retrieve" );
}
on_spawn_retrieve_trigger( watcher, player )
{
player endon( "death" );
player endon( "disconnect" );
player endon( "zmb_lost_knife" );
level endon( "game_ended" );
player waittill( "ballistic_knife_stationary", retrievable_model, normal, prey );
if ( !isDefined( retrievable_model ) )
{
return;
}
trigger_pos = [];
if ( isDefined( prey ) || isplayer( prey ) && isai( prey ) )
{
trigger_pos[ 0 ] = prey.origin[ 0 ];
trigger_pos[ 1 ] = prey.origin[ 1 ];
trigger_pos[ 2 ] = prey.origin[ 2 ] + 10;
}
else
{
trigger_pos[ 0 ] = retrievable_model.origin[ 0 ] + ( 10 * normal[ 0 ] );
trigger_pos[ 1 ] = retrievable_model.origin[ 1 ] + ( 10 * normal[ 1 ] );
trigger_pos[ 2 ] = retrievable_model.origin[ 2 ] + ( 10 * normal[ 2 ] );
}
pickup_trigger = spawn( "trigger_radius_use", ( trigger_pos[ 0 ], trigger_pos[ 1 ], trigger_pos[ 2 ] ) );
pickup_trigger setcursorhint( "HINT_NOICON" );
pickup_trigger.owner = player;
retrievable_model.retrievabletrigger = pickup_trigger;
hint_string = &"WEAPON_BALLISTIC_KNIFE_PICKUP";
if ( isDefined( hint_string ) )
{
pickup_trigger sethintstring( hint_string );
}
else
{
pickup_trigger sethintstring( &"GENERIC_PICKUP" );
}
pickup_trigger setteamfortrigger( player.team );
player clientclaimtrigger( pickup_trigger );
pickup_trigger enablelinkto();
if ( isDefined( prey ) )
{
pickup_trigger linkto( prey );
}
else
{
pickup_trigger linkto( retrievable_model );
}
if ( isDefined( level.knife_planted ) )
{
[[ level.knife_planted ]]( retrievable_model, pickup_trigger, prey );
}
retrievable_model thread watch_use_trigger( pickup_trigger, retrievable_model, ::pick_up, watcher.weapon, watcher.pickupsoundplayer, watcher.pickupsound );
player thread watch_shutdown( pickup_trigger, retrievable_model );
}
debug_print( endpos )
{
/#
self endon( "death" );
while ( 1 )
{
print3d( endpos, "pickup_trigger" );
wait 0,05;
#/
}
}
watch_use_trigger( trigger, model, callback, weapon, playersoundonuse, npcsoundonuse )
{
self endon( "death" );
self endon( "delete" );
level endon( "game_ended" );
while ( 1 )
{
trigger waittill( "trigger", player );
while ( !isalive( player ) )
{
continue;
}
while ( !player isonground() )
{
continue;
}
if ( isDefined( trigger.triggerteam ) && player.team != trigger.triggerteam )
{
continue;
}
if ( isDefined( trigger.claimedby ) && player != trigger.claimedby )
{
continue;
}
if ( player usebuttonpressed() && !player.throwinggrenade && !player meleebuttonpressed() )
{
if ( isDefined( playersoundonuse ) )
{
player playlocalsound( playersoundonuse );
}
if ( isDefined( npcsoundonuse ) )
{
player playsound( npcsoundonuse );
}
player thread [[ callback ]]( weapon, model, trigger );
return;
}
else
{
}
}
}
pick_up( weapon, model, trigger )
{
current_weapon = self getcurrentweapon();
if ( current_weapon != weapon )
{
clip_ammo = self getweaponammoclip( weapon );
if ( !clip_ammo )
{
self setweaponammoclip( weapon, 1 );
}
else
{
new_ammo_stock = self getweaponammostock( weapon ) + 1;
self setweaponammostock( weapon, new_ammo_stock );
}
}
else
{
new_ammo_stock = self getweaponammostock( weapon ) + 1;
self setweaponammostock( weapon, new_ammo_stock );
}
self maps/mp/zombies/_zm_stats::increment_client_stat( "ballistic_knives_pickedup" );
self maps/mp/zombies/_zm_stats::increment_player_stat( "ballistic_knives_pickedup" );
model destroy_ent();
trigger destroy_ent();
}
destroy_ent()
{
if ( isDefined( self ) )
{
if ( isDefined( self.glowing_model ) )
{
self.glowing_model delete();
}
self delete();
}
}
watch_shutdown( trigger, model )
{
self waittill_any( "death", "disconnect", "zmb_lost_knife" );
trigger destroy_ent();
model destroy_ent();
}
drop_knives_to_ground( player )
{
player endon( "death" );
player endon( "zmb_lost_knife" );
for ( ;; )
{
level waittill( "drop_objects_to_ground", origin, radius );
if ( distancesquared( origin, self.origin ) < ( radius * radius ) )
{
self physicslaunch( ( 0, 0, 1 ), vectorScale( ( 0, 0, 1 ), 5 ) );
self thread update_retrieve_trigger( player );
}
}
}
force_drop_knives_to_ground_on_death( player, prey )
{
self endon( "death" );
player endon( "zmb_lost_knife" );
prey waittill( "death" );
self unlink();
self physicslaunch( ( 0, 0, 1 ), vectorScale( ( 0, 0, 1 ), 5 ) );
self thread update_retrieve_trigger( player );
}
update_retrieve_trigger( player )
{
self endon( "death" );
player endon( "zmb_lost_knife" );
if ( isDefined( level.custom_update_retrieve_trigger ) )
{
self [[ level.custom_update_retrieve_trigger ]]( player );
return;
}
self waittill( "stationary" );
trigger = self.retrievabletrigger;
trigger.origin = ( self.origin[ 0 ], self.origin[ 1 ], self.origin[ 2 ] + 10 );
trigger linkto( self );
}

53
zm_transit_dr_patch/maps/mp/zombies/_zm_weap_bowie.gsc Normal file
View File

@ -0,0 +1,53 @@
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( isDefined( level.bowie_cost ) )
{
cost = level.bowie_cost;
}
else
{
cost = 3000;
}
maps/mp/zombies/_zm_melee_weapon::init( "bowie_knife_zm", "zombie_bowie_flourish", "knife_ballistic_bowie_zm", "knife_ballistic_bowie_upgraded_zm", cost, "bowie_upgrade", &"ZOMBIE_WEAPON_BOWIE_BUY", "bowie", ::has_bowie, ::give_bowie, ::take_bowie, ::bowie_flourish );
maps/mp/zombies/_zm_weapons::add_retrievable_knife_init_name( "knife_ballistic_bowie" );
maps/mp/zombies/_zm_weapons::add_retrievable_knife_init_name( "knife_ballistic_bowie_upgraded" );
}
spectator_respawn()
{
maps/mp/zombies/_zm_melee_weapon::spectator_respawn( "bowie_upgrade", ::take_bowie, ::has_bowie );
}
has_bowie()
{
if ( is_true( level._allow_melee_weapon_switching ) )
{
return 0;
}
if ( !is_true( self._sickle_zm_equipped ) || is_true( self._bowie_zm_equipped ) && is_true( self._tazer_zm_equipped ) )
{
return 1;
}
return 0;
}
give_bowie()
{
self._bowie_zm_equipped = 1;
self._sickle_zm_equipped = undefined;
self._tazer_zm_equipped = undefined;
}
take_bowie()
{
self._bowie_zm_equipped = undefined;
}
bowie_flourish()
{
}

487
zm_transit_dr_patch/maps/mp/zombies/_zm_weap_claymore.gsc Normal file
View File

@ -0,0 +1,487 @@
#include maps/mp/gametypes_zm/_weaponobjects;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm_weapons;
#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;
init()
{
if ( !isDefined( level.claymores_max_per_player ) )
{
level.claymores_max_per_player = 12;
}
trigs = getentarray( "claymore_purchase", "targetname" );
i = 0;
while ( i < trigs.size )
{
model = getent( trigs[ i ].target, "targetname" );
if ( isDefined( model ) )
{
model hide();
}
i++;
}
array_thread( trigs, ::buy_claymores );
level thread give_claymores_after_rounds();
level.claymores_on_damage = ::satchel_damage;
level.pickup_claymores = ::pickup_claymores;
level.pickup_claymores_trigger_listener = ::pickup_claymores_trigger_listener;
level.claymore_detectiondot = cos( 70 );
level.claymore_detectionmindist = 20;
level._effect[ "claymore_laser" ] = loadfx( "weapon/claymore/fx_claymore_laser" );
}
buy_claymores()
{
self.zombie_cost = 1000;
self sethintstring( &"ZOMBIE_CLAYMORE_PURCHASE" );
self setcursorhint( "HINT_NOICON" );
self endon( "kill_trigger" );
if ( !isDefined( self.stub ) )
{
return;
}
if ( isDefined( self.stub ) && !isDefined( self.stub.claymores_triggered ) )
{
self.stub.claymores_triggered = 0;
}
self.claymores_triggered = self.stub.claymores_triggered;
while ( 1 )
{
self waittill( "trigger", who );
while ( who in_revive_trigger() )
{
continue;
}
while ( who has_powerup_weapon() )
{
wait 0,1;
}
if ( is_player_valid( who ) )
{
if ( who.score >= self.zombie_cost )
{
if ( !who is_player_placeable_mine( "claymore_zm" ) )
{
play_sound_at_pos( "purchase", self.origin );
who maps/mp/zombies/_zm_score::minus_to_player_score( self.zombie_cost );
who thread claymore_setup();
who thread show_claymore_hint( "claymore_purchased" );
who thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", "grenade" );
if ( isDefined( self.stub ) )
{
self.claymores_triggered = self.stub.claymores_triggered;
}
if ( self.claymores_triggered == 0 )
{
model = getent( self.target, "targetname" );
if ( isDefined( model ) )
{
model thread maps/mp/zombies/_zm_weapons::weapon_show( who );
}
else
{
if ( isDefined( self.clientfieldname ) )
{
level setclientfield( self.clientfieldname, 1 );
}
}
self.claymores_triggered = 1;
if ( isDefined( self.stub ) )
{
self.stub.claymores_triggered = 1;
}
}
trigs = getentarray( "claymore_purchase", "targetname" );
i = 0;
while ( i < trigs.size )
{
trigs[ i ] setinvisibletoplayer( who );
i++;
}
}
else who thread show_claymore_hint( "already_purchased" );
}
}
}
}
claymore_unitrigger_update_prompt( player )
{
if ( player is_player_placeable_mine( "claymore_zm" ) )
{
return 0;
}
return 1;
}
set_claymore_visible()
{
players = get_players();
trigs = getentarray( "claymore_purchase", "targetname" );
while ( 1 )
{
j = 0;
while ( j < players.size )
{
while ( !players[ j ] is_player_placeable_mine( "claymore_zm" ) )
{
i = 0;
while ( i < trigs.size )
{
trigs[ i ] setinvisibletoplayer( players[ j ], 0 );
i++;
}
}
j++;
}
wait 1;
players = get_players();
}
}
claymore_safe_to_plant()
{
if ( self.owner.claymores.size >= level.claymores_max_per_player )
{
return 0;
}
if ( isDefined( level.claymore_safe_to_plant ) )
{
return self [[ level.claymore_safe_to_plant ]]();
}
return 1;
}
claymore_wait_and_detonate()
{
wait 0,1;
self detonate( self.owner );
}
claymore_watch()
{
self endon( "death" );
while ( 1 )
{
self waittill( "grenade_fire", claymore, weapname );
if ( weapname == "claymore_zm" )
{
claymore.owner = self;
claymore.team = self.team;
self notify( "zmb_enable_claymore_prompt" );
if ( claymore claymore_safe_to_plant() )
{
if ( isDefined( level.claymore_planted ) )
{
self thread [[ level.claymore_planted ]]( claymore );
}
claymore thread satchel_damage();
claymore thread claymore_detonation();
claymore thread play_claymore_effects();
self maps/mp/zombies/_zm_stats::increment_client_stat( "claymores_planted" );
self maps/mp/zombies/_zm_stats::increment_player_stat( "claymores_planted" );
break;
}
else
{
claymore thread claymore_wait_and_detonate();
}
}
}
}
claymore_setup()
{
if ( !isDefined( self.claymores ) )
{
self.claymores = [];
}
self thread claymore_watch();
self giveweapon( "claymore_zm" );
self set_player_placeable_mine( "claymore_zm" );
self setactionslot( 4, "weapon", "claymore_zm" );
self setweaponammostock( "claymore_zm", 2 );
}
adjust_trigger_origin( origin )
{
origin += vectorScale( ( 0, 0, 1 ), 20 );
return origin;
}
on_spawn_retrieve_trigger( watcher, player )
{
self maps/mp/gametypes_zm/_weaponobjects::onspawnretrievableweaponobject( watcher, player );
if ( isDefined( self.pickuptrigger ) )
{
self.pickuptrigger sethintlowpriority( 0 );
}
}
pickup_claymores()
{
player = self.owner;
if ( !player hasweapon( "claymore_zm" ) )
{
player thread claymore_watch();
player giveweapon( "claymore_zm" );
player set_player_placeable_mine( "claymore_zm" );
player setactionslot( 4, "weapon", "claymore_zm" );
player setweaponammoclip( "claymore_zm", 0 );
player notify( "zmb_enable_claymore_prompt" );
}
else
{
clip_ammo = player getweaponammoclip( self.name );
clip_max_ammo = weaponclipsize( self.name );
if ( clip_ammo >= clip_max_ammo )
{
player notify( "zmb_disable_claymore_prompt" );
return;
}
}
self pick_up();
clip_ammo = player getweaponammoclip( self.name );
clip_max_ammo = weaponclipsize( self.name );
if ( clip_ammo >= clip_max_ammo )
{
player notify( "zmb_disable_claymore_prompt" );
}
player maps/mp/zombies/_zm_stats::increment_client_stat( "claymores_pickedup" );
player maps/mp/zombies/_zm_stats::increment_player_stat( "claymores_pickedup" );
}
pickup_claymores_trigger_listener( trigger, player )
{
self thread pickup_claymores_trigger_listener_enable( trigger, player );
self thread pickup_claymores_trigger_listener_disable( trigger, player );
}
pickup_claymores_trigger_listener_enable( trigger, player )
{
self endon( "delete" );
while ( 1 )
{
player waittill_any( "zmb_enable_claymore_prompt", "spawned_player" );
if ( !isDefined( trigger ) )
{
return;
}
trigger trigger_on();
trigger linkto( self );
}
}
pickup_claymores_trigger_listener_disable( trigger, player )
{
self endon( "delete" );
while ( 1 )
{
player waittill( "zmb_disable_claymore_prompt" );
if ( !isDefined( trigger ) )
{
return;
}
trigger unlink();
trigger trigger_off();
}
}
shouldaffectweaponobject( object )
{
pos = self.origin + vectorScale( ( 0, 0, 1 ), 32 );
dirtopos = pos - object.origin;
objectforward = anglesToForward( object.angles );
dist = vectordot( dirtopos, objectforward );
if ( dist < level.claymore_detectionmindist )
{
return 0;
}
dirtopos = vectornormalize( dirtopos );
dot = vectordot( dirtopos, objectforward );
return dot > level.claymore_detectiondot;
}
claymore_detonation()
{
self endon( "death" );
self waittill_not_moving();
detonateradius = 96;
damagearea = spawn( "trigger_radius", self.origin + ( 0, 0, 0 - detonateradius ), 4, detonateradius, detonateradius * 2 );
damagearea setexcludeteamfortrigger( self.team );
damagearea enablelinkto();
damagearea linkto( self );
if ( is_true( self.isonbus ) )
{
damagearea setmovingplatformenabled( 1 );
}
self.damagearea = damagearea;
self thread delete_claymores_on_death( self.owner, damagearea );
self.owner.claymores[ self.owner.claymores.size ] = self;
while ( 1 )
{
damagearea waittill( "trigger", ent );
if ( isDefined( self.owner ) && ent == self.owner )
{
continue;
}
while ( isDefined( ent.pers ) && isDefined( ent.pers[ "team" ] ) && ent.pers[ "team" ] == self.team )
{
continue;
}
while ( !ent shouldaffectweaponobject( self ) )
{
continue;
}
if ( ent damageconetrace( self.origin, self ) > 0 )
{
self playsound( "wpn_claymore_alert" );
wait 0,4;
if ( isDefined( self.owner ) )
{
self detonate( self.owner );
}
else
{
self detonate( undefined );
}
return;
}
}
}
delete_claymores_on_death( player, ent )
{
self waittill( "death" );
if ( isDefined( player ) )
{
arrayremovevalue( player.claymores, self );
}
wait 0,05;
if ( isDefined( ent ) )
{
ent delete();
}
}
satchel_damage()
{
self setcandamage( 1 );
self.health = 100000;
self.maxhealth = self.health;
attacker = undefined;
while ( 1 )
{
self waittill( "damage", amount, attacker );
if ( !isDefined( self ) )
{
return;
}
self.health = self.maxhealth;
while ( !isplayer( attacker ) )
{
continue;
}
if ( isDefined( self.owner ) && attacker == self.owner )
{
continue;
}
while ( isDefined( attacker.pers ) && isDefined( attacker.pers[ "team" ] ) && attacker.pers[ "team" ] != level.zombie_team )
{
continue;
}
}
if ( level.satchelexplodethisframe )
{
wait ( 0,1 + randomfloat( 0,4 ) );
}
else wait 0,05;
if ( !isDefined( self ) )
{
return;
}
level.satchelexplodethisframe = 1;
thread reset_satchel_explode_this_frame();
self detonate( attacker );
}
reset_satchel_explode_this_frame()
{
wait 0,05;
level.satchelexplodethisframe = 0;
}
play_claymore_effects()
{
self endon( "death" );
self waittill_not_moving();
playfxontag( level._effect[ "claymore_laser" ], self, "tag_fx" );
}
give_claymores_after_rounds()
{
while ( 1 )
{
level waittill( "between_round_over" );
while ( !level flag_exists( "teleporter_used" ) || !flag( "teleporter_used" ) )
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( players[ i ] is_player_placeable_mine( "claymore_zm" ) )
{
players[ i ] giveweapon( "claymore_zm" );
players[ i ] set_player_placeable_mine( "claymore_zm" );
players[ i ] setactionslot( 4, "weapon", "claymore_zm" );
players[ i ] setweaponammoclip( "claymore_zm", 2 );
}
i++;
}
}
}
}
init_hint_hudelem( x, y, alignx, aligny, fontscale, alpha )
{
self.x = x;
self.y = y;
self.alignx = alignx;
self.aligny = aligny;
self.fontscale = fontscale;
self.alpha = alpha;
self.sort = 20;
}
setup_client_hintelem()
{
self endon( "death" );
self endon( "disconnect" );
if ( !isDefined( self.hintelem ) )
{
self.hintelem = newclienthudelem( self );
}
self.hintelem init_hint_hudelem( 320, 220, "center", "bottom", 1,6, 1 );
}
show_claymore_hint( string )
{
self endon( "death" );
self endon( "disconnect" );
if ( string == "claymore_purchased" )
{
text = &"ZOMBIE_CLAYMORE_HOWTO";
}
else
{
text = &"ZOMBIE_CLAYMORE_ALREADY_PURCHASED";
}
self setup_client_hintelem();
self.hintelem settext( text );
wait 3,5;
self.hintelem settext( "" );
}

565
zm_transit_dr_patch/maps/mp/zombies/_zm_weap_cymbal_monkey.gsc Normal file
View File

@ -0,0 +1,565 @@
#include maps/mp/zombies/_zm_clone;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
#using_animtree( "zombie_cymbal_monkey" );
init()
{
if ( !cymbal_monkey_exists() )
{
return;
}
/#
level.zombiemode_devgui_cymbal_monkey_give = ::player_give_cymbal_monkey;
#/
level._effect[ "monkey_glow" ] = loadfx( "maps/zombie/fx_zombie_monkey_light" );
level._effect[ "grenade_samantha_steal" ] = loadfx( "maps/zombie/fx_zmb_blackhole_trap_end" );
level.cymbal_monkeys = [];
scriptmodelsuseanimtree( -1 );
}
player_give_cymbal_monkey()
{
self giveweapon( "cymbal_monkey_zm" );
self set_player_tactical_grenade( "cymbal_monkey_zm" );
self thread player_handle_cymbal_monkey();
}
player_handle_cymbal_monkey()
{
self notify( "starting_monkey_watch" );
self endon( "disconnect" );
self endon( "starting_monkey_watch" );
attract_dist_diff = level.monkey_attract_dist_diff;
if ( !isDefined( attract_dist_diff ) )
{
attract_dist_diff = 45;
}
num_attractors = level.num_monkey_attractors;
if ( !isDefined( num_attractors ) )
{
num_attractors = 96;
}
max_attract_dist = level.monkey_attract_dist;
if ( !isDefined( max_attract_dist ) )
{
max_attract_dist = 1536;
}
while ( 1 )
{
grenade = get_thrown_monkey();
self player_throw_cymbal_monkey( grenade, num_attractors, max_attract_dist, attract_dist_diff );
wait 0,05;
}
}
watch_for_dud( model, actor )
{
self endon( "death" );
self waittill( "grenade_dud" );
model.dud = 1;
self playsound( "zmb_vox_monkey_scream" );
self.monk_scream_vox = 1;
wait 3;
if ( isDefined( model ) )
{
model delete();
}
if ( isDefined( actor ) )
{
actor delete();
}
if ( isDefined( self.damagearea ) )
{
self.damagearea delete();
}
if ( isDefined( self ) )
{
self delete();
}
}
watch_for_emp( model, actor )
{
self endon( "death" );
while ( 1 )
{
level waittill( "emp_detonate", origin, radius );
if ( distancesquared( origin, self.origin ) < ( radius * radius ) )
{
break;
}
else
{
}
}
self.stun_fx = 1;
if ( isDefined( level._equipment_emp_destroy_fx ) )
{
playfx( level._equipment_emp_destroy_fx, self.origin + vectorScale( ( 0, 0, -1 ), 5 ), ( 0, randomfloat( 360 ), 0 ) );
}
wait 0,15;
self.attract_to_origin = 0;
self deactivate_zombie_point_of_interest();
model clearanim( %o_monkey_bomb, 0 );
wait 1;
self detonate();
wait 1;
if ( isDefined( model ) )
{
model delete();
}
if ( isDefined( actor ) )
{
actor delete();
}
if ( isDefined( self.damagearea ) )
{
self.damagearea delete();
}
if ( isDefined( self ) )
{
self delete();
}
}
clone_player_angles( owner )
{
self endon( "death" );
owner endon( "death" );
while ( isDefined( self ) )
{
self.angles = owner.angles;
wait 0,05;
}
}
show_briefly( showtime )
{
self endon( "show_owner" );
if ( isDefined( self.show_for_time ) )
{
self.show_for_time = showtime;
return;
}
self.show_for_time = showtime;
self setvisibletoall();
while ( self.show_for_time > 0 )
{
self.show_for_time -= 0,05;
wait 0,05;
}
self setvisibletoallexceptteam( level.zombie_team );
self.show_for_time = undefined;
}
show_owner_on_attack( owner )
{
owner endon( "hide_owner" );
owner endon( "show_owner" );
self endon( "explode" );
self endon( "death" );
self endon( "grenade_dud" );
owner.show_for_time = undefined;
for ( ;; )
{
owner waittill( "weapon_fired" );
owner thread show_briefly( 0,5 );
}
}
hide_owner( owner )
{
owner notify( "hide_owner" );
owner endon( "hide_owner" );
owner setperk( "specialty_immunemms" );
owner.no_burning_sfx = 1;
owner notify( "stop_flame_sounds" );
owner setvisibletoallexceptteam( level.zombie_team );
owner.hide_owner = 1;
if ( isDefined( level._effect[ "human_disappears" ] ) )
{
playfx( level._effect[ "human_disappears" ], owner.origin );
}
self thread show_owner_on_attack( owner );
evt = self waittill_any_return( "explode", "death", "grenade_dud" );
/#
println( "ZMCLONE: Player visible again because of " + evt );
#/
owner notify( "show_owner" );
owner unsetperk( "specialty_immunemms" );
if ( isDefined( level._effect[ "human_disappears" ] ) )
{
playfx( level._effect[ "human_disappears" ], owner.origin );
}
owner.no_burning_sfx = undefined;
owner setvisibletoall();
owner.hide_owner = undefined;
owner show();
}
proximity_detonate( owner )
{
wait 1,5;
if ( !isDefined( self ) )
{
return;
}
detonateradius = 96;
explosionradius = detonateradius * 2;
damagearea = spawn( "trigger_radius", self.origin + ( 0, 0, 0 - detonateradius ), 4, detonateradius, detonateradius * 1,5 );
damagearea setexcludeteamfortrigger( owner.team );
damagearea enablelinkto();
damagearea linkto( self );
self.damagearea = damagearea;
while ( isDefined( self ) )
{
damagearea waittill( "trigger", ent );
if ( isDefined( owner ) && ent == owner )
{
continue;
}
if ( isDefined( ent.team ) && ent.team == owner.team )
{
continue;
}
self playsound( "wpn_claymore_alert" );
dist = distance( self.origin, ent.origin );
radiusdamage( self.origin + vectorScale( ( 0, 0, -1 ), 12 ), explosionradius, 1, 1, owner, "MOD_GRENADE_SPLASH", "cymbal_monkey_zm" );
if ( isDefined( owner ) )
{
self detonate( owner );
}
else
{
self detonate( undefined );
}
break;
}
if ( isDefined( damagearea ) )
{
damagearea delete();
}
}
player_throw_cymbal_monkey( grenade, num_attractors, max_attract_dist, attract_dist_diff )
{
self endon( "disconnect" );
self endon( "starting_monkey_watch" );
if ( isDefined( grenade ) )
{
grenade endon( "death" );
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
if ( isDefined( grenade.damagearea ) )
{
grenade.damagearea delete();
}
grenade delete();
return;
}
grenade hide();
model = spawn( "script_model", grenade.origin );
model setmodel( "weapon_zombie_monkey_bomb" );
model useanimtree( -1 );
model linkto( grenade );
model.angles = grenade.angles;
model thread monkey_cleanup( grenade );
clone = undefined;
if ( isDefined( level.cymbal_monkey_dual_view ) && level.cymbal_monkey_dual_view )
{
model setvisibletoallexceptteam( level.zombie_team );
clone = maps/mp/zombies/_zm_clone::spawn_player_clone( self, vectorScale( ( 0, 0, -1 ), 999 ), level.cymbal_monkey_clone_weapon, undefined );
model.simulacrum = clone;
clone maps/mp/zombies/_zm_clone::clone_animate( "idle" );
clone thread clone_player_angles( self );
clone notsolid();
clone ghost();
}
grenade thread watch_for_dud( model, clone );
grenade thread watch_for_emp( model, clone );
info = spawnstruct();
info.sound_attractors = [];
grenade thread monitor_zombie_groans( info );
grenade waittill( "stationary" );
if ( isDefined( level.grenade_planted ) )
{
self thread [[ level.grenade_planted ]]( grenade, model );
}
if ( isDefined( grenade ) )
{
if ( isDefined( model ) )
{
model setanim( %o_monkey_bomb );
if ( isDefined( grenade.backlinked ) && !grenade.backlinked )
{
model unlink();
model.origin = grenade.origin;
model.angles = grenade.angles;
}
}
if ( isDefined( clone ) )
{
clone forceteleport( grenade.origin, grenade.angles );
clone thread hide_owner( self );
grenade thread proximity_detonate( self );
clone show();
clone setinvisibletoall();
clone setvisibletoteam( level.zombie_team );
}
grenade resetmissiledetonationtime();
playfxontag( level._effect[ "monkey_glow" ], model, "origin_animate_jnt" );
valid_poi = check_point_in_enabled_zone( grenade.origin, undefined, undefined );
if ( isDefined( level.check_valid_poi ) )
{
valid_poi = grenade [[ level.check_valid_poi ]]( valid_poi );
}
if ( valid_poi )
{
grenade create_zombie_point_of_interest( max_attract_dist, num_attractors, 10000 );
grenade.attract_to_origin = 1;
grenade thread create_zombie_point_of_interest_attractor_positions( 4, attract_dist_diff );
grenade thread wait_for_attractor_positions_complete();
grenade thread do_monkey_sound( model, info );
level.cymbal_monkeys[ level.cymbal_monkeys.size ] = grenade;
}
else
{
grenade.script_noteworthy = undefined;
level thread grenade_stolen_by_sam( grenade, model, clone );
}
return;
}
else
{
grenade.script_noteworthy = undefined;
level thread grenade_stolen_by_sam( grenade, model, clone );
}
}
}
grenade_stolen_by_sam( ent_grenade, ent_model, ent_actor )
{
if ( !isDefined( ent_model ) )
{
return;
}
direction = ent_model.origin;
direction = ( direction[ 1 ], direction[ 0 ], 0 );
if ( direction[ 1 ] < 0 || direction[ 0 ] > 0 && direction[ 1 ] > 0 )
{
direction = ( direction[ 0 ], direction[ 1 ] * -1, 0 );
}
else
{
if ( direction[ 0 ] < 0 )
{
direction = ( direction[ 0 ] * -1, direction[ 1 ], 0 );
}
}
players = get_players();
i = 0;
while ( i < players.size )
{
if ( isalive( players[ i ] ) )
{
players[ i ] playlocalsound( level.zmb_laugh_alias );
}
i++;
}
playfxontag( level._effect[ "grenade_samantha_steal" ], ent_model, "tag_origin" );
ent_model movez( 60, 1, 0,25, 0,25 );
ent_model vibrate( direction, 1,5, 2,5, 1 );
ent_model waittill( "movedone" );
if ( isDefined( self.damagearea ) )
{
self.damagearea delete();
}
ent_model delete();
if ( isDefined( ent_actor ) )
{
ent_actor delete();
}
if ( isDefined( ent_grenade ) )
{
if ( isDefined( ent_grenade.damagearea ) )
{
ent_grenade.damagearea delete();
}
ent_grenade delete();
}
}
wait_for_attractor_positions_complete()
{
self waittill( "attractor_positions_generated" );
self.attract_to_origin = 0;
}
monkey_cleanup( parent )
{
while ( 1 )
{
if ( !isDefined( parent ) )
{
if ( isDefined( self ) && isDefined( self.dud ) && self.dud )
{
wait 6;
}
if ( isDefined( self.simulacrum ) )
{
self.simulacrum delete();
}
self_delete();
return;
}
wait 0,05;
}
}
do_monkey_sound( model, info )
{
self.monk_scream_vox = 0;
if ( isDefined( level.grenade_safe_to_bounce ) )
{
if ( !( [[ level.grenade_safe_to_bounce ]]( self.owner, "cymbal_monkey_zm" ) ) )
{
self playsound( "zmb_vox_monkey_scream" );
self.monk_scream_vox = 1;
}
}
if ( !self.monk_scream_vox && level.music_override == 0 )
{
if ( isDefined( level.cymbal_monkey_dual_view ) && level.cymbal_monkey_dual_view )
{
self playsoundtoteam( "zmb_monkey_song", "allies" );
}
else
{
self playsound( "zmb_monkey_song" );
}
}
if ( !self.monk_scream_vox )
{
self thread play_delayed_explode_vox();
}
self waittill( "explode", position );
level notify( "grenade_exploded" );
monkey_index = -1;
i = 0;
while ( i < level.cymbal_monkeys.size )
{
if ( !isDefined( level.cymbal_monkeys[ i ] ) )
{
monkey_index = i;
break;
}
else
{
i++;
}
}
if ( monkey_index >= 0 )
{
arrayremoveindex( level.cymbal_monkeys, monkey_index );
}
if ( isDefined( model ) )
{
model clearanim( %o_monkey_bomb, 0,2 );
}
i = 0;
while ( i < info.sound_attractors.size )
{
if ( isDefined( info.sound_attractors[ i ] ) )
{
info.sound_attractors[ i ] notify( "monkey_blown_up" );
}
i++;
}
}
play_delayed_explode_vox()
{
wait 6,5;
if ( isDefined( self ) )
{
self playsound( "zmb_vox_monkey_explode" );
}
}
get_thrown_monkey()
{
self endon( "disconnect" );
self endon( "starting_monkey_watch" );
while ( 1 )
{
self waittill( "grenade_fire", grenade, weapname );
if ( weapname == "cymbal_monkey_zm" )
{
grenade.use_grenade_special_long_bookmark = 1;
grenade.grenade_multiattack_bookmark_count = 1;
return grenade;
}
wait 0,05;
}
}
monitor_zombie_groans( info )
{
self endon( "explode" );
while ( 1 )
{
if ( !isDefined( self ) )
{
return;
}
while ( !isDefined( self.attractor_array ) )
{
wait 0,05;
}
i = 0;
while ( i < self.attractor_array.size )
{
if ( array_check_for_dupes( info.sound_attractors, self.attractor_array[ i ] ) )
{
if ( isDefined( self.origin ) && isDefined( self.attractor_array[ i ].origin ) )
{
if ( distancesquared( self.origin, self.attractor_array[ i ].origin ) < 250000 )
{
info.sound_attractors[ info.sound_attractors.size ] = self.attractor_array[ i ];
self.attractor_array[ i ] thread play_zombie_groans();
}
}
}
i++;
}
wait 0,05;
}
}
play_zombie_groans()
{
self endon( "death" );
self endon( "monkey_blown_up" );
while ( 1 )
{
if ( isDefined( self ) )
{
self playsound( "zmb_vox_zombie_groan" );
wait randomfloatrange( 2, 3 );
continue;
}
else
{
return;
}
}
}
cymbal_monkey_exists()
{
return isDefined( level.zombie_weapons[ "cymbal_monkey_zm" ] );
}

369
zm_transit_dr_patch/maps/mp/zombies/_zm_weap_emp_bomb.gsc Normal file
View File

@ -0,0 +1,369 @@
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/zombies/_zm_power;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( !emp_bomb_exists() )
{
return;
}
set_zombie_var( "emp_stun_range", 600 );
set_zombie_var( "emp_stun_time", 20 );
set_zombie_var( "emp_perk_off_range", 420 );
set_zombie_var( "emp_perk_off_time", 90 );
precacheshellshock( "frag_grenade_mp" );
/#
level.zombiemode_devgui_emp_bomb_give = ::player_give_emp_bomb;
#/
level thread onplayerconnect();
level._equipment_emp_destroy_fx = loadfx( "weapon/emp/fx_emp_explosion_equip" );
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player thread watch_for_grenade_throw();
}
}
player_give_emp_bomb()
{
self giveweapon( "emp_grenade_zm" );
self set_player_tactical_grenade( "emp_grenade_zm" );
}
emp_bomb_exists()
{
return isDefined( level.zombie_weapons[ "emp_grenade_zm" ] );
}
watch_for_grenade_throw()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "grenade_fire", grenade, weapname );
while ( weapname != "emp_grenade_zm" )
{
continue;
}
grenade.use_grenade_special_bookmark = 1;
grenade.grenade_multiattack_bookmark_count = 1;
grenade.owner = self;
self thread emp_detonate( grenade );
}
}
emp_detonate( grenade )
{
grenade_owner = undefined;
if ( isDefined( grenade.owner ) )
{
grenade_owner = grenade.owner;
}
grenade waittill( "explode", grenade_origin );
emp_radius = level.zombie_vars[ "emp_perk_off_range" ];
emp_time = level.zombie_vars[ "emp_perk_off_time" ];
origin = grenade_origin;
if ( !isDefined( origin ) )
{
return;
}
level notify( "emp_detonate" );
self thread emp_detonate_zombies( grenade_origin, grenade_owner );
if ( isDefined( level.custom_emp_detonate ) )
{
thread [[ level.custom_emp_detonate ]]( grenade_origin );
}
if ( isDefined( grenade_owner ) )
{
grenade_owner thread destroyequipment( origin, emp_radius );
}
players_emped = emp_players( origin, emp_radius );
disabled_list = maps/mp/zombies/_zm_power::change_power_in_radius( -1, origin, emp_radius );
wait emp_time;
maps/mp/zombies/_zm_power::revert_power_to_list( 1, origin, emp_radius, disabled_list );
unemp_players( players_emped );
}
emp_detonate_zombies( grenade_origin, grenade_owner )
{
zombies = get_array_of_closest( grenade_origin, getaispeciesarray( level.zombie_team, "all" ), undefined, undefined, level.zombie_vars[ "emp_stun_range" ] );
if ( !isDefined( zombies ) )
{
return;
}
i = 0;
while ( i < zombies.size )
{
if ( !isDefined( zombies[ i ] ) || isDefined( zombies[ i ].ignore_inert ) && zombies[ i ].ignore_inert )
{
i++;
continue;
}
else
{
zombies[ i ].becoming_inert = 1;
}
i++;
}
stunned = 0;
i = 0;
while ( i < zombies.size )
{
if ( !isDefined( zombies[ i ] ) || isDefined( zombies[ i ].ignore_inert ) && zombies[ i ].ignore_inert )
{
i++;
continue;
}
else
{
stunned++;
zombies[ i ] thread stun_zombie();
wait 0,05;
}
i++;
}
if ( stunned >= 10 && isDefined( grenade_owner ) )
{
grenade_owner notify( "the_lights_of_their_eyes" );
}
}
stun_zombie()
{
self endon( "death" );
self notify( "stun_zombie" );
self endon( "stun_zombie" );
if ( self.health <= 0 )
{
/#
iprintln( "trying to stun a dead zombie" );
#/
return;
}
if ( isDefined( self.stun_zombie ) )
{
self thread [[ self.stun_zombie ]]();
return;
}
self thread maps/mp/zombies/_zm_ai_basic::start_inert();
}
emp_players( origin, radius )
{
players_emped = [];
players = get_players();
rsquared = radius * radius;
_a192 = players;
_k192 = getFirstArrayKey( _a192 );
while ( isDefined( _k192 ) )
{
player = _a192[ _k192 ];
if ( isalive( player ) && distancesquared( origin, player.origin ) < rsquared )
{
player player_emp_on();
players_emped[ players_emped.size ] = player;
}
_k192 = getNextArrayKey( _a192, _k192 );
}
return players_emped;
}
unemp_players( players_emped )
{
_a206 = players_emped;
_k206 = getFirstArrayKey( _a206 );
while ( isDefined( _k206 ) )
{
player = _a206[ _k206 ];
player player_emp_off();
_k206 = getNextArrayKey( _a206, _k206 );
}
}
player_emp_on()
{
self.empgrenaded = 1;
self setempjammed( 1 );
self shellshock( "frag_grenade_mp", 2 );
}
player_emp_off()
{
if ( isDefined( self ) )
{
self stopshellshock();
self setempjammed( 0 );
self.empgrenaded = undefined;
}
}
getwatcherforweapon( weapname )
{
if ( !isDefined( self ) )
{
return undefined;
}
if ( !isplayer( self ) )
{
return undefined;
}
i = 0;
while ( i < self.weaponobjectwatcherarray.size )
{
if ( self.weaponobjectwatcherarray[ i ].weapon != weapname )
{
i++;
continue;
}
else
{
return self.weaponobjectwatcherarray[ i ];
}
i++;
}
return undefined;
}
destroyequipment( origin, radius )
{
grenades = getentarray( "grenade", "classname" );
rsquared = radius * radius;
i = 0;
while ( i < grenades.size )
{
item = grenades[ i ];
if ( distancesquared( origin, item.origin ) > rsquared )
{
i++;
continue;
}
else if ( !isDefined( item.name ) )
{
i++;
continue;
}
else if ( !is_offhand_weapon( item.name ) )
{
i++;
continue;
}
else watcher = item.owner getwatcherforweapon( item.name );
if ( !isDefined( watcher ) )
{
i++;
continue;
}
else
{
watcher thread waitanddetonate( item, 0, self, "emp_grenade_zm" );
}
i++;
}
equipment = maps/mp/zombies/_zm_equipment::get_destructible_equipment_list();
i = 0;
while ( i < equipment.size )
{
item = equipment[ i ];
if ( !isDefined( item ) )
{
i++;
continue;
}
else if ( distancesquared( origin, item.origin ) > rsquared )
{
i++;
continue;
}
else if ( isDefined( item.isriotshield ) && item.isriotshield )
{
i++;
continue;
}
else
{
waitanddamage( item, 505 );
}
i++;
}
}
isempweapon( weaponname )
{
if ( isDefined( weaponname ) && weaponname != "emp_mp" || weaponname == "emp_grenade_mp" && weaponname == "emp_grenade_zm" )
{
return 1;
}
return 0;
}
waitanddetonate( object, delay, attacker, weaponname )
{
object endon( "death" );
object endon( "hacked" );
from_emp = isempweapon( weaponname );
if ( from_emp )
{
object.stun_fx = 1;
if ( isDefined( level._equipment_emp_destroy_fx ) )
{
playfx( level._equipment_emp_destroy_fx, object.origin + vectorScale( ( 0, 0, 1 ), 5 ), ( 0, randomfloat( 360 ), 0 ) );
}
delay = 1,1;
}
if ( delay )
{
wait delay;
}
if ( isDefined( object.detonated ) && object.detonated == 1 )
{
return;
}
if ( !isDefined( self.detonate ) )
{
return;
}
if ( isDefined( attacker ) && isplayer( attacker ) && isDefined( attacker.pers[ "team" ] ) && isDefined( object.owner ) && isDefined( object.owner.pers[ "team" ] ) )
{
if ( level.teambased )
{
if ( attacker.pers[ "team" ] != object.owner.pers[ "team" ] )
{
attacker notify( "destroyed_explosive" );
}
}
else
{
if ( attacker != object.owner )
{
attacker notify( "destroyed_explosive" );
}
}
}
object.detonated = 1;
object [[ self.detonate ]]( attacker, weaponname );
}
waitanddamage( object, damage )
{
object endon( "death" );
object endon( "hacked" );
object.stun_fx = 1;
if ( isDefined( level._equipment_emp_destroy_fx ) )
{
playfx( level._equipment_emp_destroy_fx, object.origin + vectorScale( ( 0, 0, 1 ), 5 ), ( 0, randomfloat( 360 ), 0 ) );
}
delay = 1,1;
if ( delay )
{
wait delay;
}
object maps/mp/zombies/_zm_equipment::item_damage( damage );
}

910
zm_transit_dr_patch/maps/mp/zombies/_zm_weap_jetgun.gsc Normal file
View File

@ -0,0 +1,910 @@
#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;
#/
}
}

777
zm_transit_dr_patch/maps/mp/zombies/_zm_weap_riotshield.gsc Normal file
View File

@ -0,0 +1,777 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/animscripts/zm_death;
#include maps/mp/zombies/_zm_unitrigger;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/gametypes_zm/_weaponobjects;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
maps/mp/zombies/_zm_riotshield::init();
set_zombie_var( "riotshield_cylinder_radius", 360 );
set_zombie_var( "riotshield_fling_range", 90 );
set_zombie_var( "riotshield_gib_range", 90 );
set_zombie_var( "riotshield_gib_damage", 75 );
set_zombie_var( "riotshield_knockdown_range", 90 );
set_zombie_var( "riotshield_knockdown_damage", 15 );
set_zombie_var( "riotshield_hit_points", 1500 );
set_zombie_var( "riotshield_fling_damage_shield", 100 );
set_zombie_var( "riotshield_knockdown_damage_shield", 15 );
level.riotshield_network_choke_count = 0;
level.riotshield_gib_refs = [];
level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "guts";
level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "right_arm";
level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "left_arm";
level.riotshield_damage_callback = ::player_damage_shield;
level.deployed_riotshield_damage_callback = ::deployed_damage_shield;
level.transferriotshield = ::transferriotshield;
level.cantransferriotshield = ::cantransferriotshield;
maps/mp/zombies/_zm_spawner::register_zombie_damage_callback( ::riotshield_zombie_damage_response );
maps/mp/zombies/_zm_equipment::register_equipment( "riotshield_zm", &"ZOMBIE_EQUIP_RIOTSHIELD_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_RIOTSHIELD_HOWTO", "riotshield_zm_icon", "riotshield", ::riotshield_activation_watcher_thread, undefined, ::dropshield, ::pickupshield );
maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "riotshield", &"ZOMBIE_EQUIP_RIOTSHIELD_PICKUP_HINT_STRING" );
onplayerconnect_callback( ::onplayerconnect );
}
onplayerconnect()
{
self.player_shield_reset_health = ::player_init_shield_health;
self.player_shield_apply_damage = ::player_damage_shield;
self.player_shield_reset_location = ::player_init_shield_location;
self thread watchriotshielduse();
self thread watchriotshieldmelee();
self thread player_watch_laststand();
}
dropshield()
{
self.shield_placement = 0;
self maps/mp/zombies/_zm_riotshield::updateriotshieldmodel();
item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "t6_wpn_zmb_shield_world", "riotshield_zm", self.origin + vectorScale( ( 0, 0, 1 ), 30 ), self.angles );
if ( isDefined( item ) )
{
item.shielddamagetaken = self.shielddamagetaken;
item.original_owner = self;
item.owner = undefined;
item.name = level.riotshield_name;
item.isriotshield = 1;
item deployed_damage_shield( 0 );
item setscriptmoverflag( 0 );
item.requires_pickup = 1;
item thread watchtoofriendly( self );
}
self takeweapon( level.riotshield_name );
return item;
}
watchtoofriendly( player )
{
wait 1;
if ( isDefined( self ) && isDefined( player ) && distance2dsquared( self.origin, player.origin ) < 36 )
{
if ( isalive( player ) )
{
player playlocalsound( level.zmb_laugh_alias );
}
player maps/mp/zombies/_zm_stats::increment_client_stat( "cheat_total", 0 );
self deployed_damage_shield( 2000 );
}
}
pickupshield( item )
{
item.owner = self;
damage = item.shielddamagetaken;
damagemax = level.zombie_vars[ "riotshield_hit_points" ];
self.shielddamagetaken = damage;
self player_set_shield_health( damage, damagemax );
}
placeshield( origin, angles )
{
if ( self getcurrentweapon() != level.riotshield_name )
{
self switchtoweapon( level.riotshield_name );
self waittill( "weapon_change" );
}
item = self maps/mp/zombies/_zm_riotshield::doriotshielddeploy( origin, angles );
if ( isDefined( item ) )
{
item.origin = self.origin + vectorScale( ( 0, 0, 1 ), 30 );
item.angles = self.angles;
item.owner = self;
}
return item;
}
cantransferriotshield( fromplayer, toplayer )
{
if ( isDefined( toplayer.screecher_weapon ) )
{
return 0;
}
if ( isDefined( toplayer.is_drinking ) && toplayer.is_drinking > 0 )
{
return 0;
}
if ( toplayer maps/mp/zombies/_zm_laststand::player_is_in_laststand() || toplayer in_revive_trigger() )
{
return 0;
}
if ( toplayer isthrowinggrenade() )
{
return 0;
}
if ( fromplayer == toplayer )
{
return 1;
}
if ( toplayer is_player_equipment( level.riotshield_name ) && toplayer.shield_placement != 3 )
{
return 0;
}
if ( fromplayer.session_team != toplayer.session_team )
{
return 0;
}
return 1;
}
transferriotshield( fromplayer, toplayer )
{
damage = fromplayer.shielddamagetaken;
toplayer player_take_riotshield();
fromplayer player_take_riotshield();
toplayer.shielddamagetaken = damage;
toplayer.shield_placement = 3;
toplayer.shield_damage_level = 0;
toplayer maps/mp/zombies/_zm_equipment::equipment_give( "riotshield_zm" );
toplayer switchtoweapon( "riotshield_zm" );
damagemax = level.zombie_vars[ "riotshield_hit_points" ];
toplayer player_set_shield_health( damage, damagemax );
}
player_take_riotshield()
{
self notify( "destroy_riotshield" );
if ( self getcurrentweapon() == "riotshield_zm" )
{
new_primary = "";
if ( isDefined( self.laststand ) && self.laststand )
{
new_primary = self.laststandpistol;
self giveweapon( new_primary );
}
else
{
primaryweapons = self getweaponslistprimaries();
i = 0;
while ( i < primaryweapons.size )
{
if ( primaryweapons[ i ] != "riotshield_zm" )
{
new_primary = primaryweapons[ i ];
break;
}
else
{
i++;
}
}
if ( new_primary == "" )
{
self maps/mp/zombies/_zm_weapons::give_fallback_weapon();
new_primary = "zombie_fists_zm";
}
}
self switchtoweaponimmediate( new_primary );
self playsound( "wpn_riotshield_zm_destroy" );
self waittill( "weapon_change" );
}
self maps/mp/zombies/_zm_riotshield::removeriotshield();
self maps/mp/zombies/_zm_equipment::equipment_take( "riotshield_zm" );
self.hasriotshield = 0;
self.hasriotshieldequipped = 0;
}
player_watch_laststand()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "entering_last_stand" );
if ( self getcurrentweapon() == "riotshield_zm" )
{
new_primary = self.laststandpistol;
self giveweapon( new_primary );
self switchtoweaponimmediate( new_primary );
}
}
}
player_init_shield_health()
{
retval = self.shielddamagetaken > 0;
self.shielddamagetaken = 0;
self.shield_damage_level = 0;
self maps/mp/zombies/_zm_riotshield::updateriotshieldmodel();
return retval;
}
player_init_shield_location()
{
self.hasriotshield = 1;
self.hasriotshieldequipped = 0;
self.shield_placement = 2;
self maps/mp/zombies/_zm_riotshield::updateriotshieldmodel();
}
player_set_shield_health( damage, max_damage )
{
shieldhealth = int( ( 100 * ( max_damage - damage ) ) / max_damage );
if ( shieldhealth >= 50 )
{
self.shield_damage_level = 0;
}
else if ( shieldhealth >= 25 )
{
self.shield_damage_level = 2;
}
else
{
self.shield_damage_level = 3;
}
self maps/mp/zombies/_zm_riotshield::updateriotshieldmodel();
}
deployed_set_shield_health( damage, max_damage )
{
shieldhealth = int( ( 100 * ( max_damage - damage ) ) / max_damage );
if ( shieldhealth >= 50 )
{
self.shield_damage_level = 0;
}
else if ( shieldhealth >= 25 )
{
self.shield_damage_level = 2;
}
else
{
self.shield_damage_level = 3;
}
self maps/mp/zombies/_zm_riotshield::updatestandaloneriotshieldmodel();
}
player_damage_shield( idamage, bheld )
{
damagemax = level.zombie_vars[ "riotshield_hit_points" ];
if ( !isDefined( self.shielddamagetaken ) )
{
self.shielddamagetaken = 0;
}
self.shielddamagetaken += idamage;
if ( self.shielddamagetaken >= damagemax )
{
if ( bheld || !isDefined( self.shield_ent ) )
{
self playrumbleonentity( "damage_heavy" );
earthquake( 1, 0,75, self.origin, 100 );
}
else
{
if ( isDefined( self.shield_ent ) )
{
if ( is_true( self.shield_ent.destroy_begun ) )
{
return;
}
self.shield_ent.destroy_begun = 1;
shield_origin = self.shield_ent.origin;
level thread maps/mp/zombies/_zm_equipment::equipment_disappear_fx( shield_origin, level._riotshield_dissapear_fx );
wait 1;
playsoundatposition( "wpn_riotshield_zm_destroy", shield_origin );
}
}
self thread player_take_riotshield();
}
else
{
if ( bheld )
{
self playrumbleonentity( "damage_light" );
earthquake( 0,5, 0,5, self.origin, 100 );
}
self player_set_shield_health( self.shielddamagetaken, damagemax );
self playsound( "fly_riotshield_zm_impact_zombies" );
}
}
deployed_damage_shield( idamage )
{
damagemax = level.zombie_vars[ "riotshield_hit_points" ];
if ( !isDefined( self.shielddamagetaken ) )
{
self.shielddamagetaken = 0;
}
self.shielddamagetaken += idamage;
if ( self.shielddamagetaken >= damagemax )
{
shield_origin = self.origin;
if ( isDefined( self.stub ) )
{
thread maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.stub );
}
if ( isDefined( self.original_owner ) )
{
self.original_owner maps/mp/zombies/_zm_equipment::equipment_take( "riotshield_zm" );
}
maps/mp/zombies/_zm_equipment::equipment_disappear_fx( shield_origin, level._riotshield_dissapear_fx );
playsoundatposition( "wpn_riotshield_zm_destroy", shield_origin );
self_delete();
}
else
{
self deployed_set_shield_health( self.shielddamagetaken, damagemax );
}
}
riotshield_activation_watcher_thread()
{
self endon( "zombified" );
self endon( "disconnect" );
self endon( "riotshield_zm_taken" );
while ( 1 )
{
self waittill_either( "riotshield_zm_activate", "riotshield_zm_deactivate" );
}
}
watchriotshielduse()
{
self endon( "death" );
self endon( "disconnect" );
self.shielddamagetaken = 0;
self thread maps/mp/zombies/_zm_riotshield::trackriotshield();
self thread maps/mp/zombies/_zm_riotshield::watchshieldlaststand();
self thread trackstuckzombies();
for ( ;; )
{
self waittill( "raise_riotshield" );
self thread maps/mp/zombies/_zm_riotshield::startriotshielddeploy();
}
}
watchriotshieldmelee()
{
for ( ;; )
{
self waittill( "weapon_melee", weapon );
if ( weapon == level.riotshield_name )
{
self riotshield_melee();
}
}
}
is_riotshield_damage( mod, player, amount )
{
if ( mod == "MOD_MELEE" && player hasweapon( level.riotshield_name ) && amount < 10 )
{
return 1;
}
return 0;
}
riotshield_damage( amount )
{
}
riotshield_fling_zombie( player, fling_vec, index )
{
if ( !isDefined( self ) || !isalive( self ) )
{
return;
}
if ( isDefined( self.ignore_riotshield ) && self.ignore_riotshield )
{
return;
}
if ( isDefined( self.riotshield_fling_func ) )
{
self [[ self.riotshield_fling_func ]]( player );
return;
}
damage = 2500;
self dodamage( damage, player.origin, player, player, "", "MOD_IMPACT" );
if ( self.health < 1 )
{
self.riotshield_death = 1;
self startragdoll();
self launchragdoll( fling_vec );
}
}
zombie_knockdown( player, gib )
{
damage = level.zombie_vars[ "riotshield_knockdown_damage" ];
if ( isDefined( level.override_riotshield_damage_func ) )
{
self [[ level.override_riotshield_damage_func ]]( player, gib );
}
else
{
if ( gib )
{
self.a.gib_ref = random( level.riotshield_gib_refs );
self thread maps/mp/animscripts/zm_death::do_gib();
}
self dodamage( damage, player.origin, player );
}
}
riotshield_knockdown_zombie( player, gib )
{
self endon( "death" );
playsoundatposition( "vox_riotshield_forcehit", self.origin );
playsoundatposition( "wpn_riotshield_proj_impact", self.origin );
if ( !isDefined( self ) || !isalive( self ) )
{
return;
}
if ( isDefined( self.riotshield_knockdown_func ) )
{
self [[ self.riotshield_knockdown_func ]]( player, gib );
}
else
{
self zombie_knockdown( player, gib );
}
self dodamage( level.zombie_vars[ "riotshield_knockdown_damage" ], player.origin, player );
self playsound( "fly_riotshield_forcehit" );
}
riotshield_get_enemies_in_range()
{
view_pos = self geteye();
zombies = get_array_of_closest( view_pos, get_round_enemy_array(), undefined, undefined, 2 * level.zombie_vars[ "riotshield_knockdown_range" ] );
if ( !isDefined( zombies ) )
{
return;
}
knockdown_range_squared = level.zombie_vars[ "riotshield_knockdown_range" ] * level.zombie_vars[ "riotshield_knockdown_range" ];
gib_range_squared = level.zombie_vars[ "riotshield_gib_range" ] * level.zombie_vars[ "riotshield_gib_range" ];
fling_range_squared = level.zombie_vars[ "riotshield_fling_range" ] * level.zombie_vars[ "riotshield_fling_range" ];
cylinder_radius_squared = level.zombie_vars[ "riotshield_cylinder_radius" ] * level.zombie_vars[ "riotshield_cylinder_radius" ];
forward_view_angles = self getweaponforwarddir();
end_pos = view_pos + vectorScale( forward_view_angles, level.zombie_vars[ "riotshield_knockdown_range" ] );
/#
if ( getDvarInt( #"BF480CE9" ) == 2 )
{
near_circle_pos = view_pos + vectorScale( forward_view_angles, 2 );
circle( near_circle_pos, level.zombie_vars[ "riotshield_cylinder_radius" ], ( 0, 0, 1 ), 0, 0, 100 );
line( near_circle_pos, end_pos, ( 0, 0, 1 ), 1, 0, 100 );
circle( end_pos, level.zombie_vars[ "riotshield_cylinder_radius" ], ( 0, 0, 1 ), 0, 0, 100 );
#/
}
i = 0;
while ( i < zombies.size )
{
if ( !isDefined( zombies[ i ] ) || !isalive( zombies[ i ] ) )
{
i++;
continue;
}
else
{
test_origin = zombies[ i ] getcentroid();
test_range_squared = distancesquared( view_pos, test_origin );
if ( test_range_squared > knockdown_range_squared )
{
zombies[ i ] riotshield_debug_print( "range", ( 0, 0, 1 ) );
return;
}
normal = vectornormalize( test_origin - view_pos );
dot = vectordot( forward_view_angles, normal );
if ( dot <= 0 )
{
zombies[ i ] riotshield_debug_print( "dot", ( 0, 0, 1 ) );
i++;
continue;
}
else radial_origin = pointonsegmentnearesttopoint( view_pos, end_pos, test_origin );
if ( distancesquared( test_origin, radial_origin ) > cylinder_radius_squared )
{
zombies[ i ] riotshield_debug_print( "cylinder", ( 0, 0, 1 ) );
i++;
continue;
}
else if ( zombies[ i ] damageconetrace( view_pos, self ) == 0 )
{
zombies[ i ] riotshield_debug_print( "cone", ( 0, 0, 1 ) );
i++;
continue;
}
else if ( test_range_squared < fling_range_squared )
{
level.riotshield_fling_enemies[ level.riotshield_fling_enemies.size ] = zombies[ i ];
dist_mult = ( fling_range_squared - test_range_squared ) / fling_range_squared;
fling_vec = vectornormalize( test_origin - view_pos );
if ( test_range_squared >= 5000 )
{
fling_vec += vectornormalize( test_origin - radial_origin );
}
fling_vec = ( fling_vec[ 0 ], fling_vec[ 1 ], abs( fling_vec[ 2 ] ) );
fling_vec = vectorScale( fling_vec, 100 + ( 100 * dist_mult ) );
level.riotshield_fling_vecs[ level.riotshield_fling_vecs.size ] = fling_vec;
zombies[ i ] riotshield_debug_print( "fling", ( 0, 0, 1 ) );
i++;
continue;
}
else
{
level.riotshield_knockdown_enemies[ level.riotshield_knockdown_enemies.size ] = zombies[ i ];
level.riotshield_knockdown_gib[ level.riotshield_knockdown_gib.size ] = 0;
zombies[ i ] riotshield_debug_print( "knockdown", ( 0, 0, 1 ) );
}
}
i++;
}
}
riotshield_network_choke()
{
level.riotshield_network_choke_count++;
if ( level.riotshield_network_choke_count % 10 )
{
wait_network_frame();
wait_network_frame();
wait_network_frame();
}
}
riotshield_melee()
{
if ( !isDefined( level.riotshield_knockdown_enemies ) )
{
level.riotshield_knockdown_enemies = [];
level.riotshield_knockdown_gib = [];
level.riotshield_fling_enemies = [];
level.riotshield_fling_vecs = [];
}
self riotshield_get_enemies_in_range();
shield_damage = 0;
level.riotshield_network_choke_count = 0;
i = 0;
while ( i < level.riotshield_fling_enemies.size )
{
riotshield_network_choke();
if ( isDefined( level.riotshield_fling_enemies[ i ] ) )
{
level.riotshield_fling_enemies[ i ] thread riotshield_fling_zombie( self, level.riotshield_fling_vecs[ i ], i );
shield_damage += level.zombie_vars[ "riotshield_fling_damage_shield" ];
}
i++;
}
i = 0;
while ( i < level.riotshield_knockdown_enemies.size )
{
riotshield_network_choke();
level.riotshield_knockdown_enemies[ i ] thread riotshield_knockdown_zombie( self, level.riotshield_knockdown_gib[ i ] );
shield_damage += level.zombie_vars[ "riotshield_knockdown_damage_shield" ];
i++;
}
level.riotshield_knockdown_enemies = [];
level.riotshield_knockdown_gib = [];
level.riotshield_fling_enemies = [];
level.riotshield_fling_vecs = [];
if ( shield_damage )
{
self player_damage_shield( shield_damage, 0 );
}
}
trackstuckzombies()
{
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "deployed_riotshield" );
if ( isDefined( self.riotshieldentity ) )
{
self thread watchstuckzombies();
}
}
}
attack_shield( shield )
{
self endon( "death" );
shield.owner endon( "death" );
shield.owner endon( "disconnect" );
shield.owner endon( "start_riotshield_deploy" );
shield.owner endon( "destroy_riotshield" );
if ( isDefined( self.doing_shield_attack ) && self.doing_shield_attack )
{
return 0;
}
self.old_origin = self.origin;
if ( getDvar( "zombie_shield_attack_freq" ) == "" )
{
setdvar( "zombie_shield_attack_freq", "15" );
}
freq = getDvarInt( "zombie_shield_attack_freq" );
self.doing_shield_attack = 1;
self.enemyoverride[ 0 ] = shield.origin;
self.enemyoverride[ 1 ] = shield;
wait ( randomint( 100 ) / 100 );
self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "attack", self.animname );
attackanim = "zm_riotshield_melee";
if ( !self.has_legs )
{
attackanim += "_crawl";
}
self orientmode( "face point", shield.origin );
self animscripted( self.origin, flat_angle( vectorToAngle( shield.origin - self.origin ) ), attackanim );
if ( isDefined( shield.owner.player_shield_apply_damage ) )
{
shield.owner [[ shield.owner.player_shield_apply_damage ]]( 100, 0 );
}
else
{
shield.owner player_damage_shield( 100, 0 );
}
self thread attack_shield_stop( shield );
wait ( randomint( 100 ) / 100 );
self.doing_shield_attack = 0;
self orientmode( "face default" );
}
attack_shield_stop( shield )
{
self notify( "attack_shield_stop" );
self endon( "attack_shield_stop" );
self endon( "death" );
shield waittill( "death" );
self stopanimscripted();
if ( isDefined( self.doing_shield_attack ) && self.doing_shield_attack )
{
breachanim = "zm_riotshield_breakthrough";
if ( !self.has_legs )
{
breachanim += "_crawl";
}
self animscripted( self.origin, flat_angle( self.angles ), breachanim );
}
}
window_notetracks( msg, player )
{
self endon( "death" );
while ( 1 )
{
self waittill( msg, notetrack );
if ( notetrack == "end" )
{
return;
}
if ( notetrack == "fire" )
{
player player_damage_shield( 100, 0 );
}
}
}
watchstuckzombies()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "start_riotshield_deploy" );
self endon( "destroy_riotshield" );
self endon( "deployed_riotshield" );
level endon( "intermission" );
self.riotshieldentity maps/mp/zombies/_zm_equipment::item_attract_zombies();
}
riotshield_active()
{
return self maps/mp/zombies/_zm_equipment::is_equipment_active( "riotshield_zm" );
}
riotshield_debug_print( msg, color )
{
/#
if ( !getDvarInt( #"BF480CE9" ) )
{
return;
}
if ( !isDefined( color ) )
{
color = ( 0, 0, 1 );
}
print3d( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), msg, color, 1, 1, 40 );
#/
}
shield_zombie_attract_func( poi )
{
}
shield_zombie_arrive_func( poi )
{
self endon( "death" );
self endon( "zombie_acquire_enemy" );
self endon( "path_timer_done" );
self waittill( "goal" );
if ( isDefined( poi.owner ) )
{
poi.owner player_damage_shield( 100, 0 );
if ( isDefined( poi.owner.player_shield_apply_damage ) )
{
poi.owner [[ poi.owner.player_shield_apply_damage ]]( 100, 0 );
}
}
}
createriotshieldattractor()
{
self create_zombie_point_of_interest( 50, 8, 0, 1, ::shield_zombie_attract_func, ::shield_zombie_arrive_func );
self thread create_zombie_point_of_interest_attractor_positions( 4, 15, 15 );
return get_zombie_point_of_interest( self.origin );
}
riotshield_zombie_damage_response( mod, hit_location, hit_origin, player, amount )
{
if ( self is_riotshield_damage( mod, player, amount ) )
{
self riotshield_damage( amount );
return 1;
}
return 0;
}
watchriotshieldattractor()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "start_riotshield_deploy" );
self endon( "destroy_riotshield" );
self endon( "deployed_riotshield" );
poi = self.riotshieldentity createriotshieldattractor();
}
trackriotshieldattractor()
{
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "deployed_riotshield" );
self thread watchriotshieldattractor();
}
}

150
zm_transit_dr_patch/maps/mp/zombies/_zm_weap_tazer_knuckles.gsc Normal file
View File

@ -0,0 +1,150 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_spawner;
#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()
{
registerclientfield( "toplayer", "tazer_flourish", 1, 1, "int" );
register_melee_weapon_for_level( "tazer_knuckles_zm" );
if ( isDefined( level.tazer_cost ) )
{
cost = level.tazer_cost;
}
else
{
cost = 6000;
}
level.use_tazer_impact_fx = 0;
maps/mp/zombies/_zm_melee_weapon::init( "tazer_knuckles_zm", "zombie_tazer_flourish", "knife_ballistic_no_melee_zm", "knife_ballistic_no_melee_upgraded_zm", cost, "tazer_upgrade", &"ZOMBIE_WEAPON_TAZER_BUY", "tazerknuckles", ::has_tazer, ::give_tazer, ::take_tazer, ::tazer_flourish_fx );
maps/mp/zombies/_zm_weapons::add_retrievable_knife_init_name( "knife_ballistic_no_melee" );
maps/mp/zombies/_zm_weapons::add_retrievable_knife_init_name( "knife_ballistic_no_melee_upgraded" );
maps/mp/zombies/_zm_spawner::add_cusom_zombie_spawn_logic( ::watch_bodily_functions );
level._effect[ "fx_zmb_taser_vomit" ] = loadfx( "maps/zombie/fx_zmb_taser_vomit" );
level._effect[ "fx_zmb_taser_flourish" ] = loadfx( "weapon/taser/fx_taser_knuckles_anim_zmb" );
if ( level.script != "zm_transit" )
{
level._effect[ "fx_zmb_tazer_impact" ] = loadfx( "weapon/taser/fx_taser_knuckles_impact_zmb" );
level.use_tazer_impact_fx = 1;
}
level.tazer_flourish_delay = 0,5;
}
spectator_respawn()
{
maps/mp/zombies/_zm_melee_weapon::spectator_respawn( "tazer_upgrade", ::take_tazer, ::has_tazer );
}
watch_bodily_functions()
{
if ( isDefined( self.isscreecher ) || self.isscreecher && isDefined( self.is_avogadro ) && self.is_avogadro )
{
return;
}
while ( 1 )
{
self waittill( "damage", amount, attacker, direction_vec, point, type );
if ( !isDefined( self ) )
{
return;
}
if ( !isDefined( attacker ) || !isplayer( attacker ) )
{
continue;
}
while ( type != "MOD_MELEE" )
{
continue;
}
if ( !attacker hasweapon( "tazer_knuckles_zm" ) || isDefined( self.hasriotshieldequipped ) && self.hasriotshieldequipped )
{
continue;
}
ch = randomint( 100 );
if ( ch < 4 )
{
playfxontag( level._effect[ "fx_zmb_taser_vomit" ], self, "j_neck" );
}
if ( level.use_tazer_impact_fx )
{
tags = [];
tags[ 0 ] = "J_Head";
tags[ 1 ] = "J_Neck";
playfxontag( level._effect[ "fx_zmb_tazer_impact" ], self, random( tags ) );
}
}
}
onplayerconnect()
{
self thread onplayerspawned();
}
onplayerspawned()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "spawned_player" );
self thread watchtazerknucklemelee();
}
}
watchtazerknucklemelee()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "weapon_melee", weapon );
if ( weapon == "tazer_knuckles_zm" )
{
self tazerknuckle_melee();
}
}
}
tazerknuckle_melee()
{
}
has_tazer()
{
if ( isDefined( level._allow_melee_weapon_switching ) && level._allow_melee_weapon_switching )
{
return 0;
}
if ( isDefined( self._sickle_zm_equipped ) && !self._sickle_zm_equipped && isDefined( self._bowie_zm_equipped ) || self._bowie_zm_equipped && isDefined( self._tazer_zm_equipped ) && self._tazer_zm_equipped )
{
return 1;
}
return 0;
}
give_tazer()
{
self._tazer_zm_equipped = 1;
self._bowie_zm_equipped = undefined;
self._sickle_zm_equipped = undefined;
}
take_tazer()
{
self._tazer_zm_equipped = undefined;
}
tazer_flourish_fx()
{
self waittill( "weapon_change", newweapon );
if ( newweapon == "zombie_tazer_flourish" )
{
self endon( "weapon_change" );
wait level.tazer_flourish_delay;
self thread maps/mp/zombies/_zm_audio::playerexert( "hitmed" );
self setclientfieldtoplayer( "tazer_flourish", 1 );
wait_network_frame();
self setclientfieldtoplayer( "tazer_flourish", 0 );
}
}

2722
zm_transit_dr_patch/maps/mp/zombies/_zm_weapons.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

1229
zm_transit_dr_patch/maps/mp/zombies/_zm_zonemgr.gsc Normal file
View File

File diff suppressed because it is too large Load Diff