INSANEMODE/Recompilable-gscs-for-BO2-zombies-and-multiplayer
1
0
Fork 0
mirror of https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git synced 2025-06-17 22:27:58 -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

497
zm_transit_dr_patch/maps/mp/_art.gsc Normal file
View File

@ -0,0 +1,497 @@
#include maps/mp/_utility;
#include common_scripts/utility;
main()
{
/#
if ( getDvar( "scr_art_tweak" ) == "" || getDvar( "scr_art_tweak" ) == "0" )
{
setdvar( "scr_art_tweak", 0 );
}
if ( getDvar( "scr_dof_enable" ) == "" )
{
setdvar( "scr_dof_enable", "1" );
}
if ( getDvar( "scr_cinematic_autofocus" ) == "" )
{
setdvar( "scr_cinematic_autofocus", "1" );
}
if ( getDvar( "scr_art_visionfile" ) == "" && isDefined( level.script ) )
{
setdvar( "scr_art_visionfile", level.script );
}
if ( getDvar( "debug_reflection" ) == "" )
{
setdvar( "debug_reflection", "0" );
}
if ( getDvar( "debug_reflection_matte" ) == "" )
{
setdvar( "debug_reflection_matte", "0" );
}
if ( getDvar( "debug_color_pallete" ) == "" )
{
setdvar( "debug_color_pallete", "0" );
}
precachemodel( "test_sphere_lambert" );
precachemodel( "test_macbeth_chart" );
precachemodel( "test_macbeth_chart_unlit" );
precachemodel( "test_sphere_silver" );
level thread debug_reflection();
level thread debug_reflection_matte();
level thread debug_color_pallete();
#/
if ( !isDefined( level.dofdefault ) )
{
level.dofdefault[ "nearStart" ] = 0;
level.dofdefault[ "nearEnd" ] = 1;
level.dofdefault[ "farStart" ] = 8000;
level.dofdefault[ "farEnd" ] = 10000;
level.dofdefault[ "nearBlur" ] = 6;
level.dofdefault[ "farBlur" ] = 0;
}
level.curdof = ( level.dofdefault[ "farStart" ] - level.dofdefault[ "nearEnd" ] ) / 2;
/#
thread tweakart();
#/
if ( !isDefined( level.script ) )
{
level.script = tolower( getDvar( "mapname" ) );
}
}
artfxprintln( file, string )
{
/#
if ( file == -1 )
{
return;
}
fprintln( file, string );
#/
}
strtok_loc( string, par1 )
{
stringlist = [];
indexstring = "";
i = 0;
while ( i < string.size )
{
if ( string[ i ] == " " )
{
stringlist[ stringlist.size ] = indexstring;
indexstring = "";
i++;
continue;
}
else
{
indexstring += string[ i ];
}
i++;
}
if ( indexstring.size )
{
stringlist[ stringlist.size ] = indexstring;
}
return stringlist;
}
setfogsliders()
{
fogall = strtok_loc( getDvar( "g_fogColorReadOnly" ), " " );
red = fogall[ 0 ];
green = fogall[ 1 ];
blue = fogall[ 2 ];
halfplane = getDvar( "g_fogHalfDistReadOnly" );
nearplane = getDvar( "g_fogStartDistReadOnly" );
if ( isDefined( red ) && isDefined( green ) || !isDefined( blue ) && !isDefined( halfplane ) )
{
red = 1;
green = 1;
blue = 1;
halfplane = 10000001;
nearplane = 10000000;
}
setdvar( "scr_fog_exp_halfplane", halfplane );
setdvar( "scr_fog_nearplane", nearplane );
setdvar( "scr_fog_color", ( red + " " ) + green + " " + blue );
}
tweakart()
{
/#
if ( !isDefined( level.tweakfile ) )
{
level.tweakfile = 0;
}
if ( getDvar( "scr_fog_baseheight" ) == "" )
{
setdvar( "scr_fog_exp_halfplane", "500" );
setdvar( "scr_fog_exp_halfheight", "500" );
setdvar( "scr_fog_nearplane", "0" );
setdvar( "scr_fog_baseheight", "0" );
}
setdvar( "scr_fog_fraction", "1.0" );
setdvar( "scr_art_dump", "0" );
setdvar( "scr_art_sun_fog_dir_set", "0" );
setdvar( "scr_dof_nearStart", level.dofdefault[ "nearStart" ] );
setdvar( "scr_dof_nearEnd", level.dofdefault[ "nearEnd" ] );
setdvar( "scr_dof_farStart", level.dofdefault[ "farStart" ] );
setdvar( "scr_dof_farEnd", level.dofdefault[ "farEnd" ] );
setdvar( "scr_dof_nearBlur", level.dofdefault[ "nearBlur" ] );
setdvar( "scr_dof_farBlur", level.dofdefault[ "farBlur" ] );
file = undefined;
filename = undefined;
tweak_toggle = 1;
for ( ;; )
{
while ( getDvarInt( "scr_art_tweak" ) == 0 )
{
tweak_toggle = 1;
wait 0,05;
}
if ( tweak_toggle )
{
tweak_toggle = 0;
fogsettings = getfogsettings();
setdvar( "scr_fog_nearplane", fogsettings[ 0 ] );
setdvar( "scr_fog_exp_halfplane", fogsettings[ 1 ] );
setdvar( "scr_fog_exp_halfheight", fogsettings[ 3 ] );
setdvar( "scr_fog_baseheight", fogsettings[ 2 ] );
setdvar( "scr_fog_color", fogsettings[ 4 ] + " " + fogsettings[ 5 ] + " " + fogsettings[ 6 ] );
setdvar( "scr_fog_color_scale", fogsettings[ 7 ] );
setdvar( "scr_sun_fog_color", fogsettings[ 8 ] + " " + fogsettings[ 9 ] + " " + fogsettings[ 10 ] );
level.fogsundir = [];
level.fogsundir[ 0 ] = fogsettings[ 11 ];
level.fogsundir[ 1 ] = fogsettings[ 12 ];
level.fogsundir[ 2 ] = fogsettings[ 13 ];
setdvar( "scr_sun_fog_start_angle", fogsettings[ 14 ] );
setdvar( "scr_sun_fog_end_angle", fogsettings[ 15 ] );
setdvar( "scr_fog_max_opacity", fogsettings[ 16 ] );
}
level.fogexphalfplane = getDvarFloat( "scr_fog_exp_halfplane" );
level.fogexphalfheight = getDvarFloat( "scr_fog_exp_halfheight" );
level.fognearplane = getDvarFloat( "scr_fog_nearplane" );
level.fogbaseheight = getDvarFloat( "scr_fog_baseheight" );
level.fogcolorred = getDvarColorRed( "scr_fog_color" );
level.fogcolorgreen = getDvarColorGreen( "scr_fog_color" );
level.fogcolorblue = getDvarColorBlue( "scr_fog_color" );
level.fogcolorscale = getDvarFloat( "scr_fog_color_scale" );
level.sunfogcolorred = getDvarColorRed( "scr_sun_fog_color" );
level.sunfogcolorgreen = getDvarColorGreen( "scr_sun_fog_color" );
level.sunfogcolorblue = getDvarColorBlue( "scr_sun_fog_color" );
level.sunstartangle = getDvarFloat( "scr_sun_fog_start_angle" );
level.sunendangle = getDvarFloat( "scr_sun_fog_end_angle" );
level.fogmaxopacity = getDvarFloat( "scr_fog_max_opacity" );
if ( getDvarInt( "scr_art_sun_fog_dir_set" ) )
{
setdvar( "scr_art_sun_fog_dir_set", "0" );
println( "Setting sun fog direction to facing of player" );
players = get_players();
dir = vectornormalize( anglesToForward( players[ 0 ] getplayerangles() ) );
level.fogsundir = [];
level.fogsundir[ 0 ] = dir[ 0 ];
level.fogsundir[ 1 ] = dir[ 1 ];
level.fogsundir[ 2 ] = dir[ 2 ];
}
fovslidercheck();
dumpsettings();
if ( !getDvarInt( "scr_fog_disable" ) )
{
if ( !isDefined( level.fogsundir ) )
{
level.fogsundir = [];
level.fogsundir[ 0 ] = 1;
level.fogsundir[ 1 ] = 0;
level.fogsundir[ 2 ] = 0;
}
setvolfog( level.fognearplane, level.fogexphalfplane, level.fogexphalfheight, level.fogbaseheight, level.fogcolorred, level.fogcolorgreen, level.fogcolorblue, level.fogcolorscale, level.sunfogcolorred, level.sunfogcolorgreen, level.sunfogcolorblue, level.fogsundir[ 0 ], level.fogsundir[ 1 ], level.fogsundir[ 2 ], level.sunstartangle, level.sunendangle, 0, level.fogmaxopacity );
}
else
{
setexpfog( 100000000, 100000001, 0, 0, 0, 0 );
}
wait 0,1;
#/
}
}
fovslidercheck()
{
if ( level.dofdefault[ "nearStart" ] >= level.dofdefault[ "nearEnd" ] )
{
level.dofdefault[ "nearStart" ] = level.dofdefault[ "nearEnd" ] - 1;
setdvar( "scr_dof_nearStart", level.dofdefault[ "nearStart" ] );
}
if ( level.dofdefault[ "nearEnd" ] <= level.dofdefault[ "nearStart" ] )
{
level.dofdefault[ "nearEnd" ] = level.dofdefault[ "nearStart" ] + 1;
setdvar( "scr_dof_nearEnd", level.dofdefault[ "nearEnd" ] );
}
if ( level.dofdefault[ "farStart" ] >= level.dofdefault[ "farEnd" ] )
{
level.dofdefault[ "farStart" ] = level.dofdefault[ "farEnd" ] - 1;
setdvar( "scr_dof_farStart", level.dofdefault[ "farStart" ] );
}
if ( level.dofdefault[ "farEnd" ] <= level.dofdefault[ "farStart" ] )
{
level.dofdefault[ "farEnd" ] = level.dofdefault[ "farStart" ] + 1;
setdvar( "scr_dof_farEnd", level.dofdefault[ "farEnd" ] );
}
if ( level.dofdefault[ "farBlur" ] >= level.dofdefault[ "nearBlur" ] )
{
level.dofdefault[ "farBlur" ] = level.dofdefault[ "nearBlur" ] - 0,1;
setdvar( "scr_dof_farBlur", level.dofdefault[ "farBlur" ] );
}
if ( level.dofdefault[ "farStart" ] <= level.dofdefault[ "nearEnd" ] )
{
level.dofdefault[ "farStart" ] = level.dofdefault[ "nearEnd" ] + 1;
setdvar( "scr_dof_farStart", level.dofdefault[ "farStart" ] );
}
}
dumpsettings()
{
/#
if ( getDvar( "scr_art_dump" ) != "0" )
{
println( "\tstart_dist = " + level.fognearplane + ";" );
println( "\thalf_dist = " + level.fogexphalfplane + ";" );
println( "\thalf_height = " + level.fogexphalfheight + ";" );
println( "\tbase_height = " + level.fogbaseheight + ";" );
println( "\tfog_r = " + level.fogcolorred + ";" );
println( "\tfog_g = " + level.fogcolorgreen + ";" );
println( "\tfog_b = " + level.fogcolorblue + ";" );
println( "\tfog_scale = " + level.fogcolorscale + ";" );
println( "\tsun_col_r = " + level.sunfogcolorred + ";" );
println( "\tsun_col_g = " + level.sunfogcolorgreen + ";" );
println( "\tsun_col_b = " + level.sunfogcolorblue + ";" );
println( "\tsun_dir_x = " + level.fogsundir[ 0 ] + ";" );
println( "\tsun_dir_y = " + level.fogsundir[ 1 ] + ";" );
println( "\tsun_dir_z = " + level.fogsundir[ 2 ] + ";" );
println( "\tsun_start_ang = " + level.sunstartangle + ";" );
println( "\tsun_stop_ang = " + level.sunendangle + ";" );
println( "\ttime = 0;" );
println( "\tmax_fog_opacity = " + level.fogmaxopacity + ";" );
println( "" );
println( "\tsetVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale," );
println( "\t\tsun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang, " );
println( "\t\tsun_stop_ang, time, max_fog_opacity);" );
setdvar( "scr_art_dump", "0" );
#/
}
}
debug_reflection()
{
/#
level.debug_reflection = 0;
while ( 1 )
{
wait 0,1;
if ( getDvar( "debug_reflection" ) == "2" || level.debug_reflection != 2 && getDvar( "debug_reflection" ) == "3" && level.debug_reflection != 3 )
{
remove_reflection_objects();
if ( getDvar( "debug_reflection" ) == "2" )
{
create_reflection_objects();
level.debug_reflection = 2;
}
else
{
create_reflection_objects();
create_reflection_object();
level.debug_reflection = 3;
}
continue;
}
else
{
if ( getDvar( "debug_reflection" ) == "1" && level.debug_reflection != 1 )
{
setdvar( "debug_reflection_matte", "0" );
setdvar( "debug_color_pallete", "0" );
remove_reflection_objects();
create_reflection_object();
level.debug_reflection = 1;
break;
}
else
{
if ( getDvar( "debug_reflection" ) == "0" && level.debug_reflection != 0 )
{
remove_reflection_objects();
level.debug_reflection = 0;
}
}
}
#/
}
}
remove_reflection_objects()
{
/#
if ( level.debug_reflection != 2 && level.debug_reflection == 3 && isDefined( level.debug_reflection_objects ) )
{
i = 0;
while ( i < level.debug_reflection_objects.size )
{
level.debug_reflection_objects[ i ] delete();
i++;
}
level.debug_reflection_objects = undefined;
}
if ( level.debug_reflection != 1 && level.debug_reflection != 3 && level.debug_reflection_matte != 1 || level.debug_color_pallete == 1 && level.debug_color_pallete == 2 )
{
if ( isDefined( level.debug_reflectionobject ) )
{
level.debug_reflectionobject delete();
#/
}
}
}
create_reflection_objects()
{
/#
reflection_locs = getreflectionlocs();
i = 0;
while ( i < reflection_locs.size )
{
level.debug_reflection_objects[ i ] = spawn( "script_model", reflection_locs[ i ] );
level.debug_reflection_objects[ i ] setmodel( "test_sphere_silver" );
i++;
#/
}
}
create_reflection_object( model )
{
if ( !isDefined( model ) )
{
model = "test_sphere_silver";
}
/#
if ( isDefined( level.debug_reflectionobject ) )
{
level.debug_reflectionobject delete();
}
players = get_players();
player = players[ 0 ];
level.debug_reflectionobject = spawn( "script_model", player geteye() + vectorScale( anglesToForward( player.angles ), 100 ) );
level.debug_reflectionobject setmodel( model );
level.debug_reflectionobject.origin = player geteye() + vectorScale( anglesToForward( player getplayerangles() ), 100 );
level.debug_reflectionobject linkto( player );
thread debug_reflection_buttons();
#/
}
debug_reflection_buttons()
{
/#
level notify( "new_reflection_button_running" );
level endon( "new_reflection_button_running" );
level.debug_reflectionobject endon( "death" );
offset = 100;
lastoffset = offset;
while ( getDvar( "debug_reflection" ) != "1" && getDvar( "debug_reflection" ) != "3" && getDvar( "debug_reflection_matte" ) != "1" || getDvar( "debug_color_pallete" ) == "1" && getDvar( "debug_color_pallete" ) == "2" )
{
players = get_players();
if ( players[ 0 ] buttonpressed( "BUTTON_X" ) )
{
offset += 50;
}
if ( players[ 0 ] buttonpressed( "BUTTON_Y" ) )
{
offset -= 50;
}
if ( offset > 1000 )
{
offset = 1000;
}
if ( offset < 64 )
{
offset = 64;
}
level.debug_reflectionobject unlink();
level.debug_reflectionobject.origin = players[ 0 ] geteye() + vectorScale( anglesToForward( players[ 0 ] getplayerangles() ), offset );
temp_angles = vectorToAngle( players[ 0 ].origin - level.debug_reflectionobject.origin );
level.debug_reflectionobject.angles = ( 0, temp_angles[ 1 ], 0 );
lastoffset = offset;
line( level.debug_reflectionobject.origin, getreflectionorigin( level.debug_reflectionobject.origin ), ( 1, 0, 0 ), 1, 1 );
wait 0,05;
if ( isDefined( level.debug_reflectionobject ) )
{
level.debug_reflectionobject linkto( players[ 0 ] );
}
#/
}
}
debug_reflection_matte()
{
/#
level.debug_reflection_matte = 0;
while ( 1 )
{
wait 0,1;
if ( getDvar( "debug_reflection_matte" ) == "1" && level.debug_reflection_matte != 1 )
{
setdvar( "debug_reflection", "0" );
setdvar( "debug_color_pallete", "0" );
remove_reflection_objects();
create_reflection_object( "test_sphere_lambert" );
level.debug_reflection_matte = 1;
continue;
}
else
{
if ( getDvar( "debug_reflection_matte" ) == "0" && level.debug_reflection_matte != 0 )
{
remove_reflection_objects();
level.debug_reflection_matte = 0;
}
}
#/
}
}
debug_color_pallete()
{
/#
level.debug_color_pallete = 0;
while ( 1 )
{
wait 0,1;
if ( getDvar( "debug_color_pallete" ) == "1" && level.debug_color_pallete != 1 )
{
setdvar( "debug_reflection", "0" );
setdvar( "debug_reflection_matte", "0" );
remove_reflection_objects();
create_reflection_object( "test_macbeth_chart" );
level.debug_color_pallete = 1;
continue;
}
else
{
if ( getDvar( "debug_color_pallete" ) == "2" && level.debug_color_pallete != 2 )
{
remove_reflection_objects();
create_reflection_object( "test_macbeth_chart_unlit" );
level.debug_color_pallete = 2;
break;
}
else
{
if ( getDvar( "debug_color_pallete" ) == "0" && level.debug_color_pallete != 0 )
{
remove_reflection_objects();
level.debug_color_pallete = 0;
}
}
}
#/
}
}

150
zm_transit_dr_patch/maps/mp/_audio.gsc Normal file
View File

@ -0,0 +1,150 @@
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
}
wait_until_first_player()
{
players = get_players();
if ( !isDefined( players[ 0 ] ) )
{
level waittill( "first_player_ready" );
}
players = get_players();
i = 0;
while ( i < players.size )
{
players[ i ] thread monitor_player_sprint();
i++;
}
}
stand_think( trig )
{
killtext = "kill_stand_think" + trig getentitynumber();
self endon( "disconnect" );
self endon( "death" );
self endon( killtext );
while ( 1 )
{
if ( self.player_is_moving )
{
trig playsound( trig.script_label );
}
wait 1;
}
}
monitor_player_sprint()
{
self endon( "disconnect" );
self thread monitor_player_movement();
self._is_sprinting = 0;
while ( 1 )
{
self waittill( "sprint_begin" );
self._is_sprinting = 1;
self waittill( "sprint_end" );
self._is_sprinting = 0;
}
}
monitor_player_movement()
{
self endon( "disconnect" );
while ( 1 )
{
org_1 = self.origin;
wait 1;
org_2 = self.origin;
distancemoved = distancesquared( org_1, org_2 );
if ( distancemoved > 4096 )
{
self.player_is_moving = 1;
continue;
}
else
{
self.player_is_moving = 0;
}
}
}
thread_enter_exit_sound( trig )
{
self endon( "death" );
self endon( "disconnect" );
trig.touchingplayers[ self getentitynumber() ] = 1;
if ( isDefined( trig.script_sound ) && trig.script_activated && self._is_sprinting )
{
self playsound( trig.script_sound );
}
self thread stand_think( trig );
while ( self istouching( trig ) )
{
wait 0,1;
}
self notify( "kill_stand_think" + trig getentitynumber() );
self playsound( trig.script_noteworthy );
trig.touchingplayers[ self getentitynumber() ] = 0;
}
thread_step_trigger()
{
if ( !isDefined( self.script_activated ) )
{
self.script_activated = 1;
}
while ( !isDefined( self.touchingplayers ) )
{
self.touchingplayers = [];
i = 0;
while ( i < 4 )
{
self.touchingplayers[ i ] = 0;
i++;
}
}
while ( 1 )
{
self waittill( "trigger", who );
if ( self.touchingplayers[ who getentitynumber() ] == 0 )
{
who thread thread_enter_exit_sound( self );
}
}
}
disable_bump_trigger( triggername )
{
triggers = getentarray( "audio_bump_trigger", "targetname" );
while ( isDefined( triggers ) )
{
i = 0;
while ( i < triggers.size )
{
if ( isDefined( triggers[ i ].script_label ) && triggers[ i ].script_label == triggername )
{
triggers[ i ].script_activated = 0;
}
i++;
}
}
}
get_player_index_number( player )
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( players[ i ] == player )
{
return i;
}
i++;
}
return 1;
}

273
zm_transit_dr_patch/maps/mp/_ballistic_knife.gsc Normal file
View File

@ -0,0 +1,273 @@
#include maps/mp/_challenges;
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
precachemodel( "t6_wpn_ballistic_knife_projectile" );
precachemodel( "t6_wpn_ballistic_knife_blade_retrieve" );
}
onspawn( watcher, player )
{
player endon( "death" );
player endon( "disconnect" );
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( "t6_wpn_ballistic_knife_projectile" );
retrievable_model setteam( player.team );
retrievable_model setowner( player );
retrievable_model.owner = player;
retrievable_model.angles = angles;
retrievable_model.name = watcher.weapon;
retrievable_model.targetname = "sticky_weapon";
if ( isDefined( prey ) )
{
if ( level.teambased && isplayer( prey ) && player.team == prey.team )
{
isfriendly = 1;
}
else
{
if ( level.teambased && isai( prey ) && player.team == prey.aiteam )
{
isfriendly = 1;
}
}
if ( !isfriendly )
{
if ( isalive( prey ) )
{
retrievable_model droptoground( retrievable_model.origin, 80 );
}
else
{
retrievable_model linkto( prey, bone );
}
}
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 dropknivestoground();
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" );
glowing_retrievable_model = spawn( "script_model", self.origin );
self.glowing_model = glowing_retrievable_model;
glowing_retrievable_model.angles = self.angles;
glowing_retrievable_model linkto( self );
if ( isDefined( prey ) && !isalive( prey ) )
{
wait 2;
}
glowing_retrievable_model setmodel( "t6_wpn_ballistic_knife_blade_retrieve" );
}
watch_shutdown()
{
pickuptrigger = self.pickuptrigger;
glowing_model = self.glowing_model;
self waittill( "death" );
if ( isDefined( pickuptrigger ) )
{
pickuptrigger delete();
}
if ( isDefined( glowing_model ) )
{
glowing_model delete();
}
}
onspawnretrievetrigger( watcher, player )
{
player endon( "death" );
player endon( "disconnect" );
level endon( "game_ended" );
player waittill( "ballistic_knife_stationary", retrievable_model, normal, prey );
if ( !isDefined( retrievable_model ) )
{
return;
}
vec_scale = 10;
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 ] + vec_scale;
}
else
{
trigger_pos[ 0 ] = retrievable_model.origin[ 0 ] + ( vec_scale * normal[ 0 ] );
trigger_pos[ 1 ] = retrievable_model.origin[ 1 ] + ( vec_scale * normal[ 1 ] );
trigger_pos[ 2 ] = retrievable_model.origin[ 2 ] + ( vec_scale * normal[ 2 ] );
}
trigger_pos[ 2 ] -= 50;
pickup_trigger = spawn( "trigger_radius", ( trigger_pos[ 0 ], trigger_pos[ 1 ], trigger_pos[ 2 ] ), 0, 50, 100 );
pickup_trigger.owner = player;
retrievable_model.pickuptrigger = pickup_trigger;
pickup_trigger enablelinkto();
if ( isDefined( prey ) )
{
pickup_trigger linkto( prey );
}
else
{
pickup_trigger linkto( retrievable_model );
}
retrievable_model thread watch_use_trigger( pickup_trigger, retrievable_model, ::pick_up, watcher.pickupsoundplayer, watcher.pickupsound );
retrievable_model thread watch_shutdown();
}
watch_use_trigger( trigger, model, callback, playersoundonuse, npcsoundonuse )
{
self endon( "death" );
self endon( "delete" );
level endon( "game_ended" );
max_ammo = weaponmaxammo( "knife_ballistic_mp" ) + 1;
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;
}
while ( !player hasweapon( "knife_ballistic_mp" ) )
{
continue;
}
ammo_stock = player getweaponammostock( "knife_ballistic_mp" );
ammo_clip = player getweaponammoclip( "knife_ballistic_mp" );
current_weapon = player getcurrentweapon();
total_ammo = ammo_stock + ammo_clip;
hasreloaded = 1;
if ( total_ammo > 0 && ammo_stock == total_ammo && current_weapon == "knife_ballistic_mp" )
{
hasreloaded = 0;
}
if ( total_ammo >= max_ammo || !hasreloaded )
{
continue;
}
if ( isDefined( playersoundonuse ) )
{
player playlocalsound( playersoundonuse );
}
if ( isDefined( npcsoundonuse ) )
{
player playsound( npcsoundonuse );
}
self thread [[ callback ]]( player );
return;
}
}
pick_up( player )
{
self destroy_ent();
current_weapon = player getcurrentweapon();
player maps/mp/_challenges::pickedupballisticknife();
if ( current_weapon != "knife_ballistic_mp" )
{
clip_ammo = player getweaponammoclip( "knife_ballistic_mp" );
if ( !clip_ammo )
{
player setweaponammoclip( "knife_ballistic_mp", 1 );
}
else
{
new_ammo_stock = player getweaponammostock( "knife_ballistic_mp" ) + 1;
player setweaponammostock( "knife_ballistic_mp", new_ammo_stock );
}
}
else
{
new_ammo_stock = player getweaponammostock( "knife_ballistic_mp" ) + 1;
player setweaponammostock( "knife_ballistic_mp", new_ammo_stock );
}
}
destroy_ent()
{
if ( isDefined( self ) )
{
pickuptrigger = self.pickuptrigger;
if ( isDefined( pickuptrigger ) )
{
pickuptrigger delete();
}
if ( isDefined( self.glowing_model ) )
{
self.glowing_model delete();
}
self delete();
}
}
dropknivestoground()
{
self endon( "death" );
for ( ;; )
{
level waittill( "drop_objects_to_ground", origin, radius );
self droptoground( origin, radius );
}
}
droptoground( origin, radius )
{
if ( distancesquared( origin, self.origin ) < ( radius * radius ) )
{
self physicslaunch( ( 0, 0, 1 ), vectorScale( ( 0, 0, 1 ), 5 ) );
self thread updateretrievetrigger();
}
}
updateretrievetrigger()
{
self endon( "death" );
self waittill( "stationary" );
trigger = self.pickuptrigger;
trigger.origin = ( self.origin[ 0 ], self.origin[ 1 ], self.origin[ 2 ] + 10 );
trigger linkto( self );
}

87
zm_transit_dr_patch/maps/mp/_bb.gsc Normal file
View File

@ -0,0 +1,87 @@
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
level thread onplayerconnect();
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connected", player );
player thread onplayerspawned();
player thread onplayerdeath();
}
}
onplayerspawned()
{
self endon( "disconnect" );
self._bbdata = [];
for ( ;; )
{
self waittill( "spawned_player" );
self._bbdata[ "score" ] = 0;
self._bbdata[ "momentum" ] = 0;
self._bbdata[ "spawntime" ] = getTime();
self._bbdata[ "shots" ] = 0;
self._bbdata[ "hits" ] = 0;
}
}
onplayerdisconnect()
{
for ( ;; )
{
self waittill( "disconnect" );
self commitspawndata();
return;
}
}
onplayerdeath()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "death" );
self commitspawndata();
}
}
commitspawndata()
{
/#
assert( isDefined( self._bbdata ) );
#/
if ( !isDefined( self._bbdata ) )
{
return;
}
bbprint( "mpplayerlives", "gametime %d spawnid %d lifescore %d lifemomentum %d lifetime %d name %s", getTime(), getplayerspawnid( self ), self._bbdata[ "score" ], self._bbdata[ "momentum" ], getTime() - self._bbdata[ "spawntime" ], self.name );
}
commitweapondata( spawnid, currentweapon, time0 )
{
/#
assert( isDefined( self._bbdata ) );
#/
if ( !isDefined( self._bbdata ) )
{
return;
}
time1 = getTime();
bbprint( "mpweapons", "spawnid %d name %s duration %d shots %d hits %d", spawnid, currentweapon, time1 - time0, self._bbdata[ "shots" ], self._bbdata[ "hits" ] );
self._bbdata[ "shots" ] = 0;
self._bbdata[ "hits" ] = 0;
}
bbaddtostat( statname, delta )
{
if ( isDefined( self._bbdata ) && isDefined( self._bbdata[ statname ] ) )
{
self._bbdata[ statname ] += delta;
}
}

19
zm_transit_dr_patch/maps/mp/_busing.gsc Normal file
View File

@ -0,0 +1,19 @@
#include maps/mp/_utility;
businit()
{
/#
assert( level.clientscripts );
#/
level.busstate = "";
registerclientsys( "busCmd" );
}
setbusstate( state )
{
if ( level.busstate != state )
{
setclientsysstate( "busCmd", state );
}
level.busstate = state;
}

2109
zm_transit_dr_patch/maps/mp/_challenges.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

67
zm_transit_dr_patch/maps/mp/_compass.gsc Normal file
View File

@ -0,0 +1,67 @@
setupminimap( material )
{
requiredmapaspectratio = getDvarFloat( "scr_RequiredMapAspectratio" );
corners = getentarray( "minimap_corner", "targetname" );
if ( corners.size != 2 )
{
/#
println( "^1Error: There are not exactly two "minimap_corner" entities in the map. Could not set up minimap." );
#/
return;
}
corner0 = ( corners[ 0 ].origin[ 0 ], corners[ 0 ].origin[ 1 ], 0 );
corner1 = ( corners[ 1 ].origin[ 0 ], corners[ 1 ].origin[ 1 ], 0 );
cornerdiff = corner1 - corner0;
north = ( cos( getnorthyaw() ), sin( getnorthyaw() ), 0 );
west = ( 0 - north[ 1 ], north[ 0 ], 0 );
if ( vectordot( cornerdiff, west ) > 0 )
{
if ( vectordot( cornerdiff, north ) > 0 )
{
northwest = corner1;
southeast = corner0;
}
else
{
side = vecscale( north, vectordot( cornerdiff, north ) );
northwest = corner1 - side;
southeast = corner0 + side;
}
}
else if ( vectordot( cornerdiff, north ) > 0 )
{
side = vecscale( north, vectordot( cornerdiff, north ) );
northwest = corner0 + side;
southeast = corner1 - side;
}
else
{
northwest = corner0;
southeast = corner1;
}
if ( requiredmapaspectratio > 0 )
{
northportion = vectordot( northwest - southeast, north );
westportion = vectordot( northwest - southeast, west );
mapaspectratio = westportion / northportion;
if ( mapaspectratio < requiredmapaspectratio )
{
incr = requiredmapaspectratio / mapaspectratio;
addvec = vecscale( west, westportion * ( incr - 1 ) * 0,5 );
}
else
{
incr = mapaspectratio / requiredmapaspectratio;
addvec = vecscale( north, northportion * ( incr - 1 ) * 0,5 );
}
northwest += addvec;
southeast -= addvec;
}
setminimap( material, northwest[ 0 ], northwest[ 1 ], southeast[ 0 ], southeast[ 1 ] );
}
vecscale( vec, scalar )
{
return ( vec[ 0 ] * scalar, vec[ 1 ] * scalar, vec[ 2 ] * scalar );
}

3273
zm_transit_dr_patch/maps/mp/_createfx.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

1019
zm_transit_dr_patch/maps/mp/_createfxmenu.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

545
zm_transit_dr_patch/maps/mp/_createfxundo.gsc Normal file
View File

@ -0,0 +1,545 @@
#include maps/mp/_createfxmenu;
#include maps/mp/_createfx;
#include maps/mp/_utility;
#include common_scripts/utility;
store_undo_state( change_type, ents )
{
if ( !isDefined( level.cfx_undo_states ) )
{
level.cfx_undo_states = [];
level.cfx_redo_states = [];
level.cfx_limbo_state = spawnstruct();
level.cfx_max_states = 10;
}
if ( !isarray( ents ) )
{
ents = array( ents );
}
temp_array = [];
i = 0;
while ( i < ents.size )
{
temp_array[ i ] = copy_fx_ent( ents[ i ] );
i++;
}
state = spawnstruct();
state.operation = change_type;
state.last_action = level.cfx_last_action;
state.ent_array = temp_array;
if ( level.cfx_undo_states.size >= level.cfx_max_states )
{
level.cfx_undo_states = array_drop( level.cfx_undo_states );
}
level.cfx_undo_states[ level.cfx_undo_states.size ] = state;
level.cfx_redo_states = [];
level.cfx_limbo_state = undefined;
debug_print_latest_state( "undo" );
}
undo()
{
if ( isDefined( level.createfxent ) || !isDefined( level.cfx_undo_states ) && level.cfx_undo_states.size < 1 )
{
return;
}
revert_state = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
if ( level.cfx_last_action != "none" )
{
store_undo_state( "edit", level.selected_fx_ents );
move_undo_state_to_redo();
clear_entity_selection( "skip_undo" );
apply_state_change( "undo", revert_state );
move_undo_state_to_limbo();
level.cfx_last_action = "none";
}
else clear_entity_selection( "skip_undo" );
if ( revert_state.operation != "edit" )
{
apply_state_change( "undo", revert_state );
move_undo_state_to_redo();
level.cfx_last_action = "none";
}
else if ( isDefined( level.cfx_limbo_state ) )
{
move_limbo_state_to_redo();
apply_state_change( "undo", revert_state );
move_undo_state_to_limbo();
level.cfx_last_action = "none";
}
else
{
if ( level.cfx_undo_states.size > 1 )
{
move_undo_state_to_redo();
revert_state = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
}
apply_state_change( "undo", revert_state );
move_undo_state_to_limbo();
}
}
apply_state_change( type, revert_state )
{
if ( type == "undo" )
{
/#
println( "^2CreateFX: Undo operation" );
#/
if ( revert_state.operation == "edit" )
{
undo_edit( revert_state.ent_array );
}
else if ( revert_state.operation == "add" )
{
undo_add( revert_state.ent_array );
}
else
{
if ( revert_state.operation == "delete" )
{
undo_delete( revert_state.ent_array );
}
}
}
else /#
println( "^2CreateFX: Redo operation" );
#/
if ( revert_state.operation == "edit" )
{
undo_edit( revert_state.ent_array );
}
else if ( revert_state.operation == "add" )
{
undo_delete( revert_state.ent_array );
}
else
{
if ( revert_state.operation == "delete" )
{
undo_add( revert_state.ent_array );
}
}
}
move_undo_state_to_redo()
{
if ( level.cfx_redo_states.size >= level.cfx_max_states )
{
level.cfx_redo_states = array_drop( level.cfx_redo_states );
}
level.cfx_redo_states[ level.cfx_redo_states.size ] = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
level.cfx_undo_states = array_pop( level.cfx_undo_states );
debug_print_latest_state( "undo" );
debug_print_latest_state( "redo" );
}
move_redo_state_to_undo()
{
if ( level.cfx_undo_states.size >= level.cfx_max_states )
{
level.cfx_undo_states = array_drop( level.cfx_undo_states );
}
level.cfx_undo_states[ level.cfx_undo_states.size ] = level.cfx_redo_states[ level.cfx_redo_states.size - 1 ];
level.cfx_redo_states = array_pop( level.cfx_redo_states );
debug_print_latest_state( "undo" );
debug_print_latest_state( "redo" );
}
move_undo_state_to_limbo()
{
level.cfx_limbo_state = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
level.cfx_undo_states = array_pop( level.cfx_undo_states );
debug_print_latest_state( "undo" );
debug_print_latest_state( "limbo" );
}
move_redo_state_to_limbo()
{
level.cfx_limbo_state = level.cfx_redo_states[ level.cfx_redo_states.size - 1 ];
level.cfx_redo_states = array_pop( level.cfx_redo_states );
debug_print_latest_state( "redo" );
debug_print_latest_state( "limbo" );
}
move_limbo_state_to_undo()
{
if ( level.cfx_undo_states.size >= level.cfx_max_states )
{
level.cfx_undo_states = array_drop( level.cfx_undo_states );
}
level.cfx_undo_states[ level.cfx_undo_states.size ] = level.cfx_limbo_state;
level.cfx_limbo_state = undefined;
debug_print_latest_state( "undo" );
debug_print_latest_state( "limbo" );
}
move_limbo_state_to_redo()
{
if ( level.cfx_redo_states.size >= level.cfx_max_states )
{
level.cfx_redo_states = array_drop( level.cfx_redo_states );
}
level.cfx_redo_states[ level.cfx_redo_states.size ] = level.cfx_limbo_state;
level.cfx_limbo_state = undefined;
debug_print_latest_state( "redo" );
}
undo_edit( ent_array )
{
ent_array = reorder_ent_array_by_uniqueid( ent_array );
/#
println( "^3CreateFX: Undoing edit" );
debug_print_ent_array( ent_array, "ent_array[]" );
debug_print_ent_array( level.createfxent, "level.createFXent[]" );
#/
last_id = ent_array[ ent_array.size - 1 ].uniqueid;
if ( last_id > ( level.createfxent.size - 1 ) )
{
last_id = level.createfxent.size - 1;
}
j = ent_array.size - 1;
source_ent = ent_array[ j ];
i = last_id;
while ( i >= 0 )
{
target_ent = level.createfxent[ i ];
if ( source_ent.uniqueid == target_ent.uniqueid )
{
copy_values_between_fx_ents( source_ent, target_ent );
select_entity( i, target_ent, "skip_undo" );
j--;
if ( j < 0 )
{
break;
}
else
{
source_ent = ent_array[ j ];
}
i--;
}
}
update_selected_entities();
/#
println( "^1CreateFX: Finished edit" );
debug_print_ent_array( level.createfxent, "level.createFXent[]" );
#/
}
undo_add( ent_array )
{
ent_array = reorder_ent_array_by_uniqueid( ent_array );
/#
println( "^3createfx: Undoing add." );
debug_print_ent_array( ent_array, "ent_array[]" );
debug_print_ent_array( level.createfxent, "level.createFXent[]" );
#/
last_id = ent_array[ ent_array.size - 1 ].uniqueid;
if ( last_id > ( level.createfxent.size - 1 ) )
{
last_id = level.createfxent.size - 1;
}
j = ent_array.size - 1;
source_ent = ent_array[ j ];
i = last_id;
while ( i >= 0 )
{
target_ent = level.createfxent[ i ];
if ( source_ent.uniqueid == target_ent.uniqueid )
{
if ( isDefined( target_ent.looper ) )
{
target_ent.looper delete();
}
target_ent notify( "stop_loop" );
j--;
if ( j < 0 )
{
break;
}
else
{
source_ent = ent_array[ j ];
}
i--;
}
}
/#
debug_print_ent_array( level.createfxent, "level.createFXent[]" );
println( "createfx: Starting array_remove_undefined()" );
#/
arrayremovevalue( level.createfxent, undefined );
/#
println( "^1CreateFX: Finished undo add." );
debug_print_ent_array( level.createfxent, "level.createFXent[]" );
#/
clear_fx_hudelements();
}
undo_delete( ent_array )
{
/#
println( "^3CreateFX: Undoing delete" );
debug_print_ent_array( ent_array, "ent_array in undo_delete()" );
debug_print_ent_array( level.createfxent, "level.createFXent[]" );
#/
ent_array = reorder_ent_array_by_uniqueid( ent_array );
if ( level.createfxent.size == 0 )
{
i = 0;
while ( i < ent_array.size )
{
level.createfxent[ i ] = copy_fx_ent( ent_array[ i ] );
i++;
}
}
else temp_array = [];
i = 0;
j = 0;
while ( j < level.createfxent.size )
{
target_ent = level.createfxent[ j ];
if ( i >= ent_array.size )
{
temp_array[ temp_array.size ] = target_ent;
j++;
continue;
}
else source_ent = ent_array[ i ];
if ( target_ent.uniqueid < source_ent.uniqueid )
{
temp_array[ temp_array.size ] = target_ent;
j++;
continue;
}
else
{
temp_array[ temp_array.size ] = copy_fx_ent( source_ent );
j--;
i++;
}
j++;
}
while ( i < ent_array.size )
{
temp_array[ temp_array.size ] = ent_array[ i ];
i++;
}
level.createfxent = temp_array;
/#
println( "^1Createfx: Finished undoing delete, pre-selection" );
debug_print_ent_array( level.createfxent, "level.createFXent[]" );
#/
last_id = ent_array[ ent_array.size - 1 ].uniqueid;
if ( last_id > ( level.createfxent.size - 1 ) )
{
last_id = level.createfxent.size - 1;
}
j = ent_array.size - 1;
source_ent = ent_array[ j ];
i = last_id;
while ( i >= 0 )
{
target_ent = level.createfxent[ i ];
if ( source_ent.uniqueid == target_ent.uniqueid )
{
target_ent post_entity_creation_function();
select_entity( i, target_ent, "skip_undo" );
j--;
if ( j < 0 )
{
break;
}
else
{
source_ent = ent_array[ j ];
}
i--;
}
}
update_selected_entities();
}
redo()
{
if ( isDefined( level.createfxent ) || !isDefined( level.cfx_redo_states ) && level.cfx_redo_states.size < 1 )
{
return;
}
clear_entity_selection( "skip_undo" );
if ( isDefined( level.cfx_limbo_state ) )
{
move_limbo_state_to_undo();
move_redo_state_to_limbo();
apply_state_change( "redo", level.cfx_limbo_state );
}
else revert_state = level.cfx_redo_states[ level.cfx_redo_states.size - 1 ];
apply_state_change( "redo", revert_state );
if ( revert_state.operation == "edit" )
{
move_redo_state_to_limbo();
}
else
{
move_redo_state_to_undo();
}
level.cfx_last_action = "none";
}
reorder_ent_array_by_uniqueid( ent_array )
{
if ( ent_array.size <= 1 )
{
return ent_array;
}
array_size = ent_array.size;
i = 0;
while ( i < ( array_size - 1 ) )
{
j = i + 1;
while ( j < array_size )
{
if ( ent_array[ i ].uniqueid > ent_array[ j ].uniqueid )
{
temp_ent = ent_array[ i ];
ent_array[ i ] = ent_array[ j ];
ent_array[ j ] = temp_ent;
}
j++;
}
i++;
}
return ent_array;
}
copy_fx_ent( ent )
{
temp_ent = spawnstruct();
temp_ent.drawn = ent.drawn;
temp_ent.drawn_axis_model = ent.drawn_axis_model;
temp_ent.last_fx_index = ent.last_fx_index;
temp_ent.textalpha = ent.textalpha;
temp_ent.uniqueid = ent.uniqueid;
temp_ent.v = ent.v;
return temp_ent;
}
copy_values_between_fx_ents( source, dest )
{
dest.drawn = source.drawn;
dest.drawn_axis_model = source.drawn_axis_model;
dest.last_fx_index = source.last_fx_index;
dest.textalpha = source.textalpha;
dest.v = source.v;
return dest;
}
array_pop( array )
{
array_size = array.size - 1;
temp_array = [];
if ( array_size <= 0 )
{
return temp_array;
}
i = 0;
while ( i < array_size )
{
temp_array[ i ] = array[ i ];
i++;
}
array = temp_array;
return array;
}
array_drop( array )
{
if ( array.size > 0 )
{
temp_array = [];
i = 1;
while ( i < array.size )
{
temp_array[ i - 1 ] = array[ i ];
i++;
}
array = temp_array;
}
return array;
}
debug_print_ent_array( array, name )
{
/#
if ( isDefined( name ) )
{
println( "Printing out " + name );
}
else
{
println( "Printing out some array" );
}
i = 0;
while ( i < array.size )
{
if ( !isDefined( array[ i ] ) )
{
println( "" + i + ": deleted effect" );
i++;
continue;
}
else
{
println( "" + i + ": uniqueid: " + array[ i ].uniqueid + " fxid: " + array[ i ].v[ "fxid" ] );
}
i++;
#/
}
}
debug_print_latest_state( type )
{
/#
println( "^3Saving " + type + " state" );
if ( type == "undo" )
{
if ( !isDefined( level.cfx_undo_states[ level.cfx_undo_states.size - 1 ] ) )
{
println( "There are no undo states." );
return;
}
state = level.cfx_undo_states[ level.cfx_undo_states.size - 1 ];
size = level.cfx_undo_states.size - 1;
}
else if ( type == "redo" )
{
if ( !isDefined( level.cfx_redo_states[ level.cfx_redo_states.size - 1 ] ) )
{
println( "There are no redo states." );
return;
}
state = level.cfx_redo_states[ level.cfx_redo_states.size - 1 ];
size = level.cfx_redo_states.size - 1;
}
else
{
if ( !isDefined( level.cfx_limbo_state ) )
{
println( "There is no limbo state." );
return;
}
state = level.cfx_limbo_state;
size = 0;
}
println( "State " + size + " - " + state.operation + ": " + state.last_action );
debug_print_ent_array( state.ent_array, "save state ent_array" );
#/
}

97
zm_transit_dr_patch/maps/mp/_demo.gsc Normal file
View File

@ -0,0 +1,97 @@
init()
{
level.bookmark[ "kill" ] = 0;
level.bookmark[ "event" ] = 1;
level.bookmark[ "zm_round_end" ] = 2;
level.bookmark[ "zm_player_downed" ] = 3;
level.bookmark[ "zm_player_revived" ] = 4;
level.bookmark[ "zm_player_bledout" ] = 5;
level.bookmark[ "zm_player_use_magicbox" ] = 6;
level.bookmark[ "score_event" ] = 7;
level.bookmark[ "medal" ] = 8;
level.bookmark[ "round_result" ] = 9;
level.bookmark[ "game_result" ] = 10;
level.bookmark[ "zm_powerup_dropped" ] = 11;
level.bookmark[ "zm_player_powerup_grabbed" ] = 12;
level.bookmark[ "zm_player_perk" ] = 13;
level.bookmark[ "zm_power" ] = 14;
level.bookmark[ "zm_player_door" ] = 15;
level.bookmark[ "zm_player_buildable_placed" ] = 16;
level.bookmark[ "zm_player_use_packapunch" ] = 17;
level.bookmark[ "zm_player_rampage" ] = 18;
level.bookmark[ "zm_player_grenade_special" ] = 19;
level.bookmark[ "zm_player_grenade_multiattack" ] = 20;
level.bookmark[ "zm_player_meat_stink" ] = 21;
level.bookmark[ "zm_player_grabbed_magicbox" ] = 22;
level.bookmark[ "zm_player_grabbed_packapunch" ] = 23;
level.bookmark[ "zm_player_grenade_special_long" ] = 24;
}
bookmark( type, time, clientent1, clientent2, eventpriority, inflictorent, overrideentitycamera, actorent )
{
/#
assert( isDefined( level.bookmark[ type ] ), "Unable to find a bookmark type for type - " + type );
#/
client1 = 255;
client2 = 255;
inflictorentnum = -1;
inflictorenttype = 0;
inflictorbirthtime = 0;
actorentnum = undefined;
scoreeventpriority = 0;
if ( isDefined( clientent1 ) )
{
client1 = clientent1 getentitynumber();
}
if ( isDefined( clientent2 ) )
{
client2 = clientent2 getentitynumber();
}
if ( isDefined( eventpriority ) )
{
scoreeventpriority = eventpriority;
}
if ( isDefined( inflictorent ) )
{
inflictorentnum = inflictorent getentitynumber();
inflictorenttype = inflictorent getentitytype();
if ( isDefined( inflictorent.birthtime ) )
{
inflictorbirthtime = inflictorent.birthtime;
}
}
if ( !isDefined( overrideentitycamera ) )
{
overrideentitycamera = 0;
}
if ( isDefined( actorent ) )
{
actorentnum = actorent getentitynumber();
}
adddemobookmark( level.bookmark[ type ], time, client1, client2, scoreeventpriority, inflictorentnum, inflictorenttype, inflictorbirthtime, overrideentitycamera, actorentnum );
}
gameresultbookmark( type, winningteamindex, losingteamindex )
{
/#
assert( isDefined( level.bookmark[ type ] ), "Unable to find a bookmark type for type - " + type );
#/
client1 = 255;
client2 = 255;
scoreeventpriority = 0;
inflictorentnum = -1;
inflictorenttype = 0;
inflictorbirthtime = 0;
overrideentitycamera = 0;
actorentnum = undefined;
if ( isDefined( winningteamindex ) )
{
client1 = winningteamindex;
}
if ( isDefined( losingteamindex ) )
{
client2 = losingteamindex;
}
adddemobookmark( level.bookmark[ type ], getTime(), client1, client2, scoreeventpriority, inflictorentnum, inflictorenttype, inflictorbirthtime, overrideentitycamera, actorentnum );
}

458
zm_transit_dr_patch/maps/mp/_fx.gsc Normal file
View File

@ -0,0 +1,458 @@
#include maps/mp/_createfx;
#include maps/mp/_utility;
#include common_scripts/utility;
print_org( fxcommand, fxid, fxpos, waittime )
{
/#
if ( getDvar( "debug" ) == "1" )
{
println( "{" );
println( ""origin" "" + fxpos[ 0 ] + " " + fxpos[ 1 ] + " " + fxpos[ 2 ] + """ );
println( ""classname" "script_model"" );
println( ""model" "fx"" );
println( ""script_fxcommand" "" + fxcommand + """ );
println( ""script_fxid" "" + fxid + """ );
println( ""script_delay" "" + waittime + """ );
println( "}" );
#/
}
}
oneshotfx( fxid, fxpos, waittime, fxpos2 )
{
}
oneshotfxthread()
{
wait 0,05;
if ( self.v[ "delay" ] > 0 )
{
wait self.v[ "delay" ];
}
create_triggerfx();
}
create_triggerfx()
{
self.looper = spawnfx_wrapper( self.v[ "fxid" ], self.v[ "origin" ], self.v[ "forward" ], self.v[ "up" ] );
triggerfx( self.looper, self.v[ "delay" ] );
create_loopsound();
}
exploderfx( num, fxid, fxpos, waittime, fxpos2, firefx, firefxdelay, firefxsound, fxsound, fxquake, fxdamage, soundalias, repeat, delay_min, delay_max, damage_radius, firefxtimeout, exploder_group )
{
if ( 1 )
{
ent = createexploder( fxid );
ent.v[ "origin" ] = fxpos;
ent.v[ "angles" ] = ( 0, 0, 0 );
if ( isDefined( fxpos2 ) )
{
ent.v[ "angles" ] = vectorToAngle( fxpos2 - fxpos );
}
ent.v[ "delay" ] = waittime;
ent.v[ "exploder" ] = num;
return;
}
fx = spawn( "script_origin", ( 0, 0, 0 ) );
fx.origin = fxpos;
fx.angles = vectorToAngle( fxpos2 - fxpos );
fx.script_exploder = num;
fx.script_fxid = fxid;
fx.script_delay = waittime;
fx.script_firefx = firefx;
fx.script_firefxdelay = firefxdelay;
fx.script_firefxsound = firefxsound;
fx.script_sound = fxsound;
fx.script_earthquake = fxquake;
fx.script_damage = fxdamage;
fx.script_radius = damage_radius;
fx.script_soundalias = soundalias;
fx.script_firefxtimeout = firefxtimeout;
fx.script_repeat = repeat;
fx.script_delay_min = delay_min;
fx.script_delay_max = delay_max;
fx.script_exploder_group = exploder_group;
forward = anglesToForward( fx.angles );
forward = vectorScale( forward, 150 );
fx.targetpos = fxpos + forward;
if ( !isDefined( level._script_exploders ) )
{
level._script_exploders = [];
}
level._script_exploders[ level._script_exploders.size ] = fx;
maps/mp/_createfx::createfx_showorigin( fxid, fxpos, waittime, fxpos2, "exploderfx", fx, undefined, firefx, firefxdelay, firefxsound, fxsound, fxquake, fxdamage, soundalias, repeat, delay_min, delay_max, damage_radius, firefxtimeout );
}
loopfx( fxid, fxpos, waittime, fxpos2, fxstart, fxstop, timeout )
{
/#
println( "Loopfx is deprecated!" );
#/
ent = createloopeffect( fxid );
ent.v[ "origin" ] = fxpos;
ent.v[ "angles" ] = ( 0, 0, 0 );
if ( isDefined( fxpos2 ) )
{
ent.v[ "angles" ] = vectorToAngle( fxpos2 - fxpos );
}
ent.v[ "delay" ] = waittime;
}
create_looper()
{
self.looper = playloopedfx( level._effect[ self.v[ "fxid" ] ], self.v[ "delay" ], self.v[ "origin" ], 0, self.v[ "forward" ], self.v[ "up" ] );
create_loopsound();
}
create_loopsound()
{
self notify( "stop_loop" );
if ( isDefined( self.v[ "soundalias" ] ) && self.v[ "soundalias" ] != "nil" )
{
if ( isDefined( self.looper ) )
{
self.looper thread maps/mp/_utility::loop_fx_sound( self.v[ "soundalias" ], self.v[ "origin" ], "death" );
return;
}
else
{
thread maps/mp/_utility::loop_fx_sound( self.v[ "soundalias" ], self.v[ "origin" ], "stop_loop" );
}
}
}
stop_loopsound()
{
self notify( "stop_loop" );
}
loopfxthread()
{
wait 0,05;
if ( isDefined( self.fxstart ) )
{
level waittill( "start fx" + self.fxstart );
}
while ( 1 )
{
create_looper();
if ( isDefined( self.timeout ) )
{
thread loopfxstop( self.timeout );
}
if ( isDefined( self.fxstop ) )
{
level waittill( "stop fx" + self.fxstop );
}
else
{
return;
}
if ( isDefined( self.looper ) )
{
self.looper delete();
}
if ( isDefined( self.fxstart ) )
{
level waittill( "start fx" + self.fxstart );
continue;
}
else
{
return;
}
}
}
loopfxchangeid( ent )
{
self endon( "death" );
ent waittill( "effect id changed", change );
}
loopfxchangeorg( ent )
{
self endon( "death" );
for ( ;; )
{
ent waittill( "effect org changed", change );
self.origin = change;
}
}
loopfxchangedelay( ent )
{
self endon( "death" );
ent waittill( "effect delay changed", change );
}
loopfxdeletion( ent )
{
self endon( "death" );
ent waittill( "effect deleted" );
self delete();
}
loopfxstop( timeout )
{
self endon( "death" );
wait timeout;
self.looper delete();
}
loopsound( sound, pos, waittime )
{
level thread loopsoundthread( sound, pos, waittime );
}
loopsoundthread( sound, pos, waittime )
{
org = spawn( "script_origin", pos );
org.origin = pos;
org playloopsound( sound );
}
gunfireloopfx( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
{
thread gunfireloopfxthread( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax );
}
gunfireloopfxthread( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
{
level endon( "stop all gunfireloopfx" );
wait 0,05;
if ( betweensetsmax < betweensetsmin )
{
temp = betweensetsmax;
betweensetsmax = betweensetsmin;
betweensetsmin = temp;
}
betweensetsbase = betweensetsmin;
betweensetsrange = betweensetsmax - betweensetsmin;
if ( shotdelaymax < shotdelaymin )
{
temp = shotdelaymax;
shotdelaymax = shotdelaymin;
shotdelaymin = temp;
}
shotdelaybase = shotdelaymin;
shotdelayrange = shotdelaymax - shotdelaymin;
if ( shotsmax < shotsmin )
{
temp = shotsmax;
shotsmax = shotsmin;
shotsmin = temp;
}
shotsbase = shotsmin;
shotsrange = shotsmax - shotsmin;
fxent = spawnfx( level._effect[ fxid ], fxpos );
for ( ;; )
{
shotnum = shotsbase + randomint( shotsrange );
i = 0;
while ( i < shotnum )
{
triggerfx( fxent );
wait ( shotdelaybase + randomfloat( shotdelayrange ) );
i++;
}
wait ( betweensetsbase + randomfloat( betweensetsrange ) );
}
}
gunfireloopfxvec( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
{
thread gunfireloopfxvecthread( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax );
}
gunfireloopfxvecthread( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
{
level endon( "stop all gunfireloopfx" );
wait 0,05;
if ( betweensetsmax < betweensetsmin )
{
temp = betweensetsmax;
betweensetsmax = betweensetsmin;
betweensetsmin = temp;
}
betweensetsbase = betweensetsmin;
betweensetsrange = betweensetsmax - betweensetsmin;
if ( shotdelaymax < shotdelaymin )
{
temp = shotdelaymax;
shotdelaymax = shotdelaymin;
shotdelaymin = temp;
}
shotdelaybase = shotdelaymin;
shotdelayrange = shotdelaymax - shotdelaymin;
if ( shotsmax < shotsmin )
{
temp = shotsmax;
shotsmax = shotsmin;
shotsmin = temp;
}
shotsbase = shotsmin;
shotsrange = shotsmax - shotsmin;
fxpos2 = vectornormalize( fxpos2 - fxpos );
fxent = spawnfx( level._effect[ fxid ], fxpos, fxpos2 );
for ( ;; )
{
shotnum = shotsbase + randomint( shotsrange );
i = 0;
while ( i < int( shotnum / level.fxfireloopmod ) )
{
triggerfx( fxent );
delay = ( shotdelaybase + randomfloat( shotdelayrange ) ) * level.fxfireloopmod;
if ( delay < 0,05 )
{
delay = 0,05;
}
wait delay;
i++;
}
wait ( shotdelaybase + randomfloat( shotdelayrange ) );
wait ( betweensetsbase + randomfloat( betweensetsrange ) );
}
}
setfireloopmod( value )
{
level.fxfireloopmod = 1 / value;
}
setup_fx()
{
if ( isDefined( self.script_fxid ) || !isDefined( self.script_fxcommand ) && !isDefined( self.script_delay ) )
{
return;
}
org = undefined;
if ( isDefined( self.target ) )
{
ent = getent( self.target, "targetname" );
if ( isDefined( ent ) )
{
org = ent.origin;
}
}
fxstart = undefined;
if ( isDefined( self.script_fxstart ) )
{
fxstart = self.script_fxstart;
}
fxstop = undefined;
if ( isDefined( self.script_fxstop ) )
{
fxstop = self.script_fxstop;
}
if ( self.script_fxcommand == "OneShotfx" )
{
oneshotfx( self.script_fxid, self.origin, self.script_delay, org );
}
if ( self.script_fxcommand == "loopfx" )
{
loopfx( self.script_fxid, self.origin, self.script_delay, org, fxstart, fxstop );
}
if ( self.script_fxcommand == "loopsound" )
{
loopsound( self.script_fxid, self.origin, self.script_delay );
}
self delete();
}
script_print_fx()
{
/#
if ( isDefined( self.script_fxid ) || !isDefined( self.script_fxcommand ) && !isDefined( self.script_delay ) )
{
println( "Effect at origin ", self.origin, " doesn't have script_fxid/script_fxcommand/script_delay" );
self delete();
return;
}
if ( isDefined( self.target ) )
{
org = getent( self.target, "targetname" ).origin;
}
else
{
org = "undefined";
}
if ( self.script_fxcommand == "OneShotfx" )
{
println( "mapsmp_fx::OneShotfx("" + self.script_fxid + "", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
}
if ( self.script_fxcommand == "loopfx" )
{
println( "mapsmp_fx::LoopFx("" + self.script_fxid + "", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
}
if ( self.script_fxcommand == "loopsound" )
{
println( "mapsmp_fx::LoopSound("" + self.script_fxid + "", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
#/
}
}
script_playfx( id, pos, pos2 )
{
if ( !id )
{
return;
}
if ( isDefined( pos2 ) )
{
playfx( id, pos, pos2 );
}
else
{
playfx( id, pos );
}
}
script_playfxontag( id, ent, tag )
{
if ( !id )
{
return;
}
playfxontag( id, ent, tag );
}
grenadeexplosionfx( pos )
{
playfx( level._effect[ "mechanical explosion" ], pos );
earthquake( 0,15, 0,5, pos, 250 );
}
soundfx( fxid, fxpos, endonnotify )
{
org = spawn( "script_origin", ( 0, 0, 0 ) );
org.origin = fxpos;
org playloopsound( fxid );
if ( isDefined( endonnotify ) )
{
org thread soundfxdelete( endonnotify );
}
}
soundfxdelete( endonnotify )
{
level waittill( endonnotify );
self delete();
}
blenddelete( blend )
{
self waittill( "death" );
blend delete();
}
spawnfx_wrapper( fx_id, origin, forward, up )
{
/#
assert( isDefined( level._effect[ fx_id ] ), "Missing level._effect["" + fx_id + ""]. You did not setup the fx before calling it in createFx." );
#/
fx_object = spawnfx( level._effect[ fx_id ], origin, forward, up );
return fx_object;
}

6
zm_transit_dr_patch/maps/mp/_fxanim.gsc Normal file
View File

@ -0,0 +1,6 @@
init()
{
level.scr_anim = [];
level.scr_anim[ "fxanim_props" ] = [];
}

60
zm_transit_dr_patch/maps/mp/_global_fx.gsc Normal file
View File

@ -0,0 +1,60 @@
#include maps/mp/_utility;
#include common_scripts/utility;
main()
{
randomstartdelay = randomfloatrange( -20, -15 );
global_fx( "barrel_fireFX_origin", "global_barrel_fire", "fire/firelp_barrel_pm", randomstartdelay, "fire_barrel_small" );
global_fx( "ch_streetlight_02_FX_origin", "ch_streetlight_02_FX", "misc/lighthaze", randomstartdelay );
global_fx( "me_streetlight_01_FX_origin", "me_streetlight_01_FX", "misc/lighthaze_bog_a", randomstartdelay );
global_fx( "ch_street_light_01_on", "lamp_glow_FX", "misc/light_glow_white", randomstartdelay );
global_fx( "highway_lamp_post", "ch_streetlight_02_FX", "misc/lighthaze_villassault", randomstartdelay );
global_fx( "cs_cargoship_spotlight_on_FX_origin", "cs_cargoship_spotlight_on_FX", "misc/lighthaze", randomstartdelay );
global_fx( "me_dumpster_fire_FX_origin", "me_dumpster_fire_FX", "fire/firelp_med_pm_nodistort", randomstartdelay, "fire_dumpster_medium" );
global_fx( "com_tires_burning01_FX_origin", "com_tires_burning01_FX", "fire/tire_fire_med", randomstartdelay );
global_fx( "icbm_powerlinetower_FX_origin", "icbm_powerlinetower_FX", "misc/power_tower_light_red_blink", randomstartdelay );
}
global_fx( targetname, fxname, fxfile, delay, soundalias )
{
ents = getstructarray( targetname, "targetname" );
if ( !isDefined( ents ) )
{
return;
}
if ( ents.size <= 0 )
{
return;
}
i = 0;
while ( i < ents.size )
{
ents[ i ] global_fx_create( fxname, fxfile, delay, soundalias );
i++;
}
}
global_fx_create( fxname, fxfile, delay, soundalias )
{
if ( !isDefined( level._effect ) )
{
level._effect = [];
}
if ( !isDefined( level._effect[ fxname ] ) )
{
level._effect[ fxname ] = loadfx( fxfile );
}
if ( !isDefined( self.angles ) )
{
self.angles = ( 0, 0, 0 );
}
ent = createoneshoteffect( fxname );
ent.v[ "origin" ] = self.origin;
ent.v[ "angles" ] = self.angles;
ent.v[ "fxid" ] = fxname;
ent.v[ "delay" ] = delay;
if ( isDefined( soundalias ) )
{
ent.v[ "soundalias" ] = soundalias;
}
}

407
zm_transit_dr_patch/maps/mp/_interactive_objects.gsc Normal file
View File

@ -0,0 +1,407 @@
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
level.barrelexplodingthisframe = 0;
qbarrels = 0;
all_barrels = [];
barrels = getentarray( "explodable_barrel", "targetname" );
while ( isDefined( barrels ) && barrels.size > 0 )
{
qbarrels = 1;
i = 0;
while ( i < barrels.size )
{
all_barrels[ all_barrels.size ] = barrels[ i ];
i++;
}
}
barrels = getentarray( "explodable_barrel", "script_noteworthy" );
while ( isDefined( barrels ) && barrels.size > 0 )
{
qbarrels = 1;
i = 0;
while ( i < barrels.size )
{
all_barrels[ all_barrels.size ] = barrels[ i ];
i++;
}
}
if ( qbarrels )
{
precachemodel( "global_explosive_barrel" );
level.barrelburn = 100;
level.barrelhealth = 250;
level.barrelingsound = "exp_redbarrel_ignition";
level.barrelexpsound = "exp_redbarrel";
level.breakables_fx[ "barrel" ][ "burn_start" ] = loadfx( "destructibles/fx_barrel_ignite" );
level.breakables_fx[ "barrel" ][ "burn" ] = loadfx( "destructibles/fx_barrel_fire_top" );
level.breakables_fx[ "barrel" ][ "explode" ] = loadfx( "destructibles/fx_barrelexp" );
array_thread( all_barrels, ::explodable_barrel_think );
}
qcrates = 0;
all_crates = [];
crates = getentarray( "flammable_crate", "targetname" );
while ( isDefined( crates ) && crates.size > 0 )
{
qcrates = 1;
i = 0;
while ( i < crates.size )
{
all_crates[ all_crates.size ] = crates[ i ];
i++;
}
}
crates = getentarray( "flammable_crate", "script_noteworthy" );
while ( isDefined( crates ) && crates.size > 0 )
{
qcrates = 1;
i = 0;
while ( i < crates.size )
{
all_crates[ all_crates.size ] = crates[ i ];
i++;
}
}
if ( qcrates )
{
precachemodel( "global_flammable_crate_jap_piece01_d" );
level.crateburn = 100;
level.cratehealth = 200;
level.breakables_fx[ "ammo_crate" ][ "burn_start" ] = loadfx( "destructibles/fx_ammobox_ignite" );
level.breakables_fx[ "ammo_crate" ][ "burn" ] = loadfx( "destructibles/fx_ammobox_fire_top" );
level.breakables_fx[ "ammo_crate" ][ "explode" ] = loadfx( "destructibles/fx_ammoboxExp" );
level.crateignsound = "Ignition_ammocrate";
level.crateexpsound = "Explo_ammocrate";
array_thread( all_crates, ::flammable_crate_think );
}
if ( !qbarrels && !qcrates )
{
return;
}
}
explodable_barrel_think()
{
if ( self.classname != "script_model" )
{
return;
}
self endon( "exploding" );
self breakable_clip();
self.health = level.barrelhealth;
self setcandamage( 1 );
self.targetname = "explodable_barrel";
if ( sessionmodeiszombiesgame() )
{
self.removeexplodable = 1;
}
for ( ;; )
{
self waittill( "damage", amount, attacker, direction_vec, p, type );
/#
println( "BARRELDAMAGE: " + type );
#/
if ( type == "MOD_MELEE" || type == "MOD_IMPACT" )
{
continue;
}
else
{
if ( isDefined( self.script_requires_player ) && self.script_requires_player && !isplayer( attacker ) )
{
break;
}
else
{
if ( isDefined( self.script_selfisattacker ) && self.script_selfisattacker )
{
self.damageowner = self;
}
else
{
self.damageowner = attacker;
}
self.health -= amount;
if ( self.health <= level.barrelburn )
{
self thread explodable_barrel_burn();
}
}
}
}
}
explodable_barrel_burn()
{
count = 0;
startedfx = 0;
up = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
worldup = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
dot = vectordot( up, worldup );
offset1 = ( 0, 0, 1 );
offset2 = up * vectorScale( ( 0, 0, 1 ), 44 );
if ( dot < 0,5 )
{
offset1 = ( up * vectorScale( ( 0, 0, 1 ), 22 ) ) - vectorScale( ( 0, 0, 1 ), 30 );
offset2 = ( up * vectorScale( ( 0, 0, 1 ), 22 ) ) + vectorScale( ( 0, 0, 1 ), 14 );
}
while ( self.health > 0 )
{
if ( !startedfx )
{
playfx( level.breakables_fx[ "barrel" ][ "burn_start" ], self.origin + offset1 );
level thread play_sound_in_space( level.barrelingsound, self.origin );
startedfx = 1;
}
if ( count > 20 )
{
count = 0;
}
playfx( level.breakables_fx[ "barrel" ][ "burn" ], self.origin + offset2 );
self playloopsound( "barrel_fuse" );
if ( count == 0 )
{
self.health -= 10 + randomint( 10 );
}
count++;
wait 0,05;
}
level notify( "explosion_started" );
self thread explodable_barrel_explode();
}
explodable_barrel_explode()
{
self notify( "exploding" );
self death_notify_wrapper();
up = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
worldup = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
dot = vectordot( up, worldup );
offset = ( 0, 0, 1 );
if ( dot < 0,5 )
{
start = self.origin + vectorScale( up, 22 );
trace = physicstrace( start, start + vectorScale( ( 0, 0, 1 ), 64 ) );
end = trace[ "position" ];
offset = end - self.origin;
}
offset += vectorScale( ( 0, 0, 1 ), 4 );
mindamage = 1;
maxdamage = 250;
blastradius = 250;
level thread play_sound_in_space( level.barrelexpsound, self.origin );
playfx( level.breakables_fx[ "barrel" ][ "explode" ], self.origin + offset );
physicsexplosionsphere( self.origin + offset, 100, 80, 1, maxdamage, mindamage );
level.barrelexplodingthisframe = 1;
if ( isDefined( self.remove ) )
{
self.remove delete();
}
if ( isDefined( self.radius ) )
{
blastradius = self.radius;
}
self radiusdamage( self.origin + vectorScale( ( 0, 0, 1 ), 56 ), blastradius, maxdamage, mindamage, self.damageowner );
attacker = undefined;
if ( isDefined( self.damageowner ) )
{
attacker = self.damageowner;
}
level.lastexplodingbarrel[ "time" ] = getTime();
level.lastexplodingbarrel[ "origin" ] = self.origin + vectorScale( ( 0, 0, 1 ), 30 );
if ( isDefined( self.removeexplodable ) )
{
self hide();
}
else
{
self setmodel( "global_explosive_barrel" );
}
if ( dot < 0,5 )
{
start = self.origin + vectorScale( up, 22 );
trace = physicstrace( start, start + vectorScale( ( 0, 0, 1 ), 64 ) );
pos = trace[ "position" ];
self.origin = pos;
self.angles += vectorScale( ( 0, 0, 1 ), 90 );
}
wait 0,05;
level.barrelexplodingthisframe = 0;
}
flammable_crate_think()
{
if ( self.classname != "script_model" )
{
return;
}
self endon( "exploding" );
self breakable_clip();
self.health = level.cratehealth;
self setcandamage( 1 );
for ( ;; )
{
self waittill( "damage", amount, attacker, direction_vec, p, type );
if ( isDefined( self.script_requires_player ) && self.script_requires_player && !isplayer( attacker ) )
{
continue;
}
else
{
if ( isDefined( self.script_selfisattacker ) && self.script_selfisattacker )
{
self.damageowner = self;
}
else
{
self.damageowner = attacker;
}
if ( level.barrelexplodingthisframe )
{
wait randomfloat( 1 );
}
self.health -= amount;
if ( self.health <= level.crateburn )
{
self thread flammable_crate_burn();
}
}
}
}
flammable_crate_burn()
{
count = 0;
startedfx = 0;
up = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
worldup = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
dot = vectordot( up, worldup );
offset1 = ( 0, 0, 1 );
offset2 = up * vectorScale( ( 0, 0, 1 ), 44 );
if ( dot < 0,5 )
{
offset1 = ( up * vectorScale( ( 0, 0, 1 ), 22 ) ) - vectorScale( ( 0, 0, 1 ), 30 );
offset2 = ( up * vectorScale( ( 0, 0, 1 ), 22 ) ) + vectorScale( ( 0, 0, 1 ), 14 );
}
while ( self.health > 0 )
{
if ( !startedfx )
{
playfx( level.breakables_fx[ "ammo_crate" ][ "burn_start" ], self.origin );
level thread play_sound_in_space( level.crateignsound, self.origin );
startedfx = 1;
}
if ( count > 20 )
{
count = 0;
}
playfx( level.breakables_fx[ "ammo_crate" ][ "burn" ], self.origin );
if ( count == 0 )
{
self.health -= 10 + randomint( 10 );
}
count++;
wait 0,05;
}
self thread flammable_crate_explode();
}
flammable_crate_explode()
{
self notify( "exploding" );
self death_notify_wrapper();
up = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
worldup = anglesToUp( vectorScale( ( 0, 0, 1 ), 90 ) );
dot = vectordot( up, worldup );
offset = ( 0, 0, 1 );
if ( dot < 0,5 )
{
start = self.origin + vectorScale( up, 22 );
trace = physicstrace( start, start + vectorScale( ( 0, 0, 1 ), 64 ) );
end = trace[ "position" ];
offset = end - self.origin;
}
offset += vectorScale( ( 0, 0, 1 ), 4 );
mindamage = 1;
maxdamage = 250;
blastradius = 250;
level thread play_sound_in_space( level.crateexpsound, self.origin );
playfx( level.breakables_fx[ "ammo_crate" ][ "explode" ], self.origin );
physicsexplosionsphere( self.origin + offset, 100, 80, 1, maxdamage, mindamage );
level.barrelexplodingthisframe = 1;
if ( isDefined( self.remove ) )
{
self.remove delete();
}
if ( isDefined( self.radius ) )
{
blastradius = self.radius;
}
attacker = undefined;
if ( isDefined( self.damageowner ) )
{
attacker = self.damageowner;
}
self radiusdamage( self.origin + vectorScale( ( 0, 0, 1 ), 30 ), blastradius, maxdamage, mindamage, attacker );
self setmodel( "global_flammable_crate_jap_piece01_d" );
if ( dot < 0,5 )
{
start = self.origin + vectorScale( up, 22 );
trace = physicstrace( start, start + vectorScale( ( 0, 0, 1 ), 64 ) );
pos = trace[ "position" ];
self.origin = pos;
self.angles += vectorScale( ( 0, 0, 1 ), 90 );
}
wait 0,05;
level.barrelexplodingthisframe = 0;
}
breakable_clip()
{
if ( isDefined( self.target ) )
{
targ = getent( self.target, "targetname" );
if ( targ.classname == "script_brushmodel" )
{
self.remove = targ;
return;
}
}
if ( isDefined( level.breakables_clip ) && level.breakables_clip.size > 0 )
{
self.remove = getclosestent( self.origin, level.breakables_clip );
}
if ( isDefined( self.remove ) )
{
arrayremovevalue( level.breakables_clip, self.remove );
}
}
getclosestent( org, array )
{
if ( array.size < 1 )
{
return;
}
dist = 256;
ent = undefined;
i = 0;
while ( i < array.size )
{
newdist = distance( array[ i ] getorigin(), org );
if ( newdist >= dist )
{
i++;
continue;
}
else
{
dist = newdist;
ent = array[ i ];
}
i++;
}
return ent;
}

30
zm_transit_dr_patch/maps/mp/_music.gsc Normal file
View File

@ -0,0 +1,30 @@
#include maps/mp/_utility;
music_init()
{
/#
assert( level.clientscripts );
#/
level.musicstate = "";
registerclientsys( "musicCmd" );
}
setmusicstate( state, player )
{
if ( isDefined( level.musicstate ) )
{
if ( isDefined( player ) )
{
setclientsysstate( "musicCmd", state, player );
return;
}
else
{
if ( level.musicstate != state )
{
setclientsysstate( "musicCmd", state );
}
}
}
level.musicstate = state;
}

342
zm_transit_dr_patch/maps/mp/_script_gen.gsc Normal file
View File

@ -0,0 +1,342 @@
#include maps/mp/_script_gen;
#include maps/mp/_utility;
#include common_scripts/utility;
script_gen_dump_checksaved()
{
signatures = getarraykeys( level.script_gen_dump );
i = 0;
while ( i < signatures.size )
{
if ( !isDefined( level.script_gen_dump2[ signatures[ i ] ] ) )
{
level.script_gen_dump_reasons[ level.script_gen_dump_reasons.size ] = "Signature unmatched( removed feature ): " + signatures[ i ];
}
i++;
}
}
script_gen_dump()
{
/#
script_gen_dump_checksaved();
if ( !level.script_gen_dump_reasons.size )
{
flag_set( "scriptgen_done" );
return;
}
firstrun = 0;
if ( level.bscriptgened )
{
println( " " );
println( " " );
println( " " );
println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
println( "^3Dumping scriptgen dump for these reasons" );
println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
i = 0;
while ( i < level.script_gen_dump_reasons.size )
{
if ( issubstr( level.script_gen_dump_reasons[ i ], "nowrite" ) )
{
substr = getsubstr( level.script_gen_dump_reasons[ i ], 15 );
println( ( i + ". ) " ) + substr );
}
else
{
println( ( i + ". ) " ) + level.script_gen_dump_reasons[ i ] );
}
if ( level.script_gen_dump_reasons[ i ] == "First run" )
{
firstrun = 1;
}
i++;
}
println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
println( " " );
if ( firstrun )
{
println( "for First Run make sure you delete all of the vehicle precache script calls, createart calls, createfx calls( most commonly placed in maps\\" + level.script + "_fx.gsc ) " );
println( " " );
println( "replace:" );
println( "maps\\_load::main( 1 );" );
println( " " );
println( "with( don't forget to add this file to P4 ):" );
println( "maps\\scriptgen\\" + level.script + "_scriptgen::main();" );
println( " " );
}
println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
println( " " );
println( "^2 / \\ / \\ / \\" );
println( "^2scroll up" );
println( "^2 / \\ / \\ / \\" );
println( " " );
}
else
{
return;
}
filename = "scriptgen/" + level.script + "_scriptgen.gsc";
csvfilename = "zone_source/" + level.script + ".csv";
if ( level.bscriptgened )
{
file = openfile( filename, "write" );
}
else
{
file = 0;
}
assert( file != -1, "File not writeable( check it and and restart the map ): " + filename );
script_gen_dumpprintln( file, "// script generated script do not write your own script here it will go away if you do." );
script_gen_dumpprintln( file, "main()" );
script_gen_dumpprintln( file, "{" );
script_gen_dumpprintln( file, "" );
script_gen_dumpprintln( file, "\tlevel.script_gen_dump = [];" );
script_gen_dumpprintln( file, "" );
signatures = getarraykeys( level.script_gen_dump );
i = 0;
while ( i < signatures.size )
{
if ( !issubstr( level.script_gen_dump[ signatures[ i ] ], "nowrite" ) )
{
script_gen_dumpprintln( file, "\t" + level.script_gen_dump[ signatures[ i ] ] );
}
i++;
}
i = 0;
while ( i < signatures.size )
{
if ( !issubstr( level.script_gen_dump[ signatures[ i ] ], "nowrite" ) )
{
script_gen_dumpprintln( file, "\tlevel.script_gen_dump[ " + """ + signatures[ i ] + """ + " ] = " + """ + signatures[ i ] + """ + ";" );
i++;
continue;
}
else
{
script_gen_dumpprintln( file, "\tlevel.script_gen_dump[ " + """ + signatures[ i ] + """ + " ] = " + ""nowrite"" + ";" );
}
i++;
}
script_gen_dumpprintln( file, "" );
keys1 = undefined;
keys2 = undefined;
if ( isDefined( level.sg_precacheanims ) )
{
keys1 = getarraykeys( level.sg_precacheanims );
}
while ( isDefined( keys1 ) )
{
i = 0;
while ( i < keys1.size )
{
script_gen_dumpprintln( file, "\tanim_precach_" + keys1[ i ] + "();" );
i++;
}
}
script_gen_dumpprintln( file, "\tmaps\\_load::main( 1, " + level.bcsvgened + ", 1 );" );
script_gen_dumpprintln( file, "}" );
script_gen_dumpprintln( file, "" );
if ( isDefined( level.sg_precacheanims ) )
{
keys1 = getarraykeys( level.sg_precacheanims );
}
while ( isDefined( keys1 ) )
{
i = 0;
while ( i < keys1.size )
{
script_gen_dumpprintln( file, "#using_animtree( "" + keys1[ i ] + "" );" );
script_gen_dumpprintln( file, "anim_precach_" + keys1[ i ] + "()" );
script_gen_dumpprintln( file, "{" );
script_gen_dumpprintln( file, "\tlevel.sg_animtree[ "" + keys1[ i ] + "" ] = #animtree;" );
keys2 = getarraykeys( level.sg_precacheanims[ keys1[ i ] ] );
while ( isDefined( keys2 ) )
{
j = 0;
while ( j < keys2.size )
{
script_gen_dumpprintln( file, "\tlevel.sg_anim[ "" + keys2[ j ] + "" ] = %" + keys2[ j ] + ";" );
j++;
}
}
script_gen_dumpprintln( file, "}" );
script_gen_dumpprintln( file, "" );
i++;
}
}
if ( level.bscriptgened )
{
saved = closefile( file );
}
else
{
saved = 1;
}
if ( level.bcsvgened )
{
csvfile = openfile( csvfilename, "write" );
}
else
{
csvfile = 0;
}
assert( csvfile != -1, "File not writeable( check it and and restart the map ): " + csvfilename );
signatures = getarraykeys( level.script_gen_dump );
i = 0;
while ( i < signatures.size )
{
script_gen_csvdumpprintln( csvfile, signatures[ i ] );
i++;
}
if ( level.bcsvgened )
{
csvfilesaved = closefile( csvfile );
}
else
{
csvfilesaved = 1;
}
assert( csvfilesaved == 1, "csv not saved( see above message? ): " + csvfilename );
assert( saved == 1, "map not saved( see above message? ): " + filename );
#/
/#
assert( !level.bscriptgened, "SCRIPTGEN generated: follow instructions listed above this error in the console" );
#/
if ( level.bscriptgened )
{
/#
assertmsg( "SCRIPTGEN updated: Rebuild fast file and run map again" );
#/
}
flag_set( "scriptgen_done" );
}
script_gen_csvdumpprintln( file, signature )
{
prefix = undefined;
writtenprefix = undefined;
path = "";
extension = "";
if ( issubstr( signature, "ignore" ) )
{
prefix = "ignore";
}
else if ( issubstr( signature, "col_map_sp" ) )
{
prefix = "col_map_sp";
}
else if ( issubstr( signature, "gfx_map" ) )
{
prefix = "gfx_map";
}
else if ( issubstr( signature, "rawfile" ) )
{
prefix = "rawfile";
}
else if ( issubstr( signature, "sound" ) )
{
prefix = "sound";
}
else if ( issubstr( signature, "xmodel" ) )
{
prefix = "xmodel";
}
else if ( issubstr( signature, "xanim" ) )
{
prefix = "xanim";
}
else if ( issubstr( signature, "item" ) )
{
prefix = "item";
writtenprefix = "weapon";
path = "sp/";
}
else if ( issubstr( signature, "fx" ) )
{
prefix = "fx";
}
else if ( issubstr( signature, "menu" ) )
{
prefix = "menu";
writtenprefix = "menufile";
path = "ui / scriptmenus/";
extension = ".menu";
}
else if ( issubstr( signature, "rumble" ) )
{
prefix = "rumble";
writtenprefix = "rawfile";
path = "rumble/";
}
else if ( issubstr( signature, "shader" ) )
{
prefix = "shader";
writtenprefix = "material";
}
else if ( issubstr( signature, "shock" ) )
{
prefix = "shock";
writtenprefix = "rawfile";
extension = ".shock";
path = "shock/";
}
else if ( issubstr( signature, "string" ) )
{
prefix = "string";
/#
assertmsg( "string not yet supported by scriptgen" );
#/
}
else if ( issubstr( signature, "turret" ) )
{
prefix = "turret";
writtenprefix = "weapon";
path = "sp/";
}
else
{
if ( issubstr( signature, "vehicle" ) )
{
prefix = "vehicle";
writtenprefix = "rawfile";
path = "vehicles/";
}
}
if ( !isDefined( prefix ) )
{
return;
}
if ( !isDefined( writtenprefix ) )
{
string = ( prefix + ", " ) + getsubstr( signature, prefix.size + 1, signature.size );
}
else
{
string = ( writtenprefix + ", " ) + path + getsubstr( signature, prefix.size + 1, signature.size ) + extension;
}
/#
if ( file == -1 || !level.bcsvgened )
{
println( string );
}
else
{
fprintln( file, string );
#/
}
}
script_gen_dumpprintln( file, string )
{
/#
if ( file == -1 || !level.bscriptgened )
{
println( string );
}
else
{
fprintln( file, string );
#/
}
}

56
zm_transit_dr_patch/maps/mp/_serverfaceanim_mp.gsc Normal file
View File

@ -0,0 +1,56 @@
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
for ( ;; )
{
level waittill( "connecting", player );
player thread onplayerspawned();
}
}
onplayerspawned()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "spawned_player" );
self thread init_serverfaceanim();
}
}
init_serverfaceanim()
{
self.do_face_anims = 1;
if ( !isDefined( level.face_event_handler ) )
{
level.face_event_handler = spawnstruct();
level.face_event_handler.events = [];
level.face_event_handler.events[ "death" ] = "face_death";
level.face_event_handler.events[ "grenade danger" ] = "face_alert";
level.face_event_handler.events[ "bulletwhizby" ] = "face_alert";
level.face_event_handler.events[ "projectile_impact" ] = "face_alert";
level.face_event_handler.events[ "explode" ] = "face_alert";
level.face_event_handler.events[ "alert" ] = "face_alert";
level.face_event_handler.events[ "shoot" ] = "face_shoot_single";
level.face_event_handler.events[ "melee" ] = "face_melee";
level.face_event_handler.events[ "damage" ] = "face_pain";
level thread wait_for_face_event();
}
}
wait_for_face_event()
{
while ( 1 )
{
level waittill( "face", face_notify, ent );
if ( isDefined( ent ) && isDefined( ent.do_face_anims ) && ent.do_face_anims )
{
if ( isDefined( level.face_event_handler.events[ face_notify ] ) )
{
ent sendfaceevent( level.face_event_handler.events[ face_notify ] );
}
}
}
}

12
zm_transit_dr_patch/maps/mp/_sticky_grenade.gsc Normal file
View File

@ -0,0 +1,12 @@
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
loadfx( "weapon/crossbow/fx_trail_crossbow_blink_grn_os" );
loadfx( "weapon/crossbow/fx_trail_crossbow_blink_red_os" );
}
watch_bolt_detonation( owner )
{
}

3077
zm_transit_dr_patch/maps/mp/_utility.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

507
zm_transit_dr_patch/maps/mp/_visionset_mgr.gsc Normal file
View File

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

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_climb_down_pothole.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "climb_down_pothole" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_climb_up_pothole.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "climb_up_pothole" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_jump_across_120.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "jump_across_120" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_jump_down_127.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "jump_down_127" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_jump_down_190.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "jump_down_190" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_jump_down_222.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "jump_down_222" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_jump_down_48.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "jump_down_48" );
}

14
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_jump_down_96.gsc Normal file
View File

@ -0,0 +1,14 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
if ( isDefined( self.isdog ) && self.isdog )
{
dog_jump_down( 96, 7 );
}
else
{
dosimpletraverse( "jump_down_96" );
}
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_jump_up_127.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "jump_up_127" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_jump_up_222.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "jump_up_222" );
}

41
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_mantle_over_40.gsc Normal file
View File

@ -0,0 +1,41 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
traversestate = "zm_traverse_barrier";
traversealias = "barrier_walk";
if ( self.has_legs )
{
switch( self.zombie_move_speed )
{
case "walk":
case "walk_slide":
traversealias = "barrier_walk";
break;
case "run":
case "run_slide":
traversealias = "barrier_run";
break;
case "sprint":
case "sprint_slide":
case "super_sprint":
traversealias = "barrier_sprint";
break;
default:
if ( isDefined( level.zm_mantle_over_40_move_speed_override ) )
{
traversealias = self [[ level.zm_mantle_over_40_move_speed_override ]]();
}
else /#
assertmsg( "Zombie move speed of '" + self.zombie_move_speed + "' is not supported for mantle_over_40." );
#/
}
}
else
{
traversestate = "zm_traverse_barrier_crawl";
traversealias = "barrier_crawl";
}
self dotraverse( traversestate, traversealias );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_mantle_over_40_hurdle.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
self dosimpletraverse( "mantle_over_40_hurdle" );
}

29
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_traverse_car.gsc Normal file
View File

@ -0,0 +1,29 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
speed = "";
if ( !isDefined( self.isdog ) || !self.isdog )
{
switch( self.zombie_move_speed )
{
case "walk":
case "walk_slide":
speed = "";
break;
case "run":
case "run_slide":
speed = "_run";
break;
case "sprint":
case "sprint_slide":
case "super_sprint":
speed = "_sprint";
break;
default:
}
}
dosimpletraverse( "traverse_car" + speed, 1 );
}
}

21
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_traverse_car_reverse.gsc Normal file
View File

@ -0,0 +1,21 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
speed = "";
if ( !self.has_legs )
{
switch( self.zombie_move_speed )
{
case "sprint":
case "sprint_slide":
case "super_sprint":
speed = "_sprint";
break;
default:
}
}
dosimpletraverse( "traverse_car_reverse" + speed, 1 );
}
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_traverse_diner_counter.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "traverse_diner_counter", 1 );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_traverse_diner_counter_reverse.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "traverse_diner_counter_reverse", 1 );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_traverse_diner_roof.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "traverse_diner_roof" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_traverse_diner_roof_hatch_up.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "traverse_diner_roof_hatch_up" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_traverse_diner_roof_up.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "traverse_diner_roof_up" );
}

7
zm_transit_dr_patch/maps/mp/animscripts/traverse/zm_traverse_garage_door.gsc Normal file
View File

@ -0,0 +1,7 @@
#include maps/mp/animscripts/traverse/zm_shared;
#include maps/mp/animscripts/traverse/shared;
main()
{
dosimpletraverse( "traverse_garage_door", 1 );
}

44
zm_transit_dr_patch/maps/mp/createart/zm_transit_art.gsc Normal file
View File

@ -0,0 +1,44 @@
main()
{
level.tweakfile = 1;
setdvar( "scr_fog_exp_halfplane", "639.219" );
setdvar( "scr_fog_exp_halfheight", "18691.3" );
setdvar( "scr_fog_nearplane", "138.679" );
setdvar( "scr_fog_red", "0.806694" );
setdvar( "scr_fog_green", "0.962521" );
setdvar( "scr_fog_blue", "0.9624" );
setdvar( "scr_fog_baseheight", "1145.21" );
setdvar( "visionstore_glowTweakEnable", "0" );
setdvar( "visionstore_glowTweakRadius0", "5" );
setdvar( "visionstore_glowTweakRadius1", "" );
setdvar( "visionstore_glowTweakBloomCutoff", "0.5" );
setdvar( "visionstore_glowTweakBloomDesaturation", "0" );
setdvar( "visionstore_glowTweakBloomIntensity0", "1" );
setdvar( "visionstore_glowTweakBloomIntensity1", "" );
setdvar( "visionstore_glowTweakSkyBleedIntensity0", "" );
setdvar( "visionstore_glowTweakSkyBleedIntensity1", "" );
start_dist = 138,679;
half_dist = 1011,624;
half_height = 10834,5;
base_height = 1145,21;
fog_r = 0,501961;
fog_g = 0,501961;
fog_b = 0,501961;
fog_scale = 7,5834;
sun_col_r = 0,501961;
sun_col_g = 0,501961;
sun_col_b = 0,501961;
sun_dir_x = -0,99;
sun_dir_y = 0,06;
sun_dir_z = -0,11;
sun_start_ang = 0;
sun_stop_ang = 0;
time = 0;
max_fog_opacity = 0,8546;
setvolfog( start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale, sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang, sun_stop_ang, time, max_fog_opacity );
visionsetnaked( "zm_transit", 0 );
setdvar( "r_lightGridEnableTweaks", 1 );
setdvar( "r_lightGridIntensity", 1,4 );
setdvar( "r_lightGridContrast", 0,2 );
}

3930
zm_transit_dr_patch/maps/mp/createfx/zm_transit_fx.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

207
zm_transit_dr_patch/maps/mp/gametypes_zm/_callbacksetup.gsc Normal file
View File

@ -0,0 +1,207 @@
#include maps/mp/gametypes_zm/_hostmigration;
#include maps/mp/gametypes_zm/_globallogic_actor;
#include maps/mp/gametypes_zm/_globallogic_player;
#include maps/mp/gametypes_zm/_globallogic;
#include maps/mp/_audio;
#include maps/mp/_utility;
codecallback_startgametype()
{
if ( !isDefined( level.gametypestarted ) || !level.gametypestarted )
{
[[ level.callbackstartgametype ]]();
level.gametypestarted = 1;
}
}
codecallback_finalizeinitialization()
{
maps/mp/_utility::callback( "on_finalize_initialization" );
}
codecallback_playerconnect()
{
self endon( "disconnect" );
self thread maps/mp/_audio::monitor_player_sprint();
[[ level.callbackplayerconnect ]]();
}
codecallback_playerdisconnect()
{
self notify( "disconnect" );
client_num = self getentitynumber();
[[ level.callbackplayerdisconnect ]]();
}
codecallback_hostmigration()
{
/#
println( "****CodeCallback_HostMigration****" );
#/
[[ level.callbackhostmigration ]]();
}
codecallback_hostmigrationsave()
{
/#
println( "****CodeCallback_HostMigrationSave****" );
#/
[[ level.callbackhostmigrationsave ]]();
}
codecallback_prehostmigrationsave()
{
/#
println( "****CodeCallback_PreHostMigrationSave****" );
#/
[[ level.callbackprehostmigrationsave ]]();
}
codecallback_playermigrated()
{
/#
println( "****CodeCallback_PlayerMigrated****" );
#/
[[ level.callbackplayermigrated ]]();
}
codecallback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
{
self endon( "disconnect" );
[[ level.callbackplayerdamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex );
}
codecallback_playerkilled( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration )
{
self endon( "disconnect" );
[[ level.callbackplayerkilled ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration );
}
codecallback_playerlaststand( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration )
{
self endon( "disconnect" );
[[ level.callbackplayerlaststand ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration );
}
codecallback_playermelee( eattacker, idamage, sweapon, vorigin, vdir, boneindex, shieldhit )
{
self endon( "disconnect" );
[[ level.callbackplayermelee ]]( eattacker, idamage, sweapon, vorigin, vdir, boneindex, shieldhit );
}
codecallback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
{
[[ level.callbackactordamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex );
}
codecallback_actorkilled( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset )
{
[[ level.callbackactorkilled ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset );
}
codecallback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, damagefromunderneath, modelindex, partname )
{
[[ level.callbackvehicledamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, damagefromunderneath, modelindex, partname );
}
codecallback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, timeoffset )
{
}
codecallback_faceeventnotify( notify_msg, ent )
{
if ( isDefined( ent ) && isDefined( ent.do_face_anims ) && ent.do_face_anims )
{
if ( isDefined( level.face_event_handler ) && isDefined( level.face_event_handler.events[ notify_msg ] ) )
{
ent sendfaceevent( level.face_event_handler.events[ notify_msg ] );
}
}
}
codecallback_menuresponse( action, arg )
{
if ( !isDefined( level.menuresponsequeue ) )
{
level.menuresponsequeue = [];
level thread menuresponsequeuepump();
}
index = level.menuresponsequeue.size;
level.menuresponsequeue[ index ] = spawnstruct();
level.menuresponsequeue[ index ].action = action;
level.menuresponsequeue[ index ].arg = arg;
level.menuresponsequeue[ index ].ent = self;
level notify( "menuresponse_queue" );
}
menuresponsequeuepump()
{
while ( 1 )
{
level waittill( "menuresponse_queue" );
level.menuresponsequeue[ 0 ].ent notify( "menuresponse" );
arrayremoveindex( level.menuresponsequeue, 0, 0 );
wait 0,05;
}
}
setupcallbacks()
{
setdefaultcallbacks();
level.idflags_radius = 1;
level.idflags_no_armor = 2;
level.idflags_no_knockback = 4;
level.idflags_penetration = 8;
level.idflags_destructible_entity = 16;
level.idflags_shield_explosive_impact = 32;
level.idflags_shield_explosive_impact_huge = 64;
level.idflags_shield_explosive_splash = 128;
level.idflags_no_team_protection = 256;
level.idflags_no_protection = 512;
level.idflags_passthru = 1024;
}
setdefaultcallbacks()
{
level.callbackstartgametype = ::maps/mp/gametypes_zm/_globallogic::callback_startgametype;
level.callbackplayerconnect = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerconnect;
level.callbackplayerdisconnect = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerdisconnect;
level.callbackplayerdamage = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerdamage;
level.callbackplayerkilled = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerkilled;
level.callbackplayermelee = ::maps/mp/gametypes_zm/_globallogic_player::callback_playermelee;
level.callbackplayerlaststand = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerlaststand;
level.callbackactordamage = ::maps/mp/gametypes_zm/_globallogic_actor::callback_actordamage;
level.callbackactorkilled = ::maps/mp/gametypes_zm/_globallogic_actor::callback_actorkilled;
level.callbackplayermigrated = ::maps/mp/gametypes_zm/_globallogic_player::callback_playermigrated;
level.callbackhostmigration = ::maps/mp/gametypes_zm/_hostmigration::callback_hostmigration;
level.callbackhostmigrationsave = ::maps/mp/gametypes_zm/_hostmigration::callback_hostmigrationsave;
level.callbackprehostmigrationsave = ::maps/mp/gametypes_zm/_hostmigration::callback_prehostmigrationsave;
}
abortlevel()
{
/#
println( "ERROR: Aborting level - gametype is not supported" );
#/
level.callbackstartgametype = ::callbackvoid;
level.callbackplayerconnect = ::callbackvoid;
level.callbackplayerdisconnect = ::callbackvoid;
level.callbackplayerdamage = ::callbackvoid;
level.callbackplayerkilled = ::callbackvoid;
level.callbackplayermelee = ::callbackvoid;
level.callbackplayerlaststand = ::callbackvoid;
level.callbackactordamage = ::callbackvoid;
level.callbackactorkilled = ::callbackvoid;
level.callbackvehicledamage = ::callbackvoid;
setdvar( "g_gametype", "dm" );
exitlevel( 0 );
}
codecallback_glasssmash( pos, dir )
{
level notify( "glass_smash" );
}
callbackvoid()
{
}

16
zm_transit_dr_patch/maps/mp/gametypes_zm/_clientids.gsc Normal file
View File

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

160
zm_transit_dr_patch/maps/mp/gametypes_zm/_damagefeedback.gsc Normal file
View File

@ -0,0 +1,160 @@
init()
{
precacheshader( "damage_feedback" );
precacheshader( "damage_feedback_flak" );
precacheshader( "damage_feedback_tac" );
level thread onplayerconnect();
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player.hud_damagefeedback = newdamageindicatorhudelem( player );
player.hud_damagefeedback.horzalign = "center";
player.hud_damagefeedback.vertalign = "middle";
player.hud_damagefeedback.x = -12;
player.hud_damagefeedback.y = -12;
player.hud_damagefeedback.alpha = 0;
player.hud_damagefeedback.archived = 1;
player.hud_damagefeedback setshader( "damage_feedback", 24, 48 );
player.hitsoundtracker = 1;
}
}
updatedamagefeedback( mod, inflictor, perkfeedback )
{
if ( !isplayer( self ) || sessionmodeiszombiesgame() )
{
return;
}
if ( isDefined( mod ) && mod != "MOD_CRUSH" && mod != "MOD_GRENADE_SPLASH" && mod != "MOD_HIT_BY_OBJECT" )
{
if ( isDefined( inflictor ) && isDefined( inflictor.soundmod ) )
{
switch( inflictor.soundmod )
{
case "player":
self thread playhitsound( mod, "mpl_hit_alert" );
break;
case "heli":
self thread playhitsound( mod, "mpl_hit_alert_air" );
break;
case "hpm":
self thread playhitsound( mod, "mpl_hit_alert_hpm" );
break;
case "taser_spike":
self thread playhitsound( mod, "mpl_hit_alert_taser_spike" );
break;
case "dog":
case "straferun":
case "default_loud":
self thread playhitsound( mod, "mpl_hit_heli_gunner" );
break;
default:
self thread playhitsound( mod, "mpl_hit_alert_low" );
break;
}
}
else self thread playhitsound( mod, "mpl_hit_alert_low" );
}
if ( isDefined( perkfeedback ) )
{
switch( perkfeedback )
{
case "flakjacket":
self.hud_damagefeedback setshader( "damage_feedback_flak", 24, 48 );
break;
case "tacticalMask":
self.hud_damagefeedback setshader( "damage_feedback_tac", 24, 48 );
break;
}
}
else self.hud_damagefeedback setshader( "damage_feedback", 24, 48 );
self.hud_damagefeedback.alpha = 1;
self.hud_damagefeedback fadeovertime( 1 );
self.hud_damagefeedback.alpha = 0;
}
}
playhitsound( mod, alert )
{
self endon( "disconnect" );
if ( self.hitsoundtracker )
{
self.hitsoundtracker = 0;
self playlocalsound( alert );
wait 0,05;
self.hitsoundtracker = 1;
}
}
updatespecialdamagefeedback( hitent )
{
if ( !isplayer( self ) )
{
return;
}
if ( !isDefined( hitent ) )
{
return;
}
if ( !isplayer( hitent ) )
{
return;
}
wait 0,05;
if ( !isDefined( self.directionalhitarray ) )
{
self.directionalhitarray = [];
hitentnum = hitent getentitynumber();
self.directionalhitarray[ hitentnum ] = 1;
self thread sendhitspecialeventatframeend( hitent );
}
else
{
hitentnum = hitent getentitynumber();
self.directionalhitarray[ hitentnum ] = 1;
}
}
sendhitspecialeventatframeend( hitent )
{
self endon( "disconnect" );
waittillframeend;
enemyshit = 0;
value = 1;
entbitarray0 = 0;
i = 0;
while ( i < 32 )
{
if ( isDefined( self.directionalhitarray[ i ] ) && self.directionalhitarray[ i ] != 0 )
{
entbitarray0 += value;
enemyshit++;
}
value *= 2;
i++;
}
entbitarray1 = 0;
i = 33;
while ( i < 64 )
{
if ( isDefined( self.directionalhitarray[ i ] ) && self.directionalhitarray[ i ] != 0 )
{
entbitarray1 += value;
enemyshit++;
}
value *= 2;
i++;
}
if ( enemyshit )
{
self directionalhitindicator( entbitarray0, entbitarray1 );
}
self.directionalhitarray = undefined;
entbitarray0 = 0;
entbitarray1 = 0;
}

2630
zm_transit_dr_patch/maps/mp/gametypes_zm/_gameobjects.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

0
zm_transit_dr_patch/maps/mp/gametypes_zm/_globalentities.gsc Normal file
View File

207
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_actor.gsc Normal file
View File

@ -0,0 +1,207 @@
#include maps/mp/_challenges;
#include maps/mp/gametypes_zm/_damagefeedback;
#include maps/mp/gametypes_zm/_weapons;
#include maps/mp/gametypes_zm/_globallogic_utils;
#include maps/mp/gametypes_zm/_globallogic_player;
#include maps/mp/_utility;
callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex )
{
if ( game[ "state" ] == "postgame" )
{
return;
}
if ( self.aiteam == "spectator" )
{
return;
}
if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( eattacker.candocombat ) && !eattacker.candocombat )
{
return;
}
self.idflags = idflags;
self.idflagstime = getTime();
eattacker = maps/mp/gametypes_zm/_globallogic_player::figureoutattacker( eattacker );
if ( !isDefined( vdir ) )
{
idflags |= level.idflags_no_knockback;
}
friendly = 0;
if ( self.health == self.maxhealth || !isDefined( self.attackers ) )
{
self.attackers = [];
self.attackerdata = [];
self.attackerdamage = [];
}
if ( maps/mp/gametypes_zm/_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) )
{
smeansofdeath = "MOD_HEAD_SHOT";
}
if ( level.onlyheadshots )
{
if ( smeansofdeath == "MOD_PISTOL_BULLET" || smeansofdeath == "MOD_RIFLE_BULLET" )
{
return;
}
else
{
if ( smeansofdeath == "MOD_HEAD_SHOT" )
{
idamage = 150;
}
}
}
if ( sweapon == "none" && isDefined( einflictor ) )
{
if ( isDefined( einflictor.targetname ) && einflictor.targetname == "explodable_barrel" )
{
sweapon = "explodable_barrel_mp";
}
else
{
if ( isDefined( einflictor.destructible_type ) && issubstr( einflictor.destructible_type, "vehicle_" ) )
{
sweapon = "destructible_car_mp";
}
}
}
if ( idflags & level.idflags_no_protection )
{
if ( isplayer( eattacker ) )
{
eattacker.pers[ "participation" ]++;
}
prevhealthratio = self.health / self.maxhealth;
if ( level.teambased && isplayer( eattacker ) && self != eattacker && self.aiteam == eattacker.pers[ "team" ] )
{
if ( level.friendlyfire == 0 )
{
return;
}
else if ( level.friendlyfire == 1 )
{
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
}
else if ( level.friendlyfire == 2 )
{
return;
}
else
{
if ( level.friendlyfire == 3 )
{
idamage = int( idamage * 0,5 );
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
}
}
friendly = 1;
}
else
{
if ( isDefined( eattacker ) && isDefined( self.script_owner ) && eattacker == self.script_owner && !level.hardcoremode )
{
return;
}
if ( isDefined( eattacker ) && isDefined( self.script_owner ) && isDefined( eattacker.script_owner ) && eattacker.script_owner == self.script_owner )
{
return;
}
if ( idamage < 1 )
{
idamage = 1;
}
if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( sweapon ) && !issubstr( smeansofdeath, "MOD_MELEE" ) )
{
eattacker thread maps/mp/gametypes_zm/_weapons::checkhit( sweapon );
}
if ( issubstr( smeansofdeath, "MOD_GRENADE" ) && isDefined( einflictor ) && isDefined( einflictor.iscooked ) )
{
self.wascooked = getTime();
}
else
{
self.wascooked = undefined;
}
if ( isDefined( eattacker ) )
{
self.lastdamagewasfromenemy = eattacker != self;
}
self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
}
if ( isDefined( eattacker ) && eattacker != self )
{
if ( sweapon != "artillery_mp" || !isDefined( einflictor ) && !isai( einflictor ) )
{
if ( idamage > 0 )
{
eattacker thread maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor );
}
}
}
}
/#
if ( getDvarInt( "g_debugDamage" ) )
{
println( "actor:" + self getentitynumber() + " health:" + self.health + " attacker:" + eattacker.clientid + " inflictor is player:" + isplayer( einflictor ) + " damage:" + idamage + shitloc + ";" + boneindex + "\n" );
#/
}
if ( 1 )
{
lpselfnum = self getentitynumber();
lpselfteam = self.aiteam;
lpattackerteam = "";
if ( isplayer( eattacker ) )
{
lpattacknum = eattacker getentitynumber();
lpattackguid = eattacker getguid();
lpattackname = eattacker.name;
lpattackerteam = eattacker.pers[ "team" ];
}
else
{
lpattacknum = -1;
lpattackguid = "";
lpattackname = "";
lpattackerteam = "world";
}
logprint( "AD;" + lpselfnum + ";" + lpselfteam + ";" + lpattackguid + ";" + lpattacknum + ";" + lpattackerteam + ";" + lpattackname + ";" + sweapon + ";" + idamage + ";" + smeansofdeath + ";" + shitloc + "\n" );
}
}
callback_actorkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime )
{
if ( game[ "state" ] == "postgame" )
{
return;
}
if ( isai( attacker ) && isDefined( attacker.script_owner ) )
{
if ( attacker.script_owner.team != self.aiteam )
{
attacker = attacker.script_owner;
}
}
if ( attacker.classname == "script_vehicle" && isDefined( attacker.owner ) )
{
attacker = attacker.owner;
}
if ( isDefined( attacker ) && isplayer( attacker ) )
{
if ( !level.teambased || self.aiteam != attacker.pers[ "team" ] )
{
level.globalkillstreaksdestroyed++;
attacker addweaponstat( "dogs_mp", "destroyed", 1 );
attacker maps/mp/_challenges::killeddog();
}
}
}

1034
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_audio.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

230
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_defaults.gsc Normal file
View File

@ -0,0 +1,230 @@
#include maps/mp/gametypes_zm/_spawnlogic;
#include maps/mp/gametypes_zm/_globallogic_audio;
#include maps/mp/gametypes_zm/_globallogic_score;
#include maps/mp/gametypes_zm/_globallogic;
#include maps/mp/gametypes_zm/_globallogic_utils;
#include maps/mp/_utility;
#include common_scripts/utility;
getwinningteamfromloser( losing_team )
{
if ( level.multiteam )
{
return "tie";
}
else
{
if ( losing_team == "axis" )
{
return "allies";
}
}
return "axis";
}
default_onforfeit( team )
{
level.gameforfeited = 1;
level notify( "forfeit in progress" );
level endon( "forfeit in progress" );
level endon( "abort forfeit" );
forfeit_delay = 20;
announcement( game[ "strings" ][ "opponent_forfeiting_in" ], forfeit_delay, 0 );
wait 10;
announcement( game[ "strings" ][ "opponent_forfeiting_in" ], 10, 0 );
wait 10;
endreason = &"";
if ( !isDefined( team ) )
{
setdvar( "ui_text_endreason", game[ "strings" ][ "players_forfeited" ] );
endreason = game[ "strings" ][ "players_forfeited" ];
winner = level.players[ 0 ];
}
else if ( isDefined( level.teams[ team ] ) )
{
endreason = game[ "strings" ][ team + "_forfeited" ];
setdvar( "ui_text_endreason", endreason );
winner = getwinningteamfromloser( team );
}
else
{
/#
assert( isDefined( team ), "Forfeited team is not defined" );
#/
/#
assert( 0, "Forfeited team " + team + " is not allies or axis" );
#/
winner = "tie";
}
level.forcedend = 1;
if ( isplayer( winner ) )
{
logstring( "forfeit, win: " + winner getxuid() + "(" + winner.name + ")" );
}
else
{
maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "forfeit", winner );
}
thread maps/mp/gametypes_zm/_globallogic::endgame( winner, endreason );
}
default_ondeadevent( team )
{
if ( isDefined( level.teams[ team ] ) )
{
eliminatedstring = game[ "strings" ][ team + "_eliminated" ];
iprintln( eliminatedstring );
makedvarserverinfo( "ui_text_endreason", eliminatedstring );
setdvar( "ui_text_endreason", eliminatedstring );
winner = getwinningteamfromloser( team );
maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "team eliminated", winner );
thread maps/mp/gametypes_zm/_globallogic::endgame( winner, eliminatedstring );
}
else makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "tie" ] );
setdvar( "ui_text_endreason", game[ "strings" ][ "tie" ] );
maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "tie" );
if ( level.teambased )
{
thread maps/mp/gametypes_zm/_globallogic::endgame( "tie", game[ "strings" ][ "tie" ] );
}
else
{
thread maps/mp/gametypes_zm/_globallogic::endgame( undefined, game[ "strings" ][ "tie" ] );
}
}
default_onalivecountchange( team )
{
}
default_onroundendgame( winner )
{
return winner;
}
default_ononeleftevent( team )
{
if ( !level.teambased )
{
winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer();
if ( isDefined( winner ) )
{
logstring( "last one alive, win: " + winner.name );
}
else
{
logstring( "last one alive, win: unknown" );
}
thread maps/mp/gametypes_zm/_globallogic::endgame( winner, &"MP_ENEMIES_ELIMINATED" );
}
else
{
index = 0;
while ( index < level.players.size )
{
player = level.players[ index ];
if ( !isalive( player ) )
{
index++;
continue;
}
else if ( !isDefined( player.pers[ "team" ] ) || player.pers[ "team" ] != team )
{
index++;
continue;
}
else
{
player maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "sudden_death" );
}
index++;
}
}
}
default_ontimelimit()
{
winner = undefined;
if ( level.teambased )
{
winner = maps/mp/gametypes_zm/_globallogic::determineteamwinnerbygamestat( "teamScores" );
maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "time limit", winner );
}
else winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer();
if ( isDefined( winner ) )
{
logstring( "time limit, win: " + winner.name );
}
else
{
logstring( "time limit, tie" );
}
makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "time_limit_reached" ] );
setdvar( "ui_text_endreason", game[ "strings" ][ "time_limit_reached" ] );
thread maps/mp/gametypes_zm/_globallogic::endgame( winner, game[ "strings" ][ "time_limit_reached" ] );
}
default_onscorelimit()
{
if ( !level.endgameonscorelimit )
{
return 0;
}
winner = undefined;
if ( level.teambased )
{
winner = maps/mp/gametypes_zm/_globallogic::determineteamwinnerbygamestat( "teamScores" );
maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "scorelimit", winner );
}
else winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer();
if ( isDefined( winner ) )
{
logstring( "scorelimit, win: " + winner.name );
}
else
{
logstring( "scorelimit, tie" );
}
makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "score_limit_reached" ] );
setdvar( "ui_text_endreason", game[ "strings" ][ "score_limit_reached" ] );
thread maps/mp/gametypes_zm/_globallogic::endgame( winner, game[ "strings" ][ "score_limit_reached" ] );
return 1;
}
default_onspawnspectator( origin, angles )
{
if ( isDefined( origin ) && isDefined( angles ) )
{
self spawn( origin, angles );
return;
}
spawnpointname = "mp_global_intermission";
spawnpoints = getentarray( spawnpointname, "classname" );
/#
assert( spawnpoints.size, "There are no mp_global_intermission spawn points in the map. There must be at least one." );
#/
spawnpoint = maps/mp/gametypes_zm/_spawnlogic::getspawnpoint_random( spawnpoints );
self spawn( spawnpoint.origin, spawnpoint.angles );
}
default_onspawnintermission()
{
spawnpointname = "mp_global_intermission";
spawnpoints = getentarray( spawnpointname, "classname" );
spawnpoint = spawnpoints[ 0 ];
if ( isDefined( spawnpoint ) )
{
self spawn( spawnpoint.origin, spawnpoint.angles );
}
else
{
/#
maps/mp/_utility::error( "NO " + spawnpointname + " SPAWNPOINTS IN MAP" );
#/
}
}
default_gettimelimit()
{
return clamp( getgametypesetting( "timeLimit" ), level.timelimitmin, level.timelimitmax );
}

2235
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_player.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

873
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_score.gsc Normal file
View File

@ -0,0 +1,873 @@
#include maps/mp/gametypes_zm/_globallogic_utils;
#include maps/mp/_challenges;
#include maps/mp/gametypes_zm/_globallogic_audio;
#include maps/mp/gametypes_zm/_globallogic_score;
#include maps/mp/gametypes_zm/_globallogic;
#include maps/mp/_bb;
#include maps/mp/_utility;
#include common_scripts/utility;
updatematchbonusscores( winner )
{
}
givematchbonus( scoretype, score )
{
}
doskillupdate( winner )
{
skillupdate( winner, level.teambased );
}
gethighestscoringplayer()
{
players = level.players;
winner = undefined;
tie = 0;
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ].score ) )
{
i++;
continue;
}
else if ( players[ i ].score < 1 )
{
i++;
continue;
}
else if ( !isDefined( winner ) || players[ i ].score > winner.score )
{
winner = players[ i ];
tie = 0;
i++;
continue;
}
else
{
if ( players[ i ].score == winner.score )
{
tie = 1;
}
}
i++;
}
if ( tie || !isDefined( winner ) )
{
return undefined;
}
else
{
return winner;
}
}
resetscorechain()
{
self notify( "reset_score_chain" );
self.scorechain = 0;
self.rankupdatetotal = 0;
}
scorechaintimer()
{
self notify( "score_chain_timer" );
self endon( "reset_score_chain" );
self endon( "score_chain_timer" );
self endon( "death" );
self endon( "disconnect" );
wait 20;
self thread resetscorechain();
}
roundtonearestfive( score )
{
rounding = score % 5;
if ( rounding <= 2 )
{
return score - rounding;
}
else
{
return score + ( 5 - rounding );
}
}
giveplayermomentumnotification( score, label, descvalue, countstowardrampage )
{
rampagebonus = 0;
if ( isDefined( level.usingrampage ) && level.usingrampage )
{
if ( countstowardrampage )
{
if ( !isDefined( self.scorechain ) )
{
self.scorechain = 0;
}
self.scorechain++;
self thread scorechaintimer();
}
if ( isDefined( self.scorechain ) && self.scorechain >= 999 )
{
rampagebonus = roundtonearestfive( int( ( score * level.rampagebonusscale ) + 0,5 ) );
}
}
if ( score != 0 )
{
self luinotifyevent( &"score_event", 3, label, score, rampagebonus );
}
score += rampagebonus;
if ( score > 0 && self hasperk( "specialty_earnmoremomentum" ) )
{
score = roundtonearestfive( int( ( score * getDvarFloat( "perk_killstreakMomentumMultiplier" ) ) + 0,5 ) );
}
_setplayermomentum( self, self.pers[ "momentum" ] + score );
}
resetplayermomentumondeath()
{
if ( isDefined( level.usingscorestreaks ) && level.usingscorestreaks )
{
_setplayermomentum( self, 0 );
self thread resetscorechain();
}
}
giveplayermomentum( event, player, victim, weapon, descvalue )
{
}
giveplayerscore( event, player, victim, weapon, descvalue )
{
scorediff = 0;
momentum = player.pers[ "momentum" ];
giveplayermomentum( event, player, victim, weapon, descvalue );
newmomentum = player.pers[ "momentum" ];
if ( level.overrideplayerscore )
{
return 0;
}
pixbeginevent( "level.onPlayerScore" );
score = player.pers[ "score" ];
[[ level.onplayerscore ]]( event, player, victim );
newscore = player.pers[ "score" ];
pixendevent();
bbprint( "mpplayerscore", "spawnid %d gametime %d type %s player %s delta %d deltamomentum %d team %s", getplayerspawnid( player ), getTime(), event, player.name, newscore - score, newmomentum - momentum, player.team );
player maps/mp/_bb::bbaddtostat( "score", newscore - score );
if ( score == newscore )
{
return 0;
}
pixbeginevent( "givePlayerScore" );
recordplayerstats( player, "score", newscore );
scorediff = newscore - score;
player addplayerstatwithgametype( "score", scorediff );
if ( isDefined( player.pers[ "lastHighestScore" ] ) && newscore > player.pers[ "lastHighestScore" ] )
{
player setdstat( "HighestStats", "highest_score", newscore );
}
pixendevent();
return scorediff;
}
default_onplayerscore( event, player, victim )
{
}
_setplayerscore( player, score )
{
}
_getplayerscore( player )
{
return player.pers[ "score" ];
}
_setplayermomentum( player, momentum )
{
momentum = clamp( momentum, 0, 2000 );
oldmomentum = player.pers[ "momentum" ];
if ( momentum == oldmomentum )
{
return;
}
player maps/mp/_bb::bbaddtostat( "momentum", momentum - oldmomentum );
if ( momentum > oldmomentum )
{
highestmomentumcost = 0;
numkillstreaks = player.killstreak.size;
killstreaktypearray = [];
}
player.pers[ "momentum" ] = momentum;
player.momentum = player.pers[ "momentum" ];
}
_giveplayerkillstreakinternal( player, momentum, oldmomentum, killstreaktypearray )
{
}
setplayermomentumdebug()
{
/#
setdvar( "sv_momentumPercent", 0 );
while ( 1 )
{
wait 1;
momentumpercent = getdvarfloatdefault( "sv_momentumPercent", 0 );
if ( momentumpercent != 0 )
{
player = gethostplayer();
if ( !isDefined( player ) )
{
return;
}
if ( isDefined( player.killstreak ) )
{
_setplayermomentum( player, int( 2000 * ( momentumpercent / 100 ) ) );
}
}
#/
}
}
giveteamscore( event, team, player, victim )
{
if ( level.overrideteamscore )
{
return;
}
pixbeginevent( "level.onTeamScore" );
teamscore = game[ "teamScores" ][ team ];
[[ level.onteamscore ]]( event, team );
pixendevent();
newscore = game[ "teamScores" ][ team ];
bbprint( "mpteamscores", "gametime %d event %s team %d diff %d score %d", getTime(), event, team, newscore - teamscore, newscore );
if ( teamscore == newscore )
{
return;
}
updateteamscores( team );
thread maps/mp/gametypes_zm/_globallogic::checkscorelimit();
}
giveteamscoreforobjective( team, score )
{
teamscore = game[ "teamScores" ][ team ];
onteamscore( score, team );
newscore = game[ "teamScores" ][ team ];
bbprint( "mpteamobjscores", "gametime %d team %d diff %d score %d", getTime(), team, newscore - teamscore, newscore );
if ( teamscore == newscore )
{
return;
}
updateteamscores( team );
thread maps/mp/gametypes_zm/_globallogic::checkscorelimit();
}
_setteamscore( team, teamscore )
{
if ( teamscore == game[ "teamScores" ][ team ] )
{
return;
}
game[ "teamScores" ][ team ] = teamscore;
updateteamscores( team );
thread maps/mp/gametypes_zm/_globallogic::checkscorelimit();
}
resetteamscores()
{
while ( isDefined( level.roundscorecarry ) || level.roundscorecarry == 0 && maps/mp/_utility::isfirstround() )
{
_a591 = level.teams;
_k591 = getFirstArrayKey( _a591 );
while ( isDefined( _k591 ) )
{
team = _a591[ _k591 ];
game[ "teamScores" ][ team ] = 0;
_k591 = getNextArrayKey( _a591, _k591 );
}
}
maps/mp/gametypes_zm/_globallogic_score::updateallteamscores();
}
resetallscores()
{
resetteamscores();
resetplayerscores();
}
resetplayerscores()
{
players = level.players;
winner = undefined;
tie = 0;
i = 0;
while ( i < players.size )
{
if ( isDefined( players[ i ].pers[ "score" ] ) )
{
_setplayerscore( players[ i ], 0 );
}
i++;
}
}
updateteamscores( team )
{
setteamscore( team, game[ "teamScores" ][ team ] );
level thread maps/mp/gametypes_zm/_globallogic::checkteamscorelimitsoon( team );
}
updateallteamscores()
{
_a629 = level.teams;
_k629 = getFirstArrayKey( _a629 );
while ( isDefined( _k629 ) )
{
team = _a629[ _k629 ];
updateteamscores( team );
_k629 = getNextArrayKey( _a629, _k629 );
}
}
_getteamscore( team )
{
return game[ "teamScores" ][ team ];
}
gethighestteamscoreteam()
{
score = 0;
winning_teams = [];
_a645 = level.teams;
_k645 = getFirstArrayKey( _a645 );
while ( isDefined( _k645 ) )
{
team = _a645[ _k645 ];
team_score = game[ "teamScores" ][ team ];
if ( team_score > score )
{
score = team_score;
winning_teams = [];
}
if ( team_score == score )
{
winning_teams[ team ] = team;
}
_k645 = getNextArrayKey( _a645, _k645 );
}
return winning_teams;
}
areteamarraysequal( teamsa, teamsb )
{
if ( teamsa.size != teamsb.size )
{
return 0;
}
_a668 = teamsa;
_k668 = getFirstArrayKey( _a668 );
while ( isDefined( _k668 ) )
{
team = _a668[ _k668 ];
if ( !isDefined( teamsb[ team ] ) )
{
return 0;
}
_k668 = getNextArrayKey( _a668, _k668 );
}
return 1;
}
onteamscore( score, team )
{
game[ "teamScores" ][ team ] += score;
if ( level.scorelimit && game[ "teamScores" ][ team ] > level.scorelimit )
{
game[ "teamScores" ][ team ] = level.scorelimit;
}
if ( level.splitscreen )
{
return;
}
if ( level.scorelimit == 1 )
{
return;
}
iswinning = gethighestteamscoreteam();
if ( iswinning.size == 0 )
{
return;
}
if ( ( getTime() - level.laststatustime ) < 5000 )
{
return;
}
if ( areteamarraysequal( iswinning, level.waswinning ) )
{
return;
}
level.laststatustime = getTime();
while ( iswinning.size == 1 )
{
_a707 = iswinning;
_k707 = getFirstArrayKey( _a707 );
while ( isDefined( _k707 ) )
{
team = _a707[ _k707 ];
if ( isDefined( level.waswinning[ team ] ) )
{
if ( level.waswinning.size == 1 )
{
}
}
else
{
maps/mp/gametypes_zm/_globallogic_audio::leaderdialog( "lead_taken", team, "status" );
}
_k707 = getNextArrayKey( _a707, _k707 );
}
}
while ( level.waswinning.size == 1 )
{
_a726 = level.waswinning;
_k726 = getFirstArrayKey( _a726 );
while ( isDefined( _k726 ) )
{
team = _a726[ _k726 ];
if ( isDefined( iswinning[ team ] ) )
{
if ( iswinning.size == 1 )
{
}
else if ( level.waswinning.size > 1 )
{
}
}
else
{
maps/mp/gametypes_zm/_globallogic_audio::leaderdialog( "lead_lost", team, "status" );
}
_k726 = getNextArrayKey( _a726, _k726 );
}
}
level.waswinning = iswinning;
}
default_onteamscore( event, team )
{
}
initpersstat( dataname, record_stats, init_to_stat_value )
{
if ( !isDefined( self.pers[ dataname ] ) )
{
self.pers[ dataname ] = 0;
}
if ( !isDefined( record_stats ) || record_stats == 1 )
{
recordplayerstats( self, dataname, int( self.pers[ dataname ] ) );
}
if ( isDefined( init_to_stat_value ) && init_to_stat_value == 1 )
{
self.pers[ dataname ] = self getdstat( "PlayerStatsList", dataname, "StatValue" );
}
}
getpersstat( dataname )
{
return self.pers[ dataname ];
}
incpersstat( dataname, increment, record_stats, includegametype )
{
pixbeginevent( "incPersStat" );
self.pers[ dataname ] += increment;
if ( isDefined( includegametype ) && includegametype )
{
self addplayerstatwithgametype( dataname, increment );
}
else
{
self addplayerstat( dataname, increment );
}
if ( !isDefined( record_stats ) || record_stats == 1 )
{
self thread threadedrecordplayerstats( dataname );
}
pixendevent();
}
threadedrecordplayerstats( dataname )
{
self endon( "disconnect" );
waittillframeend;
recordplayerstats( self, dataname, self.pers[ dataname ] );
}
updatewinstats( winner )
{
}
updatelossstats( loser )
{
loser addplayerstatwithgametype( "losses", 1 );
loser updatestatratio( "wlratio", "wins", "losses" );
loser notify( "loss" );
}
updatetiestats( loser )
{
loser addplayerstatwithgametype( "losses", -1 );
loser addplayerstatwithgametype( "ties", 1 );
loser updatestatratio( "wlratio", "wins", "losses" );
loser setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 );
loser notify( "tie" );
}
updatewinlossstats( winner )
{
if ( !waslastround() && !level.hostforcedend )
{
return;
}
players = level.players;
if ( !isDefined( winner ) || isDefined( winner ) && !isplayer( winner ) && winner == "tie" )
{
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ].pers[ "team" ] ) )
{
i++;
continue;
}
else if ( level.hostforcedend && players[ i ] ishost() )
{
i++;
continue;
}
else
{
updatetiestats( players[ i ] );
}
i++;
}
}
else if ( isplayer( winner ) )
{
if ( level.hostforcedend && winner ishost() )
{
return;
}
updatewinstats( winner );
}
else
{
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ].pers[ "team" ] ) )
{
i++;
continue;
}
else if ( level.hostforcedend && players[ i ] ishost() )
{
i++;
continue;
}
else
{
if ( winner == "tie" )
{
updatetiestats( players[ i ] );
i++;
continue;
}
else if ( players[ i ].pers[ "team" ] == winner )
{
updatewinstats( players[ i ] );
i++;
continue;
}
else
{
players[ i ] setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 );
}
}
i++;
}
}
}
backupandclearwinstreaks()
{
}
restorewinstreaks( winner )
{
}
inckillstreaktracker( sweapon )
{
self endon( "disconnect" );
waittillframeend;
if ( sweapon == "artillery_mp" )
{
self.pers[ "artillery_kills" ]++;
}
if ( sweapon == "dog_bite_mp" )
{
self.pers[ "dog_kills" ]++;
}
}
trackattackerkill( name, rank, xp, prestige, xuid )
{
self endon( "disconnect" );
attacker = self;
waittillframeend;
pixbeginevent( "trackAttackerKill" );
if ( !isDefined( attacker.pers[ "killed_players" ][ name ] ) )
{
attacker.pers[ "killed_players" ][ name ] = 0;
}
if ( !isDefined( attacker.killedplayerscurrent[ name ] ) )
{
attacker.killedplayerscurrent[ name ] = 0;
}
if ( !isDefined( attacker.pers[ "nemesis_tracking" ][ name ] ) )
{
attacker.pers[ "nemesis_tracking" ][ name ] = 0;
}
attacker.pers[ "killed_players" ][ name ]++;
attacker.killedplayerscurrent[ name ]++;
attacker.pers[ "nemesis_tracking" ][ name ] += 1;
if ( attacker.pers[ "nemesis_name" ] == name )
{
attacker maps/mp/_challenges::killednemesis();
}
if ( attacker.pers[ "nemesis_name" ] == "" || attacker.pers[ "nemesis_tracking" ][ name ] > attacker.pers[ "nemesis_tracking" ][ attacker.pers[ "nemesis_name" ] ] )
{
attacker.pers[ "nemesis_name" ] = name;
attacker.pers[ "nemesis_rank" ] = rank;
attacker.pers[ "nemesis_rankIcon" ] = prestige;
attacker.pers[ "nemesis_xp" ] = xp;
attacker.pers[ "nemesis_xuid" ] = xuid;
}
else
{
if ( isDefined( attacker.pers[ "nemesis_name" ] ) && attacker.pers[ "nemesis_name" ] == name )
{
attacker.pers[ "nemesis_rank" ] = rank;
attacker.pers[ "nemesis_xp" ] = xp;
}
}
pixendevent();
}
trackattackeedeath( attackername, rank, xp, prestige, xuid )
{
self endon( "disconnect" );
waittillframeend;
pixbeginevent( "trackAttackeeDeath" );
if ( !isDefined( self.pers[ "killed_by" ][ attackername ] ) )
{
self.pers[ "killed_by" ][ attackername ] = 0;
}
self.pers[ "killed_by" ][ attackername ]++;
if ( !isDefined( self.pers[ "nemesis_tracking" ][ attackername ] ) )
{
self.pers[ "nemesis_tracking" ][ attackername ] = 0;
}
self.pers[ "nemesis_tracking" ][ attackername ] += 1,5;
if ( self.pers[ "nemesis_name" ] == "" || self.pers[ "nemesis_tracking" ][ attackername ] > self.pers[ "nemesis_tracking" ][ self.pers[ "nemesis_name" ] ] )
{
self.pers[ "nemesis_name" ] = attackername;
self.pers[ "nemesis_rank" ] = rank;
self.pers[ "nemesis_rankIcon" ] = prestige;
self.pers[ "nemesis_xp" ] = xp;
self.pers[ "nemesis_xuid" ] = xuid;
}
else
{
if ( isDefined( self.pers[ "nemesis_name" ] ) && self.pers[ "nemesis_name" ] == attackername )
{
self.pers[ "nemesis_rank" ] = rank;
self.pers[ "nemesis_xp" ] = xp;
}
}
if ( self.pers[ "nemesis_name" ] == attackername && self.pers[ "nemesis_tracking" ][ attackername ] >= 2 )
{
self setclientuivisibilityflag( "killcam_nemesis", 1 );
}
else
{
self setclientuivisibilityflag( "killcam_nemesis", 0 );
}
pixendevent();
}
default_iskillboosting()
{
return 0;
}
givekillstats( smeansofdeath, sweapon, evictim )
{
self endon( "disconnect" );
waittillframeend;
if ( level.rankedmatch && self [[ level.iskillboosting ]]() )
{
/#
self iprintlnbold( "GAMETYPE DEBUG: NOT GIVING YOU OFFENSIVE CREDIT AS BOOSTING PREVENTION" );
#/
return;
}
pixbeginevent( "giveKillStats" );
self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "kills", 1, 1, 1 );
self.kills = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "kills" );
self updatestatratio( "kdratio", "kills", "deaths" );
attacker = self;
if ( smeansofdeath == "MOD_HEAD_SHOT" )
{
attacker thread incpersstat( "headshots", 1, 1, 0 );
attacker.headshots = attacker.pers[ "headshots" ];
evictim recordkillmodifier( "headshot" );
}
pixendevent();
}
inctotalkills( team )
{
if ( level.teambased && isDefined( level.teams[ team ] ) )
{
game[ "totalKillsTeam" ][ team ]++;
}
game[ "totalKills" ]++;
}
setinflictorstat( einflictor, eattacker, sweapon )
{
if ( !isDefined( eattacker ) )
{
return;
}
if ( !isDefined( einflictor ) )
{
eattacker addweaponstat( sweapon, "hits", 1 );
return;
}
if ( !isDefined( einflictor.playeraffectedarray ) )
{
einflictor.playeraffectedarray = [];
}
foundnewplayer = 1;
i = 0;
while ( i < einflictor.playeraffectedarray.size )
{
if ( einflictor.playeraffectedarray[ i ] == self )
{
foundnewplayer = 0;
break;
}
else
{
i++;
}
}
if ( foundnewplayer )
{
einflictor.playeraffectedarray[ einflictor.playeraffectedarray.size ] = self;
if ( sweapon == "concussion_grenade_mp" || sweapon == "tabun_gas_mp" )
{
eattacker addweaponstat( sweapon, "used", 1 );
}
eattacker addweaponstat( sweapon, "hits", 1 );
}
}
processshieldassist( killedplayer )
{
self endon( "disconnect" );
killedplayer endon( "disconnect" );
wait 0,05;
maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed();
if ( !isDefined( level.teams[ self.pers[ "team" ] ] ) )
{
return;
}
if ( self.pers[ "team" ] == killedplayer.pers[ "team" ] )
{
return;
}
if ( !level.teambased )
{
return;
}
self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "assists", 1, 1, 1 );
self.assists = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "assists" );
}
processassist( killedplayer, damagedone, weapon )
{
self endon( "disconnect" );
killedplayer endon( "disconnect" );
wait 0,05;
maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed();
if ( !isDefined( level.teams[ self.pers[ "team" ] ] ) )
{
return;
}
if ( self.pers[ "team" ] == killedplayer.pers[ "team" ] )
{
return;
}
if ( !level.teambased )
{
return;
}
assist_level = "assist";
assist_level_value = int( ceil( damagedone / 25 ) );
if ( assist_level_value < 1 )
{
assist_level_value = 1;
}
else
{
if ( assist_level_value > 3 )
{
assist_level_value = 3;
}
}
assist_level = ( assist_level + "_" ) + ( assist_level_value * 25 );
self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "assists", 1, 1, 1 );
self.assists = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "assists" );
switch( weapon )
{
case "concussion_grenade_mp":
assist_level = "assist_concussion";
break;
case "flash_grenade_mp":
assist_level = "assist_flash";
break;
case "emp_grenade_mp":
assist_level = "assist_emp";
break;
case "proximity_grenade_aoe_mp":
case "proximity_grenade_mp":
assist_level = "assist_proximity";
break;
}
self maps/mp/_challenges::assisted();
}
xpratethread()
{
/#
#/
}

959
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_spawn.gsc Normal file
View File

@ -0,0 +1,959 @@
#include maps/mp/gametypes_zm/_spawnlogic;
#include maps/mp/gametypes_zm/_globallogic_defaults;
#include maps/mp/gametypes_zm/_hostmigration;
#include maps/mp/gametypes_zm/_spectating;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/gametypes_zm/_globallogic_score;
#include maps/mp/gametypes_zm/_globallogic_ui;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/gametypes_zm/_hud_message;
#include maps/mp/gametypes_zm/_globallogic;
#include maps/mp/gametypes_zm/_globallogic_utils;
#include maps/mp/gametypes_zm/_globallogic_audio;
#include maps/mp/gametypes_zm/_spawning;
#include maps/mp/gametypes_zm/_globallogic_player;
#include maps/mp/_utility;
#include common_scripts/utility;
timeuntilspawn( includeteamkilldelay )
{
if ( level.ingraceperiod && !self.hasspawned )
{
return 0;
}
respawndelay = 0;
if ( self.hasspawned )
{
result = self [[ level.onrespawndelay ]]();
if ( isDefined( result ) )
{
respawndelay = result;
}
else
{
respawndelay = level.playerrespawndelay;
}
if ( includeteamkilldelay && isDefined( self.teamkillpunish ) && self.teamkillpunish )
{
respawndelay += maps/mp/gametypes_zm/_globallogic_player::teamkilldelay();
}
}
wavebased = level.waverespawndelay > 0;
if ( wavebased )
{
return self timeuntilwavespawn( respawndelay );
}
return respawndelay;
}
allteamshaveexisted()
{
_a34 = level.teams;
_k34 = getFirstArrayKey( _a34 );
while ( isDefined( _k34 ) )
{
team = _a34[ _k34 ];
if ( !level.everexisted[ team ] )
{
return 0;
}
_k34 = getNextArrayKey( _a34, _k34 );
}
return 1;
}
mayspawn()
{
if ( isDefined( level.mayspawn ) && !( self [[ level.mayspawn ]]() ) )
{
return 0;
}
if ( level.inovertime )
{
return 0;
}
if ( level.playerqueuedrespawn && !isDefined( self.allowqueuespawn ) && !level.ingraceperiod && !level.usestartspawns )
{
return 0;
}
if ( level.numlives )
{
if ( level.teambased )
{
gamehasstarted = allteamshaveexisted();
}
else
{
if ( level.maxplayercount > 1 )
{
if ( !isoneround() )
{
gamehasstarted = !isfirstround();
}
}
}
if ( !self.pers[ "lives" ] && gamehasstarted )
{
return 0;
}
else
{
if ( gamehasstarted )
{
if ( !level.ingraceperiod && !self.hasspawned && !level.wagermatch )
{
return 0;
}
}
}
}
return 1;
}
timeuntilwavespawn( minimumwait )
{
earliestspawntime = getTime() + ( minimumwait * 1000 );
lastwavetime = level.lastwave[ self.pers[ "team" ] ];
wavedelay = level.wavedelay[ self.pers[ "team" ] ] * 1000;
if ( wavedelay == 0 )
{
return 0;
}
numwavespassedearliestspawntime = ( earliestspawntime - lastwavetime ) / wavedelay;
numwaves = ceil( numwavespassedearliestspawntime );
timeofspawn = lastwavetime + ( numwaves * wavedelay );
if ( isDefined( self.wavespawnindex ) )
{
timeofspawn += 50 * self.wavespawnindex;
}
return ( timeofspawn - getTime() ) / 1000;
}
stoppoisoningandflareonspawn()
{
self endon( "disconnect" );
self.inpoisonarea = 0;
self.inburnarea = 0;
self.inflarevisionarea = 0;
self.ingroundnapalm = 0;
}
spawnplayerprediction()
{
self endon( "disconnect" );
self endon( "end_respawn" );
self endon( "game_ended" );
self endon( "joined_spectators" );
self endon( "spawned" );
while ( 1 )
{
wait 0,5;
if ( isDefined( level.onspawnplayerunified ) && getDvarInt( #"CF6EEB8B" ) == 0 )
{
maps/mp/gametypes_zm/_spawning::onspawnplayer_unified( 1 );
continue;
}
else
{
self [[ level.onspawnplayer ]]( 1 );
}
}
}
giveloadoutlevelspecific( team, class )
{
pixbeginevent( "giveLoadoutLevelSpecific" );
if ( isDefined( level.givecustomcharacters ) )
{
self [[ level.givecustomcharacters ]]();
}
if ( isDefined( level.givecustomloadout ) )
{
self [[ level.givecustomloadout ]]();
}
pixendevent();
}
spawnplayer()
{
pixbeginevent( "spawnPlayer_preUTS" );
self endon( "disconnect" );
self endon( "joined_spectators" );
self notify( "spawned" );
level notify( "player_spawned" );
self notify( "end_respawn" );
self setspawnvariables();
if ( !self.hasspawned )
{
self.underscorechance = 70;
self thread maps/mp/gametypes_zm/_globallogic_audio::sndstartmusicsystem();
}
if ( level.teambased )
{
self.sessionteam = self.team;
}
else
{
self.sessionteam = "none";
self.ffateam = self.team;
}
hadspawned = self.hasspawned;
self.sessionstate = "playing";
self.spectatorclient = -1;
self.killcamentity = -1;
self.archivetime = 0;
self.psoffsettime = 0;
self.statusicon = "";
self.damagedplayers = [];
if ( getDvarInt( #"C8077F47" ) > 0 )
{
self.maxhealth = getDvarInt( #"C8077F47" );
}
else
{
self.maxhealth = level.playermaxhealth;
}
self.health = self.maxhealth;
self.friendlydamage = undefined;
self.hasspawned = 1;
self.spawntime = getTime();
self.afk = 0;
if ( self.pers[ "lives" ] || !isDefined( level.takelivesondeath ) && level.takelivesondeath == 0 )
{
self.pers[ "lives" ]--;
if ( self.pers[ "lives" ] == 0 )
{
level notify( "player_eliminated" );
self notify( "player_eliminated" );
}
}
self.laststand = undefined;
self.revivingteammate = 0;
self.burning = undefined;
self.nextkillstreakfree = undefined;
self.activeuavs = 0;
self.activecounteruavs = 0;
self.activesatellites = 0;
self.deathmachinekills = 0;
self.disabledweapon = 0;
self resetusability();
self maps/mp/gametypes_zm/_globallogic_player::resetattackerlist();
self.diedonvehicle = undefined;
if ( !self.wasaliveatmatchstart )
{
if ( level.ingraceperiod || maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() < 20000 )
{
self.wasaliveatmatchstart = 1;
}
}
self setdepthoffield( 0, 0, 512, 512, 4, 0 );
self resetfov();
pixbeginevent( "onSpawnPlayer" );
if ( isDefined( level.onspawnplayerunified ) && getDvarInt( #"CF6EEB8B" ) == 0 )
{
self [[ level.onspawnplayerunified ]]();
}
else
{
self [[ level.onspawnplayer ]]( 0 );
}
if ( isDefined( level.playerspawnedcb ) )
{
self [[ level.playerspawnedcb ]]();
}
pixendevent();
pixendevent();
level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus();
pixbeginevent( "spawnPlayer_postUTS" );
self thread stoppoisoningandflareonspawn();
self stopburning();
/#
assert( maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.class ) );
#/
self giveloadoutlevelspecific( self.team, self.class );
if ( level.inprematchperiod )
{
self freeze_player_controls( 1 );
team = self.pers[ "team" ];
if ( isDefined( self.pers[ "music" ].spawn ) && self.pers[ "music" ].spawn == 0 )
{
if ( level.wagermatch )
{
music = "SPAWN_WAGER";
}
else
{
music = game[ "music" ][ "spawn_" + team ];
}
self thread maps/mp/gametypes_zm/_globallogic_audio::set_music_on_player( music, 0, 0 );
self.pers[ "music" ].spawn = 1;
}
if ( level.splitscreen )
{
if ( isDefined( level.playedstartingmusic ) )
{
music = undefined;
}
else
{
level.playedstartingmusic = 1;
}
}
if ( !isDefined( level.disableprematchmessages ) || level.disableprematchmessages == 0 )
{
thread maps/mp/gametypes_zm/_hud_message::showinitialfactionpopup( team );
hintmessage = getobjectivehinttext( self.pers[ "team" ] );
if ( isDefined( hintmessage ) )
{
self thread maps/mp/gametypes_zm/_hud_message::hintmessage( hintmessage );
}
if ( isDefined( game[ "dialog" ][ "gametype" ] ) || !level.splitscreen && self == level.players[ 0 ] )
{
if ( !isDefined( level.infinalfight ) || !level.infinalfight )
{
if ( level.hardcoremode )
{
self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype_hardcore" );
}
else
{
self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype" );
}
}
}
if ( team == game[ "attackers" ] )
{
self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "offense_obj", "introboost" );
}
else
{
self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "defense_obj", "introboost" );
}
}
}
else
{
self freeze_player_controls( 0 );
self enableweapons();
if ( !hadspawned && game[ "state" ] == "playing" )
{
pixbeginevent( "sound" );
team = self.team;
if ( isDefined( self.pers[ "music" ].spawn ) && self.pers[ "music" ].spawn == 0 )
{
self thread maps/mp/gametypes_zm/_globallogic_audio::set_music_on_player( "SPAWN_SHORT", 0, 0 );
self.pers[ "music" ].spawn = 1;
}
if ( level.splitscreen )
{
if ( isDefined( level.playedstartingmusic ) )
{
music = undefined;
}
else
{
level.playedstartingmusic = 1;
}
}
if ( !isDefined( level.disableprematchmessages ) || level.disableprematchmessages == 0 )
{
thread maps/mp/gametypes_zm/_hud_message::showinitialfactionpopup( team );
hintmessage = getobjectivehinttext( self.pers[ "team" ] );
if ( isDefined( hintmessage ) )
{
self thread maps/mp/gametypes_zm/_hud_message::hintmessage( hintmessage );
}
if ( isDefined( game[ "dialog" ][ "gametype" ] ) || !level.splitscreen && self == level.players[ 0 ] )
{
if ( !isDefined( level.infinalfight ) || !level.infinalfight )
{
if ( level.hardcoremode )
{
self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype_hardcore" );
}
else
{
self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype" );
}
}
}
if ( team == game[ "attackers" ] )
{
self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "offense_obj", "introboost" );
}
else
{
self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "defense_obj", "introboost" );
}
}
pixendevent();
}
}
if ( getDvar( "scr_showperksonspawn" ) == "" )
{
setdvar( "scr_showperksonspawn", "0" );
}
if ( level.hardcoremode )
{
setdvar( "scr_showperksonspawn", "0" );
}
if ( !level.splitscreen && getDvarInt( "scr_showperksonspawn" ) == 1 && game[ "state" ] != "postgame" )
{
pixbeginevent( "showperksonspawn" );
if ( level.perksenabled == 1 )
{
self maps/mp/gametypes_zm/_hud_util::showperks();
}
self thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutaftertime( 3 );
self thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutondeath();
pixendevent();
}
if ( isDefined( self.pers[ "momentum" ] ) )
{
self.momentum = self.pers[ "momentum" ];
}
pixendevent();
waittillframeend;
self notify( "spawned_player" );
self logstring( "S " + self.origin[ 0 ] + " " + self.origin[ 1 ] + " " + self.origin[ 2 ] );
setdvar( "scr_selecting_location", "" );
/#
if ( getDvarInt( #"F8D00F60" ) > 0 )
{
self thread maps/mp/gametypes_zm/_globallogic_score::xpratethread();
#/
}
self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "health_reboot", 1, 0 );
if ( game[ "state" ] == "postgame" )
{
/#
assert( !level.intermission );
#/
self maps/mp/gametypes_zm/_globallogic_player::freezeplayerforroundend();
}
}
spawnspectator( origin, angles )
{
self notify( "spawned" );
self notify( "end_respawn" );
in_spawnspectator( origin, angles );
}
respawn_asspectator( origin, angles )
{
in_spawnspectator( origin, angles );
}
in_spawnspectator( origin, angles )
{
pixmarker( "BEGIN: in_spawnSpectator" );
self setspawnvariables();
if ( self.pers[ "team" ] == "spectator" )
{
self clearlowermessage();
}
self.sessionstate = "spectator";
self.spectatorclient = -1;
self.killcamentity = -1;
self.archivetime = 0;
self.psoffsettime = 0;
self.friendlydamage = undefined;
if ( self.pers[ "team" ] == "spectator" )
{
self.statusicon = "";
}
else
{
self.statusicon = "hud_status_dead";
}
maps/mp/gametypes_zm/_spectating::setspectatepermissionsformachine();
[[ level.onspawnspectator ]]( origin, angles );
if ( level.teambased && !level.splitscreen )
{
self thread spectatorthirdpersonness();
}
level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus();
pixmarker( "END: in_spawnSpectator" );
}
spectatorthirdpersonness()
{
self endon( "disconnect" );
self endon( "spawned" );
self notify( "spectator_thirdperson_thread" );
self endon( "spectator_thirdperson_thread" );
self.spectatingthirdperson = 0;
}
forcespawn( time )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "spawned" );
if ( !isDefined( time ) )
{
time = 60;
}
wait time;
if ( self.hasspawned )
{
return;
}
if ( self.pers[ "team" ] == "spectator" )
{
return;
}
if ( !maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.pers[ "class" ] ) )
{
self.pers[ "class" ] = "CLASS_CUSTOM1";
self.class = self.pers[ "class" ];
}
self maps/mp/gametypes_zm/_globallogic_ui::closemenus();
self thread [[ level.spawnclient ]]();
}
kickifdontspawn()
{
/#
if ( getDvarInt( "scr_hostmigrationtest" ) == 1 )
{
return;
#/
}
if ( self ishost() )
{
return;
}
self kickifidontspawninternal();
}
kickifidontspawninternal()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "spawned" );
waittime = 90;
if ( getDvar( #"4257CF5C" ) != "" )
{
waittime = getDvarFloat( #"4257CF5C" );
}
mintime = 45;
if ( getDvar( #"0DF057E0" ) != "" )
{
mintime = getDvarFloat( #"0DF057E0" );
}
starttime = getTime();
kickwait( waittime );
timepassed = ( getTime() - starttime ) / 1000;
if ( timepassed < ( waittime - 0,1 ) && timepassed < mintime )
{
return;
}
if ( self.hasspawned )
{
return;
}
if ( sessionmodeisprivate() )
{
return;
}
if ( self.pers[ "team" ] == "spectator" )
{
return;
}
kick( self getentitynumber() );
}
kickwait( waittime )
{
level endon( "game_ended" );
maps/mp/gametypes_zm/_hostmigration::waitlongdurationwithhostmigrationpause( waittime );
}
spawninterroundintermission()
{
self notify( "spawned" );
self notify( "end_respawn" );
self setspawnvariables();
self clearlowermessage();
self freeze_player_controls( 0 );
self.sessionstate = "spectator";
self.spectatorclient = -1;
self.killcamentity = -1;
self.archivetime = 0;
self.psoffsettime = 0;
self.friendlydamage = undefined;
self maps/mp/gametypes_zm/_globallogic_defaults::default_onspawnintermission();
self setorigin( self.origin );
self setplayerangles( self.angles );
self setdepthoffield( 0, 128, 512, 4000, 6, 1,8 );
}
spawnintermission( usedefaultcallback )
{
self notify( "spawned" );
self notify( "end_respawn" );
self endon( "disconnect" );
self setspawnvariables();
self clearlowermessage();
self freeze_player_controls( 0 );
if ( level.rankedmatch && waslastround() )
{
if ( !self.postgamemilestones || self.postgamecontracts && self.postgamepromotion )
{
if ( self.postgamepromotion )
{
self playlocalsound( "mus_level_up" );
}
else if ( self.postgamecontracts )
{
self playlocalsound( "mus_challenge_complete" );
}
else
{
if ( self.postgamemilestones )
{
self playlocalsound( "mus_contract_complete" );
}
}
self closeingamemenu();
self openmenu( game[ "menu_endgameupdate" ] );
waittime = 4;
while ( waittime )
{
wait 0,25;
waittime -= 0,25;
self openmenu( game[ "menu_endgameupdate" ] );
}
self closemenu();
}
}
self.sessionstate = "intermission";
self.spectatorclient = -1;
self.killcamentity = -1;
self.archivetime = 0;
self.psoffsettime = 0;
self.friendlydamage = undefined;
if ( isDefined( usedefaultcallback ) && usedefaultcallback )
{
maps/mp/gametypes_zm/_globallogic_defaults::default_onspawnintermission();
}
else
{
[[ level.onspawnintermission ]]();
}
self setdepthoffield( 0, 128, 512, 4000, 6, 1,8 );
}
spawnqueuedclientonteam( team )
{
player_to_spawn = undefined;
i = 0;
while ( i < level.deadplayers[ team ].size )
{
player = level.deadplayers[ team ][ i ];
if ( player.waitingtospawn )
{
i++;
continue;
}
else
{
player_to_spawn = player;
break;
}
i++;
}
if ( isDefined( player_to_spawn ) )
{
player_to_spawn.allowqueuespawn = 1;
player_to_spawn maps/mp/gametypes_zm/_globallogic_ui::closemenus();
player_to_spawn thread [[ level.spawnclient ]]();
}
}
spawnqueuedclient( dead_player_team, killer )
{
if ( !level.playerqueuedrespawn )
{
return;
}
maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed();
spawn_team = undefined;
if ( isDefined( killer ) && isDefined( killer.team ) && isDefined( level.teams[ killer.team ] ) )
{
spawn_team = killer.team;
}
if ( isDefined( spawn_team ) )
{
spawnqueuedclientonteam( spawn_team );
return;
}
_a746 = level.teams;
_k746 = getFirstArrayKey( _a746 );
while ( isDefined( _k746 ) )
{
team = _a746[ _k746 ];
if ( team == dead_player_team )
{
}
else
{
spawnqueuedclientonteam( team );
}
_k746 = getNextArrayKey( _a746, _k746 );
}
}
allteamsnearscorelimit()
{
if ( !level.teambased )
{
return 0;
}
if ( level.scorelimit <= 1 )
{
return 0;
}
_a763 = level.teams;
_k763 = getFirstArrayKey( _a763 );
while ( isDefined( _k763 ) )
{
team = _a763[ _k763 ];
if ( ( level.scorelimit - 1 ) < game[ "teamScores" ][ team ] )
{
return 0;
}
_k763 = getNextArrayKey( _a763, _k763 );
}
return 1;
}
shouldshowrespawnmessage()
{
if ( waslastround() )
{
return 0;
}
if ( isoneround() )
{
return 0;
}
if ( isDefined( level.livesdonotreset ) && level.livesdonotreset )
{
return 0;
}
if ( allteamsnearscorelimit() )
{
return 0;
}
return 1;
}
default_spawnmessage()
{
setlowermessage( game[ "strings" ][ "spawn_next_round" ] );
self thread maps/mp/gametypes_zm/_globallogic_ui::removespawnmessageshortly( 3 );
}
showspawnmessage()
{
if ( shouldshowrespawnmessage() )
{
self thread [[ level.spawnmessage ]]();
}
}
spawnclient( timealreadypassed )
{
pixbeginevent( "spawnClient" );
/#
assert( isDefined( self.team ) );
#/
/#
assert( maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.class ) );
#/
if ( !self mayspawn() )
{
currentorigin = self.origin;
currentangles = self.angles;
self showspawnmessage();
self thread [[ level.spawnspectator ]]( currentorigin + vectorScale( ( 0, 0, 1 ), 60 ), currentangles );
pixendevent();
return;
}
if ( self.waitingtospawn )
{
pixendevent();
return;
}
self.waitingtospawn = 1;
self.allowqueuespawn = undefined;
self waitandspawnclient( timealreadypassed );
if ( isDefined( self ) )
{
self.waitingtospawn = 0;
}
pixendevent();
}
waitandspawnclient( timealreadypassed )
{
self endon( "disconnect" );
self endon( "end_respawn" );
level endon( "game_ended" );
if ( !isDefined( timealreadypassed ) )
{
timealreadypassed = 0;
}
spawnedasspectator = 0;
if ( isDefined( self.teamkillpunish ) && self.teamkillpunish )
{
teamkilldelay = maps/mp/gametypes_zm/_globallogic_player::teamkilldelay();
if ( teamkilldelay > timealreadypassed )
{
teamkilldelay -= timealreadypassed;
timealreadypassed = 0;
}
else
{
timealreadypassed -= teamkilldelay;
teamkilldelay = 0;
}
if ( teamkilldelay > 0 )
{
setlowermessage( &"MP_FRIENDLY_FIRE_WILL_NOT", teamkilldelay );
self thread respawn_asspectator( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), self.angles );
spawnedasspectator = 1;
wait teamkilldelay;
}
self.teamkillpunish = 0;
}
if ( !isDefined( self.wavespawnindex ) && isDefined( level.waveplayerspawnindex[ self.team ] ) )
{
self.wavespawnindex = level.waveplayerspawnindex[ self.team ];
level.waveplayerspawnindex[ self.team ]++;
}
timeuntilspawn = timeuntilspawn( 0 );
if ( timeuntilspawn > timealreadypassed )
{
timeuntilspawn -= timealreadypassed;
timealreadypassed = 0;
}
else
{
timealreadypassed -= timeuntilspawn;
timeuntilspawn = 0;
}
if ( timeuntilspawn > 0 )
{
if ( level.playerqueuedrespawn )
{
setlowermessage( game[ "strings" ][ "you_will_spawn" ], timeuntilspawn );
}
else if ( self issplitscreen() )
{
setlowermessage( game[ "strings" ][ "waiting_to_spawn_ss" ], timeuntilspawn, 1 );
}
else
{
setlowermessage( game[ "strings" ][ "waiting_to_spawn" ], timeuntilspawn );
}
if ( !spawnedasspectator )
{
spawnorigin = self.origin + vectorScale( ( 0, 0, 1 ), 60 );
spawnangles = self.angles;
if ( isDefined( level.useintermissionpointsonwavespawn ) && [[ level.useintermissionpointsonwavespawn ]]() == 1 )
{
spawnpoint = maps/mp/gametypes_zm/_spawnlogic::getrandomintermissionpoint();
if ( isDefined( spawnpoint ) )
{
spawnorigin = spawnpoint.origin;
spawnangles = spawnpoint.angles;
}
}
self thread respawn_asspectator( spawnorigin, spawnangles );
}
spawnedasspectator = 1;
self maps/mp/gametypes_zm/_globallogic_utils::waitfortimeornotify( timeuntilspawn, "force_spawn" );
self notify( "stop_wait_safe_spawn_button" );
}
wavebased = level.waverespawndelay > 0;
if ( !level.playerforcerespawn && self.hasspawned && !wavebased && !self.wantsafespawn && !level.playerqueuedrespawn )
{
setlowermessage( game[ "strings" ][ "press_to_spawn" ] );
if ( !spawnedasspectator )
{
self thread respawn_asspectator( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), self.angles );
}
spawnedasspectator = 1;
self waitrespawnorsafespawnbutton();
}
self.waitingtospawn = 0;
self clearlowermessage();
self.wavespawnindex = undefined;
self.respawntimerstarttime = undefined;
self thread [[ level.spawnplayer ]]();
}
waitrespawnorsafespawnbutton()
{
self endon( "disconnect" );
self endon( "end_respawn" );
while ( 1 )
{
if ( self usebuttonpressed() )
{
return;
}
else
{
wait 0,05;
}
}
}
waitinspawnqueue()
{
self endon( "disconnect" );
self endon( "end_respawn" );
if ( !level.ingraceperiod && !level.usestartspawns )
{
currentorigin = self.origin;
currentangles = self.angles;
self thread [[ level.spawnspectator ]]( currentorigin + vectorScale( ( 0, 0, 1 ), 60 ), currentangles );
self waittill( "queue_respawn" );
}
}
setthirdperson( value )
{
if ( !level.console )
{
return;
}
if ( !isDefined( self.spectatingthirdperson ) || value != self.spectatingthirdperson )
{
self.spectatingthirdperson = value;
if ( value )
{
self setclientthirdperson( 1 );
self setdepthoffield( 0, 128, 512, 4000, 6, 1,8 );
}
else
{
self setclientthirdperson( 0 );
self setdepthoffield( 0, 0, 512, 4000, 4, 0 );
}
self resetfov();
}
}
setspawnvariables()
{
resettimeout();
self stopshellshock();
self stoprumble( "damage_heavy" );
}

544
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_ui.gsc Normal file
View File

@ -0,0 +1,544 @@
#include maps/mp/gametypes_zm/_globallogic_player;
#include maps/mp/gametypes_zm/_spectating;
#include maps/mp/gametypes_zm/_globallogic;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
init()
{
precachestring( &"MP_HALFTIME" );
precachestring( &"MP_OVERTIME" );
precachestring( &"MP_ROUNDEND" );
precachestring( &"MP_INTERMISSION" );
precachestring( &"MP_SWITCHING_SIDES_CAPS" );
precachestring( &"MP_FRIENDLY_FIRE_WILL_NOT" );
precachestring( &"MP_RAMPAGE" );
precachestring( &"medal_received" );
precachestring( &"killstreak_received" );
precachestring( &"prox_grenade_notify" );
precachestring( &"player_callout" );
precachestring( &"score_event" );
precachestring( &"rank_up" );
precachestring( &"gun_level_complete" );
precachestring( &"challenge_complete" );
if ( sessionmodeiszombiesgame() )
{
precachestring( &"hud_update_survival_team" );
}
if ( level.splitscreen )
{
precachestring( &"MP_ENDED_GAME" );
}
else
{
precachestring( &"MP_HOST_ENDED_GAME" );
}
}
setupcallbacks()
{
level.autoassign = ::menuautoassign;
level.spectator = ::menuspectator;
level.class = ::menuclass;
level.teammenu = ::menuteam;
}
hideloadoutaftertime( delay )
{
self endon( "disconnect" );
self endon( "perks_hidden" );
wait delay;
self thread hideallperks( 0,4 );
self notify( "perks_hidden" );
}
hideloadoutondeath()
{
self endon( "disconnect" );
self endon( "perks_hidden" );
self waittill( "death" );
self hideallperks();
self notify( "perks_hidden" );
}
hideloadoutonkill()
{
self endon( "disconnect" );
self endon( "death" );
self endon( "perks_hidden" );
self waittill( "killed_player" );
self hideallperks();
self notify( "perks_hidden" );
}
freegameplayhudelems()
{
while ( isDefined( self.perkicon ) )
{
numspecialties = 0;
while ( numspecialties < level.maxspecialties )
{
if ( isDefined( self.perkicon[ numspecialties ] ) )
{
self.perkicon[ numspecialties ] destroyelem();
self.perkname[ numspecialties ] destroyelem();
}
numspecialties++;
}
}
if ( isDefined( self.perkhudelem ) )
{
self.perkhudelem destroyelem();
}
if ( isDefined( self.killstreakicon ) )
{
if ( isDefined( self.killstreakicon[ 0 ] ) )
{
self.killstreakicon[ 0 ] destroyelem();
}
if ( isDefined( self.killstreakicon[ 1 ] ) )
{
self.killstreakicon[ 1 ] destroyelem();
}
if ( isDefined( self.killstreakicon[ 2 ] ) )
{
self.killstreakicon[ 2 ] destroyelem();
}
if ( isDefined( self.killstreakicon[ 3 ] ) )
{
self.killstreakicon[ 3 ] destroyelem();
}
if ( isDefined( self.killstreakicon[ 4 ] ) )
{
self.killstreakicon[ 4 ] destroyelem();
}
}
self notify( "perks_hidden" );
if ( isDefined( self.lowermessage ) )
{
self.lowermessage destroyelem();
}
if ( isDefined( self.lowertimer ) )
{
self.lowertimer destroyelem();
}
if ( isDefined( self.proxbar ) )
{
self.proxbar destroyelem();
}
if ( isDefined( self.proxbartext ) )
{
self.proxbartext destroyelem();
}
if ( isDefined( self.carryicon ) )
{
self.carryicon destroyelem();
}
}
teamplayercountsequal( playercounts )
{
count = undefined;
_a150 = level.teams;
_k150 = getFirstArrayKey( _a150 );
while ( isDefined( _k150 ) )
{
team = _a150[ _k150 ];
if ( !isDefined( count ) )
{
count = playercounts[ team ];
}
else
{
if ( count != playercounts[ team ] )
{
return 0;
}
}
_k150 = getNextArrayKey( _a150, _k150 );
}
return 1;
}
teamwithlowestplayercount( playercounts, ignore_team )
{
count = 9999;
lowest_team = undefined;
_a169 = level.teams;
_k169 = getFirstArrayKey( _a169 );
while ( isDefined( _k169 ) )
{
team = _a169[ _k169 ];
if ( count > playercounts[ team ] )
{
count = playercounts[ team ];
lowest_team = team;
}
_k169 = getNextArrayKey( _a169, _k169 );
}
return lowest_team;
}
menuautoassign( comingfrommenu )
{
teamkeys = getarraykeys( level.teams );
assignment = teamkeys[ randomint( teamkeys.size ) ];
self closemenus();
if ( isDefined( level.forceallallies ) && level.forceallallies )
{
assignment = "allies";
}
else
{
if ( level.teambased )
{
if ( getDvarInt( "party_autoteams" ) == 1 )
{
if ( level.allow_teamchange == "1" || self.hasspawned && comingfrommenu )
{
assignment = "";
break;
}
else
{
team = getassignedteam( self );
switch( team )
{
case 1:
assignment = teamkeys[ 1 ];
break;
case 2:
assignment = teamkeys[ 0 ];
break;
case 3:
assignment = teamkeys[ 2 ];
break;
case 4:
if ( !isDefined( level.forceautoassign ) || !level.forceautoassign )
{
self setclientscriptmainmenu( game[ "menu_class" ] );
return;
}
default:
assignment = "";
if ( isDefined( level.teams[ team ] ) )
{
assignment = team;
}
else
{
if ( team == "spectator" && !level.forceautoassign )
{
self setclientscriptmainmenu( game[ "menu_class" ] );
return;
}
}
}
}
}
if ( assignment == "" || getDvarInt( "party_autoteams" ) == 0 )
{
if ( sessionmodeiszombiesgame() )
{
assignment = "allies";
}
}
if ( assignment == self.pers[ "team" ] || self.sessionstate == "playing" && self.sessionstate == "dead" )
{
self beginclasschoice();
return;
}
}
else if ( getDvarInt( "party_autoteams" ) == 1 )
{
if ( level.allow_teamchange != "1" || !self.hasspawned && !comingfrommenu )
{
team = getassignedteam( self );
if ( isDefined( level.teams[ team ] ) )
{
assignment = team;
}
else
{
if ( team == "spectator" && !level.forceautoassign )
{
self setclientscriptmainmenu( game[ "menu_class" ] );
return;
}
}
}
}
}
if ( assignment != self.pers[ "team" ] || self.sessionstate == "playing" && self.sessionstate == "dead" )
{
self.switching_teams = 1;
self.joining_team = assignment;
self.leaving_team = self.pers[ "team" ];
self suicide();
}
self.pers[ "team" ] = assignment;
self.team = assignment;
self.class = undefined;
self updateobjectivetext();
if ( level.teambased )
{
self.sessionteam = assignment;
}
else
{
self.sessionteam = "none";
self.ffateam = assignment;
}
if ( !isalive( self ) )
{
self.statusicon = "hud_status_dead";
}
self notify( "joined_team" );
level notify( "joined_team" );
self notify( "end_respawn" );
self beginclasschoice();
self setclientscriptmainmenu( game[ "menu_class" ] );
}
teamscoresequal()
{
score = undefined;
_a413 = level.teams;
_k413 = getFirstArrayKey( _a413 );
while ( isDefined( _k413 ) )
{
team = _a413[ _k413 ];
if ( !isDefined( score ) )
{
score = getteamscore( team );
}
else
{
if ( score != getteamscore( team ) )
{
return 0;
}
}
_k413 = getNextArrayKey( _a413, _k413 );
}
return 1;
}
teamwithlowestscore()
{
score = 99999999;
lowest_team = undefined;
_a432 = level.teams;
_k432 = getFirstArrayKey( _a432 );
while ( isDefined( _k432 ) )
{
team = _a432[ _k432 ];
if ( score > getteamscore( team ) )
{
lowest_team = team;
}
_k432 = getNextArrayKey( _a432, _k432 );
}
return lowest_team;
}
pickteamfromscores( teams )
{
assignment = "allies";
if ( teamscoresequal() )
{
assignment = teams[ randomint( teams.size ) ];
}
else
{
assignment = teamwithlowestscore();
}
return assignment;
}
getsplitscreenteam()
{
index = 0;
while ( index < level.players.size )
{
if ( !isDefined( level.players[ index ] ) )
{
index++;
continue;
}
else if ( level.players[ index ] == self )
{
index++;
continue;
}
else if ( !self isplayeronsamemachine( level.players[ index ] ) )
{
index++;
continue;
}
else
{
team = level.players[ index ].sessionteam;
if ( team != "spectator" )
{
return team;
}
}
index++;
}
return "";
}
updateobjectivetext()
{
if ( sessionmodeiszombiesgame() || self.pers[ "team" ] == "spectator" )
{
self setclientcgobjectivetext( "" );
return;
}
if ( level.scorelimit > 0 )
{
self setclientcgobjectivetext( getobjectivescoretext( self.pers[ "team" ] ) );
}
else
{
self setclientcgobjectivetext( getobjectivetext( self.pers[ "team" ] ) );
}
}
closemenus()
{
self closemenu();
self closeingamemenu();
}
beginclasschoice( forcenewchoice )
{
/#
assert( isDefined( level.teams[ self.pers[ "team" ] ] ) );
#/
team = self.pers[ "team" ];
if ( level.disablecac == 1 )
{
self.pers[ "class" ] = level.defaultclass;
self.class = level.defaultclass;
if ( self.sessionstate != "playing" && game[ "state" ] == "playing" )
{
self thread [[ level.spawnclient ]]();
}
level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus();
self thread maps/mp/gametypes_zm/_spectating::setspectatepermissionsformachine();
return;
}
if ( level.wagermatch )
{
self openmenu( game[ "menu_changeclass_wager" ] );
}
else if ( getDvarInt( "barebones_class_mode" ) )
{
self openmenu( game[ "menu_changeclass_barebones" ] );
}
else
{
self openmenu( game[ "menu_changeclass_" + team ] );
}
}
showmainmenuforteam()
{
/#
assert( isDefined( level.teams[ self.pers[ "team" ] ] ) );
#/
team = self.pers[ "team" ];
if ( level.wagermatch )
{
self openmenu( game[ "menu_changeclass_wager" ] );
}
else
{
self openmenu( game[ "menu_changeclass_" + team ] );
}
}
menuteam( team )
{
self closemenus();
if ( !level.console && level.allow_teamchange == "0" && isDefined( self.hasdonecombat ) && self.hasdonecombat )
{
return;
}
if ( self.pers[ "team" ] != team )
{
if ( level.ingraceperiod || !isDefined( self.hasdonecombat ) && !self.hasdonecombat )
{
self.hasspawned = 0;
}
if ( self.sessionstate == "playing" )
{
self.switching_teams = 1;
self.joining_team = team;
self.leaving_team = self.pers[ "team" ];
self suicide();
}
self.pers[ "team" ] = team;
self.team = team;
self.class = undefined;
self updateobjectivetext();
if ( level.teambased )
{
self.sessionteam = team;
}
else
{
self.sessionteam = "none";
self.ffateam = team;
}
self setclientscriptmainmenu( game[ "menu_class" ] );
self notify( "joined_team" );
level notify( "joined_team" );
self notify( "end_respawn" );
}
self beginclasschoice();
}
menuspectator()
{
self closemenus();
if ( self.pers[ "team" ] != "spectator" )
{
if ( isalive( self ) )
{
self.switching_teams = 1;
self.joining_team = "spectator";
self.leaving_team = self.pers[ "team" ];
self suicide();
}
self.pers[ "team" ] = "spectator";
self.team = "spectator";
self.class = undefined;
self updateobjectivetext();
self.sessionteam = "spectator";
if ( !level.teambased )
{
self.ffateam = "spectator";
}
[[ level.spawnspectator ]]();
self thread maps/mp/gametypes_zm/_globallogic_player::spectate_player_watcher();
self setclientscriptmainmenu( game[ "menu_class" ] );
self notify( "joined_spectators" );
}
}
menuclass( response )
{
self closemenus();
}
removespawnmessageshortly( delay )
{
self endon( "disconnect" );
waittillframeend;
self endon( "end_respawn" );
wait delay;
self clearlowermessage( 2 );
}

478
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_utils.gsc Normal file
View File

@ -0,0 +1,478 @@
#include maps/mp/gametypes_zm/_globallogic_score;
#include maps/mp/gametypes_zm/_hostmigration;
#include maps/mp/gametypes_zm/_hud_message;
#include maps/mp/_utility;
waittillslowprocessallowed()
{
while ( level.lastslowprocessframe == getTime() )
{
wait 0,05;
}
level.lastslowprocessframe = getTime();
}
testmenu()
{
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
wait 10;
notifydata = spawnstruct();
notifydata.titletext = &"MP_CHALLENGE_COMPLETED";
notifydata.notifytext = "wheee";
notifydata.sound = "mp_challenge_complete";
self thread maps/mp/gametypes_zm/_hud_message::notifymessage( notifydata );
}
}
testshock()
{
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
wait 3;
numshots = randomint( 6 );
i = 0;
while ( i < numshots )
{
iprintlnbold( numshots );
self shellshock( "frag_grenade_mp", 0,2 );
wait 0,1;
i++;
}
}
}
testhps()
{
self endon( "death" );
self endon( "disconnect" );
hps = [];
hps[ hps.size ] = "radar_mp";
hps[ hps.size ] = "artillery_mp";
hps[ hps.size ] = "dogs_mp";
for ( ;; )
{
hp = "radar_mp";
wait 20;
}
}
timeuntilroundend()
{
if ( level.gameended )
{
timepassed = ( getTime() - level.gameendtime ) / 1000;
timeremaining = level.postroundtime - timepassed;
if ( timeremaining < 0 )
{
return 0;
}
return timeremaining;
}
if ( level.inovertime )
{
return undefined;
}
if ( level.timelimit <= 0 )
{
return undefined;
}
if ( !isDefined( level.starttime ) )
{
return undefined;
}
timepassed = ( gettimepassed() - level.starttime ) / 1000;
timeremaining = ( level.timelimit * 60 ) - timepassed;
return timeremaining + level.postroundtime;
}
gettimeremaining()
{
return ( ( level.timelimit * 60 ) * 1000 ) - gettimepassed();
}
registerpostroundevent( eventfunc )
{
if ( !isDefined( level.postroundevents ) )
{
level.postroundevents = [];
}
level.postroundevents[ level.postroundevents.size ] = eventfunc;
}
executepostroundevents()
{
if ( !isDefined( level.postroundevents ) )
{
return;
}
i = 0;
while ( i < level.postroundevents.size )
{
[[ level.postroundevents[ i ] ]]();
i++;
}
}
getvalueinrange( value, minvalue, maxvalue )
{
if ( value > maxvalue )
{
return maxvalue;
}
else
{
if ( value < minvalue )
{
return minvalue;
}
else
{
return value;
}
}
}
assertproperplacement()
{
/#
numplayers = level.placement[ "all" ].size;
i = 0;
while ( i < ( numplayers - 1 ) )
{
if ( isDefined( level.placement[ "all" ][ i ] ) && isDefined( level.placement[ "all" ][ i + 1 ] ) )
{
if ( level.placement[ "all" ][ i ].score < level.placement[ "all" ][ i + 1 ].score )
{
println( "^1Placement array:" );
i = 0;
while ( i < numplayers )
{
player = level.placement[ "all" ][ i ];
println( "^1" + i + ". " + player.name + ": " + player.score );
i++;
}
assertmsg( "Placement array was not properly sorted" );
return;
}
}
else
{
i++;
#/
}
}
}
isvalidclass( class )
{
if ( level.oldschool || sessionmodeiszombiesgame() )
{
/#
assert( !isDefined( class ) );
#/
return 1;
}
if ( isDefined( class ) )
{
return class != "";
}
}
playtickingsound( gametype_tick_sound )
{
self endon( "death" );
self endon( "stop_ticking" );
level endon( "game_ended" );
time = level.bombtimer;
while ( 1 )
{
self playsound( gametype_tick_sound );
if ( time > 10 )
{
time -= 1;
wait 1;
}
else if ( time > 4 )
{
time -= 0,5;
wait 0,5;
}
else if ( time > 1 )
{
time -= 0,4;
wait 0,4;
}
else
{
time -= 0,3;
wait 0,3;
}
maps/mp/gametypes_zm/_hostmigration::waittillhostmigrationdone();
}
}
stoptickingsound()
{
self notify( "stop_ticking" );
}
gametimer()
{
level endon( "game_ended" );
level waittill( "prematch_over" );
level.starttime = getTime();
level.discardtime = 0;
if ( isDefined( game[ "roundMillisecondsAlreadyPassed" ] ) )
{
level.starttime -= game[ "roundMillisecondsAlreadyPassed" ];
}
prevtime = getTime();
while ( game[ "state" ] == "playing" )
{
if ( !level.timerstopped )
{
game[ "timepassed" ] += getTime() - prevtime;
}
prevtime = getTime();
wait 1;
}
}
gettimepassed()
{
if ( !isDefined( level.starttime ) )
{
return 0;
}
if ( level.timerstopped )
{
return level.timerpausetime - level.starttime - level.discardtime;
}
else
{
return getTime() - level.starttime - level.discardtime;
}
}
pausetimer()
{
if ( level.timerstopped )
{
return;
}
level.timerstopped = 1;
level.timerpausetime = getTime();
}
resumetimer()
{
if ( !level.timerstopped )
{
return;
}
level.timerstopped = 0;
level.discardtime += getTime() - level.timerpausetime;
}
getscoreremaining( team )
{
/#
if ( !isplayer( self ) )
{
assert( isDefined( team ) );
}
#/
scorelimit = level.scorelimit;
if ( isplayer( self ) )
{
return scorelimit - maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( self );
}
else
{
return scorelimit - getteamscore( team );
}
}
getscoreperminute( team )
{
/#
if ( !isplayer( self ) )
{
assert( isDefined( team ) );
}
#/
scorelimit = level.scorelimit;
timelimit = level.timelimit;
minutespassed = ( gettimepassed() / 60000 ) + 0,0001;
if ( isplayer( self ) )
{
return maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( self ) / minutespassed;
}
else
{
return getteamscore( team ) / minutespassed;
}
}
getestimatedtimeuntilscorelimit( team )
{
/#
if ( !isplayer( self ) )
{
assert( isDefined( team ) );
}
#/
scoreperminute = self getscoreperminute( team );
scoreremaining = self getscoreremaining( team );
if ( !scoreperminute )
{
return 999999;
}
return scoreremaining / scoreperminute;
}
rumbler()
{
self endon( "disconnect" );
while ( 1 )
{
wait 0,1;
self playrumbleonentity( "damage_heavy" );
}
}
waitfortimeornotify( time, notifyname )
{
self endon( notifyname );
wait time;
}
waitfortimeornotifynoartillery( time, notifyname )
{
self endon( notifyname );
wait time;
while ( isDefined( level.artilleryinprogress ) )
{
/#
assert( level.artilleryinprogress );
#/
wait 0,25;
}
}
isheadshot( sweapon, shitloc, smeansofdeath, einflictor )
{
if ( shitloc != "head" && shitloc != "helmet" )
{
return 0;
}
switch( smeansofdeath )
{
case "MOD_BAYONET":
case "MOD_MELEE":
return 0;
case "MOD_IMPACT":
if ( sweapon != "knife_ballistic_mp" )
{
return 0;
}
}
return 1;
}
gethitlocheight( shitloc )
{
switch( shitloc )
{
case "head":
case "helmet":
case "neck":
return 60;
case "gun":
case "left_arm_lower":
case "left_arm_upper":
case "left_hand":
case "right_arm_lower":
case "right_arm_upper":
case "right_hand":
case "torso_upper":
return 48;
case "torso_lower":
return 40;
case "left_leg_upper":
case "right_leg_upper":
return 32;
case "left_leg_lower":
case "right_leg_lower":
return 10;
case "left_foot":
case "right_foot":
return 5;
}
return 48;
}
debugline( start, end )
{
/#
i = 0;
while ( i < 50 )
{
line( start, end );
wait 0,05;
i++;
#/
}
}
isexcluded( entity, entitylist )
{
index = 0;
while ( index < entitylist.size )
{
if ( entity == entitylist[ index ] )
{
return 1;
}
index++;
}
return 0;
}
waitfortimeornotifies( desireddelay )
{
startedwaiting = getTime();
waitedtime = ( getTime() - startedwaiting ) / 1000;
if ( waitedtime < desireddelay )
{
wait ( desireddelay - waitedtime );
return desireddelay;
}
else
{
return waitedtime;
}
}
logteamwinstring( wintype, winner )
{
log_string = wintype;
if ( isDefined( winner ) )
{
log_string = ( log_string + ", win: " ) + winner;
}
_a469 = level.teams;
_k469 = getFirstArrayKey( _a469 );
while ( isDefined( _k469 ) )
{
team = _a469[ _k469 ];
log_string = ( log_string + ", " ) + team + ": " + game[ "teamScores" ][ team ];
_k469 = getNextArrayKey( _a469, _k469 );
}
logstring( log_string );
}

471
zm_transit_dr_patch/maps/mp/gametypes_zm/_globallogic_vehicle.gsc Normal file
View File

@ -0,0 +1,471 @@
#include maps/mp/gametypes_zm/_damagefeedback;
#include maps/mp/gametypes_zm/_globallogic_player;
#include maps/mp/gametypes_zm/_weapons;
#include maps/mp/_utility;
callback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname )
{
self.idflags = idflags;
self.idflagstime = getTime();
if ( game[ "state" ] == "postgame" )
{
return;
}
if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( eattacker.candocombat ) && !eattacker.candocombat )
{
return;
}
if ( !isDefined( vdir ) )
{
idflags |= level.idflags_no_knockback;
}
friendly = 0;
if ( isDefined( self.maxhealth ) || self.health == self.maxhealth && !isDefined( self.attackers ) )
{
self.attackers = [];
self.attackerdata = [];
self.attackerdamage = [];
}
if ( sweapon == "none" && isDefined( einflictor ) )
{
if ( isDefined( einflictor.targetname ) && einflictor.targetname == "explodable_barrel" )
{
sweapon = "explodable_barrel_mp";
}
else
{
if ( isDefined( einflictor.destructible_type ) && issubstr( einflictor.destructible_type, "vehicle_" ) )
{
sweapon = "destructible_car_mp";
}
}
}
if ( idflags & level.idflags_no_protection )
{
if ( self isvehicleimmunetodamage( idflags, smeansofdeath, sweapon ) )
{
return;
}
if ( smeansofdeath == "MOD_PISTOL_BULLET" || smeansofdeath == "MOD_RIFLE_BULLET" )
{
}
else
{
if ( smeansofdeath == "MOD_PROJECTILE" || smeansofdeath == "MOD_GRENADE" )
{
idamage *= getvehicleprojectilescalar( sweapon );
idamage = int( idamage );
if ( idamage == 0 )
{
return;
}
}
else
{
if ( smeansofdeath == "MOD_GRENADE_SPLASH" )
{
idamage *= getvehicleunderneathsplashscalar( sweapon );
idamage = int( idamage );
if ( idamage == 0 )
{
return;
}
}
}
}
idamage *= level.vehicledamagescalar;
idamage = int( idamage );
if ( isplayer( eattacker ) )
{
eattacker.pers[ "participation" ]++;
}
prevhealthratio = self.health / self.maxhealth;
if ( isDefined( self.owner ) && isplayer( self.owner ) )
{
team = self.owner.pers[ "team" ];
}
if ( level.teambased && isplayer( eattacker ) && team == eattacker.pers[ "team" ] )
{
if ( level.friendlyfire == 0 )
{
if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
{
return;
}
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 1 );
}
else if ( level.friendlyfire == 1 )
{
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 );
}
else if ( level.friendlyfire == 2 )
{
if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
{
return;
}
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 1 );
}
else
{
if ( level.friendlyfire == 3 )
{
idamage = int( idamage * 0,5 );
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 );
}
}
friendly = 1;
}
else
{
if ( !level.teambased && isDefined( self.targetname ) && self.targetname == "rcbomb" )
{
}
else
{
if ( isDefined( self.owner ) && isDefined( eattacker ) && self.owner == eattacker )
{
return;
}
}
if ( idamage < 1 )
{
idamage = 1;
}
if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( sweapon ) )
{
eattacker thread maps/mp/gametypes_zm/_weapons::checkhit( sweapon );
}
if ( issubstr( smeansofdeath, "MOD_GRENADE" ) && isDefined( einflictor.iscooked ) )
{
self.wascooked = getTime();
}
else
{
self.wascooked = undefined;
}
attacker_seat = undefined;
if ( isDefined( eattacker ) )
{
attacker_seat = self getoccupantseat( eattacker );
}
if ( isDefined( eattacker ) )
{
self.lastdamagewasfromenemy = !isDefined( attacker_seat );
}
self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 );
if ( level.gametype == "hack" && sweapon != "emp_grenade_mp" )
{
idamage = 0;
}
}
if ( isDefined( eattacker ) && eattacker != self )
{
if ( maps/mp/gametypes_zm/_globallogic_player::dodamagefeedback( sweapon, einflictor ) )
{
if ( idamage > 0 )
{
eattacker thread maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor );
}
}
}
}
/#
if ( getDvarInt( "g_debugDamage" ) )
{
println( "actor:" + self getentitynumber() + " health:" + self.health + " attacker:" + eattacker.clientid + " inflictor is player:" + isplayer( einflictor ) + " damage:" + idamage + " hitLoc:" + shitloc );
#/
}
if ( 1 )
{
lpselfnum = self getentitynumber();
lpselfteam = "";
lpattackerteam = "";
if ( isplayer( eattacker ) )
{
lpattacknum = eattacker getentitynumber();
lpattackguid = eattacker getguid();
lpattackname = eattacker.name;
lpattackerteam = eattacker.pers[ "team" ];
}
else
{
lpattacknum = -1;
lpattackguid = "";
lpattackname = "";
lpattackerteam = "world";
}
logprint( "VD;" + lpselfnum + ";" + lpselfteam + ";" + lpattackguid + ";" + lpattacknum + ";" + lpattackerteam + ";" + lpattackname + ";" + sweapon + ";" + idamage + ";" + smeansofdeath + ";" + shitloc + "\n" );
}
}
callback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime )
{
idamage = 0;
finnerdamage = 0;
fouterdamage = 0;
self.idflags = idflags;
self.idflagstime = getTime();
if ( game[ "state" ] == "postgame" )
{
return;
}
if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( eattacker.candocombat ) && !eattacker.candocombat )
{
return;
}
friendly = 0;
if ( idflags & level.idflags_no_protection )
{
if ( self isvehicleimmunetodamage( idflags, smeansofdeath, sweapon ) )
{
return;
}
if ( smeansofdeath != "MOD_PROJECTILE_SPLASH" || smeansofdeath == "MOD_GRENADE_SPLASH" && smeansofdeath == "MOD_EXPLOSIVE" )
{
scalar = getvehicleprojectilesplashscalar( sweapon );
idamage = int( idamage * scalar );
finnerdamage *= scalar;
fouterdamage *= scalar;
if ( finnerdamage == 0 )
{
return;
}
if ( idamage < 1 )
{
idamage = 1;
}
}
occupant_team = undefined;
if ( level.teambased && isplayer( eattacker ) && occupant_team == eattacker.pers[ "team" ] )
{
if ( level.friendlyfire == 0 )
{
if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
{
return;
}
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
}
else if ( level.friendlyfire == 1 )
{
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
}
else if ( level.friendlyfire == 2 )
{
if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
{
return;
}
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
}
else
{
if ( level.friendlyfire == 3 )
{
idamage = int( idamage * 0,5 );
if ( idamage < 1 )
{
idamage = 1;
}
self.lastdamagewasfromenemy = 0;
self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
}
}
friendly = 1;
return;
}
else
{
if ( idamage < 1 )
{
idamage = 1;
}
self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
}
}
}
vehiclecrush()
{
self endon( "disconnect" );
if ( isDefined( level._effect ) && isDefined( level._effect[ "tanksquish" ] ) )
{
playfx( level._effect[ "tanksquish" ], self.origin + vectorScale( ( 0, 0, 1 ), 30 ) );
}
self playsound( "chr_crunch" );
}
getvehicleprojectilescalar( sweapon )
{
if ( sweapon == "satchel_charge_mp" )
{
scale = 1;
}
else if ( sweapon == "sticky_grenade_mp" )
{
scale = 1;
}
else if ( sweapon == "claymore_mp" )
{
scale = 1;
}
else if ( sweapon == "remote_missile_missile_mp" )
{
scale = 10;
}
else if ( sweapon == "remote_mortar_missile_mp" )
{
scale = 10;
}
else if ( sweapon == "smaw_mp" )
{
scale = 0,2;
}
else if ( sweapon == "fhj18_mp" )
{
scale = 0,2;
}
else if ( issubstr( sweapon, "gl_" ) )
{
scale = 1;
}
else if ( issubstr( sweapon, "turret_mp" ) )
{
scale = 1;
}
else if ( issubstr( sweapon, "grenade" ) )
{
scale = 1;
}
else
{
scale = 1;
}
return scale;
}
getvehicleprojectilesplashscalar( sweapon )
{
if ( sweapon == "satchel_charge_mp" )
{
scale = 1;
}
else if ( sweapon == "sticky_grenade_mp" )
{
scale = 1;
}
else if ( sweapon == "claymore_mp" )
{
scale = 1;
}
else if ( sweapon == "remote_missile_missile_mp" )
{
scale = 10;
}
else if ( sweapon == "remote_mortar_missile_mp" )
{
scale = 4;
}
else if ( sweapon == "chopper_minigun_mp" )
{
scale = 0,5;
}
else if ( issubstr( sweapon, "gl_" ) )
{
scale = 0,5;
}
else if ( issubstr( sweapon, "turrent_mp" ) )
{
scale = 0,1;
}
else if ( issubstr( sweapon, "grenade" ) )
{
scale = 1;
}
else
{
scale = 1;
}
return scale;
}
getvehicleunderneathsplashscalar( sweapon )
{
if ( sweapon == "satchel_charge_mp" )
{
scale = 10;
scale *= 3;
}
else
{
scale = 1;
}
return scale;
}
getvehiclebulletdamage( sweapon )
{
if ( issubstr( sweapon, "ptrs41_" ) )
{
idamage = 25;
}
else if ( issubstr( sweapon, "gunner" ) )
{
idamage = 5;
}
else if ( issubstr( sweapon, "mg42_bipod" ) || issubstr( sweapon, "30cal_bipod" ) )
{
idamage = 5;
}
else
{
idamage = 1;
}
return idamage;
}
allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon )
{
if ( isDefined( self.allowfriendlyfiredamageoverride ) )
{
return [[ self.allowfriendlyfiredamageoverride ]]( einflictor, eattacker, smeansofdeath, sweapon );
}
vehicle = eattacker getvehicleoccupied();
return 0;
}

995
zm_transit_dr_patch/maps/mp/gametypes_zm/_gv_actions.gsc Normal file
View File

@ -0,0 +1,995 @@
#include maps/mp/gametypes_zm/_globallogic_ui;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/gametypes_zm/_globallogic_score;
#include maps/mp/gametypes_zm/_globallogic;
#include common_scripts/utility;
#include maps/mp/_utility;
initializeactionarray()
{
level.gametypeactions = [];
level.gametypeactions[ "GiveAmmo" ] = ::dogiveammo;
level.gametypeactions[ "RemoveAmmo" ] = ::doremoveammo;
level.gametypeactions[ "PlaySound" ] = ::doplaysound;
level.gametypeactions[ "EnableUAV" ] = ::doenableuav;
level.gametypeactions[ "GiveScore" ] = ::dogivescore;
level.gametypeactions[ "RemoveScore" ] = ::doremovescore;
level.gametypeactions[ "SetHeader" ] = ::dosetheader;
level.gametypeactions[ "SetSubHeader" ] = ::dosetsubheader;
level.gametypeactions[ "DisplayMessage" ] = ::dodisplaymessage;
level.gametypeactions[ "GiveHealth" ] = ::dogivehealth;
level.gametypeactions[ "RemoveHealth" ] = ::doremovehealth;
level.gametypeactions[ "SetHealthRegen" ] = ::dosethealthregen;
level.gametypeactions[ "ChangeClass" ] = ::dochangeclass;
level.gametypeactions[ "ChangeTeam" ] = ::dochangeteam;
level.gametypeactions[ "GivePerk" ] = ::dogiveperk;
level.gametypeactions[ "RemovePerk" ] = ::doremoveperk;
level.gametypeactions[ "GiveInvuln" ] = ::dogiveinvuln;
level.gametypeactions[ "RemoveInvuln" ] = ::doremoveinvuln;
level.gametypeactions[ "SetDamageModifier" ] = ::dosetdamagemodifier;
level.gametypeactions[ "GiveKillstreak" ] = ::dogivekillstreak;
level.gametypeactions[ "RemoveKillstreak" ] = ::doremovekillstreak;
level.gametypeactions[ "GiveLives" ] = ::dogivelives;
level.gametypeactions[ "RemoveLives" ] = ::doremovelives;
level.gametypeactions[ "ScaleMoveSpeed" ] = ::doscalemovespeed;
level.gametypeactions[ "ShowOnRadar" ] = ::doshowonradar;
level.conditionals = [];
level.conditionals[ "Equals" ] = ::equals;
level.conditionals[ "==" ] = ::equals;
level.conditionals[ "!=" ] = ::notequals;
level.conditionals[ "<" ] = ::lessthan;
level.conditionals[ "<=" ] = ::lessthanequals;
level.conditionals[ ">" ] = ::greaterthan;
level.conditionals[ ">=" ] = ::greaterthanequals;
level.conditionals[ "InPlace" ] = ::inplace;
level.conditionallefthandside = [];
level.conditionallefthandside[ "PlayersLeft" ] = ::playersleft;
level.conditionallefthandside[ "RoundsPlayed" ] = ::roundsplayed;
level.conditionallefthandside[ "HitBy" ] = ::hitby;
level.conditionallefthandside[ "PlayersClass" ] = ::playersclass;
level.conditionallefthandside[ "VictimsClass" ] = ::playersclass;
level.conditionallefthandside[ "AttackersClass" ] = ::attackersclass;
level.conditionallefthandside[ "PlayersPlace" ] = ::playersplace;
level.conditionallefthandside[ "VictimsPlace" ] = ::playersplace;
level.conditionallefthandside[ "AttackersPlace" ] = ::attackersplace;
level.targets = [];
level.targets[ "Everyone" ] = ::gettargeteveryone;
level.targets[ "PlayersLeft" ] = ::gettargetplayersleft;
level.targets[ "PlayersEliminated" ] = ::gettargetplayerseliminated;
level.targets[ "PlayersTeam" ] = ::gettargetplayersteam;
level.targets[ "VictimsTeam" ] = ::gettargetplayersteam;
level.targets[ "OtherTeam" ] = ::gettargetotherteam;
level.targets[ "AttackersTeam" ] = ::gettargetotherteam;
level.targets[ "PlayersLeftOnPlayersTeam" ] = ::gettargetplayersleftonplayersteam;
level.targets[ "PlayersLeftOnOtherTeam" ] = ::gettargetplayersleftonotherteam;
level.targets[ "PlayersLeftOnVictimsTeam" ] = ::gettargetplayersleftonplayersteam;
level.targets[ "PlayersLeftOnAttackersTeam" ] = ::gettargetplayersleftonotherteam;
level.targets[ "PlayersEliminatedOnPlayersTeam" ] = ::gettargetplayerseliminatedonplayersteam;
level.targets[ "PlayersEliminatedOnOtherTeam" ] = ::gettargetplayerseliminatedonotherteam;
level.targets[ "PlayersEliminatedOnVictimsTeam" ] = ::gettargetplayerseliminatedonplayersteam;
level.targets[ "PlayersEliminatedOnAttackersTeam" ] = ::gettargetplayerseliminatedonotherteam;
level.targets[ "AssistingPlayers" ] = ::getassistingplayers;
}
equals( param1, param2 )
{
return param1 == param2;
}
notequals( param1, param2 )
{
return param1 != param2;
}
lessthan( param1, param2 )
{
return param1 < param2;
}
lessthanequals( param1, param2 )
{
return param1 <= param2;
}
greaterthan( param1, param2 )
{
return param1 > param2;
}
greaterthanequals( param1, param2 )
{
return param1 >= param2;
}
inplace( param1, param2 )
{
if ( param1 == param2 )
{
return 1;
}
if ( param2 == "top3" && param1 == "first" )
{
return 1;
}
return 0;
}
playersleft( rule )
{
return 0;
}
roundsplayed( rule )
{
return game[ "roundsplayed" ] + 1;
}
hitby( rule )
{
meansofdeath = rule.target[ "MeansOfDeath" ];
weapon = rule.target[ "Weapon" ];
if ( !isDefined( meansofdeath ) || !isDefined( weapon ) )
{
return undefined;
}
switch( weapon )
{
case "knife_ballistic_mp":
return "knife";
}
switch( meansofdeath )
{
case "MOD_PISTOL_BULLET":
case "MOD_RIFLE_BULLET":
return "bullet";
case "MOD_BAYONET":
case "MOD_MELEE":
return "knife";
case "MOD_HEAD_SHOT":
return "headshot";
case "MOD_EXPLOSIVE":
case "MOD_GRENADE":
case "MOD_GRENADE_SPLASH":
case "MOD_PROJECTILE":
case "MOD_PROJECTILE_SPLASH":
return "explosive";
}
return undefined;
}
getplayersclass( player )
{
return player.pers[ "class" ];
}
playersclass( rule )
{
player = rule.target[ "Player" ];
return getplayersclass( player );
}
attackersclass( rule )
{
player = rule.target[ "Attacker" ];
return getplayersclass( player );
}
getplayersplace( player )
{
maps/mp/gametypes_zm/_globallogic::updateplacement();
if ( !isDefined( level.placement[ "all" ] ) )
{
return;
}
place = 0;
while ( place < level.placement[ "all" ].size )
{
if ( level.placement[ "all" ][ place ] == player )
{
place++;
continue;
}
else
{
place++;
}
}
place++;
if ( place == 1 )
{
return "first";
}
else
{
if ( place <= 3 )
{
return "top3";
}
else
{
if ( place == level.placement[ "all" ].size )
{
return "last";
}
}
}
return "middle";
}
playersplace( rule )
{
player = rule.target[ "Player" ];
return getplayersplace( player );
}
attackersplace( rule )
{
player = rule.target[ "Attacker" ];
return getplayersplace( player );
}
gettargeteveryone( rule )
{
return level.players;
}
gettargetplayersleft( rule )
{
return 0;
}
gettargetplayerseliminated( rule )
{
return 0;
}
gettargetplayersteam( rule )
{
player = rule.target[ "Player" ];
if ( !isDefined( player ) )
{
return [];
}
return getplayersonteam( level.players, player.pers[ "team" ] );
}
gettargetotherteam( rule )
{
player = rule.target[ "Player" ];
if ( !isDefined( player ) )
{
return [];
}
return getplayersonteam( level.players, getotherteam( player.pers[ "team" ] ) );
}
gettargetplayersleftonplayersteam( rule )
{
return [];
}
gettargetplayersleftonotherteam( rule )
{
return [];
}
gettargetplayerseliminatedonplayersteam( rule )
{
return [];
}
gettargetplayerseliminatedonotherteam( rule )
{
return [];
}
getassistingplayers( rule )
{
assisters = [];
attacker = rule.target[ "Attacker" ];
if ( !isDefined( rule.target[ "Assisters" ] ) || !isDefined( attacker ) )
{
return assisters;
}
j = 0;
while ( j < rule.target[ "Assisters" ].size )
{
player = rule.target[ "Assisters" ][ j ];
if ( !isDefined( player ) )
{
j++;
continue;
}
else if ( player == attacker )
{
j++;
continue;
}
else
{
assisters[ assisters.size ] = player;
}
j++;
}
return assisters;
}
executegametypeeventrule( rule )
{
if ( !aregametypeeventruleconditionalsmet( rule ) )
{
return;
}
if ( !isDefined( level.gametypeactions[ rule.action ] ) )
{
/#
error( "GAMETYPE VARIANTS - unknown action: " + rule.action + "!" );
#/
return;
}
thread internalexecuterule( rule );
}
internalexecuterule( rule )
{
}
aregametypeeventruleconditionalsmet( rule )
{
if ( !isDefined( rule.conditionals ) || rule.conditionals.size == 0 )
{
return 1;
}
combinedresult = 1;
if ( rule.conditionaleval == "OR" )
{
combinedresult = 0;
}
i = 0;
while ( i < rule.conditionals.size )
{
conditionalresult = evaluategametypeeventruleconditional( rule, rule.conditionals[ i ] );
switch( rule.conditionaleval )
{
case "AND":
if ( combinedresult )
{
combinedresult = conditionalresult;
}
break;
case "OR":
if ( !combinedresult )
{
combinedresult = conditionalresult;
}
break;
}
if ( rule.conditionaleval == "AND" && !combinedresult )
{
break;
}
else
{
if ( rule.conditionaleval == "OR" && combinedresult )
{
break;
}
else
{
i++;
}
}
}
return combinedresult;
}
evaluategametypeeventruleconditional( rule, conditional )
{
if ( isDefined( conditional.lhs ) || !isDefined( conditional.operand ) && !isDefined( conditional.rhs ) )
{
return 0;
}
if ( !isDefined( level.conditionallefthandside[ conditional.lhs ] ) )
{
return 0;
}
lhsvalue = [[ level.conditionallefthandside[ conditional.lhs ] ]]( rule );
if ( !isDefined( lhsvalue ) || !isDefined( level.conditionals[ conditional.operand ] ) )
{
return 0;
}
return [[ level.conditionals[ conditional.operand ] ]]( lhsvalue, conditional.rhs );
}
getplayersonteam( players, team )
{
playersonteam = [];
i = 0;
while ( i < players.size )
{
player = players[ i ];
if ( player.pers[ "team" ] == team )
{
playersonteam[ playersonteam.size ] = player;
}
i++;
}
return playersonteam;
}
gettargetsforgametypeeventrule( rule )
{
targets = [];
if ( !isDefined( rule.targetname ) )
{
return targets;
}
if ( isDefined( rule.target[ rule.targetname ] ) )
{
targets[ targets.size ] = rule.target[ rule.targetname ];
}
else
{
if ( isDefined( level.targets[ rule.targetname ] ) )
{
targets = [[ level.targets[ rule.targetname ] ]]( rule );
}
}
return targets;
}
doesrulehavevalidparam( rule )
{
if ( isDefined( rule.params ) && isarray( rule.params ) )
{
return rule.params.size > 0;
}
}
sortplayersbylivesdescending( players )
{
if ( !isDefined( players ) )
{
return undefined;
}
swapped = 1;
n = players.size;
while ( swapped )
{
swapped = 0;
i = 0;
while ( i < ( n - 1 ) )
{
if ( players[ i ].pers[ "lives" ] < players[ i + 1 ].pers[ "lives" ] )
{
temp = players[ i ];
players[ i ] = players[ i + 1 ];
players[ i + 1 ] = temp;
swapped = 1;
}
i++;
}
n--;
}
return players;
}
giveammo( players, amount )
{
i = 0;
while ( i < players.size )
{
wait 0,5;
player = players[ i ];
currentweapon = player getcurrentweapon();
clipammo = player getweaponammoclip( currentweapon );
player setweaponammoclip( currentweapon, clipammo + amount );
i++;
}
}
dogiveammo( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
targets = gettargetsforgametypeeventrule( rule );
giveammo( targets, rule.params[ 0 ] );
}
doremoveammo( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
targets = gettargetsforgametypeeventrule( rule );
giveammo( targets, 0 - rule.params[ 0 ] );
}
doplaysound( rule )
{
if ( doesrulehavevalidparam( rule ) )
{
playsoundonplayers( rule.params[ 0 ] );
}
}
doenableuav( rule )
{
targets = gettargetsforgametypeeventrule( rule );
targetindex = 0;
while ( targetindex < targets.size )
{
targets[ targetindex ].pers[ "hasRadar" ] = 1;
targets[ targetindex ].hasspyplane = 1;
targetindex++;
}
}
givescore( players, amount )
{
i = 0;
while ( i < players.size )
{
player = players[ i ];
score = maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( player );
maps/mp/gametypes_zm/_globallogic_score::_setplayerscore( player, score + amount );
i++;
}
}
dogivescore( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
targets = gettargetsforgametypeeventrule( rule );
givescore( targets, rule.params[ 0 ] );
}
doremovescore( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
targets = gettargetsforgametypeeventrule( rule );
givescore( targets, 0 - rule.params[ 0 ] );
}
dosetheader( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
targets = gettargetsforgametypeeventrule( rule );
targetindex = 0;
while ( targetindex < targets.size )
{
target = targets[ targetindex ];
displaytextonhudelem( target, target.customgametypeheader, rule.params[ 0 ], rule.params[ 1 ], "gv_header", rule.params[ 2 ] );
targetindex++;
}
}
dosetsubheader( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
targets = gettargetsforgametypeeventrule( rule );
targetindex = 0;
while ( targetindex < targets.size )
{
target = targets[ targetindex ];
displaytextonhudelem( target, target.customgametypesubheader, rule.params[ 0 ], rule.params[ 1 ], "gv_subheader", rule.params[ 2 ] );
targetindex++;
}
}
displaytextonhudelem( target, texthudelem, text, secondstodisplay, notifyname, valueparam )
{
texthudelem.alpha = 1;
if ( isDefined( valueparam ) )
{
texthudelem settext( text, valueparam );
}
else
{
texthudelem settext( text );
}
if ( !isDefined( secondstodisplay ) || secondstodisplay <= 0 )
{
target.doingnotify = 0;
target notify( notifyname );
return;
}
target thread fadecustomgametypehudelem( texthudelem, secondstodisplay, notifyname );
}
fadecustomgametypehudelem( hudelem, seconds, notifyname )
{
self endon( "disconnect" );
self notify( notifyname );
self endon( notifyname );
if ( seconds <= 0 )
{
return;
}
self.doingnotify = 1;
wait seconds;
while ( hudelem.alpha > 0 )
{
hudelem.alpha -= 0,05;
if ( hudelem.alpha < 0 )
{
hudelem.alpha = 0;
}
wait 0,05;
}
self.doingnotify = 0;
}
dodisplaymessage( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
targets = gettargetsforgametypeeventrule( rule );
targetindex = 0;
while ( targetindex < targets.size )
{
thread announcemessage( targets[ targetindex ], rule.params[ 0 ], 2 );
targetindex++;
}
}
announcemessage( target, messagetext, time )
{
target endon( "disconnect" );
clientannouncement( target, messagetext, int( time * 1000 ) );
if ( time == 0 )
{
time = getDvarFloat( #"E8C4FC20" );
}
target.doingnotify = 1;
wait time;
target.doingnotify = 0;
}
givehealth( players, amount )
{
i = 0;
while ( i < players.size )
{
player = players[ i ];
player.health += amount;
i++;
}
}
dogivehealth( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
givehealth( gettargetsforgametypeeventrule( rule ), rule.params[ 0 ] );
}
doremovehealth( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
givehealth( gettargetsforgametypeeventrule( rule ), 0 - rule.params[ 0 ] );
}
dosethealthregen( rule )
{
targets = gettargetsforgametypeeventrule( rule );
targetindex = 0;
while ( targetindex < targets.size )
{
player = targets[ targetindex ];
player.regenrate = rule.params[ 0 ];
targetindex++;
}
}
dochangeclass( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
}
dochangeteam( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
team = rule.params[ 0 ];
teamkeys = getarraykeys( level.teams );
targets = gettargetsforgametypeeventrule( rule );
targetindex = 0;
while ( targetindex < targets.size )
{
target = targets[ targetindex ];
if ( target.pers[ "team" ] == team )
{
targetindex++;
continue;
}
else
{
while ( team == "toggle" )
{
team = teamkeys[ randomint( teamkeys.size ) ];
teamindex = 0;
while ( teamindex < teamkeys.size )
{
if ( target.pers[ "team" ] == teamkeys[ teamindex ] )
{
team = teamkeys[ ( teamindex + 1 ) % teamkeys.size ];
break;
}
else
{
teamindex++;
}
}
}
target.pers[ "team" ] = team;
target.team = team;
if ( level.teambased )
{
target.sessionteam = team;
}
else
{
target.sessionteam = "none";
}
target notify( "joined_team" );
level notify( "joined_team" );
}
targetindex++;
}
}
displayperk( player, imagename )
{
index = 0;
if ( isDefined( player.perkicon ) )
{
index = -1;
i = 0;
while ( i < player.perkicon.size )
{
if ( player.perkicon[ i ].alpha == 0 )
{
index = i;
break;
}
else
{
i++;
}
}
if ( index == -1 )
{
return;
}
}
player maps/mp/gametypes_zm/_hud_util::showperk( index, imagename, 10 );
player thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutaftertime( 3 );
player thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutondeath();
}
setorunsetperk( players, perks, shouldset )
{
if ( level.perksenabled == 0 )
{
return;
}
if ( perks.size < 2 )
{
return;
}
hasperkalready = 0;
imagename = perks[ perks.size - 1 ];
i = 0;
while ( i < players.size )
{
player = players[ i ];
perkindex = 0;
while ( perkindex < ( perks.size - 1 ) )
{
perk = perks[ perkindex ];
if ( player hasperk( perk ) )
{
hasperkalready = 1;
}
if ( shouldset )
{
player setperk( perk );
perkindex++;
continue;
}
else
{
player unsetperk( perk );
}
perkindex++;
}
if ( shouldset && !hasperkalready && getDvarInt( "scr_showperksonspawn" ) == 1 )
{
displayperk( player, imagename );
}
i++;
}
}
dogiveperk( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
setorunsetperk( gettargetsforgametypeeventrule( rule ), rule.params, 1 );
}
doremoveperk( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
setorunsetperk( gettargetsforgametypeeventrule( rule ), rule.params, 0 );
}
giveorremovekillstreak( rule, shouldgive )
{
}
dogivekillstreak( rule )
{
giveorremovekillstreak( rule, 1 );
}
doremovekillstreak( rule )
{
giveorremovekillstreak( rule, 0 );
}
givelives( players, amount )
{
i = 0;
while ( i < players.size )
{
player = players[ i ];
player.pers[ "lives" ] += amount;
if ( player.pers[ "lives" ] < 0 )
{
player.pers[ "lives" ] = 0;
}
i++;
}
}
dogivelives( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
givelives( gettargetsforgametypeeventrule( rule ), rule.params[ 0 ] );
}
doremovelives( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
givelives( gettargetsforgametypeeventrule( rule ), 0 - rule.params[ 0 ] );
}
giveorremoveinvuln( players, shouldgiveinvuln )
{
i = 0;
while ( i < players.size )
{
player = players[ i ];
i++;
}
}
dogiveinvuln( rule )
{
giveorremoveinvuln( gettargetsforgametypeeventrule( rule ), 1 );
}
doremoveinvuln( rule )
{
giveorremoveinvuln( gettargetsforgametypeeventrule( rule ), 0 );
}
dosetdamagemodifier( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
players = gettargetsforgametypeeventrule( rule );
i = 0;
while ( i < players.size )
{
player = players[ i ];
player.damagemodifier = rule.params[ 0 ];
i++;
}
}
doscalemovespeed( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
movespeedscale = rule.params[ 0 ];
targets = gettargetsforgametypeeventrule( rule );
targetindex = 0;
while ( targetindex < targets.size )
{
target = targets[ targetindex ];
target.movementspeedmodifier = movespeedscale * target getmovespeedscale();
if ( target.movementspeedmodifier < 0,1 )
{
target.movementspeedmodifier = 0,1;
}
else
{
if ( target.movementspeedmodifier > 4 )
{
target.movementspeedmodifier = 4;
}
}
target setmovespeedscale( target.movementspeedmodifier );
targetindex++;
}
}
doshowonradar( rule )
{
if ( !doesrulehavevalidparam( rule ) )
{
return;
}
targets = gettargetsforgametypeeventrule( rule );
targetindex = 0;
while ( targetindex < targets.size )
{
if ( rule.params[ 0 ] == "enable" )
{
targets[ targetindex ] setperk( "specialty_showonradar" );
targetindex++;
continue;
}
else
{
targets[ targetindex ] unsetperk( "specialty_showonradar" );
}
targetindex++;
}
}

288
zm_transit_dr_patch/maps/mp/gametypes_zm/_healthoverlay.gsc Normal file
View File

@ -0,0 +1,288 @@
#include maps/mp/gametypes_zm/_globallogic_player;
init()
{
precacheshader( "overlay_low_health" );
level.healthoverlaycutoff = 0,55;
regentime = level.playerhealthregentime;
level.playerhealth_regularregendelay = regentime * 1000;
level.healthregendisabled = level.playerhealth_regularregendelay <= 0;
level thread onplayerconnect();
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player thread onplayerspawned();
player thread onplayerkilled();
player thread onjoinedteam();
player thread onjoinedspectators();
player thread onplayerdisconnect();
}
}
onjoinedteam()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "joined_team" );
self notify( "end_healthregen" );
}
}
onjoinedspectators()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "joined_spectators" );
self notify( "end_healthregen" );
}
}
onplayerspawned()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "spawned_player" );
self thread playerhealthregen();
}
}
onplayerkilled()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "killed_player" );
self notify( "end_healthregen" );
}
}
onplayerdisconnect()
{
self waittill( "disconnect" );
self notify( "end_healthregen" );
}
playerhealthregen()
{
self endon( "end_healthregen" );
if ( self.health <= 0 )
{
/#
assert( !isalive( self ) );
#/
return;
}
maxhealth = self.health;
oldhealth = maxhealth;
player = self;
health_add = 0;
regenrate = 0,1;
usetrueregen = 0;
veryhurt = 0;
player.breathingstoptime = -10000;
thread playerbreathingsound( maxhealth * 0,35 );
thread playerheartbeatsound( maxhealth * 0,35 );
lastsoundtime_recover = 0;
hurttime = 0;
newhealth = 0;
for ( ;; )
{
wait 0,05;
if ( isDefined( player.regenrate ) )
{
regenrate = player.regenrate;
usetrueregen = 1;
}
if ( player.health == maxhealth )
{
veryhurt = 0;
self.atbrinkofdeath = 0;
continue;
}
else if ( player.health <= 0 )
{
return;
}
if ( isDefined( player.laststand ) && player.laststand )
{
continue;
}
else
{
wasveryhurt = veryhurt;
ratio = player.health / maxhealth;
if ( ratio <= level.healthoverlaycutoff )
{
veryhurt = 1;
self.atbrinkofdeath = 1;
if ( !wasveryhurt )
{
hurttime = getTime();
}
}
if ( player.health >= oldhealth )
{
regentime = level.playerhealth_regularregendelay;
if ( player hasperk( "specialty_healthregen" ) )
{
regentime = int( regentime / getDvarFloat( "perk_healthRegenMultiplier" ) );
}
if ( ( getTime() - hurttime ) < regentime )
{
break;
}
else if ( level.healthregendisabled )
{
break;
}
else if ( ( getTime() - lastsoundtime_recover ) > regentime )
{
lastsoundtime_recover = getTime();
self notify( "snd_breathing_better" );
}
if ( veryhurt )
{
newhealth = ratio;
veryhurttime = 3000;
if ( player hasperk( "specialty_healthregen" ) )
{
veryhurttime = int( veryhurttime / getDvarFloat( "perk_healthRegenMultiplier" ) );
}
if ( getTime() > ( hurttime + veryhurttime ) )
{
newhealth += regenrate;
}
}
else if ( usetrueregen )
{
newhealth = ratio + regenrate;
}
else
{
newhealth = 1;
}
if ( newhealth >= 1 )
{
self maps/mp/gametypes_zm/_globallogic_player::resetattackerlist();
newhealth = 1;
}
if ( newhealth <= 0 )
{
return;
}
player setnormalhealth( newhealth );
change = player.health - oldhealth;
if ( change > 0 )
{
player decayplayerdamages( change );
}
oldhealth = player.health;
break;
}
else
{
oldhealth = player.health;
health_add = 0;
hurttime = getTime();
player.breathingstoptime = hurttime + 6000;
}
}
}
}
decayplayerdamages( decay )
{
if ( !isDefined( self.attackerdamage ) )
{
return;
}
i = 0;
while ( i < self.attackerdamage.size )
{
if ( !isDefined( self.attackerdamage[ i ] ) || !isDefined( self.attackerdamage[ i ].damage ) )
{
i++;
continue;
}
else
{
self.attackerdamage[ i ].damage -= decay;
if ( self.attackerdamage[ i ].damage < 0 )
{
self.attackerdamage[ i ].damage = 0;
}
}
i++;
}
}
playerbreathingsound( healthcap )
{
self endon( "end_healthregen" );
wait 2;
player = self;
for ( ;; )
{
wait 0,2;
if ( player.health <= 0 )
{
return;
}
if ( player.health >= healthcap )
{
continue;
}
else if ( level.healthregendisabled && getTime() > player.breathingstoptime )
{
continue;
}
else
{
player notify( "snd_breathing_hurt" );
wait 0,784;
wait ( 0,1 + randomfloat( 0,8 ) );
}
}
}
playerheartbeatsound( healthcap )
{
self endon( "end_healthregen" );
self.hearbeatwait = 0,2;
wait 2;
player = self;
for ( ;; )
{
wait 0,2;
if ( player.health <= 0 )
{
return;
}
if ( player.health >= healthcap )
{
self.hearbeatwait = 0,3;
continue;
}
else if ( level.healthregendisabled && getTime() > player.breathingstoptime )
{
self.hearbeatwait = 0,3;
continue;
}
else
{
player playlocalsound( "mpl_player_heartbeat" );
wait self.hearbeatwait;
if ( self.hearbeatwait <= 0,6 )
{
self.hearbeatwait += 0,1;
}
}
}
}

556
zm_transit_dr_patch/maps/mp/gametypes_zm/_hostmigration.gsc Normal file
View File

@ -0,0 +1,556 @@
#include maps/mp/zombies/_zm;
#include maps/mp/gametypes_zm/_hud;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/gametypes_zm/_hud_util;
#include common_scripts/utility;
#include maps/mp/_utility;
debug_script_structs()
{
/#
if ( isDefined( level.struct ) )
{
println( "*** Num structs " + level.struct.size );
println( "" );
i = 0;
while ( i < level.struct.size )
{
struct = level.struct[ i ];
if ( isDefined( struct.targetname ) )
{
println( "---" + i + " : " + struct.targetname );
i++;
continue;
}
else
{
println( "---" + i + " : " + "NONE" );
}
i++;
}
}
else println( "*** No structs defined." );
#/
}
updatetimerpausedness()
{
shouldbestopped = isDefined( level.hostmigrationtimer );
if ( !level.timerstopped && shouldbestopped )
{
level.timerstopped = 1;
level.timerpausetime = getTime();
}
else
{
if ( level.timerstopped && !shouldbestopped )
{
level.timerstopped = 0;
level.discardtime += getTime() - level.timerpausetime;
}
}
}
callback_hostmigrationsave()
{
}
callback_prehostmigrationsave()
{
undo_link_changes();
disablezombies( 1 );
if ( is_true( level._hm_should_pause_spawning ) )
{
flag_set( "spawn_zombies" );
}
i = 0;
while ( i < level.players.size )
{
level.players[ i ] enableinvulnerability();
i++;
}
}
pausetimer()
{
level.migrationtimerpausetime = getTime();
}
resumetimer()
{
level.discardtime += getTime() - level.migrationtimerpausetime;
}
locktimer()
{
level endon( "host_migration_begin" );
level endon( "host_migration_end" );
for ( ;; )
{
currtime = getTime();
wait 0,05;
if ( !level.timerstopped && isDefined( level.discardtime ) )
{
level.discardtime += getTime() - currtime;
}
}
}
callback_hostmigration()
{
redo_link_changes();
setslowmotion( 1, 1, 0 );
makedvarserverinfo( "ui_guncycle", 0 );
level.hostmigrationreturnedplayercount = 0;
if ( level.gameended )
{
/#
println( "Migration starting at time " + getTime() + ", but game has ended, so no countdown." );
#/
return;
}
sethostmigrationstatus( 1 );
level notify( "host_migration_begin" );
i = 0;
while ( i < level.players.size )
{
if ( isDefined( level.hostmigration_link_entity_callback ) )
{
if ( !isDefined( level.players[ i ]._host_migration_link_entity ) )
{
level.players[ i ]._host_migration_link_entity = level.players[ i ] [[ level.hostmigration_link_entity_callback ]]();
}
}
level.players[ i ] thread hostmigrationtimerthink();
i++;
}
while ( isDefined( level.hostmigration_ai_link_entity_callback ) )
{
zombies = getaiarray( level.zombie_team );
while ( isDefined( zombies ) && zombies.size > 0 )
{
_a133 = zombies;
_k133 = getFirstArrayKey( _a133 );
while ( isDefined( _k133 ) )
{
zombie = _a133[ _k133 ];
if ( !isDefined( zombie._host_migration_link_entity ) )
{
zombie._host_migration_link_entity = zombie [[ level.hostmigration_ai_link_entity_callback ]]();
}
_k133 = getNextArrayKey( _a133, _k133 );
}
}
}
if ( level.inprematchperiod )
{
level waittill( "prematch_over" );
}
/#
println( "Migration starting at time " + getTime() );
#/
level.hostmigrationtimer = 1;
thread locktimer();
zombies = getaiarray( level.zombie_team );
while ( isDefined( zombies ) && zombies.size > 0 )
{
_a156 = zombies;
_k156 = getFirstArrayKey( _a156 );
while ( isDefined( _k156 ) )
{
zombie = _a156[ _k156 ];
if ( isDefined( zombie._host_migration_link_entity ) )
{
ent = spawn( "script_origin", zombie.origin );
ent.angles = zombie.angles;
zombie linkto( ent );
ent linkto( zombie._host_migration_link_entity, "tag_origin", zombie._host_migration_link_entity worldtolocalcoords( ent.origin ), ent.angles + zombie._host_migration_link_entity.angles );
zombie._host_migration_link_helper = ent;
zombie linkto( zombie._host_migration_link_helper );
}
_k156 = getNextArrayKey( _a156, _k156 );
}
}
level endon( "host_migration_begin" );
level._hm_should_pause_spawning = flag( "spawn_zombies" );
if ( level._hm_should_pause_spawning )
{
flag_clear( "spawn_zombies" );
}
hostmigrationwait();
_a185 = level.players;
_k185 = getFirstArrayKey( _a185 );
while ( isDefined( _k185 ) )
{
player = _a185[ _k185 ];
player thread post_migration_become_vulnerable();
_k185 = getNextArrayKey( _a185, _k185 );
}
zombies = getaiarray( level.zombie_team );
while ( isDefined( zombies ) && zombies.size > 0 )
{
_a193 = zombies;
_k193 = getFirstArrayKey( _a193 );
while ( isDefined( _k193 ) )
{
zombie = _a193[ _k193 ];
if ( isDefined( zombie._host_migration_link_entity ) )
{
zombie unlink();
zombie._host_migration_link_helper delete();
zombie._host_migration_link_helper = undefined;
zombie._host_migration_link_entity = undefined;
}
_k193 = getNextArrayKey( _a193, _k193 );
}
}
enablezombies( 1 );
if ( level._hm_should_pause_spawning )
{
flag_set( "spawn_zombies" );
}
level.hostmigrationtimer = undefined;
level._hm_should_pause_spawning = undefined;
sethostmigrationstatus( 0 );
/#
println( "Migration finished at time " + getTime() );
#/
level notify( "host_migration_end" );
}
post_migration_become_vulnerable()
{
self endon( "disconnect" );
wait 3;
self disableinvulnerability();
}
matchstarttimerconsole_internal( counttime, matchstarttimer )
{
waittillframeend;
visionsetnaked( "mpIntro", 0 );
level endon( "match_start_timer_beginning" );
while ( counttime > 0 && !level.gameended )
{
matchstarttimer thread maps/mp/gametypes_zm/_hud::fontpulse( level );
wait ( matchstarttimer.inframes * 0,05 );
matchstarttimer setvalue( counttime );
if ( counttime == 2 )
{
visionsetnaked( getDvar( "mapname" ), 3 );
}
counttime--;
wait ( 1 - ( matchstarttimer.inframes * 0,05 ) );
}
}
matchstarttimerconsole( type, duration )
{
level notify( "match_start_timer_beginning" );
wait 0,05;
matchstarttext = createserverfontstring( "objective", 1,5 );
matchstarttext setpoint( "CENTER", "CENTER", 0, -40 );
matchstarttext.sort = 1001;
matchstarttext settext( game[ "strings" ][ "waiting_for_teams" ] );
matchstarttext.foreground = 0;
matchstarttext.hidewheninmenu = 1;
matchstarttext settext( game[ "strings" ][ type ] );
matchstarttimer = createserverfontstring( "objective", 2,2 );
matchstarttimer setpoint( "CENTER", "CENTER", 0, 0 );
matchstarttimer.sort = 1001;
matchstarttimer.color = ( 1, 1, 0 );
matchstarttimer.foreground = 0;
matchstarttimer.hidewheninmenu = 1;
matchstarttimer maps/mp/gametypes_zm/_hud::fontpulseinit();
counttime = int( duration );
if ( counttime >= 2 )
{
matchstarttimerconsole_internal( counttime, matchstarttimer );
visionsetnaked( getDvar( "mapname" ), 3 );
}
else
{
visionsetnaked( "mpIntro", 0 );
visionsetnaked( getDvar( "mapname" ), 1 );
}
matchstarttimer destroyelem();
matchstarttext destroyelem();
}
hostmigrationwait()
{
level endon( "game_ended" );
if ( level.hostmigrationreturnedplayercount < ( ( level.players.size * 2 ) / 3 ) )
{
thread matchstarttimerconsole( "waiting_for_teams", 20 );
hostmigrationwaitforplayers();
}
thread matchstarttimerconsole( "match_starting_in", 5 );
wait 5;
}
hostmigrationwaitforplayers()
{
level endon( "hostmigration_enoughplayers" );
wait 15;
}
hostmigrationtimerthink_internal()
{
level endon( "host_migration_begin" );
level endon( "host_migration_end" );
self.hostmigrationcontrolsfrozen = 0;
while ( !isalive( self ) )
{
self waittill( "spawned" );
}
if ( isDefined( self._host_migration_link_entity ) )
{
ent = spawn( "script_origin", self.origin );
ent.angles = self.angles;
self linkto( ent );
ent linkto( self._host_migration_link_entity, "tag_origin", self._host_migration_link_entity worldtolocalcoords( ent.origin ), ent.angles + self._host_migration_link_entity.angles );
self._host_migration_link_helper = ent;
/#
println( "Linking player to ent " + self._host_migration_link_entity.targetname );
#/
}
self.hostmigrationcontrolsfrozen = 1;
self freezecontrols( 1 );
level waittill( "host_migration_end" );
}
hostmigrationtimerthink()
{
self endon( "disconnect" );
level endon( "host_migration_begin" );
hostmigrationtimerthink_internal();
if ( self.hostmigrationcontrolsfrozen )
{
self freezecontrols( 0 );
/#
println( " Host migration unfreeze controls" );
#/
}
if ( isDefined( self._host_migration_link_entity ) )
{
self unlink();
self._host_migration_link_helper delete();
self._host_migration_link_helper = undefined;
if ( isDefined( self._host_migration_link_entity._post_host_migration_thread ) )
{
self thread [[ self._host_migration_link_entity._post_host_migration_thread ]]( self._host_migration_link_entity );
}
self._host_migration_link_entity = undefined;
}
}
waittillhostmigrationdone()
{
if ( !isDefined( level.hostmigrationtimer ) )
{
return 0;
}
starttime = getTime();
level waittill( "host_migration_end" );
return getTime() - starttime;
}
waittillhostmigrationstarts( duration )
{
if ( isDefined( level.hostmigrationtimer ) )
{
return;
}
level endon( "host_migration_begin" );
wait duration;
}
waitlongdurationwithhostmigrationpause( duration )
{
if ( duration == 0 )
{
return;
}
/#
assert( duration > 0 );
#/
starttime = getTime();
endtime = getTime() + ( duration * 1000 );
while ( getTime() < endtime )
{
waittillhostmigrationstarts( ( endtime - getTime() ) / 1000 );
if ( isDefined( level.hostmigrationtimer ) )
{
timepassed = waittillhostmigrationdone();
endtime += timepassed;
}
}
if ( getTime() != endtime )
{
/#
println( "SCRIPT WARNING: gettime() = " + getTime() + " NOT EQUAL TO endtime = " + endtime );
#/
}
waittillhostmigrationdone();
return getTime() - starttime;
}
waitlongdurationwithgameendtimeupdate( duration )
{
if ( duration == 0 )
{
return;
}
/#
assert( duration > 0 );
#/
starttime = getTime();
endtime = getTime() + ( duration * 1000 );
while ( getTime() < endtime )
{
waittillhostmigrationstarts( ( endtime - getTime() ) / 1000 );
while ( isDefined( level.hostmigrationtimer ) )
{
endtime += 1000;
setgameendtime( int( endtime ) );
wait 1;
}
}
/#
if ( getTime() != endtime )
{
println( "SCRIPT WARNING: gettime() = " + getTime() + " NOT EQUAL TO endtime = " + endtime );
#/
}
while ( isDefined( level.hostmigrationtimer ) )
{
endtime += 1000;
setgameendtime( int( endtime ) );
wait 1;
}
return getTime() - starttime;
}
find_alternate_player_place( v_origin, min_radius, max_radius, max_height, ignore_targetted_nodes )
{
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--;
}
}
}
return found_node;
}
hostmigration_put_player_in_better_place()
{
spawnpoint = undefined;
spawnpoint = find_alternate_player_place( self.origin, 50, 150, 64, 1 );
if ( !isDefined( spawnpoint ) )
{
spawnpoint = find_alternate_player_place( self.origin, 150, 400, 64, 1 );
}
if ( !isDefined( spawnpoint ) )
{
spawnpoint = find_alternate_player_place( self.origin, 50, 400, 256, 0 );
}
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 ) )
{
_a558 = structs;
_k558 = getFirstArrayKey( _a558 );
while ( isDefined( _k558 ) )
{
struct = _a558[ _k558 ];
while ( isDefined( struct.script_string ) )
{
tokens = strtok( struct.script_string, " " );
_a564 = tokens;
_k564 = getFirstArrayKey( _a564 );
while ( isDefined( _k564 ) )
{
token = _a564[ _k564 ];
if ( token == match_string )
{
spawnpoints[ spawnpoints.size ] = struct;
}
_k564 = getNextArrayKey( _a564, _k564 );
}
}
_k558 = getNextArrayKey( _a558, _k558 );
}
}
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 );
}
if ( isDefined( spawnpoint ) )
{
self setorigin( spawnpoint.origin );
}
}

163
zm_transit_dr_patch/maps/mp/gametypes_zm/_hud.gsc Normal file
View File

@ -0,0 +1,163 @@
init()
{
precacheshader( "progress_bar_bg" );
precacheshader( "progress_bar_fg" );
precacheshader( "progress_bar_fill" );
precacheshader( "score_bar_bg" );
level.uiparent = spawnstruct();
level.uiparent.horzalign = "left";
level.uiparent.vertalign = "top";
level.uiparent.alignx = "left";
level.uiparent.aligny = "top";
level.uiparent.x = 0;
level.uiparent.y = 0;
level.uiparent.width = 0;
level.uiparent.height = 0;
level.uiparent.children = [];
level.fontheight = 12;
_a103 = level.teams;
_k103 = getFirstArrayKey( _a103 );
while ( isDefined( _k103 ) )
{
team = _a103[ _k103 ];
level.hud[ team ] = spawnstruct();
_k103 = getNextArrayKey( _a103, _k103 );
}
level.primaryprogressbary = -61;
level.primaryprogressbarx = 0;
level.primaryprogressbarheight = 9;
level.primaryprogressbarwidth = 120;
level.primaryprogressbartexty = -75;
level.primaryprogressbartextx = 0;
level.primaryprogressbarfontsize = 1,4;
level.primaryprogressbarx_ss = 20;
level.primaryprogressbartextx_ss = 20;
level.primaryprogressbary_ss = 30;
level.primaryprogressbartexty_ss = 33;
level.primaryprogressbarheight_ss = 2;
level.secondaryprogressbary = -85;
level.secondaryprogressbarx = 0;
level.secondaryprogressbarheight = 9;
level.secondaryprogressbarwidth = 120;
level.secondaryprogressbartexty = -100;
level.secondaryprogressbartextx = 0;
level.secondaryprogressbarfontsize = 1,4;
level.secondaryprogressbarx_ss = 20;
level.secondaryprogressbartextx_ss = 20;
level.secondaryprogressbary_ss = 15;
level.secondaryprogressbartexty_ss = 0;
level.secondaryprogressbarheight_ss = 2;
level.teamprogressbary = 32;
level.teamprogressbarheight = 14;
level.teamprogressbarwidth = 192;
level.teamprogressbartexty = 8;
level.teamprogressbarfontsize = 1,65;
setdvar( "ui_generic_status_bar", 0 );
level.lowertextyalign = "BOTTOM";
level.lowertexty = -42;
level.lowertextfontsize = 1,4;
level.lowertextyalign_ss = "CENTER";
level.lowertexty_ss = 40;
level.lowertextfontsize_ss = 1,4;
}
fontpulseinit()
{
self.basefontscale = self.fontscale;
self.maxfontscale = self.fontscale * 2;
self.inframes = 1,5;
self.outframes = 3;
}
fontpulse( player )
{
self notify( "fontPulse" );
self endon( "fontPulse" );
self endon( "death" );
player endon( "disconnect" );
player endon( "joined_team" );
player endon( "joined_spectators" );
if ( self.outframes == 0 )
{
self.fontscale = 0,01;
}
else
{
self.fontscale = self.fontscale;
}
if ( self.inframes > 0 )
{
self changefontscaleovertime( self.inframes * 0,05 );
self.fontscale = self.maxfontscale;
wait ( self.inframes * 0,05 );
}
else
{
self.fontscale = self.maxfontscale;
self.alpha = 0;
self fadeovertime( self.outframes * 0,05 );
self.alpha = 1;
}
if ( self.outframes > 0 )
{
self changefontscaleovertime( self.outframes * 0,05 );
self.fontscale = self.basefontscale;
}
}
fadetoblackforxsec( startwait, blackscreenwait, fadeintime, fadeouttime, shadername )
{
wait startwait;
if ( !isDefined( self ) )
{
return;
}
if ( !isDefined( self.blackscreen ) )
{
self.blackscreen = newclienthudelem( self );
}
self.blackscreen.x = 0;
self.blackscreen.y = 0;
self.blackscreen.horzalign = "fullscreen";
self.blackscreen.vertalign = "fullscreen";
self.blackscreen.foreground = 0;
self.blackscreen.hidewhendead = 0;
self.blackscreen.hidewheninmenu = 1;
self.blackscreen.sort = 50;
if ( isDefined( shadername ) )
{
self.blackscreen setshader( shadername, 640, 480 );
}
else
{
self.blackscreen setshader( "black", 640, 480 );
}
self.blackscreen.alpha = 0;
if ( fadeintime > 0 )
{
self.blackscreen fadeovertime( fadeintime );
}
self.blackscreen.alpha = 1;
wait fadeintime;
if ( !isDefined( self.blackscreen ) )
{
return;
}
wait blackscreenwait;
if ( !isDefined( self.blackscreen ) )
{
return;
}
if ( fadeouttime > 0 )
{
self.blackscreen fadeovertime( fadeouttime );
}
self.blackscreen.alpha = 0;
wait fadeouttime;
if ( isDefined( self.blackscreen ) )
{
self.blackscreen destroy();
self.blackscreen = undefined;
}
}

1359
zm_transit_dr_patch/maps/mp/gametypes_zm/_hud_message.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

1152
zm_transit_dr_patch/maps/mp/gametypes_zm/_hud_util.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

175
zm_transit_dr_patch/maps/mp/gametypes_zm/_menus.gsc Normal file
View File

@ -0,0 +1,175 @@
#include maps/mp/gametypes_zm/_rank;
#include maps/mp/gametypes_zm/_globallogic;
#include maps/mp/_utility;
init()
{
precachestring( &"open_ingame_menu" );
game[ "menu_team" ] = "team_marinesopfor";
game[ "menu_initteam_allies" ] = "initteam_marines";
game[ "menu_initteam_axis" ] = "initteam_opfor";
game[ "menu_class" ] = "class";
game[ "menu_changeclass" ] = "changeclass";
game[ "menu_changeclass_offline" ] = "changeclass";
game[ "menu_wager_side_bet" ] = "sidebet";
game[ "menu_wager_side_bet_player" ] = "sidebet_player";
game[ "menu_changeclass_wager" ] = "changeclass_wager";
game[ "menu_changeclass_custom" ] = "changeclass_custom";
game[ "menu_changeclass_barebones" ] = "changeclass_barebones";
_a18 = level.teams;
_k18 = getFirstArrayKey( _a18 );
while ( isDefined( _k18 ) )
{
team = _a18[ _k18 ];
game[ "menu_changeclass_" + team ] = "changeclass";
_k18 = getNextArrayKey( _a18, _k18 );
}
game[ "menu_controls" ] = "ingame_controls";
game[ "menu_options" ] = "ingame_options";
game[ "menu_leavegame" ] = "popup_leavegame";
precachemenu( game[ "menu_controls" ] );
precachemenu( game[ "menu_options" ] );
precachemenu( game[ "menu_leavegame" ] );
precachemenu( "scoreboard" );
precachemenu( "spectate" );
precachemenu( game[ "menu_team" ] );
precachemenu( game[ "menu_changeclass_allies" ] );
precachemenu( game[ "menu_initteam_allies" ] );
precachemenu( game[ "menu_changeclass_axis" ] );
precachemenu( game[ "menu_class" ] );
precachemenu( game[ "menu_changeclass" ] );
precachemenu( game[ "menu_initteam_axis" ] );
precachemenu( game[ "menu_changeclass_offline" ] );
precachemenu( game[ "menu_changeclass_wager" ] );
precachemenu( game[ "menu_changeclass_custom" ] );
precachemenu( game[ "menu_changeclass_barebones" ] );
precachemenu( game[ "menu_wager_side_bet" ] );
precachemenu( game[ "menu_wager_side_bet_player" ] );
precachestring( &"MP_HOST_ENDED_GAME" );
precachestring( &"MP_HOST_ENDGAME_RESPONSE" );
level thread onplayerconnect();
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player thread onmenuresponse();
}
}
onmenuresponse()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "menuresponse", menu, response );
if ( response == "back" )
{
self closemenu();
self closeingamemenu();
if ( level.console )
{
if ( game[ "menu_changeclass" ] != menu && game[ "menu_changeclass_offline" ] != menu || menu == game[ "menu_team" ] && menu == game[ "menu_controls" ] )
{
if ( isDefined( level.teams[ self.pers[ "team" ] ] ) )
{
self openmenu( game[ "menu_class" ] );
}
}
}
continue;
}
else if ( response == "changeteam" && level.allow_teamchange == "1" )
{
self closemenu();
self closeingamemenu();
self openmenu( game[ "menu_team" ] );
}
if ( response == "changeclass_marines_splitscreen" )
{
self openmenu( "changeclass_marines_splitscreen" );
}
if ( response == "changeclass_opfor_splitscreen" )
{
self openmenu( "changeclass_opfor_splitscreen" );
}
if ( response == "endgame" )
{
if ( self issplitscreen() )
{
level.skipvote = 1;
if ( !level.gameended )
{
level thread maps/mp/gametypes_zm/_globallogic::forceend();
}
}
continue;
}
else if ( response == "killserverpc" )
{
level thread maps/mp/gametypes_zm/_globallogic::killserverpc();
continue;
}
else if ( response == "endround" )
{
if ( !level.gameended )
{
level thread maps/mp/gametypes_zm/_globallogic::forceend();
}
else
{
self closemenu();
self closeingamemenu();
self iprintln( &"MP_HOST_ENDGAME_RESPONSE" );
}
continue;
}
else if ( menu == game[ "menu_team" ] && level.allow_teamchange == "1" )
{
switch( response )
{
case "autoassign":
self [[ level.autoassign ]]( 1 );
break;
case "spectator":
self [[ level.spectator ]]();
break;
default:
self [[ level.teammenu ]]( response );
break;
}
continue;
}
else
{
if ( game[ "menu_changeclass" ] != menu && game[ "menu_changeclass_offline" ] != menu && game[ "menu_changeclass_wager" ] != menu || menu == game[ "menu_changeclass_custom" ] && menu == game[ "menu_changeclass_barebones" ] )
{
self closemenu();
self closeingamemenu();
if ( level.rankedmatch && issubstr( response, "custom" ) )
{
if ( self isitemlocked( maps/mp/gametypes_zm/_rank::getitemindex( "feature_cac" ) ) )
{
kick( self getentitynumber() );
}
}
self.selectedclass = 1;
self [[ level.class ]]( response );
break;
}
else
{
if ( menu == "spectate" )
{
player = getplayerfromclientnum( int( response ) );
if ( isDefined( player ) )
{
self setcurrentspectatorclient( player );
}
}
}
}
}
}

196
zm_transit_dr_patch/maps/mp/gametypes_zm/_perplayer.gsc Normal file
View File

@ -0,0 +1,196 @@
#include maps/mp/_utility;
init( id, playerbegincallback, playerendcallback )
{
precacheshader( "objpoint_default" );
handler = spawnstruct();
handler.id = id;
handler.playerbegincallback = playerbegincallback;
handler.playerendcallback = playerendcallback;
handler.enabled = 0;
handler.players = [];
thread onplayerconnect( handler );
level.handlerglobalflagval = 0;
return handler;
}
enable( handler )
{
if ( handler.enabled )
{
return;
}
handler.enabled = 1;
level.handlerglobalflagval++;
players = get_players();
i = 0;
while ( i < players.size )
{
players[ i ].handlerflagval = level.handlerglobalflagval;
i++;
}
players = handler.players;
i = 0;
while ( i < players.size )
{
if ( players[ i ].handlerflagval != level.handlerglobalflagval )
{
i++;
continue;
}
else
{
if ( players[ i ].handlers[ handler.id ].ready )
{
players[ i ] handleplayer( handler );
}
}
i++;
}
}
disable( handler )
{
if ( !handler.enabled )
{
return;
}
handler.enabled = 0;
level.handlerglobalflagval++;
players = get_players();
i = 0;
while ( i < players.size )
{
players[ i ].handlerflagval = level.handlerglobalflagval;
i++;
}
players = handler.players;
i = 0;
while ( i < players.size )
{
if ( players[ i ].handlerflagval != level.handlerglobalflagval )
{
i++;
continue;
}
else
{
if ( players[ i ].handlers[ handler.id ].ready )
{
players[ i ] unhandleplayer( handler, 0, 0 );
}
}
i++;
}
}
onplayerconnect( handler )
{
for ( ;; )
{
level waittill( "connecting", player );
if ( !isDefined( player.handlers ) )
{
player.handlers = [];
}
player.handlers[ handler.id ] = spawnstruct();
player.handlers[ handler.id ].ready = 0;
player.handlers[ handler.id ].handled = 0;
player.handlerflagval = -1;
handler.players[ handler.players.size ] = player;
player thread onplayerdisconnect( handler );
player thread onplayerspawned( handler );
player thread onjoinedteam( handler );
player thread onjoinedspectators( handler );
player thread onplayerkilled( handler );
}
}
onplayerdisconnect( handler )
{
self waittill( "disconnect" );
newplayers = [];
i = 0;
while ( i < handler.players.size )
{
if ( handler.players[ i ] != self )
{
newplayers[ newplayers.size ] = handler.players[ i ];
}
i++;
}
handler.players = newplayers;
self thread unhandleplayer( handler, 1, 1 );
}
onjoinedteam( handler )
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "joined_team" );
self thread unhandleplayer( handler, 1, 0 );
}
}
onjoinedspectators( handler )
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "joined_spectators" );
self thread unhandleplayer( handler, 1, 0 );
}
}
onplayerspawned( handler )
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "spawned_player" );
self thread handleplayer( handler );
}
}
onplayerkilled( handler )
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "killed_player" );
self thread unhandleplayer( handler, 1, 0 );
}
}
handleplayer( handler )
{
self.handlers[ handler.id ].ready = 1;
if ( !handler.enabled )
{
return;
}
if ( self.handlers[ handler.id ].handled )
{
return;
}
self.handlers[ handler.id ].handled = 1;
self thread [[ handler.playerbegincallback ]]();
}
unhandleplayer( handler, unsetready, disconnected )
{
if ( !disconnected && unsetready )
{
self.handlers[ handler.id ].ready = 0;
}
if ( !self.handlers[ handler.id ].handled )
{
return;
}
if ( !disconnected )
{
self.handlers[ handler.id ].handled = 0;
}
self thread [[ handler.playerendcallback ]]( disconnected );
}

25
zm_transit_dr_patch/maps/mp/gametypes_zm/_scoreboard.gsc Normal file
View File

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

207
zm_transit_dr_patch/maps/mp/gametypes_zm/_serversettings.gsc Normal file
View File

@ -0,0 +1,207 @@
init()
{
level.hostname = getDvar( "sv_hostname" );
if ( level.hostname == "" )
{
level.hostname = "CoDHost";
}
setdvar( "sv_hostname", level.hostname );
setdvar( "ui_hostname", level.hostname );
makedvarserverinfo( "ui_hostname", "CoDHost" );
level.motd = getDvar( "scr_motd" );
if ( level.motd == "" )
{
level.motd = "";
}
setdvar( "scr_motd", level.motd );
setdvar( "ui_motd", level.motd );
makedvarserverinfo( "ui_motd", "" );
level.allowvote = getDvar( "g_allowVote" );
if ( level.allowvote == "" )
{
level.allowvote = "1";
}
setdvar( "g_allowvote", level.allowvote );
setdvar( "ui_allowvote", level.allowvote );
makedvarserverinfo( "ui_allowvote", "1" );
level.allow_teamchange = "0";
if ( sessionmodeisprivate() || !sessionmodeisonlinegame() )
{
level.allow_teamchange = "1";
}
setdvar( "ui_allow_teamchange", level.allow_teamchange );
level.friendlyfire = getgametypesetting( "friendlyfiretype" );
setdvar( "ui_friendlyfire", level.friendlyfire );
makedvarserverinfo( "ui_friendlyfire", "0" );
if ( getDvar( "scr_mapsize" ) == "" )
{
setdvar( "scr_mapsize", "64" );
}
else if ( getDvarFloat( "scr_mapsize" ) >= 64 )
{
setdvar( "scr_mapsize", "64" );
}
else if ( getDvarFloat( "scr_mapsize" ) >= 32 )
{
setdvar( "scr_mapsize", "32" );
}
else if ( getDvarFloat( "scr_mapsize" ) >= 16 )
{
setdvar( "scr_mapsize", "16" );
}
else
{
setdvar( "scr_mapsize", "8" );
}
level.mapsize = getDvarFloat( "scr_mapsize" );
constraingametype( getDvar( "g_gametype" ) );
constrainmapsize( level.mapsize );
for ( ;; )
{
updateserversettings();
wait 5;
}
}
updateserversettings()
{
sv_hostname = getDvar( "sv_hostname" );
if ( level.hostname != sv_hostname )
{
level.hostname = sv_hostname;
setdvar( "ui_hostname", level.hostname );
}
scr_motd = getDvar( "scr_motd" );
if ( level.motd != scr_motd )
{
level.motd = scr_motd;
setdvar( "ui_motd", level.motd );
}
g_allowvote = getDvar( "g_allowVote" );
if ( level.allowvote != g_allowvote )
{
level.allowvote = g_allowvote;
setdvar( "ui_allowvote", level.allowvote );
}
scr_friendlyfire = getgametypesetting( "friendlyfiretype" );
if ( level.friendlyfire != scr_friendlyfire )
{
level.friendlyfire = scr_friendlyfire;
setdvar( "ui_friendlyfire", level.friendlyfire );
}
}
constraingametype( gametype )
{
entities = getentarray();
i = 0;
while ( i < entities.size )
{
entity = entities[ i ];
if ( gametype == "dm" )
{
if ( isDefined( entity.script_gametype_dm ) && entity.script_gametype_dm != "1" )
{
entity delete();
}
i++;
continue;
}
else if ( gametype == "tdm" )
{
if ( isDefined( entity.script_gametype_tdm ) && entity.script_gametype_tdm != "1" )
{
entity delete();
}
i++;
continue;
}
else if ( gametype == "ctf" )
{
if ( isDefined( entity.script_gametype_ctf ) && entity.script_gametype_ctf != "1" )
{
entity delete();
}
i++;
continue;
}
else if ( gametype == "hq" )
{
if ( isDefined( entity.script_gametype_hq ) && entity.script_gametype_hq != "1" )
{
entity delete();
}
i++;
continue;
}
else if ( gametype == "sd" )
{
if ( isDefined( entity.script_gametype_sd ) && entity.script_gametype_sd != "1" )
{
entity delete();
}
i++;
continue;
}
else
{
if ( gametype == "koth" )
{
if ( isDefined( entity.script_gametype_koth ) && entity.script_gametype_koth != "1" )
{
entity delete();
}
}
}
i++;
}
}
constrainmapsize( mapsize )
{
entities = getentarray();
i = 0;
while ( i < entities.size )
{
entity = entities[ i ];
if ( int( mapsize ) == 8 )
{
if ( isDefined( entity.script_mapsize_08 ) && entity.script_mapsize_08 != "1" )
{
entity delete();
}
i++;
continue;
}
else if ( int( mapsize ) == 16 )
{
if ( isDefined( entity.script_mapsize_16 ) && entity.script_mapsize_16 != "1" )
{
entity delete();
}
i++;
continue;
}
else if ( int( mapsize ) == 32 )
{
if ( isDefined( entity.script_mapsize_32 ) && entity.script_mapsize_32 != "1" )
{
entity delete();
}
i++;
continue;
}
else
{
if ( int( mapsize ) == 64 )
{
if ( isDefined( entity.script_mapsize_64 ) && entity.script_mapsize_64 != "1" )
{
entity delete();
}
}
}
i++;
}
}

64
zm_transit_dr_patch/maps/mp/gametypes_zm/_shellshock.gsc Normal file
View File

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

1073
zm_transit_dr_patch/maps/mp/gametypes_zm/_spawning.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

2496
zm_transit_dr_patch/maps/mp/gametypes_zm/_spawnlogic.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

276
zm_transit_dr_patch/maps/mp/gametypes_zm/_spectating.gsc Normal file
View File

@ -0,0 +1,276 @@
init()
{
_a3 = level.teams;
_k3 = getFirstArrayKey( _a3 );
while ( isDefined( _k3 ) )
{
team = _a3[ _k3 ];
level.spectateoverride[ team ] = spawnstruct();
_k3 = getNextArrayKey( _a3, _k3 );
}
level thread onplayerconnect();
}
onplayerconnect()
{
for ( ;; )
{
level waittill( "connecting", player );
player thread onjoinedteam();
player thread onjoinedspectators();
player thread onplayerspawned();
}
}
onplayerspawned()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "spawned_player" );
self setspectatepermissions();
}
}
onjoinedteam()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "joined_team" );
self setspectatepermissionsformachine();
}
}
onjoinedspectators()
{
self endon( "disconnect" );
for ( ;; )
{
self waittill( "joined_spectators" );
self setspectatepermissionsformachine();
}
}
updatespectatesettings()
{
level endon( "game_ended" );
index = 0;
while ( index < level.players.size )
{
level.players[ index ] setspectatepermissions();
index++;
}
}
getsplitscreenteam()
{
index = 0;
while ( index < level.players.size )
{
if ( !isDefined( level.players[ index ] ) )
{
index++;
continue;
}
else if ( level.players[ index ] == self )
{
index++;
continue;
}
else if ( !self isplayeronsamemachine( level.players[ index ] ) )
{
index++;
continue;
}
else
{
team = level.players[ index ].sessionteam;
if ( team != "spectator" )
{
return team;
}
}
index++;
}
return self.sessionteam;
}
otherlocalplayerstillalive()
{
index = 0;
while ( index < level.players.size )
{
if ( !isDefined( level.players[ index ] ) )
{
index++;
continue;
}
else if ( level.players[ index ] == self )
{
index++;
continue;
}
else if ( !self isplayeronsamemachine( level.players[ index ] ) )
{
index++;
continue;
}
else
{
if ( isalive( level.players[ index ] ) )
{
return 1;
}
}
index++;
}
return 0;
}
allowspectateallteams( allow )
{
_a114 = level.teams;
_k114 = getFirstArrayKey( _a114 );
while ( isDefined( _k114 ) )
{
team = _a114[ _k114 ];
self allowspectateteam( team, allow );
_k114 = getNextArrayKey( _a114, _k114 );
}
}
allowspectateallteamsexceptteam( skip_team, allow )
{
_a122 = level.teams;
_k122 = getFirstArrayKey( _a122 );
while ( isDefined( _k122 ) )
{
team = _a122[ _k122 ];
if ( team == skip_team )
{
}
else
{
self allowspectateteam( team, allow );
}
_k122 = getNextArrayKey( _a122, _k122 );
}
}
setspectatepermissions()
{
team = self.sessionteam;
if ( team == "spectator" )
{
if ( self issplitscreen() && !level.splitscreen )
{
team = getsplitscreenteam();
}
if ( team == "spectator" )
{
self allowspectateallteams( 1 );
self allowspectateteam( "freelook", 0 );
self allowspectateteam( "none", 1 );
self allowspectateteam( "localplayers", 1 );
return;
}
}
spectatetype = level.spectatetype;
switch( spectatetype )
{
case 0:
self allowspectateallteams( 0 );
self allowspectateteam( "freelook", 0 );
self allowspectateteam( "none", 1 );
self allowspectateteam( "localplayers", 0 );
break;
case 3:
if ( self issplitscreen() && self otherlocalplayerstillalive() )
{
self allowspectateallteams( 0 );
self allowspectateteam( "none", 0 );
self allowspectateteam( "freelook", 0 );
self allowspectateteam( "localplayers", 1 );
break;
}
else
{
case 1:
if ( !level.teambased )
{
self allowspectateallteams( 1 );
self allowspectateteam( "none", 1 );
self allowspectateteam( "freelook", 0 );
self allowspectateteam( "localplayers", 1 );
}
else if ( isDefined( team ) && isDefined( level.teams[ team ] ) )
{
self allowspectateteam( team, 1 );
self allowspectateallteamsexceptteam( team, 0 );
self allowspectateteam( "freelook", 0 );
self allowspectateteam( "none", 0 );
self allowspectateteam( "localplayers", 1 );
}
else
{
self allowspectateallteams( 0 );
self allowspectateteam( "freelook", 0 );
self allowspectateteam( "none", 0 );
self allowspectateteam( "localplayers", 1 );
}
break;
case 2:
self allowspectateallteams( 1 );
self allowspectateteam( "freelook", 1 );
self allowspectateteam( "none", 1 );
self allowspectateteam( "localplayers", 1 );
break;
}
}
if ( isDefined( team ) && isDefined( level.teams[ team ] ) )
{
if ( isDefined( level.spectateoverride[ team ].allowfreespectate ) )
{
self allowspectateteam( "freelook", 1 );
}
if ( isDefined( level.spectateoverride[ team ].allowenemyspectate ) )
{
self allowspectateallteamsexceptteam( team, 1 );
}
}
}
setspectatepermissionsformachine()
{
self setspectatepermissions();
if ( !self issplitscreen() )
{
return;
}
index = 0;
while ( index < level.players.size )
{
if ( !isDefined( level.players[ index ] ) )
{
index++;
continue;
}
else if ( level.players[ index ] == self )
{
index++;
continue;
}
else if ( !self isplayeronsamemachine( level.players[ index ] ) )
{
index++;
continue;
}
else
{
level.players[ index ] setspectatepermissions();
}
index++;
}
}

394
zm_transit_dr_patch/maps/mp/gametypes_zm/_tweakables.gsc Normal file
View File

@ -0,0 +1,394 @@
#include maps/mp/_utility;
gettweakabledvarvalue( category, name )
{
switch( category )
{
case "rule":
dvar = level.rules[ name ].dvar;
break;
case "game":
dvar = level.gametweaks[ name ].dvar;
break;
case "team":
dvar = level.teamtweaks[ name ].dvar;
break;
case "player":
dvar = level.playertweaks[ name ].dvar;
break;
case "class":
dvar = level.classtweaks[ name ].dvar;
break;
case "weapon":
dvar = level.weapontweaks[ name ].dvar;
break;
case "killstreak":
dvar = level.hardpointtweaks[ name ].dvar;
break;
case "hud":
dvar = level.hudtweaks[ name ].dvar;
break;
default:
dvar = undefined;
break;
}
/#
assert( isDefined( dvar ) );
#/
value = getDvarInt( dvar );
return value;
}
gettweakabledvar( category, name )
{
switch( category )
{
case "rule":
value = level.rules[ name ].dvar;
break;
case "game":
value = level.gametweaks[ name ].dvar;
break;
case "team":
value = level.teamtweaks[ name ].dvar;
break;
case "player":
value = level.playertweaks[ name ].dvar;
break;
case "class":
value = level.classtweaks[ name ].dvar;
break;
case "weapon":
value = level.weapontweaks[ name ].dvar;
break;
case "killstreak":
value = level.hardpointtweaks[ name ].dvar;
break;
case "hud":
value = level.hudtweaks[ name ].dvar;
break;
default:
value = undefined;
break;
}
/#
assert( isDefined( value ) );
#/
return value;
}
gettweakablevalue( category, name )
{
switch( category )
{
case "rule":
value = level.rules[ name ].value;
break;
case "game":
value = level.gametweaks[ name ].value;
break;
case "team":
value = level.teamtweaks[ name ].value;
break;
case "player":
value = level.playertweaks[ name ].value;
break;
case "class":
value = level.classtweaks[ name ].value;
break;
case "weapon":
value = level.weapontweaks[ name ].value;
break;
case "killstreak":
value = level.hardpointtweaks[ name ].value;
break;
case "hud":
value = level.hudtweaks[ name ].value;
break;
default:
value = undefined;
break;
}
overridedvar = "scr_" + level.gametype + "_" + category + "_" + name;
if ( getDvar( overridedvar ) != "" )
{
return getDvarInt( overridedvar );
}
/#
assert( isDefined( value ) );
#/
return value;
}
gettweakablelastvalue( category, name )
{
switch( category )
{
case "rule":
value = level.rules[ name ].lastvalue;
break;
case "game":
value = level.gametweaks[ name ].lastvalue;
break;
case "team":
value = level.teamtweaks[ name ].lastvalue;
break;
case "player":
value = level.playertweaks[ name ].lastvalue;
break;
case "class":
value = level.classtweaks[ name ].lastvalue;
break;
case "weapon":
value = level.weapontweaks[ name ].lastvalue;
break;
case "killstreak":
value = level.hardpointtweaks[ name ].lastvalue;
break;
case "hud":
value = level.hudtweaks[ name ].lastvalue;
break;
default:
value = undefined;
break;
}
/#
assert( isDefined( value ) );
#/
return value;
}
settweakablevalue( category, name, value )
{
switch( category )
{
case "rule":
dvar = level.rules[ name ].dvar;
break;
case "game":
dvar = level.gametweaks[ name ].dvar;
break;
case "team":
dvar = level.teamtweaks[ name ].dvar;
break;
case "player":
dvar = level.playertweaks[ name ].dvar;
break;
case "class":
dvar = level.classtweaks[ name ].dvar;
break;
case "weapon":
dvar = level.weapontweaks[ name ].dvar;
break;
case "killstreak":
dvar = level.hardpointtweaks[ name ].dvar;
break;
case "hud":
dvar = level.hudtweaks[ name ].dvar;
break;
default:
dvar = undefined;
break;
}
setdvar( dvar, value );
}
settweakablelastvalue( category, name, value )
{
switch( category )
{
case "rule":
level.rules[ name ].lastvalue = value;
break;
case "game":
level.gametweaks[ name ].lastvalue = value;
break;
case "team":
level.teamtweaks[ name ].lastvalue = value;
break;
case "player":
level.playertweaks[ name ].lastvalue = value;
break;
case "class":
level.classtweaks[ name ].lastvalue = value;
break;
case "weapon":
level.weapontweaks[ name ].lastvalue = value;
break;
case "killstreak":
level.hardpointtweaks[ name ].lastvalue = value;
break;
case "hud":
level.hudtweaks[ name ].lastvalue = value;
break;
default:
}
}
}
registertweakable( category, name, dvar, value )
{
if ( isstring( value ) )
{
if ( getDvar( dvar ) == "" )
{
setdvar( dvar, value );
}
else
{
value = getDvar( dvar );
}
}
else if ( getDvar( dvar ) == "" )
{
setdvar( dvar, value );
}
else
{
value = getDvarInt( dvar );
}
switch( category )
{
case "rule":
if ( !isDefined( level.rules[ name ] ) )
{
level.rules[ name ] = spawnstruct();
}
level.rules[ name ].value = value;
level.rules[ name ].lastvalue = value;
level.rules[ name ].dvar = dvar;
break;
case "game":
if ( !isDefined( level.gametweaks[ name ] ) )
{
level.gametweaks[ name ] = spawnstruct();
}
level.gametweaks[ name ].value = value;
level.gametweaks[ name ].lastvalue = value;
level.gametweaks[ name ].dvar = dvar;
break;
case "team":
if ( !isDefined( level.teamtweaks[ name ] ) )
{
level.teamtweaks[ name ] = spawnstruct();
}
level.teamtweaks[ name ].value = value;
level.teamtweaks[ name ].lastvalue = value;
level.teamtweaks[ name ].dvar = dvar;
break;
case "player":
if ( !isDefined( level.playertweaks[ name ] ) )
{
level.playertweaks[ name ] = spawnstruct();
}
level.playertweaks[ name ].value = value;
level.playertweaks[ name ].lastvalue = value;
level.playertweaks[ name ].dvar = dvar;
break;
case "class":
if ( !isDefined( level.classtweaks[ name ] ) )
{
level.classtweaks[ name ] = spawnstruct();
}
level.classtweaks[ name ].value = value;
level.classtweaks[ name ].lastvalue = value;
level.classtweaks[ name ].dvar = dvar;
break;
case "weapon":
if ( !isDefined( level.weapontweaks[ name ] ) )
{
level.weapontweaks[ name ] = spawnstruct();
}
level.weapontweaks[ name ].value = value;
level.weapontweaks[ name ].lastvalue = value;
level.weapontweaks[ name ].dvar = dvar;
break;
case "killstreak":
if ( !isDefined( level.hardpointtweaks[ name ] ) )
{
level.hardpointtweaks[ name ] = spawnstruct();
}
level.hardpointtweaks[ name ].value = value;
level.hardpointtweaks[ name ].lastvalue = value;
level.hardpointtweaks[ name ].dvar = dvar;
break;
case "hud":
if ( !isDefined( level.hudtweaks[ name ] ) )
{
level.hudtweaks[ name ] = spawnstruct();
}
level.hudtweaks[ name ].value = value;
level.hudtweaks[ name ].lastvalue = value;
level.hudtweaks[ name ].dvar = dvar;
break;
}
}
init()
{
level.clienttweakables = [];
level.tweakablesinitialized = 1;
level.rules = [];
level.gametweaks = [];
level.teamtweaks = [];
level.playertweaks = [];
level.classtweaks = [];
level.weapontweaks = [];
level.hardpointtweaks = [];
level.hudtweaks = [];
registertweakable( "game", "arcadescoring", "scr_game_arcadescoring", 0 );
registertweakable( "game", "difficulty", "scr_game_difficulty", 1 );
registertweakable( "game", "pinups", "scr_game_pinups", 0 );
registertweakable( "team", "teamkillerplaylistbanquantum", "scr_team_teamkillerplaylistbanquantum", 0 );
registertweakable( "team", "teamkillerplaylistbanpenalty", "scr_team_teamkillerplaylistbanpenalty", 0 );
registertweakable( "player", "allowrevive", "scr_player_allowrevive", 1 );
registertweakable( "weapon", "allowfrag", "scr_weapon_allowfrags", 1 );
registertweakable( "weapon", "allowsmoke", "scr_weapon_allowsmoke", 1 );
registertweakable( "weapon", "allowflash", "scr_weapon_allowflash", 1 );
registertweakable( "weapon", "allowc4", "scr_weapon_allowc4", 1 );
registertweakable( "weapon", "allowsatchel", "scr_weapon_allowsatchel", 1 );
registertweakable( "weapon", "allowbetty", "scr_weapon_allowbetty", 1 );
registertweakable( "weapon", "allowrpgs", "scr_weapon_allowrpgs", 1 );
registertweakable( "weapon", "allowmines", "scr_weapon_allowmines", 1 );
registertweakable( "hud", "showobjicons", "ui_hud_showobjicons", 1 );
setclienttweakable( "hud", "showobjicons" );
registertweakable( "killstreak", "allowradar", "scr_hardpoint_allowradar", 1 );
registertweakable( "killstreak", "allowradardirection", "scr_hardpoint_allowradardirection", 1 );
registertweakable( "killstreak", "allowcounteruav", "scr_hardpoint_allowcounteruav", 1 );
registertweakable( "killstreak", "allowdogs", "scr_hardpoint_allowdogs", 1 );
registertweakable( "killstreak", "allowhelicopter_comlink", "scr_hardpoint_allowhelicopter_comlink", 1 );
registertweakable( "killstreak", "allowrcbomb", "scr_hardpoint_allowrcbomb", 1 );
registertweakable( "killstreak", "allowauto_turret", "scr_hardpoint_allowauto_turret", 1 );
level thread updateuitweakables();
}
setclienttweakable( category, name )
{
level.clienttweakables[ level.clienttweakables.size ] = name;
}
updateuitweakables()
{
for ( ;; )
{
index = 0;
while ( index < level.clienttweakables.size )
{
clienttweakable = level.clienttweakables[ index ];
curvalue = gettweakabledvarvalue( "hud", clienttweakable );
lastvalue = gettweakablelastvalue( "hud", clienttweakable );
if ( curvalue != lastvalue )
{
updateserverdvar( gettweakabledvar( "hud", clienttweakable ), curvalue );
settweakablelastvalue( "hud", clienttweakable, curvalue );
}
index++;
}
wait 1;
}
}
updateserverdvar( dvar, value )
{
makedvarserverinfo( dvar, value );
}

119
zm_transit_dr_patch/maps/mp/gametypes_zm/_weapon_utils.gsc Normal file
View File

@ -0,0 +1,119 @@
#include maps/mp/_utility;
#include common_scripts/utility;
isgrenadelauncherweapon( weapon )
{
if ( getsubstr( weapon, 0, 3 ) == "gl_" )
{
return 1;
}
switch( weapon )
{
case "china_lake_mp":
case "xm25_mp":
return 1;
default:
return 0;
}
}
isdumbrocketlauncherweapon( weapon )
{
switch( weapon )
{
case "m220_tow_mp":
case "rpg_mp":
return 1;
default:
return 0;
}
}
isguidedrocketlauncherweapon( weapon )
{
switch( weapon )
{
case "fhj18_mp":
case "javelin_mp":
case "m202_flash_mp":
case "m72_law_mp":
case "smaw_mp":
return 1;
default:
return 0;
}
}
isrocketlauncherweapon( weapon )
{
if ( isdumbrocketlauncherweapon( weapon ) )
{
return 1;
}
if ( isguidedrocketlauncherweapon( weapon ) )
{
return 1;
}
return 0;
}
islauncherweapon( weapon )
{
if ( isrocketlauncherweapon( weapon ) )
{
return 1;
}
if ( isgrenadelauncherweapon( weapon ) )
{
return 1;
}
return 0;
}
isreducedteamkillweapon( weapon )
{
switch( weapon )
{
case "planemortar_mp":
return 1;
default:
return 0;
}
}
ishackweapon( weapon )
{
return 0;
}
ispistol( weapon )
{
return isDefined( level.side_arm_array[ weapon ] );
}
isflashorstunweapon( weapon )
{
if ( isDefined( weapon ) )
{
switch( weapon )
{
case "concussion_grenade_mp":
case "flash_grenade_mp":
case "proximity_grenade_aoe_mp":
case "proximity_grenade_mp":
return 1;
}
}
return 0;
}
isflashorstundamage( weapon, meansofdeath )
{
if ( isflashorstunweapon( weapon ) )
{
if ( meansofdeath != "MOD_GRENADE_SPLASH" )
{
return meansofdeath == "MOD_GAS";
}
}
}

2435
zm_transit_dr_patch/maps/mp/gametypes_zm/_weaponobjects.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

2023
zm_transit_dr_patch/maps/mp/gametypes_zm/_weapons.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

2053
zm_transit_dr_patch/maps/mp/gametypes_zm/_zm_gametype.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

28
zm_transit_dr_patch/maps/mp/gametypes_zm/zclassic.gsc Normal file
View File

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

2145
zm_transit_dr_patch/maps/mp/gametypes_zm/zcleansed.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

26
zm_transit_dr_patch/maps/mp/gametypes_zm/zturned.gsc Normal file
View File

@ -0,0 +1,26 @@
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
main()
{
maps/mp/gametypes_zm/_zm_gametype::main();
level.onprecachegametype = ::onprecachegametype;
level.onstartgametype = ::onstartgametype;
level._game_module_player_damage_callback = ::maps/mp/gametypes_zm/_zm_gametype::game_module_player_damage_callback;
level._game_module_custom_spawn_init_func = ::maps/mp/gametypes_zm/_zm_gametype::custom_spawn_init_func;
maps/mp/gametypes_zm/_zm_gametype::post_gametype_main( "zturned" );
}
onprecachegametype()
{
precacheshellshock( "tabun_gas_mp" );
level thread maps/mp/gametypes_zm/_zm_gametype::init();
maps/mp/gametypes_zm/_zm_gametype::rungametypeprecache( "zturned" );
}
onstartgametype()
{
maps/mp/gametypes_zm/_zm_gametype::setup_classic_gametype();
maps/mp/gametypes_zm/_zm_gametype::rungametypemain( "zturned" );
}

295
zm_transit_dr_patch/maps/mp/zm_transit_ambush.gsc Normal file
View File

@ -0,0 +1,295 @@
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/zombies/_zm_game_module;
#include maps/mp/zm_transit_bus;
#include maps/mp/zm_transit_utility;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
main()
{
level.numroundssincelastambushround = 0;
level.numbusstopssincelastambushround = 0;
level.numambushrounds = 0;
level.ambushpercentageperstop = 10;
level.ambushpercentageperround = 25;
flag_init( "ambush_round", 0 );
flag_init( "ambush_safe_area_active", 0 );
initambusheffects();
thread ambushroundkeeper();
/#
adddebugcommand( "devgui_cmd "Zombies:1/Bus:14/Ambush Round:6/Always:1" "zombie_devgui ambush_round always"\n" );
adddebugcommand( "devgui_cmd "Zombies:1/Bus:14/Ambush Round:6/Never:2" "zombie_devgui ambush_round never"\n" );
#/
}
initambusheffects()
{
level._effect[ "ambush_bus_fire" ] = loadfx( "env/fire/fx_fire_md" );
}
shouldstartambushround()
{
/#
if ( level.ambushpercentageperstop == 100 )
{
return 1;
}
if ( getDvarInt( "zombie_cheat" ) == 2 )
{
return 0;
#/
}
if ( level.numbusstopssincelastambushround < 2 )
{
}
randint = randomintrange( 0, 100 );
percentchance = level.numbusstopssincelastambushround * level.ambushpercentageperstop;
if ( randint < percentchance )
{
}
percentchance = level.numroundssincelastambushround * level.ambushpercentageperround;
if ( randint < percentchance )
{
}
if ( maps/mp/zm_transit_bus::busgasempty() )
{
return 1;
}
return 0;
}
isambushroundactive()
{
if ( flag_exists( "ambush_round" ) )
{
return flag( "ambush_round" );
}
}
is_ambush_round_spawning_active()
{
if ( flag_exists( "ambush_safe_area_active" ) )
{
return flag( "ambush_safe_area_active" );
}
}
ambushstartround()
{
flag_set( "ambush_round" );
ambushroundthink();
}
ambushendround()
{
level.the_bus.issafe = 1;
maps/mp/zm_transit_bus::busgasadd( 60 );
level.numbusstopssincelastambushround = 0;
level.numroundssincelastambushround = 0;
flag_clear( "ambush_round" );
}
cancelambushround()
{
flag_clear( "ambush_round" );
flag_clear( "ambush_safe_area_active" );
maps/mp/zm_transit_utility::try_resume_zombie_spawning();
bbprint( "zombie_events", "category %s type %s round %d", "DOG", "stop", level.round_number );
level.the_bus notify( "ambush_round_fail_safe" );
}
ambushroundspawning()
{
level.numambushrounds++;
wait 6;
level.the_bus.issafe = 0;
}
limitedambushspawn()
{
if ( level.numambushrounds < 3 )
{
dogcount = level.dog_targets.size * 6;
}
else
{
dogcount = level.dog_targets.size * 8;
}
setupdogspawnlocs();
level thread ambushroundspawnfailsafe( 20 );
while ( get_current_zombie_count() > 0 )
{
wait 1;
}
level notify( "end_ambushWaitFunction" );
}
ambushroundthink()
{
module = maps/mp/zombies/_zm_game_module::get_game_module( level.game_module_nml_index );
if ( isDefined( module.hub_start_func ) )
{
level thread [[ module.hub_start_func ]]( "nml" );
level notify( "game_mode_started" );
}
level thread ambushroundspawning();
ambushwaitfunction();
ambushendround();
}
ambushwaitfunction()
{
}
ambushpointfailsafe()
{
level.the_bus endon( "ambush_point" );
level.the_bus waittill( "reached_stop_point" );
cancelambushround();
}
ambushroundspawnfailsafe( timer )
{
ambushroundtimelimit = timer;
currentambushtime = 0;
while ( currentambushtime < ambushroundtimelimit )
{
if ( !flag( "ambush_round" ) )
{
return;
}
wait 1;
currentambushtime++;
}
level notify( "end_ambushWaitFunction" );
wait 5;
dogs = getaispeciesarray( "all", "zombie_dog" );
i = 0;
while ( i < dogs.size )
{
if ( isDefined( dogs[ i ].marked_for_death ) && dogs[ i ].marked_for_death )
{
i++;
continue;
}
else
{
if ( is_magic_bullet_shield_enabled( dogs[ i ] ) )
{
i++;
continue;
}
else
{
dogs[ i ] dodamage( dogs[ i ].health + 666, dogs[ i ].origin );
}
}
i++;
}
}
ambushdoghealthincrease()
{
switch( level.numambushrounds )
{
case 1:
level.dog_health = 400;
break;
case 2:
level.dog_health = 900;
break;
case 3:
level.dog_health = 1300;
break;
case 4:
level.dog_health = 1600;
break;
default:
level.dog_health = 1600;
break;
}
}
ambushroundaftermath()
{
power_up_origin = level.the_bus gettagorigin( "tag_body" );
if ( isDefined( power_up_origin ) )
{
level thread maps/mp/zombies/_zm_powerups::specific_powerup_drop( "full_ammo", power_up_origin );
}
}
ambushroundeffects()
{
wait 2;
level thread ambushlightningeffect( "tag_body" );
wait 0,5;
level thread ambushlightningeffect( "tag_wheel_back_left" );
wait 0,5;
level thread ambushlightningeffect( "tag_wheel_back_right" );
wait 0,5;
level thread ambushlightningeffect( "tag_wheel_front_left" );
wait 0,5;
level thread ambushlightningeffect( "tag_wheel_front_right" );
wait 1,5;
fxent0 = spawnandlinkfxtotag( level._effect[ "ambush_bus_fire" ], level.the_bus, "tag_body" );
fxent1 = spawnandlinkfxtotag( level._effect[ "ambush_bus_fire" ], level.the_bus, "tag_wheel_back_left" );
fxent2 = spawnandlinkfxtotag( level._effect[ "ambush_bus_fire" ], level.the_bus, "tag_wheel_back_right" );
fxent3 = spawnandlinkfxtotag( level._effect[ "ambush_bus_fire" ], level.the_bus, "tag_wheel_front_left" );
fxent4 = spawnandlinkfxtotag( level._effect[ "ambush_bus_fire" ], level.the_bus, "tag_wheel_front_right" );
level waittill( "end_ambushWaitFunction" );
fxent0 delete();
fxent1 delete();
fxent2 delete();
fxent3 delete();
fxent4 delete();
}
ambushlightningeffect( tag )
{
fxentlighting = spawnandlinkfxtotag( level._effect[ "lightning_dog_spawn" ], level.the_bus, tag );
wait 5;
fxentlighting delete();
}
setupdogspawnlocs()
{
level.enemy_dog_locations = [];
currentzone = undefined;
ambush_zones = getentarray( "ambush_volume", "script_noteworthy" );
i = 0;
while ( i < ambush_zones.size )
{
touching = 0;
b = 0;
while ( b < level.the_bus.bounds_origins.size && !touching )
{
bounds = level.the_bus.bounds_origins[ b ];
touching = bounds istouching( ambush_zones[ i ] );
b++;
}
if ( touching )
{
currentzone = ambush_zones[ i ];
break;
}
else
{
i++;
}
}
/#
assert( isDefined( currentzone ), "Bus needs to be in an ambush zone for an ambush round: " + level.the_bus.origin );
#/
level.enemy_dog_locations = getstructarray( currentzone.target, "targetname" );
}
ambushroundkeeper()
{
while ( 1 )
{
level waittill( "between_round_over" );
level.numroundssincelastambushround++;
}
}

616
zm_transit_dr_patch/maps/mp/zm_transit_classic.gsc Normal file
View File

@ -0,0 +1,616 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_blockers;
#include maps/mp/zombies/_zm;
#include maps/mp/zm_transit_distance_tracking;
#include maps/mp/zm_transit;
#include maps/mp/zm_transit_power;
#include maps/mp/zm_transit_ai_screecher;
#include maps/mp/zm_transit_bus;
#include maps/mp/zm_transit_buildables;
#include maps/mp/zm_transit_utility;
#include maps/mp/zombies/_zm_buildables;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
precache()
{
maps/mp/zombies/_zm_ai_screecher::precache();
maps/mp/zombies/_zm_ai_avogadro::precache();
maps/mp/zm_transit_buildables::include_buildables();
maps/mp/zm_transit_buildables::init_buildables();
maps/mp/zm_transit_sq::init();
maps/mp/zombies/_zm_equip_turbine::init();
maps/mp/zombies/_zm_equip_turret::init();
maps/mp/zombies/_zm_equip_electrictrap::init();
precachemodel( "zm_collision_transit_town_classic" );
precachemodel( "p_glo_tools_chest_tall" );
precachemodel( "fxanim_zom_bus_interior_mod" );
precachemodel( "p6_anim_zm_barricade_board_collision" );
precachemodel( "p6_anim_zm_barricade_board_bus_collision" );
registerclientfield( "vehicle", "the_bus_spawned", 1, 1, "int" );
registerclientfield( "vehicle", "bus_flashing_lights", 1, 1, "int" );
registerclientfield( "vehicle", "bus_head_lights", 1, 1, "int" );
registerclientfield( "vehicle", "bus_brake_lights", 1, 1, "int" );
registerclientfield( "vehicle", "bus_turn_signal_left", 1, 1, "int" );
registerclientfield( "vehicle", "bus_turn_signal_right", 1, 1, "int" );
registerclientfield( "allplayers", "screecher_sq_lights", 1, 1, "int" );
registerclientfield( "allplayers", "screecher_maxis_lights", 1, 1, "int" );
registerclientfield( "allplayers", "sq_tower_sparks", 1, 1, "int" );
onplayerconnect_callback( ::maps/mp/zm_transit_bus::onplayerconnect );
onplayerconnect_callback( ::onplayerconnect_bank_deposit_box );
onplayerconnect_callback( ::maps/mp/zm_transit_ai_screecher::portal_player_watcher );
}
main()
{
level.ta_vaultfee = 100;
level.ta_tellerfee = 100;
if ( !isDefined( level.custom_ai_type ) )
{
level.custom_ai_type = [];
}
level.custom_ai_type[ level.custom_ai_type.size ] = ::maps/mp/zombies/_zm_ai_screecher::init;
level.custom_ai_type[ level.custom_ai_type.size ] = ::maps/mp/zombies/_zm_ai_avogadro::init;
level.enemy_location_override_func = ::maps/mp/zm_transit_bus::enemy_location_override;
level.adjust_enemyoverride_func = ::maps/mp/zm_transit_bus::adjust_enemyoverride;
level.closest_player_override = ::closest_player_transit;
door_triggers = getentarray( "electric_door", "script_noteworthy" );
_a80 = door_triggers;
_k80 = getFirstArrayKey( _a80 );
while ( isDefined( _k80 ) )
{
trigger = _a80[ _k80 ];
if ( isDefined( trigger.script_flag ) && trigger.script_flag == "OnPowDoorWH" )
{
}
else
{
trigger.power_door_ignore_flag_wait = 1;
}
_k80 = getNextArrayKey( _a80, _k80 );
}
door_triggers = getentarray( "local_electric_door", "script_noteworthy" );
_a91 = door_triggers;
_k91 = getFirstArrayKey( _a91 );
while ( isDefined( _k91 ) )
{
trigger = _a91[ _k91 ];
if ( isDefined( trigger.script_flag ) && trigger.script_flag == "OnPowDoorWH" )
{
}
else
{
trigger.power_door_ignore_flag_wait = 1;
}
_k91 = getNextArrayKey( _a91, _k91 );
}
level.zm_traversal_override = ::zm_traversal_override;
level.the_bus = getent( "the_bus", "targetname" );
level thread init_bus();
level thread maps/mp/zm_transit_sq::start_transit_sidequest();
level thread inert_zombies_init();
level thread maps/mp/zm_transit_power::initializepower();
level thread maps/mp/zm_transit_ambush::main();
level thread maps/mp/zm_transit::falling_death_init();
level.check_valid_spawn_override = ::maps/mp/zm_transit::transit_respawn_override;
level.zombie_check_suppress_gibs = ::maps/mp/zm_transit_bus::shouldsuppressgibs;
level thread transit_vault_breach_init();
level thread maps/mp/zm_transit_distance_tracking::zombie_tracking_init();
level thread solo_tombstone_removal();
level thread collapsing_bridge_init();
level thread bank_deposit_box();
level thread bus_roof_damage_init();
level thread diner_hatch_access();
level thread maps/mp/zombies/_zm_buildables::think_buildables();
setdvar( "r_rimIntensity_debug", 1 );
setdvar( "r_rimIntensity", 3,5 );
level thread zm_traversal_override_ignores();
level thread maps/mp/zombies/_zm::post_main();
level.spectator_respawn_custom_score = ::callback_spectator_respawn_custom_score;
level thread triggerweaponslockerwatch();
level.custom_pap_deny_vo_func = ::transit_custom_deny_vox;
level.custom_generic_deny_vo_func = ::transit_custom_deny_vox;
level.custom_player_death_vo_func = ::transit_custom_death_vox;
level.custom_powerup_vo_response = ::transit_custom_powerup_vo_response;
level.zombie_vars[ "zombie_intermission_time" ] = 12;
}
zm_traversal_override_ignores()
{
}
zm_traversal_override( traversealias )
{
suffix = "";
sndalias = undefined;
chance = 0;
sndchance = 0;
if ( isDefined( self.isscreecher ) && !self.isscreecher && isDefined( self.is_avogadro ) && !self.is_avogadro )
{
if ( isDefined( self.traversestartnode ) && isDefined( self.traversestartnode.script_string ) && self.traversestartnode.script_string == "ignore_traverse_override" )
{
return traversealias;
}
switch( traversealias )
{
case "jump_down_48":
if ( isDefined( self.has_legs ) && self.has_legs )
{
suffix = "_stumble";
chance = 0;
}
break;
case "jump_down_127":
case "jump_down_190":
case "jump_down_222":
case "jump_down_90":
if ( isDefined( self.has_legs ) && self.has_legs )
{
suffix = "_stumble";
chance = 30;
}
break;
case "jump_up_127":
case "jump_up_190":
case "jump_up_222":
case "jump_up_48":
sndalias = "vox_zmba_zombie_pickup_" + randomint( 2 );
suffix = "_grabbed";
chance = 6;
sndchance = 3;
break;
}
if ( chance != 0 && randomint( 100 ) <= chance )
{
if ( isDefined( sndalias ) && randomint( 100 ) <= sndchance )
{
playsoundatposition( sndalias, self.origin );
}
traversealias += suffix;
}
}
return traversealias;
}
init_bus()
{
flag_wait( "start_zombie_round_logic" );
level.the_bus thread maps/mp/zm_transit_bus::bussetup();
}
closest_player_transit( origin, players )
{
if ( isDefined( level.the_bus ) || level.the_bus.numaliveplayersridingbus > 0 && isDefined( level.calc_closest_player_using_paths ) && !level.calc_closest_player_using_paths )
{
player = getclosest( origin, players );
}
else
{
player = get_closest_player_using_paths( origin, players );
}
return player;
}
transit_vault_breach_init()
{
vault_doors = getentarray( "town_bunker_door", "targetname" );
array_thread( vault_doors, ::transit_vault_breach );
}
transit_vault_breach()
{
if ( isDefined( self ) )
{
self.damage_state = 0;
if ( isDefined( self.target ) )
{
clip = getent( self.target, "targetname" );
clip linkto( self );
self.clip = clip;
}
self thread vault_breach_think();
}
else
{
return;
}
}
vault_breach_think()
{
level endon( "intermission" );
self.health = 99999;
self setcandamage( 1 );
self.damage_state = 0;
self.clip.health = 99999;
self.clip setcandamage( 1 );
while ( 1 )
{
self thread track_clip_damage();
self waittill( "damage", amount, attacker, direction, point, dmg_type, modelname, tagname, partname, weaponname );
if ( isDefined( weaponname ) && weaponname != "emp_grenade_zm" || weaponname == "ray_gun_zm" && weaponname == "ray_gun_upgraded_zm" )
{
continue;
}
if ( isDefined( amount ) && amount <= 1 )
{
continue;
}
if ( isplayer( attacker ) && dmg_type != "MOD_PROJECTILE" && dmg_type != "MOD_PROJECTILE_SPLASH" && dmg_type != "MOD_EXPLOSIVE" && dmg_type != "MOD_EXPLOSIVE_SPLASH" || dmg_type == "MOD_GRENADE" && dmg_type == "MOD_GRENADE_SPLASH" )
{
if ( self.damage_state == 0 )
{
self.damage_state = 1;
}
playfxontag( level._effect[ "def_explosion" ], self, "tag_origin" );
self playsound( "exp_vault_explode" );
self bunkerdoorrotate( 1 );
if ( isDefined( self.script_flag ) )
{
flag_set( self.script_flag );
}
if ( isDefined( self.clip ) )
{
self.clip connectpaths();
}
wait 1;
playsoundatposition( "zmb_cha_ching_loud", self.origin );
return;
}
}
}
track_clip_damage()
{
self endon( "damage" );
self.clip waittill( "damage", amount, attacker, direction, point, dmg_type );
self notify( "damage" );
}
bunkerdoorrotate( open, time )
{
if ( !isDefined( time ) )
{
time = 0,2;
}
rotate = self.script_float;
if ( !open )
{
rotate *= -1;
}
if ( isDefined( self.script_angles ) )
{
self notsolid();
self rotateto( self.script_angles, time, 0, 0 );
self thread maps/mp/zombies/_zm_blockers::door_solid_thread();
}
}
collapsing_bridge_init()
{
time = 1,5;
trig = getent( "bridge_trig", "targetname" );
if ( !isDefined( trig ) )
{
return;
}
bridge = getentarray( trig.target, "targetname" );
if ( !isDefined( bridge ) )
{
return;
}
trig waittill( "trigger", who );
trig playsound( "evt_bridge_collapse_start" );
trig thread play_delayed_sound( time );
i = 0;
while ( i < bridge.size )
{
if ( isDefined( bridge[ i ].script_angles ) )
{
rot_angle = bridge[ i ].script_angles;
}
else
{
rot_angle = ( 0, 0, 0 );
}
earthquake( randomfloatrange( 0,5, 1 ), 1,5, bridge[ i ].origin, 1000 );
exploder( 150 );
bridge[ i ] rotateto( rot_angle, time, 0, 0 );
i++;
}
wait 1;
if ( !isDefined( level.collapse_vox_said ) )
{
level thread automatonspeak( "inform", "bridge_collapse" );
level.collapse_vox_said = 1;
}
}
play_delayed_sound( time )
{
wait time;
self playsound( "evt_bridge_collapse_end" );
}
bank_deposit_box()
{
level.bank_deposit_max_amount = 250000;
level.bank_deposit_ddl_increment_amount = 1000;
deposit_trig = spawn( "trigger_radius_use", ( 588, 441,5, 6 ), 0, 4, 32 );
deposit_trig sethintstring( &"ZOMBIE_BANK_DEPOSIT_PROMPT", level.bank_deposit_ddl_increment_amount );
deposit_trig setcursorhint( "HINT_NOICON" );
deposit_trig triggerignoreteam();
deposit_trig thread bank_deposit_box_think( 1 );
level.deposit_trig = deposit_trig;
withdraw_trig = spawn( "trigger_radius_use", ( 588, 450, 6 ), 0, 4, 32 );
withdraw_trig sethintstring( &"ZOMBIE_BANK_WITHDRAW_PROMPT", level.bank_deposit_ddl_increment_amount, level.ta_vaultfee );
withdraw_trig setcursorhint( "HINT_NOICON" );
withdraw_trig triggerignoreteam();
withdraw_trig thread bank_deposit_box_think( 0 );
level.withdraw_trig = withdraw_trig;
}
onplayerconnect_bank_deposit_box()
{
account_val = self maps/mp/zombies/_zm_stats::get_map_stat( "depositBox" );
if ( account_val >= level.bank_deposit_max_amount )
{
level.deposit_trig setinvisibletoplayer( self );
}
}
bank_deposit_box_think( is_deposit )
{
account_max = level.bank_deposit_max_amount / level.bank_deposit_ddl_increment_amount;
account_increment = int( level.bank_deposit_ddl_increment_amount / 1000 );
online_game = sessionmodeisonlinegame();
for ( ;; )
{
while ( 1 )
{
self waittill( "trigger", player );
while ( !is_player_valid( player ) )
{
continue;
}
account_val = player maps/mp/zombies/_zm_stats::get_map_stat( "depositBox" );
if ( !online_game )
{
if ( !isDefined( player.account_val ) )
{
player.account_val = 0;
}
account_val = player.account_val;
}
account_deposit_expected = account_val + account_increment;
if ( isDefined( is_deposit ) && is_deposit && player.score >= level.bank_deposit_ddl_increment_amount && account_deposit_expected <= account_max )
{
player playsoundtoplayer( "zmb_vault_bank_deposit", player );
player.score -= level.bank_deposit_ddl_increment_amount;
player maps/mp/zombies/_zm_stats::set_map_stat( "depositBox", account_val + account_increment );
if ( !online_game )
{
player.account_val += account_increment;
}
if ( account_deposit_expected >= account_max )
{
level.deposit_trig setinvisibletoplayer( player );
}
break;
}
else
{
if ( isDefined( is_deposit ) && !is_deposit && account_val >= account_increment )
{
player playsoundtoplayer( "zmb_vault_bank_deposit", player );
player.score += level.bank_deposit_ddl_increment_amount;
player maps/mp/zombies/_zm_stats::set_map_stat( "depositBox", account_val - account_increment );
if ( !online_game )
{
player.account_val -= account_increment;
}
player thread do_player_general_vox( "general", "exert_laugh", 10, 50 );
player thread player_withdraw_fee();
break;
}
else
{
player thread do_player_general_vox( "general", "exert_sigh", 10, 50 );
}
}
}
}
}
player_withdraw_fee()
{
self endon( "disconnect" );
wait_network_frame();
self.score -= level.ta_vaultfee;
level.deposit_trig setvisibletoplayer( self );
}
bus_roof_damage_init()
{
trigs = getentarray( "bus_knock_off", "targetname" );
array_thread( trigs, ::bus_roof_damage );
}
bus_roof_damage()
{
while ( 1 )
{
self waittill( "trigger", who );
if ( isplayer( who ) )
{
if ( who getstance() == "stand" )
{
who dodamage( 1, who.origin );
}
}
else
{
if ( isDefined( who.marked_for_death ) && !who.marked_for_death && isDefined( who.has_legs ) && who.has_legs )
{
who dodamage( who.health + 100, who.origin );
who.marked_for_death = 1;
level.zombie_total++;
}
}
wait 0,1;
}
}
diner_hatch_access()
{
diner_hatch = getent( "diner_hatch", "targetname" );
diner_hatch_col = getent( "diner_hatch_collision", "targetname" );
diner_hatch_mantle = getent( "diner_hatch_mantle", "targetname" );
if ( !isDefined( diner_hatch ) || !isDefined( diner_hatch_col ) )
{
return;
}
diner_hatch hide();
diner_hatch_mantle.start_origin = diner_hatch_mantle.origin;
diner_hatch_mantle.origin += vectorScale( ( 0, 0, 0 ), 500 );
player = wait_for_buildable( "dinerhatch" );
diner_hatch show();
diner_hatch_col delete();
diner_hatch_mantle.origin = diner_hatch_mantle.start_origin;
player maps/mp/zombies/_zm_buildables::track_placed_buildables( "dinerhatch" );
}
inert_zombies_init()
{
inert_spawn_location = getstructarray( "inert_location", "script_noteworthy" );
if ( isDefined( inert_spawn_location ) )
{
array_thread( inert_spawn_location, ::spawn_inert_zombies );
}
}
spawn_inert_zombies()
{
if ( !isDefined( self.angles ) )
{
self.angles = ( 0, 0, 0 );
}
wait 0,1;
if ( isDefined( level.zombie_spawners ) )
{
spawner = random( level.zombie_spawners );
ai = spawn_zombie( spawner );
}
if ( isDefined( ai ) )
{
ai forceteleport( self.origin, self.angles );
ai.start_inert = 1;
}
}
sparking_power_lines()
{
lines = getentarray( "power_line_sparking", "targetname" );
}
callback_spectator_respawn_custom_score()
{
difference = 1500 - self.score;
money_required = 1;
if ( difference >= 1000 )
{
money_required = 2;
}
if ( !sessionmodeisonlinegame() )
{
if ( !isDefined( self.account_val ) )
{
self.account_val = 0;
}
if ( self.account_val >= money_required )
{
self.account_val -= money_required;
}
else
{
self.account_val = 0;
}
}
else account_val = self maps/mp/zombies/_zm_stats::get_map_stat( "depositBox" );
if ( account_val >= money_required )
{
self set_map_stat( "depositBox", account_val - money_required );
}
else
{
self set_map_stat( "depositBox", 0 );
}
}
transit_custom_deny_vox( door_buy )
{
switch( self.characterindex )
{
case 0:
alias = randomintrange( 2, 5 );
if ( isDefined( door_buy ) && door_buy )
{
alias = undefined;
}
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "door_deny", undefined, alias );
break;
case 1:
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "perk_deny", undefined, 0 );
break;
case 2:
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "perk_deny", undefined, 0 );
break;
case 3:
x = randomint( 100 );
if ( x > 66 )
{
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "perk_deny", undefined, 0 );
}
else if ( x > 33 )
{
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "no_money_box", undefined, 0 );
}
else
{
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "no_money_weapon", undefined, 0 );
}
break;
}
}
transit_custom_death_vox()
{
if ( self.characterindex != 2 )
{
return 0;
}
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "pain_high" );
return 1;
}
transit_custom_powerup_vo_response( powerup_player, powerup )
{
dist = 250000;
players = get_players();
_a746 = players;
_k746 = getFirstArrayKey( _a746 );
while ( isDefined( _k746 ) )
{
player = _a746[ _k746 ];
if ( player == powerup_player )
{
}
else if ( distancesquared( player.origin, powerup_player.origin ) < dist )
{
player do_player_general_vox( "general", "exert_laugh", 10, 5 );
}
_k746 = getNextArrayKey( _a746, _k746 );
}
}

161
zm_transit_dr_patch/maps/mp/zm_transit_distance_tracking.gsc Normal file
View File

@ -0,0 +1,161 @@
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
zombie_tracking_init()
{
level.zombie_respawned_health = [];
if ( !isDefined( level.zombie_tracking_dist ) )
{
level.zombie_tracking_dist = 1500;
}
if ( !isDefined( level.zombie_tracking_wait ) )
{
level.zombie_tracking_wait = 10;
}
for ( ;; )
{
while ( 1 )
{
zombies = get_round_enemy_array();
if ( !isDefined( zombies ) || isDefined( level.ignore_distance_tracking ) && level.ignore_distance_tracking )
{
wait level.zombie_tracking_wait;
}
}
else i = 0;
while ( i < zombies.size )
{
if ( isDefined( zombies[ i ] ) && isDefined( zombies[ i ].ignore_distance_tracking ) && !zombies[ i ].ignore_distance_tracking )
{
zombies[ i ] thread delete_zombie_noone_looking( level.zombie_tracking_dist );
}
i++;
}
wait level.zombie_tracking_wait;
}
}
delete_zombie_noone_looking( how_close )
{
self endon( "death" );
if ( !isDefined( how_close ) )
{
how_close = 1000;
}
distance_squared_check = how_close * how_close;
too_far_dist = distance_squared_check * 3;
if ( isDefined( level.zombie_tracking_too_far_dist ) )
{
too_far_dist = level.zombie_tracking_too_far_dist * level.zombie_tracking_too_far_dist;
}
self.inview = 0;
self.player_close = 0;
players = get_players();
i = 0;
while ( i < players.size )
{
if ( players[ i ].sessionstate == "spectator" )
{
i++;
continue;
}
else if ( isDefined( level.only_track_targeted_players ) )
{
if ( !isDefined( self.favoriteenemy ) || self.favoriteenemy != players[ i ] )
{
i++;
continue;
}
}
else
{
can_be_seen = self player_can_see_me( players[ i ] );
if ( can_be_seen && distancesquared( self.origin, players[ i ].origin ) < too_far_dist )
{
self.inview++;
}
if ( distancesquared( self.origin, players[ i ].origin ) < distance_squared_check )
{
self.player_close++;
}
}
i++;
}
wait 0,1;
if ( self.inview == 0 && self.player_close == 0 )
{
if ( !isDefined( self.animname ) || isDefined( self.animname ) && self.animname != "zombie" )
{
return;
}
if ( isDefined( self.electrified ) && self.electrified == 1 )
{
return;
}
if ( isDefined( self.in_the_ground ) && self.in_the_ground == 1 )
{
return;
}
zombies = getaiarray( "axis" );
if ( isDefined( self.damagemod ) && self.damagemod == "MOD_UNKNOWN" && self.health < self.maxhealth )
{
if ( isDefined( self.exclude_distance_cleanup_adding_to_total ) && !self.exclude_distance_cleanup_adding_to_total && isDefined( self.isscreecher ) && !self.isscreecher )
{
level.zombie_total++;
level.zombie_respawned_health[ level.zombie_respawned_health.size ] = self.health;
}
}
else
{
if ( ( zombies.size + level.zombie_total ) > 24 || ( zombies.size + level.zombie_total ) <= 24 && self.health >= self.maxhealth )
{
if ( isDefined( self.exclude_distance_cleanup_adding_to_total ) && !self.exclude_distance_cleanup_adding_to_total && isDefined( self.isscreecher ) && !self.isscreecher )
{
level.zombie_total++;
if ( self.health < level.zombie_health )
{
level.zombie_respawned_health[ level.zombie_respawned_health.size ] = self.health;
}
}
}
}
self maps/mp/zombies/_zm_spawner::reset_attack_spot();
self notify( "zombie_delete" );
self delete();
recalc_zombie_array();
}
}
player_can_see_me( 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 );
if ( forwarddotbanzai >= 1 )
{
anglefromcenter = 0;
}
else if ( forwarddotbanzai <= -1 )
{
anglefromcenter = 180;
}
else
{
anglefromcenter = acos( forwarddotbanzai );
}
playerfov = getDvarFloat( "cg_fov" );
banzaivsplayerfovbuffer = getDvarFloat( "g_banzai_player_fov_buffer" );
if ( banzaivsplayerfovbuffer <= 0 )
{
banzaivsplayerfovbuffer = 0,2;
}
playercanseeme = anglefromcenter <= ( ( playerfov * 0,5 ) * ( 1 - banzaivsplayerfovbuffer ) );
return playercanseeme;
}

885
zm_transit_dr_patch/maps/mp/zm_transit_dr.gsc Normal file
View File

@ -0,0 +1,885 @@
#include maps/mp/gametypes_zm/_globallogic_utils;
#include maps/mp/zombies/_zm_devgui;
#include maps/mp/zombies/_zm_zonemgr;
#include maps/mp/zm_transit_lava;
#include maps/mp/gametypes_zm/_spawning;
#include maps/mp/animscripts/zm_death;
#include maps/mp/zm_transit_dr_ffotd;
#include maps/mp/_visionset_mgr;
#include maps/mp/zm_transit_utility;
#include maps/mp/zombies/_zm_game_module;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/gametypes_zm/_zm_gametype;
#include maps/mp/_utility;
#include common_scripts/utility;
gamemode_callback_setup()
{
maps/mp/zm_transit_dr_gamemodes::init();
}
encounter_init()
{
precacheshader( "sun_moon_zombie" );
level.precachecustomcharacters = ::precache_team_characters;
level.givecustomcharacters = ::give_team_characters;
}
zclassic_init()
{
level._zcleansed_weapon_progression = array( "rpd_zm", "srm1216_zm", "judge_zm", "qcw05_zm", "kard_zm" );
survival_init();
}
zclassic_preinit()
{
zclassic_init();
}
zcleansed_preinit()
{
level._zcleansed_weapon_progression = array( "judge_zm", "srm1216_zm", "hk416_zm", "qcw05_zm", "kard_zm" );
level.cymbal_monkey_clone_weapon = "srm1216_zm";
survival_init();
}
survival_init()
{
level.force_team_characters = 1;
level.should_use_cia = 0;
if ( randomint( 100 ) > 50 )
{
level.should_use_cia = 1;
}
level.precachecustomcharacters = ::precache_team_characters;
level.givecustomcharacters = ::give_team_characters;
flag_wait( "start_zombie_round_logic" );
level.custom_intermission = ::transit_standard_intermission;
}
transit_standard_intermission()
{
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;
maps/mp/_visionset_mgr::vsmgr_deactivate( "overlay", "zm_transit_burn", self );
self stopshellshock();
points = getstructarray( "intermission", "targetname" );
point = undefined;
if ( !isDefined( points ) || points.size == 0 )
{
points = getentarray( "info_intermission", "classname" );
if ( points.size < 1 )
{
/#
println( "NO info_intermission POINTS IN MAP" );
#/
return;
}
}
self.game_over_bg = newclienthudelem( self );
self.game_over_bg.x = 0;
self.game_over_bg.y = 0;
self.game_over_bg.horzalign = "fullscreen";
self.game_over_bg.vertalign = "fullscreen";
self.game_over_bg.foreground = 1;
self.game_over_bg.sort = 1;
self.game_over_bg setshader( "black", 640, 480 );
self.game_over_bg.alpha = 1;
org = undefined;
while ( 1 )
{
_a156 = points;
_k156 = getFirstArrayKey( _a156 );
while ( isDefined( _k156 ) )
{
struct = _a156[ _k156 ];
if ( isDefined( struct.script_string ) && struct.script_string == level.scr_zm_map_start_location )
{
point = struct;
}
_k156 = getNextArrayKey( _a156, _k156 );
}
if ( !isDefined( point ) )
{
point = points[ 0 ];
}
if ( !isDefined( org ) )
{
self spawn( point.origin, point.angles );
}
if ( isDefined( point.target ) )
{
if ( !isDefined( org ) )
{
org = spawn( "script_model", self.origin + vectorScale( ( 0, 0, -1 ), 60 ) );
org setmodel( "tag_origin" );
}
org.origin = point.origin;
org.angles = point.angles;
j = 0;
while ( j < get_players().size )
{
player = get_players()[ j ];
player camerasetposition( org );
player camerasetlookat();
player cameraactivate( 1 );
j++;
}
speed = 20;
if ( isDefined( point.speed ) )
{
speed = point.speed;
}
target_point = getstruct( point.target, "targetname" );
dist = distance( point.origin, target_point.origin );
time = dist / speed;
q_time = time * 0,25;
if ( q_time > 1 )
{
q_time = 1;
}
self.game_over_bg fadeovertime( q_time );
self.game_over_bg.alpha = 0;
org moveto( target_point.origin, time, q_time, q_time );
org rotateto( target_point.angles, time, q_time, q_time );
wait ( time - q_time );
self.game_over_bg fadeovertime( q_time );
self.game_over_bg.alpha = 1;
wait q_time;
continue;
}
else
{
self.game_over_bg fadeovertime( 1 );
self.game_over_bg.alpha = 0;
wait 5;
self.game_over_bg thread fade_up_over_time( 1 );
}
}
}
zturned_preinit()
{
encounter_init();
}
createfx_callback()
{
ents = getentarray();
i = 0;
while ( i < ents.size )
{
if ( ents[ i ].classname != "info_player_start" )
{
ents[ i ] delete();
}
i++;
}
}
main()
{
level thread maps/mp/zm_transit_dr_ffotd::main_start();
level.level_createfx_callback_thread = ::createfx_callback;
level.default_game_mode = "zcleansed";
level.default_start_location = "diner";
level._get_random_encounter_func = ::maps/mp/zm_transit_utility::get_random_encounter_match;
setup_rex_starts();
maps/mp/zm_transit_dr_fx::main();
maps/mp/zombies/_zm::init_fx();
maps/mp/animscripts/zm_death::precache_gib_fx();
level.zombiemode = 1;
level._no_water_risers = 1;
if ( !isDefined( level.zombie_surfing_kills ) )
{
level.zombie_surfing_kills = 1;
level.zombie_surfing_kill_count = 6;
}
maps/mp/_sticky_grenade::init();
level.level_specific_stats_init = ::init_transit_dr_stats;
maps/mp/zombies/_load::main();
init_clientflags();
registerclientfield( "allplayers", "playerinfog", 1, 1, "int" );
level.custom_breadcrumb_store_func = ::transit_breadcrumb_store_func;
if ( getDvar( "createfx" ) == "1" )
{
return;
}
precacheshellshock( "lava" );
precacheshellshock( "lava_small" );
precache_survival_barricade_assets();
include_game_modules();
maps/mp/gametypes_zm/_spawning::level_use_unified_spawning( 1 );
level.givecustomloadout = ::givecustomloadout;
initcharacterstartindex();
level.initial_round_wait_func = ::initial_round_wait_func;
level.zombie_init_done = ::zombie_init_done;
level.zombiemode_using_pack_a_punch = 1;
level.zombiemode_reusing_pack_a_punch = 1;
level.pap_interaction_height = 47;
level.zombiemode_using_doubletap_perk = 1;
level.zombiemode_using_juggernaut_perk = 1;
level.zombiemode_using_marathon_perk = 1;
level.zombiemode_using_revive_perk = 1;
level.zombiemode_using_sleightofhand_perk = 1;
level.register_offhand_weapons_for_level_defaults_override = ::offhand_weapon_overrride;
level._zombie_custom_add_weapons = ::custom_add_weapons;
level._allow_melee_weapon_switching = 1;
level.uses_gumps = 1;
setdvar( "aim_target_fixed_actor_size", 1 );
include_weapons();
include_powerups();
level thread maps/mp/zm_transit_lava::lava_damage_init();
level.zm_transit_burn_max_duration = 2;
setup_zombie_init();
maps/mp/zombies/_zm::init();
maps/mp/zombies/_zm_weap_cymbal_monkey::init();
if ( !isDefined( level.vsmgr_prio_overlay_zm_transit_burn ) )
{
level.vsmgr_prio_overlay_zm_transit_burn = 20;
}
maps/mp/_visionset_mgr::vsmgr_register_info( "overlay", "zm_transit_burn", 1, level.vsmgr_prio_overlay_zm_transit_burn, 15, 1, ::maps/mp/_visionset_mgr::vsmgr_duration_lerp_thread_per_player, 0 );
level maps/mp/zm_transit_dr_achievement::init();
precacheitem( "death_throe_zm" );
level.zones = [];
level.zone_manager_init_func = ::transit_zone_init;
init_zones[ 0 ] = "zone_gas";
level thread maps/mp/zombies/_zm_zonemgr::manage_zones( init_zones );
level.zombie_ai_limit = 24;
setdvar( "zombiemode_path_minz_bias", 13 );
level thread maps/mp/zm_transit_dr_ffotd::main_end();
flag_wait( "start_zombie_round_logic" );
level notify( "players_done_connecting" );
/#
execdevgui( "devgui_zombie_transit_dr" );
level.custom_devgui = ::zombie_transit_dr_devgui;
#/
level thread set_transit_wind();
level.speed_change_round = 15;
level.speed_change_max = 5;
}
setup_rex_starts()
{
add_gametype( "zcleansed", ::dummy, "zcleansed", ::dummy );
add_gameloc( "diner", ::dummy, "diner", ::dummy );
}
dummy()
{
}
init_clientflags()
{
}
set_player_in_fog( onoff )
{
if ( onoff )
{
self setclientfield( "playerinfog", 1 );
}
else
{
self setclientfield( "playerinfog", 0 );
}
}
transit_breadcrumb_store_func( store_crumb )
{
if ( isDefined( self.isonbus ) && self.isonbus )
{
return 0;
}
return store_crumb;
}
post_first_init()
{
while ( !isDefined( anim.notfirsttime ) )
{
wait 0,5;
}
anim.meleerange = 36;
anim.meleerangesq = anim.meleerange * anim.meleerange;
}
set_transit_wind()
{
setdvar( "enable_global_wind", 1 );
setdvar( "wind_global_vector", "-120 -115 -120" );
setdvar( "wind_global_low_altitude", 0 );
setdvar( "wind_global_hi_altitude", 2000 );
setdvar( "wind_global_low_strength_percent", 0,5 );
}
precache_team_characters()
{
precachemodel( "c_zom_player_cdc_dlc1_fb" );
precachemodel( "c_zom_hazmat_viewhands" );
precachemodel( "c_zom_player_cia_dlc1_fb" );
precachemodel( "c_zom_suit_viewhands" );
}
precache_survival_barricade_assets()
{
survival_barricades = getstructarray( "game_mode_object" );
i = 0;
while ( i < survival_barricades.size )
{
if ( isDefined( survival_barricades[ i ].script_string ) && survival_barricades[ i ].script_string == "survival" )
{
if ( isDefined( survival_barricades[ i ].script_parameters ) )
{
precachemodel( survival_barricades[ i ].script_parameters );
}
}
i++;
}
}
initcharacterstartindex()
{
level.characterstartindex = 0;
/#
forcecharacter = getDvarInt( #"FEE4CB69" );
if ( forcecharacter != 0 )
{
level.characterstartindex = forcecharacter - 1;
#/
}
}
give_team_characters()
{
self detachall();
self set_player_is_female( 0 );
if ( !isDefined( self.characterindex ) )
{
self.characterindex = 1;
}
self setmodel( "c_zom_player_cdc_dlc1_fb" );
self.voice = "american";
self.skeleton = "base";
self setviewmodel( "c_zom_hazmat_viewhands" );
self.characterindex = 1;
self setmovespeedscale( 1 );
self setsprintduration( 4 );
self setsprintcooldown( 0 );
}
setup_personality_character_exerts()
{
level.exert_sounds[ 1 ][ "burp" ][ 0 ] = "vox_plr_0_exert_burp_0";
level.exert_sounds[ 1 ][ "burp" ][ 1 ] = "vox_plr_0_exert_burp_1";
level.exert_sounds[ 1 ][ "burp" ][ 2 ] = "vox_plr_0_exert_burp_2";
level.exert_sounds[ 1 ][ "burp" ][ 3 ] = "vox_plr_0_exert_burp_3";
level.exert_sounds[ 1 ][ "burp" ][ 4 ] = "vox_plr_0_exert_burp_4";
level.exert_sounds[ 1 ][ "burp" ][ 5 ] = "vox_plr_0_exert_burp_5";
level.exert_sounds[ 1 ][ "burp" ][ 6 ] = "vox_plr_0_exert_burp_6";
level.exert_sounds[ 2 ][ "burp" ][ 0 ] = "vox_plr_1_exert_burp_0";
level.exert_sounds[ 2 ][ "burp" ][ 1 ] = "vox_plr_1_exert_burp_1";
level.exert_sounds[ 2 ][ "burp" ][ 2 ] = "vox_plr_1_exert_burp_2";
level.exert_sounds[ 2 ][ "burp" ][ 3 ] = "vox_plr_1_exert_burp_3";
level.exert_sounds[ 3 ][ "burp" ][ 0 ] = "vox_plr_2_exert_burp_0";
level.exert_sounds[ 3 ][ "burp" ][ 1 ] = "vox_plr_2_exert_burp_1";
level.exert_sounds[ 3 ][ "burp" ][ 2 ] = "vox_plr_2_exert_burp_2";
level.exert_sounds[ 3 ][ "burp" ][ 3 ] = "vox_plr_2_exert_burp_3";
level.exert_sounds[ 3 ][ "burp" ][ 4 ] = "vox_plr_2_exert_burp_4";
level.exert_sounds[ 3 ][ "burp" ][ 5 ] = "vox_plr_2_exert_burp_5";
level.exert_sounds[ 3 ][ "burp" ][ 6 ] = "vox_plr_2_exert_burp_6";
level.exert_sounds[ 4 ][ "burp" ][ 0 ] = "vox_plr_3_exert_burp_0";
level.exert_sounds[ 4 ][ "burp" ][ 1 ] = "vox_plr_3_exert_burp_1";
level.exert_sounds[ 4 ][ "burp" ][ 2 ] = "vox_plr_3_exert_burp_2";
level.exert_sounds[ 4 ][ "burp" ][ 3 ] = "vox_plr_3_exert_burp_3";
level.exert_sounds[ 4 ][ "burp" ][ 4 ] = "vox_plr_3_exert_burp_4";
level.exert_sounds[ 4 ][ "burp" ][ 5 ] = "vox_plr_3_exert_burp_5";
level.exert_sounds[ 4 ][ "burp" ][ 6 ] = "vox_plr_3_exert_burp_6";
level.exert_sounds[ 1 ][ "hitmed" ][ 0 ] = "vox_plr_0_exert_pain_medium_0";
level.exert_sounds[ 1 ][ "hitmed" ][ 1 ] = "vox_plr_0_exert_pain_medium_1";
level.exert_sounds[ 1 ][ "hitmed" ][ 2 ] = "vox_plr_0_exert_pain_medium_2";
level.exert_sounds[ 1 ][ "hitmed" ][ 3 ] = "vox_plr_0_exert_pain_medium_3";
level.exert_sounds[ 2 ][ "hitmed" ][ 0 ] = "vox_plr_1_exert_pain_medium_0";
level.exert_sounds[ 2 ][ "hitmed" ][ 1 ] = "vox_plr_1_exert_pain_medium_1";
level.exert_sounds[ 2 ][ "hitmed" ][ 2 ] = "vox_plr_1_exert_pain_medium_2";
level.exert_sounds[ 2 ][ "hitmed" ][ 3 ] = "vox_plr_1_exert_pain_medium_3";
level.exert_sounds[ 3 ][ "hitmed" ][ 0 ] = "vox_plr_2_exert_pain_medium_0";
level.exert_sounds[ 3 ][ "hitmed" ][ 1 ] = "vox_plr_2_exert_pain_medium_1";
level.exert_sounds[ 3 ][ "hitmed" ][ 2 ] = "vox_plr_2_exert_pain_medium_2";
level.exert_sounds[ 3 ][ "hitmed" ][ 3 ] = "vox_plr_2_exert_pain_medium_3";
level.exert_sounds[ 4 ][ "hitmed" ][ 0 ] = "vox_plr_3_exert_pain_medium_0";
level.exert_sounds[ 4 ][ "hitmed" ][ 1 ] = "vox_plr_3_exert_pain_medium_1";
level.exert_sounds[ 4 ][ "hitmed" ][ 2 ] = "vox_plr_3_exert_pain_medium_2";
level.exert_sounds[ 4 ][ "hitmed" ][ 3 ] = "vox_plr_3_exert_pain_medium_3";
level.exert_sounds[ 1 ][ "hitlrg" ][ 0 ] = "vox_plr_0_exert_pain_high_0";
level.exert_sounds[ 1 ][ "hitlrg" ][ 1 ] = "vox_plr_0_exert_pain_high_1";
level.exert_sounds[ 1 ][ "hitlrg" ][ 2 ] = "vox_plr_0_exert_pain_high_2";
level.exert_sounds[ 1 ][ "hitlrg" ][ 3 ] = "vox_plr_0_exert_pain_high_3";
level.exert_sounds[ 2 ][ "hitlrg" ][ 0 ] = "vox_plr_1_exert_pain_high_0";
level.exert_sounds[ 2 ][ "hitlrg" ][ 1 ] = "vox_plr_1_exert_pain_high_1";
level.exert_sounds[ 2 ][ "hitlrg" ][ 2 ] = "vox_plr_1_exert_pain_high_2";
level.exert_sounds[ 2 ][ "hitlrg" ][ 3 ] = "vox_plr_1_exert_pain_high_3";
level.exert_sounds[ 3 ][ "hitlrg" ][ 0 ] = "vox_plr_2_exert_pain_high_0";
level.exert_sounds[ 3 ][ "hitlrg" ][ 1 ] = "vox_plr_2_exert_pain_high_1";
level.exert_sounds[ 3 ][ "hitlrg" ][ 2 ] = "vox_plr_2_exert_pain_high_2";
level.exert_sounds[ 3 ][ "hitlrg" ][ 3 ] = "vox_plr_2_exert_pain_high_3";
level.exert_sounds[ 4 ][ "hitlrg" ][ 0 ] = "vox_plr_3_exert_pain_high_0";
level.exert_sounds[ 4 ][ "hitlrg" ][ 1 ] = "vox_plr_3_exert_pain_high_1";
level.exert_sounds[ 4 ][ "hitlrg" ][ 2 ] = "vox_plr_3_exert_pain_high_2";
level.exert_sounds[ 4 ][ "hitlrg" ][ 3 ] = "vox_plr_3_exert_pain_high_3";
}
givecustomloadout( takeallweapons, alreadyspawned )
{
self giveweapon( "knife_zm" );
self give_start_weapon( 1 );
}
transit_intermission()
{
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;
maps/mp/_visionset_mgr::vsmgr_deactivate( "overlay", "zm_transit_burn", self );
self stopshellshock();
self.game_over_bg = newclienthudelem( self );
self.game_over_bg.x = 0;
self.game_over_bg.y = 0;
self.game_over_bg.horzalign = "fullscreen";
self.game_over_bg.vertalign = "fullscreen";
self.game_over_bg.foreground = 1;
self.game_over_bg.sort = 1;
self.game_over_bg setshader( "black", 640, 480 );
self.game_over_bg.alpha = 1;
if ( !isDefined( level.the_bus ) )
{
self.game_over_bg fadeovertime( 1 );
self.game_over_bg.alpha = 0;
wait 5;
self.game_over_bg thread maps/mp/zombies/_zm::fade_up_over_time( 1 );
}
else
{
zonestocheck = [];
zonestocheck[ zonestocheck.size ] = "zone_amb_bridge";
zonestocheck[ zonestocheck.size ] = "zone_trans_11";
zonestocheck[ zonestocheck.size ] = "zone_town_west";
zonestocheck[ zonestocheck.size ] = "zone_town_west2";
zonestocheck[ zonestocheck.size ] = "zone_tow";
near_bridge = 0;
_a800 = zonestocheck;
_k800 = getFirstArrayKey( _a800 );
while ( isDefined( _k800 ) )
{
zone = _a800[ _k800 ];
if ( level.the_bus maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_amb_bridge" ) )
{
near_bridge = 1;
}
_k800 = getNextArrayKey( _a800, _k800 );
}
if ( near_bridge )
{
trig = getent( "bridge_trig", "targetname" );
trig notify( "trigger" );
}
org = spawn( "script_model", level.the_bus gettagorigin( "tag_camera" ) );
org setmodel( "tag_origin" );
org.angles = level.the_bus gettagangles( "tag_camera" );
org linkto( level.the_bus );
self setorigin( org.origin );
self.angles = org.angles;
if ( !flag( "OnPriDoorYar" ) || !flag( "OnPriDoorYar2" ) )
{
flag_set( "OnPriDoorYar" );
wait_network_frame();
}
if ( !level.the_bus.ismoving )
{
level.the_bus.gracetimeatdestination = 0,1;
level.the_bus notify( "depart_early" );
}
players = get_players();
j = 0;
while ( j < players.size )
{
player = players[ j ];
player camerasetposition( org );
player camerasetlookat();
player cameraactivate( 1 );
j++;
}
self.game_over_bg fadeovertime( 1 );
self.game_over_bg.alpha = 0;
wait 12;
self.game_over_bg fadeovertime( 1 );
self.game_over_bg.alpha = 1;
wait 1;
}
}
transit_zone_init()
{
flag_init( "always_on" );
flag_set( "always_on" );
add_adjacent_zone( "zone_roadside_west", "zone_din", "always_on" );
add_adjacent_zone( "zone_roadside_west", "zone_gas", "always_on" );
add_adjacent_zone( "zone_roadside_east", "zone_gas", "always_on" );
add_adjacent_zone( "zone_roadside_east", "zone_gar", "always_on" );
add_adjacent_zone( "zone_gas", "zone_din", "always_on" );
add_adjacent_zone( "zone_gas", "zone_gar", "always_on" );
}
include_powerups()
{
gametype = getDvar( "ui_gametype" );
include_powerup( "nuke" );
include_powerup( "insta_kill" );
include_powerup( "double_points" );
include_powerup( "full_ammo" );
if ( gametype != "zgrief" )
{
include_powerup( "carpenter" );
}
}
claymore_safe_to_plant()
{
if ( self maps/mp/zm_transit_lava::object_touching_lava() )
{
return 0;
}
if ( self.owner maps/mp/zm_transit_lava::object_touching_lava() )
{
return 0;
}
return 1;
}
grenade_safe_to_throw( player, weapname )
{
return 1;
}
grenade_safe_to_bounce( player, weapname )
{
if ( !is_offhand_weapon( weapname ) && !is_grenade_launcher( weapname ) )
{
return 1;
}
if ( self maps/mp/zm_transit_lava::object_touching_lava() )
{
return 0;
}
return 1;
}
offhand_weapon_overrride()
{
register_lethal_grenade_for_level( "frag_grenade_zm" );
level.zombie_lethal_grenade_player_init = "frag_grenade_zm";
register_tactical_grenade_for_level( "cymbal_monkey_zm" );
level.zombie_tactical_grenade_player_init = undefined;
level.grenade_safe_to_throw = ::grenade_safe_to_throw;
level.grenade_safe_to_bounce = ::grenade_safe_to_bounce;
level.zombie_placeable_mine_player_init = undefined;
level.claymore_safe_to_plant = ::claymore_safe_to_plant;
register_melee_weapon_for_level( "knife_zm" );
register_melee_weapon_for_level( "bowie_knife_zm" );
level.zombie_melee_weapon_player_init = "knife_zm";
level.zombie_equipment_player_init = undefined;
}
include_weapons()
{
gametype = getDvar( "ui_gametype" );
include_weapon( "knife_zm", 0 );
include_weapon( "frag_grenade_zm", 0 );
include_weapon( "m1911_zm", 0 );
include_weapon( "m1911_upgraded_zm", 0 );
include_weapon( "python_zm" );
include_weapon( "python_upgraded_zm", 0 );
include_weapon( "judge_zm" );
include_weapon( "judge_upgraded_zm", 0 );
include_weapon( "kard_zm" );
include_weapon( "kard_upgraded_zm", 0 );
include_weapon( "fiveseven_zm" );
include_weapon( "fiveseven_upgraded_zm", 0 );
include_weapon( "beretta93r_zm", 0 );
include_weapon( "beretta93r_upgraded_zm", 0 );
include_weapon( "fivesevendw_zm" );
include_weapon( "fivesevendw_upgraded_zm", 0 );
include_weapon( "ak74u_zm", 0 );
include_weapon( "ak74u_upgraded_zm", 0 );
include_weapon( "mp5k_zm", 0 );
include_weapon( "mp5k_upgraded_zm", 0 );
include_weapon( "qcw05_zm" );
include_weapon( "qcw05_upgraded_zm", 0 );
include_weapon( "870mcs_zm", 0 );
include_weapon( "870mcs_upgraded_zm", 0 );
include_weapon( "rottweil72_zm", 0 );
include_weapon( "rottweil72_upgraded_zm", 0 );
include_weapon( "saiga12_zm" );
include_weapon( "saiga12_upgraded_zm", 0 );
include_weapon( "srm1216_zm" );
include_weapon( "srm1216_upgraded_zm", 0 );
include_weapon( "m14_zm", 0 );
include_weapon( "m14_upgraded_zm", 0 );
include_weapon( "saritch_zm" );
include_weapon( "saritch_upgraded_zm", 0 );
include_weapon( "m16_zm", 0 );
include_weapon( "m16_gl_upgraded_zm", 0 );
include_weapon( "xm8_zm" );
include_weapon( "xm8_upgraded_zm", 0 );
include_weapon( "type95_zm" );
include_weapon( "type95_upgraded_zm", 0 );
include_weapon( "tar21_zm" );
include_weapon( "tar21_upgraded_zm", 0 );
include_weapon( "galil_zm" );
include_weapon( "galil_upgraded_zm", 0 );
include_weapon( "fnfal_zm" );
include_weapon( "fnfal_upgraded_zm", 0 );
include_weapon( "dsr50_zm" );
include_weapon( "dsr50_upgraded_zm", 0 );
include_weapon( "barretm82_zm" );
include_weapon( "barretm82_upgraded_zm", 0 );
include_weapon( "rpd_zm" );
include_weapon( "rpd_upgraded_zm", 0 );
include_weapon( "hamr_zm" );
include_weapon( "hamr_upgraded_zm", 0 );
include_weapon( "usrpg_zm" );
include_weapon( "usrpg_upgraded_zm", 0 );
include_weapon( "m32_zm" );
include_weapon( "m32_upgraded_zm", 0 );
include_weapon( "hk416_zm" );
include_weapon( "hk416_upgraded_zm", 0 );
include_weapon( "cymbal_monkey_zm" );
if ( gametype != "zgrief" )
{
include_weapon( "ray_gun_zm" );
include_weapon( "ray_gun_upgraded_zm", 0 );
add_limited_weapon( "ray_gun_zm", 4 );
add_limited_weapon( "ray_gun_upgraded_zm", 4 );
}
add_limited_weapon( "m1911_zm", 0 );
}
less_than_normal()
{
return 0,5;
}
custom_add_weapons()
{
add_zombie_weapon( "m1911_zm", "m1911_upgraded_zm", &"ZOMBIE_WEAPON_M1911", 50, "", "", undefined );
add_zombie_weapon( "python_zm", "python_upgraded_zm", &"ZOMBIE_WEAPON_PYTHON", 50, "wpck_python", "", undefined, 1 );
add_zombie_weapon( "judge_zm", "judge_upgraded_zm", &"ZOMBIE_WEAPON_JUDGE", 50, "wpck_judge", "", undefined, 1 );
add_zombie_weapon( "kard_zm", "kard_upgraded_zm", &"ZOMBIE_WEAPON_KARD", 50, "wpck_kap", "", undefined, 1 );
add_zombie_weapon( "fiveseven_zm", "fiveseven_upgraded_zm", &"ZOMBIE_WEAPON_FIVESEVEN", 50, "wpck_57", "", undefined, 1 );
add_zombie_weapon( "beretta93r_zm", "beretta93r_upgraded_zm", &"ZOMBIE_WEAPON_BERETTA93r", 1000, "", "", undefined );
add_zombie_weapon( "fivesevendw_zm", "fivesevendw_upgraded_zm", &"ZOMBIE_WEAPON_FIVESEVENDW", 50, "wpck_duel57", "", undefined, 1 );
add_zombie_weapon( "ak74u_zm", "ak74u_upgraded_zm", &"ZOMBIE_WEAPON_AK74U", 1200, "smg", "", undefined );
add_zombie_weapon( "mp5k_zm", "mp5k_upgraded_zm", &"ZOMBIE_WEAPON_MP5K", 1000, "smg", "", undefined );
add_zombie_weapon( "qcw05_zm", "qcw05_upgraded_zm", &"ZOMBIE_WEAPON_QCW05", 50, "wpck_chicom", "", undefined, 1 );
add_zombie_weapon( "870mcs_zm", "870mcs_upgraded_zm", &"ZOMBIE_WEAPON_870MCS", 1500, "shotgun", "", undefined );
add_zombie_weapon( "rottweil72_zm", "rottweil72_upgraded_zm", &"ZOMBIE_WEAPON_ROTTWEIL72", 500, "shotgun", "", undefined );
add_zombie_weapon( "saiga12_zm", "saiga12_upgraded_zm", &"ZOMBIE_WEAPON_SAIGA12", 50, "wpck_saiga12", "", undefined, 1 );
add_zombie_weapon( "srm1216_zm", "srm1216_upgraded_zm", &"ZOMBIE_WEAPON_SRM1216", 50, "wpck_m1216", "", undefined, 1 );
add_zombie_weapon( "m14_zm", "m14_upgraded_zm", &"ZOMBIE_WEAPON_M14", 500, "rifle", "", undefined );
add_zombie_weapon( "saritch_zm", "saritch_upgraded_zm", &"ZOMBIE_WEAPON_SARITCH", 50, "wpck_sidr", "", undefined, 1 );
add_zombie_weapon( "m16_zm", "m16_gl_upgraded_zm", &"ZOMBIE_WEAPON_M16", 1200, "burstrifle", "", undefined );
add_zombie_weapon( "xm8_zm", "xm8_upgraded_zm", &"ZOMBIE_WEAPON_XM8", 50, "wpck_m8a1", "", undefined, 1 );
add_zombie_weapon( "type95_zm", "type95_upgraded_zm", &"ZOMBIE_WEAPON_TYPE95", 50, "wpck_type25", "", undefined, 1 );
add_zombie_weapon( "tar21_zm", "tar21_upgraded_zm", &"ZOMBIE_WEAPON_TAR21", 50, "wpck_x95l", "", undefined, 1 );
add_zombie_weapon( "galil_zm", "galil_upgraded_zm", &"ZOMBIE_WEAPON_GALIL", 50, "wpck_galil", "", undefined, 1 );
add_zombie_weapon( "fnfal_zm", "fnfal_upgraded_zm", &"ZOMBIE_WEAPON_FNFAL", 50, "wpck_fal", "", undefined, 1 );
add_zombie_weapon( "dsr50_zm", "dsr50_upgraded_zm", &"ZOMBIE_WEAPON_DR50", 50, "wpck_dsr50", "", undefined, 1 );
add_zombie_weapon( "barretm82_zm", "barretm82_upgraded_zm", &"ZOMBIE_WEAPON_BARRETM82", 50, "sniper", "", undefined );
add_zombie_weapon( "rpd_zm", "rpd_upgraded_zm", &"ZOMBIE_WEAPON_RPD", 50, "wpck_rpd", "", undefined, 1 );
add_zombie_weapon( "hamr_zm", "hamr_upgraded_zm", &"ZOMBIE_WEAPON_HAMR", 50, "wpck_hamr", "", undefined, 1 );
add_zombie_weapon( "frag_grenade_zm", undefined, &"ZOMBIE_WEAPON_FRAG_GRENADE", 250, "grenade", "", 250 );
add_zombie_weapon( "usrpg_zm", "usrpg_upgraded_zm", &"ZOMBIE_WEAPON_USRPG", 50, "wpck_rpg", "", undefined, 1 );
add_zombie_weapon( "m32_zm", "m32_upgraded_zm", &"ZOMBIE_WEAPON_M32", 50, "wpck_m32", "", undefined, 1 );
add_zombie_weapon( "cymbal_monkey_zm", undefined, &"ZOMBIE_WEAPON_SATCHEL_2000", 2000, "wpck_monkey", "", undefined, 1 );
add_zombie_weapon( "ray_gun_zm", "ray_gun_upgraded_zm", &"ZOMBIE_WEAPON_RAYGUN", 10000, "wpck_ray", "", undefined, 1 );
add_zombie_weapon( "hk416_zm", "hk416_upgraded_zm", &"ZOMBIE_WEAPON_HK416", 100, "", "", undefined );
}
include_game_modules()
{
}
initial_round_wait_func()
{
flag_wait( "initial_blackscreen_passed" );
}
zombie_init_done()
{
self.allowpain = 0;
}
setup_zombie_init()
{
zombies = getentarray( "zombie_spawner", "script_noteworthy" );
}
assign_lowest_unused_character_index()
{
charindexarray = [];
charindexarray[ 0 ] = 0;
charindexarray[ 1 ] = 1;
charindexarray[ 2 ] = 2;
charindexarray[ 3 ] = 3;
players = get_players();
if ( players.size == 1 )
{
charindexarray = array_randomize( charindexarray );
return charindexarray[ 0 ];
}
else
{
if ( players.size == 2 )
{
_a1250 = players;
_k1250 = getFirstArrayKey( _a1250 );
while ( isDefined( _k1250 ) )
{
player = _a1250[ _k1250 ];
if ( isDefined( player.characterindex ) )
{
if ( player.characterindex == 2 || player.characterindex == 0 )
{
if ( randomint( 100 ) > 50 )
{
return 1;
}
return 3;
}
else
{
if ( player.characterindex == 3 || player.characterindex == 1 )
{
if ( randomint( 100 ) > 50 )
{
return 0;
}
return 2;
}
}
}
_k1250 = getNextArrayKey( _a1250, _k1250 );
}
}
else _a1276 = players;
_k1276 = getFirstArrayKey( _a1276 );
while ( isDefined( _k1276 ) )
{
player = _a1276[ _k1276 ];
if ( isDefined( player.characterindex ) )
{
arrayremovevalue( charindexarray, player.characterindex, 0 );
}
_k1276 = getNextArrayKey( _a1276, _k1276 );
}
if ( charindexarray.size > 0 )
{
return charindexarray[ 0 ];
}
}
return 0;
}
zombie_transit_dr_devgui( cmd )
{
/#
cmd_strings = strtok( cmd, " " );
switch( cmd_strings[ 0 ] )
{
case "blue_monkey":
case "green_ammo":
case "green_double":
case "green_insta":
case "green_monkey":
case "green_nuke":
case "red_ammo":
case "red_double":
case "red_nuke":
case "yellow_double":
case "yellow_nuke":
maps/mp/zombies/_zm_devgui::zombie_devgui_give_powerup( cmd_strings[ 0 ], 1 );
break;
case "less_time":
less_time();
break;
case "more_time":
more_time();
break;
default:
}
#/
}
}
less_time()
{
/#
level.time_to_add = 30000;
if ( !isDefined( level.time_to_remove ) )
{
level.time_to_remove = 60000;
}
else
{
level.time_to_remove *= 2;
}
if ( maps/mp/gametypes_zm/_globallogic_utils::gettimeremaining() < level.time_to_remove )
{
level.time_to_remove = maps/mp/gametypes_zm/_globallogic_utils::gettimeremaining() / 2;
}
level.discardtime -= level.time_to_remove;
#/
}
more_time()
{
/#
level.time_to_remove = 30000;
if ( !isDefined( level.time_to_add ) )
{
level.time_to_add = 60000;
}
else
{
level.time_to_add *= 2;
}
level.discardtime += level.time_to_add;
#/
}
init_transit_dr_stats()
{
self maps/mp/zm_transit_dr_achievement::init_player_achievement_stats();
}

62
zm_transit_dr_patch/maps/mp/zm_transit_dr_achievement.gsc Normal file
View File

@ -0,0 +1,62 @@
#include maps/mp/gametypes_zm/_globallogic_score;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
level.achievement_sound_func = ::achievement_sound_func;
onplayerconnect_callback( ::onplayerconnect );
}
achievement_sound_func( achievement_name_lower )
{
self thread do_player_general_vox( "general", "achievement" );
}
init_player_achievement_stats()
{
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc1_polyarmory", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc1_monkey_see_monkey_doom", 0 );
self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc1_i_see_live_people", 0 );
}
onplayerconnect()
{
if ( gamemodeismode( level.gamemode_public_match ) )
{
self thread achievement_polyarmory();
self thread achievement_monkey_see_monkey_doom();
self thread achievement_i_see_live_people();
}
}
achievement_polyarmory()
{
level endon( "end_game" );
self endon( "disconnect" );
self waittill( "gun_game_achievement" );
/#
#/
self giveachievement_wrapper( "ZM_DLC1_POLYARMORY" );
}
achievement_monkey_see_monkey_doom()
{
level endon( "end_game" );
self endon( "disconnect" );
self waittill( "powerup_blue_monkey" );
/#
#/
self giveachievement_wrapper( "ZM_DLC1_MONKEY_SEE_MONKEY_DOOM" );
}
achievement_i_see_live_people()
{
level endon( "end_game" );
self endon( "disconnect" );
self waittill( "invisible_player_killed" );
/#
#/
self giveachievement_wrapper( "ZM_DLC1_I_SEE_LIVE_PEOPLE" );
}

11
zm_transit_dr_patch/maps/mp/zm_transit_dr_ffotd.gsc Normal file
View File

@ -0,0 +1,11 @@
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
main_start()
{
}
main_end()
{
}

121
zm_transit_dr_patch/maps/mp/zm_transit_dr_fx.gsc Normal file
View File

@ -0,0 +1,121 @@
#include maps/mp/_utility;
main()
{
precache_createfx_fx();
precache_scripted_fx();
maps/mp/createfx/zm_transit_fx::main();
maps/mp/createart/zm_transit_art::main();
}
precache_scripted_fx()
{
level._effect[ "switch_sparks" ] = loadfx( "env/electrical/fx_elec_wire_spark_burst" );
level._effect[ "maxis_sparks" ] = loadfx( "maps/zombie/fx_zmb_race_trail_grief" );
level._effect[ "richtofen_sparks" ] = loadfx( "maps/zombie/fx_zmb_race_trail_neutral" );
level._effect[ "sq_common_lightning" ] = loadfx( "maps/zombie/fx_zmb_tranzit_sq_lightning_orb" );
level._effect[ "zapper_light_ready" ] = loadfx( "maps/zombie/fx_zombie_zapper_light_green" );
level._effect[ "zapper_light_notready" ] = loadfx( "maps/zombie/fx_zombie_zapper_light_red" );
level._effect[ "lght_marker" ] = loadfx( "maps/zombie/fx_zmb_tranzit_marker" );
level._effect[ "lght_marker_flare" ] = loadfx( "maps/zombie/fx_zmb_tranzit_marker_fl" );
level._effect[ "poltergeist" ] = loadfx( "misc/fx_zombie_couch_effect" );
level._effect[ "zomb_gib" ] = loadfx( "maps/zombie/fx_zmb_tranzit_lava_torso_explo" );
level._effect[ "fx_headlight" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bus_headlight" );
level._effect[ "fx_headlight_lenflares" ] = loadfx( "lens_flares/fx_lf_zmb_tranzit_bus_headlight" );
level._effect[ "fx_brakelight" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bus_brakelights" );
level._effect[ "fx_emergencylight" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bus_flashing_lights" );
level._effect[ "fx_turn_signal_right" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bus_turnsignal_right" );
level._effect[ "fx_turn_signal_left" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bus_turnsignal_left" );
level._effect[ "fx_zbus_trans_fog" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bus_fog_intersect" );
level._effect[ "bus_lava_driving" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bus_fire_driving" );
level._effect[ "bus_hatch_bust" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bus_hatch_bust" );
level._effect[ "elec_md" ] = loadfx( "electrical/fx_elec_player_md" );
level._effect[ "elec_sm" ] = loadfx( "electrical/fx_elec_player_sm" );
level._effect[ "elec_torso" ] = loadfx( "electrical/fx_elec_player_torso" );
level._effect[ "blue_eyes" ] = loadfx( "maps/zombie/fx_zombie_eye_single_blue" );
level._effect[ "lava_burning" ] = loadfx( "env/fire/fx_fire_lava_player_torso" );
level._effect[ "mc_trafficlight" ] = loadfx( "maps/zombie/fx_zmb_morsecode_traffic_loop" );
level._effect[ "mc_towerlight" ] = loadfx( "maps/zombie/fx_zmb_morsecode_loop" );
}
precache_createfx_fx()
{
level._effect[ "fx_insects_swarm_md_light" ] = loadfx( "bio/insects/fx_insects_swarm_md_light" );
level._effect[ "fx_zmb_tranzit_flourescent_flicker" ] = loadfx( "maps/zombie/fx_zmb_tranzit_flourescent_flicker" );
level._effect[ "fx_zmb_tranzit_flourescent_glow" ] = loadfx( "maps/zombie/fx_zmb_tranzit_flourescent_glow" );
level._effect[ "fx_zmb_tranzit_flourescent_glow_lg" ] = loadfx( "maps/zombie/fx_zmb_tranzit_flourescent_glow_lg" );
level._effect[ "fx_zmb_tranzit_flourescent_dbl_glow" ] = loadfx( "maps/zombie/fx_zmb_tranzit_flourescent_dbl_glow" );
level._effect[ "fx_zmb_tranzit_depot_map_flicker" ] = loadfx( "maps/zombie/fx_zmb_tranzit_depot_map_flicker" );
level._effect[ "fx_zmb_tranzit_light_bulb_xsm" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_bulb_xsm" );
level._effect[ "fx_zmb_tranzit_light_glow" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_glow" );
level._effect[ "fx_zmb_tranzit_light_glow_xsm" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_glow_xsm" );
level._effect[ "fx_zmb_tranzit_light_glow_fog" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_glow_fog" );
level._effect[ "fx_zmb_tranzit_light_depot_cans" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_depot_cans" );
level._effect[ "fx_zmb_tranzit_light_desklamp" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_desklamp" );
level._effect[ "fx_zmb_tranzit_light_town_cans" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_town_cans" );
level._effect[ "fx_zmb_tranzit_light_town_cans_sm" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_town_cans_sm" );
level._effect[ "fx_zmb_tranzit_light_street_tinhat" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_street_tinhat" );
level._effect[ "fx_zmb_tranzit_street_lamp" ] = loadfx( "maps/zombie/fx_zmb_tranzit_street_lamp" );
level._effect[ "fx_zmb_tranzit_truck_light" ] = loadfx( "maps/zombie/fx_zmb_tranzit_truck_light" );
level._effect[ "fx_zmb_tranzit_spark_int_runner" ] = loadfx( "maps/zombie/fx_zmb_tranzit_spark_int_runner" );
level._effect[ "fx_zmb_tranzit_spark_ext_runner" ] = loadfx( "maps/zombie/fx_zmb_tranzit_spark_ext_runner" );
level._effect[ "fx_zmb_tranzit_spark_blue_lg_loop" ] = loadfx( "maps/zombie/fx_zmb_tranzit_spark_blue_lg_loop" );
level._effect[ "fx_zmb_tranzit_spark_blue_sm_loop" ] = loadfx( "maps/zombie/fx_zmb_tranzit_spark_blue_sm_loop" );
level._effect[ "fx_zmb_tranzit_bar_glow" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bar_glow" );
level._effect[ "fx_zmb_tranzit_transformer_on" ] = loadfx( "maps/zombie/fx_zmb_tranzit_transformer_on" );
level._effect[ "fx_zmb_fog_closet" ] = loadfx( "fog/fx_zmb_fog_closet" );
level._effect[ "fx_zmb_fog_low_300x300" ] = loadfx( "fog/fx_zmb_fog_low_300x300" );
level._effect[ "fx_zmb_fog_thick_600x600" ] = loadfx( "fog/fx_zmb_fog_thick_600x600" );
level._effect[ "fx_zmb_fog_thick_1200x600" ] = loadfx( "fog/fx_zmb_fog_thick_1200x600" );
level._effect[ "fx_zmb_fog_transition_600x600" ] = loadfx( "fog/fx_zmb_fog_transition_600x600" );
level._effect[ "fx_zmb_fog_transition_1200x600" ] = loadfx( "fog/fx_zmb_fog_transition_1200x600" );
level._effect[ "fx_zmb_fog_transition_right_border" ] = loadfx( "fog/fx_zmb_fog_transition_right_border" );
level._effect[ "fx_zmb_tranzit_smk_interior_md" ] = loadfx( "maps/zombie/fx_zmb_tranzit_smk_interior_md" );
level._effect[ "fx_zmb_tranzit_smk_interior_heavy" ] = loadfx( "maps/zombie/fx_zmb_tranzit_smk_interior_heavy" );
level._effect[ "fx_zmb_ash_ember_1000x1000" ] = loadfx( "maps/zombie/fx_zmb_ash_ember_1000x1000" );
level._effect[ "fx_zmb_ash_ember_2000x1000" ] = loadfx( "maps/zombie/fx_zmb_ash_ember_2000x1000" );
level._effect[ "fx_zmb_ash_rising_md" ] = loadfx( "maps/zombie/fx_zmb_ash_rising_md" );
level._effect[ "fx_zmb_ash_windy_heavy_sm" ] = loadfx( "maps/zombie/fx_zmb_ash_windy_heavy_sm" );
level._effect[ "fx_zmb_ash_windy_heavy_md" ] = loadfx( "maps/zombie/fx_zmb_ash_windy_heavy_md" );
level._effect[ "fx_zmb_lava_detail" ] = loadfx( "maps/zombie/fx_zmb_lava_detail" );
level._effect[ "fx_zmb_lava_edge_100" ] = loadfx( "maps/zombie/fx_zmb_lava_edge_100" );
level._effect[ "fx_zmb_lava_50x50_sm" ] = loadfx( "maps/zombie/fx_zmb_lava_50x50_sm" );
level._effect[ "fx_zmb_lava_100x100" ] = loadfx( "maps/zombie/fx_zmb_lava_100x100" );
level._effect[ "fx_zmb_lava_river" ] = loadfx( "maps/zombie/fx_zmb_lava_river" );
level._effect[ "fx_zmb_lava_creek" ] = loadfx( "maps/zombie/fx_zmb_lava_creek" );
level._effect[ "fx_zmb_lava_crevice_glow_50" ] = loadfx( "maps/zombie/fx_zmb_lava_crevice_glow_50" );
level._effect[ "fx_zmb_lava_crevice_glow_100" ] = loadfx( "maps/zombie/fx_zmb_lava_crevice_glow_100" );
level._effect[ "fx_zmb_lava_crevice_smoke_100" ] = loadfx( "maps/zombie/fx_zmb_lava_crevice_smoke_100" );
level._effect[ "fx_zmb_lava_smoke_tall" ] = loadfx( "maps/zombie/fx_zmb_lava_smoke_tall" );
level._effect[ "fx_zmb_lava_smoke_pit" ] = loadfx( "maps/zombie/fx_zmb_lava_smoke_pit" );
level._effect[ "fx_zmb_tranzit_bowling_sign_fog" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bowling_sign_fog" );
level._effect[ "fx_zmb_tranzit_lava_distort" ] = loadfx( "maps/zombie/fx_zmb_tranzit_lava_distort" );
level._effect[ "fx_zmb_tranzit_lava_distort_sm" ] = loadfx( "maps/zombie/fx_zmb_tranzit_lava_distort_sm" );
level._effect[ "fx_zmb_tranzit_lava_distort_detail" ] = loadfx( "maps/zombie/fx_zmb_tranzit_lava_distort_detail" );
level._effect[ "fx_zmb_tranzit_fire_med" ] = loadfx( "maps/zombie/fx_zmb_tranzit_fire_med" );
level._effect[ "fx_zmb_tranzit_fire_lrg" ] = loadfx( "maps/zombie/fx_zmb_tranzit_fire_lrg" );
level._effect[ "fx_zmb_tranzit_smk_column_lrg" ] = loadfx( "maps/zombie/fx_zmb_tranzit_smk_column_lrg" );
level._effect[ "fx_zmb_papers_windy_slow" ] = loadfx( "maps/zombie/fx_zmb_papers_windy_slow" );
level._effect[ "fx_zmb_tranzit_god_ray_short_warm" ] = loadfx( "maps/zombie/fx_zmb_tranzit_god_ray_short_warm" );
level._effect[ "fx_zmb_tranzit_god_ray_vault" ] = loadfx( "maps/zombie/fx_zmb_tranzit_god_ray_vault" );
level._effect[ "fx_zmb_tranzit_key_glint" ] = loadfx( "maps/zombie/fx_zmb_tranzit_key_glint" );
level._effect[ "fx_zmb_tranzit_god_ray_interior_med" ] = loadfx( "maps/zombie/fx_zmb_tranzit_god_ray_interior_med" );
level._effect[ "fx_zmb_tranzit_god_ray_interior_long" ] = loadfx( "maps/zombie/fx_zmb_tranzit_god_ray_interior_long" );
level._effect[ "fx_zmb_tranzit_god_ray_depot_cool" ] = loadfx( "maps/zombie/fx_zmb_tranzit_god_ray_depot_cool" );
level._effect[ "fx_zmb_tranzit_god_ray_depot_warm" ] = loadfx( "maps/zombie/fx_zmb_tranzit_god_ray_depot_warm" );
level._effect[ "fx_zmb_tranzit_god_ray_tunnel_warm" ] = loadfx( "maps/zombie/fx_zmb_tranzit_god_ray_tunnel_warm" );
level._effect[ "fx_zmb_tranzit_god_ray_pwr_station" ] = loadfx( "maps/zombie/fx_zmb_tranzit_god_ray_pwr_station" );
level._effect[ "fx_zmb_tranzit_light_safety" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_safety" );
level._effect[ "fx_zmb_tranzit_light_safety_off" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_safety_off" );
level._effect[ "fx_zmb_tranzit_light_safety_max" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_safety_max" );
level._effect[ "fx_zmb_tranzit_light_safety_ric" ] = loadfx( "maps/zombie/fx_zmb_tranzit_light_safety_ric" );
level._effect[ "fx_zmb_tranzit_bridge_dest" ] = loadfx( "maps/zombie/fx_zmb_tranzit_bridge_dest" );
level._effect[ "fx_zmb_tranzit_power_pulse" ] = loadfx( "maps/zombie/fx_zmb_tranzit_power_pulse" );
level._effect[ "fx_zmb_tranzit_power_on" ] = loadfx( "maps/zombie/fx_zmb_tranzit_power_on" );
level._effect[ "fx_zmb_tranzit_power_rising" ] = loadfx( "maps/zombie/fx_zmb_tranzit_power_rising" );
level._effect[ "fx_zmb_avog_storm" ] = loadfx( "maps/zombie/fx_zmb_avog_storm" );
level._effect[ "fx_zmb_avog_storm_low" ] = loadfx( "maps/zombie/fx_zmb_avog_storm_low" );
level._effect[ "glass_impact" ] = loadfx( "maps/zombie/fx_zmb_tranzit_window_dest_lg" );
level._effect[ "fx_zmb_tranzit_spark_blue_lg_os" ] = loadfx( "maps/zombie/fx_zmb_tranzit_spark_blue_lg_os" );
level._effect[ "spawn_cloud" ] = loadfx( "maps/zombie/fx_zmb_race_zombie_spawn_cloud" );
}

15
zm_transit_dr_patch/maps/mp/zm_transit_dr_gamemodes.gsc Normal file
View File

@ -0,0 +1,15 @@
#include maps/mp/zm_transit_turned_diner;
#include maps/mp/zm_transit_dr;
#include maps/mp/gametypes_zm/_zm_gametype;
#include maps/mp/zm_transit_utility;
#include maps/mp/zombies/_zm_game_module;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
add_map_gamemode( "zcleansed", ::maps/mp/zm_transit_dr::zcleansed_preinit, undefined, undefined );
add_map_gamemode( "zturned", ::maps/mp/zm_transit_dr::zturned_preinit, undefined, undefined );
add_map_location_gamemode( "zcleansed", "diner", ::maps/mp/zm_transit_turned_diner::precache, ::maps/mp/zm_transit_turned_diner::main );
}

384
zm_transit_dr_patch/maps/mp/zm_transit_lava.gsc Normal file
View File

@ -0,0 +1,384 @@
#include maps/mp/animscripts/zm_death;
#include maps/mp/_visionset_mgr;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
object_touching_lava()
{
if ( !isDefined( level.lava ) )
{
level.lava = getentarray( "lava_damage", "targetname" );
}
if ( !isDefined( level.lava ) || level.lava.size < 1 )
{
return 0;
}
if ( isDefined( self.lasttouching ) && self istouching( self.lasttouching ) )
{
return 1;
}
i = 0;
while ( i < level.lava.size )
{
if ( distancesquared( self.origin, level.lava[ i ].origin ) < 2250000 )
{
if ( isDefined( level.lava[ i ].target ) )
{
if ( self istouching( level.lava[ i ].volume ) )
{
if ( isDefined( level.lava[ i ].script_float ) && level.lava[ i ].script_float <= 0,1 )
{
return 0;
}
self.lasttouching = level.lava[ i ].volume;
return 1;
}
}
else
{
if ( self istouching( level.lava[ i ] ) )
{
self.lasttouching = level.lava[ i ];
return 1;
}
}
}
i++;
}
self.lasttouching = undefined;
return 0;
}
lava_damage_init()
{
lava = getentarray( "lava_damage", "targetname" );
if ( !isDefined( lava ) )
{
return;
}
array_thread( lava, ::lava_damage_think );
}
lava_damage_think()
{
self._trap_type = "";
if ( isDefined( self.script_noteworthy ) )
{
self._trap_type = self.script_noteworthy;
}
if ( isDefined( self.target ) )
{
self.volume = getent( self.target, "targetname" );
/#
assert( isDefined( self.volume ), "No volume found for lava target " + self.target );
#/
}
while ( 1 )
{
self waittill( "trigger", ent );
if ( isDefined( ent.ignore_lava_damage ) && ent.ignore_lava_damage )
{
continue;
}
while ( isDefined( ent.is_burning ) )
{
continue;
}
if ( isDefined( self.target ) && !ent istouching( self.volume ) )
{
continue;
}
if ( isplayer( ent ) )
{
switch( self._trap_type )
{
case "fire":
default:
if ( !isDefined( self.script_float ) || self.script_float >= 0,1 )
{
ent thread player_lava_damage( self );
}
break;
}
break;
continue;
}
else if ( !isDefined( ent.marked_for_death ) )
{
switch( self._trap_type )
{
case "fire":
default:
if ( !isDefined( self.script_float ) || self.script_float >= 0,1 )
{
ent thread zombie_lava_damage( self );
}
break;
break;
}
}
}
}
player_lava_damage( trig )
{
self endon( "zombified" );
self endon( "death" );
self endon( "disconnect" );
max_dmg = 15;
min_dmg = 5;
burn_time = 1;
if ( isDefined( self.is_zombie ) && self.is_zombie )
{
return;
}
self thread player_stop_burning();
if ( isDefined( trig.script_float ) )
{
max_dmg *= trig.script_float;
min_dmg *= trig.script_float;
burn_time *= trig.script_float;
if ( burn_time >= 1,5 )
{
burn_time = 1,5;
}
}
if ( !isDefined( self.is_burning ) && is_player_valid( self ) )
{
self.is_burning = 1;
maps/mp/_visionset_mgr::vsmgr_activate( "overlay", "zm_transit_burn", self, burn_time, level.zm_transit_burn_max_duration );
self notify( "burned" );
if ( isDefined( trig.script_float ) && trig.script_float >= 0,1 )
{
self thread player_burning_fx();
}
if ( !self hasperk( "specialty_armorvest" ) || ( self.health - 100 ) < 1 )
{
radiusdamage( self.origin, 10, max_dmg, min_dmg );
wait 0,5;
self.is_burning = undefined;
return;
}
else
{
if ( self hasperk( "specialty_armorvest" ) )
{
self dodamage( 15, self.origin );
}
else
{
self dodamage( 1, self.origin );
}
wait 0,5;
self.is_burning = undefined;
}
}
}
player_stop_burning()
{
self notify( "player_stop_burning" );
self endon( "player_stop_burning" );
self endon( "death_or_disconnect" );
self waittill( "zombified" );
self notify( "stop_flame_damage" );
maps/mp/_visionset_mgr::vsmgr_deactivate( "overlay", "zm_transit_burn", self );
}
zombie_burning_fx()
{
self endon( "death" );
if ( isDefined( self.is_on_fire ) && self.is_on_fire )
{
return;
}
self.is_on_fire = 1;
self thread maps/mp/animscripts/zm_death::on_fire_timeout();
if ( isDefined( level._effect ) && isDefined( level._effect[ "lava_burning" ] ) )
{
if ( !self.isdog )
{
playfxontag( level._effect[ "lava_burning" ], self, "J_SpineLower" );
self thread zombie_burning_audio();
}
}
if ( isDefined( level._effect ) && isDefined( level._effect[ "character_fire_death_sm" ] ) )
{
wait 1;
if ( randomint( 2 ) > 1 )
{
tagarray = [];
tagarray[ 0 ] = "J_Elbow_LE";
tagarray[ 1 ] = "J_Elbow_RI";
tagarray[ 2 ] = "J_Knee_RI";
tagarray[ 3 ] = "J_Knee_LE";
tagarray = randomize_array( tagarray );
playfxontag( level._effect[ "character_fire_death_sm" ], self, tagarray[ 0 ] );
return;
}
else
{
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 = randomize_array( tagarray );
playfxontag( level._effect[ "character_fire_death_sm" ], self, tagarray[ 0 ] );
}
}
}
zombie_burning_audio()
{
self playloopsound( "zmb_fire_loop" );
self waittill_either( "stop_flame_damage", "death" );
if ( isDefined( self ) && isalive( self ) )
{
self stoploopsound( 0,25 );
}
}
player_burning_fx()
{
self endon( "death" );
if ( isDefined( self.is_on_fire ) && self.is_on_fire )
{
return;
}
if ( isDefined( self.no_burning_sfx ) && !self.no_burning_sfx )
{
self thread player_burning_audio();
}
self.is_on_fire = 1;
self thread maps/mp/animscripts/zm_death::on_fire_timeout();
if ( isDefined( level._effect ) && isDefined( level._effect[ "character_fire_death_sm" ] ) )
{
playfxontag( level._effect[ "character_fire_death_sm" ], self, "J_SpineLower" );
}
}
player_burning_audio()
{
fire_ent = spawn( "script_model", self.origin );
wait_network_frame();
fire_ent linkto( self );
fire_ent playloopsound( "evt_plr_fire_loop" );
self waittill_any( "stop_flame_damage", "stop_flame_sounds", "death", "discoonect" );
fire_ent delete();
}
zombie_lava_damage( trap )
{
self endon( "death" );
zombie_dmg = 1;
if ( isDefined( self.script_float ) )
{
zombie_dmg *= self.script_float;
}
switch( trap._trap_type )
{
case "fire":
default:
if ( isDefined( self.animname ) || !isDefined( self.is_on_fire ) && !self.is_on_fire )
{
if ( level.burning_zombies.size < 6 && zombie_dmg >= 1 )
{
level.burning_zombies[ level.burning_zombies.size ] = self;
self playsound( "ignite" );
self thread zombie_burning_fx();
self thread zombie_burning_watch();
self thread zombie_burning_dmg();
self thread zombie_exploding_death( zombie_dmg, trap );
wait randomfloat( 1,25 );
}
}
if ( self.health > ( level.zombie_health / 2 ) && self.health > zombie_dmg )
{
self dodamage( zombie_dmg, self.origin, trap );
}
break;
}
}
zombie_burning_watch()
{
self waittill_any( "stop_flame_damage", "death" );
arrayremovevalue( level.burning_zombies, self );
}
zombie_exploding_death( zombie_dmg, trap )
{
self endon( "stop_flame_damage" );
if ( isDefined( self.isdog ) && self.isdog && isDefined( self.a.nodeath ) )
{
return;
}
while ( isDefined( self ) && self.health >= zombie_dmg && isDefined( self.is_on_fire ) && self.is_on_fire )
{
wait 0,5;
}
if ( isDefined( self ) && isDefined( self.is_on_fire ) && self.is_on_fire && isDefined( self.damageweapon ) && self.damageweapon != "tazer_knuckles_zm" || self.damageweapon == "jetgun_zm" && isDefined( self.knuckles_extinguish_flames ) && self.knuckles_extinguish_flames )
{
return;
}
tag = "J_SpineLower";
if ( isDefined( self.animname ) && self.animname == "zombie_dog" )
{
tag = "tag_origin";
}
if ( is_mature() )
{
if ( isDefined( level._effect[ "zomb_gib" ] ) )
{
playfx( level._effect[ "zomb_gib" ], self gettagorigin( tag ) );
}
}
else
{
if ( isDefined( level._effect[ "spawn_cloud" ] ) )
{
playfx( level._effect[ "spawn_cloud" ], self gettagorigin( tag ) );
}
}
self radiusdamage( self.origin, 128, 30, 15, undefined, "MOD_EXPLOSIVE" );
self ghost();
if ( isDefined( self.isdog ) && self.isdog )
{
self hide();
}
else
{
self delay_thread( 1, ::self_delete );
}
}
zombie_burning_dmg()
{
self endon( "death" );
damageradius = 25;
damage = 2;
while ( isDefined( self.is_on_fire ) && self.is_on_fire )
{
eyeorigin = self geteye();
players = get_players();
i = 0;
while ( i < players.size )
{
if ( is_player_valid( players[ i ] ) )
{
playereye = players[ i ] geteye();
if ( distancesquared( eyeorigin, playereye ) < ( damageradius * damageradius ) )
{
players[ i ] dodamage( damage, self.origin, self );
players[ i ] notify( "burned" );
}
}
i++;
}
wait 1;
}
}

583
zm_transit_dr_patch/maps/mp/zm_transit_power.gsc Normal file
View File

@ -0,0 +1,583 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_zonemgr;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/_visionset_mgr;
#include maps/mp/zm_transit_utility;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
initializepower()
{
level thread electricswitch();
level thread powerevent();
registerclientfield( "toplayer", "power_rumble", 1, 1, "int" );
if ( !isDefined( level.vsmgr_prio_visionset_zm_transit_power_high_low ) )
{
level.vsmgr_prio_visionset_zm_transit_power_high_low = 20;
}
maps/mp/_visionset_mgr::vsmgr_register_info( "visionset", "zm_power_high_low", 1, level.vsmgr_prio_visionset_zm_transit_power_high_low, 7, 1, ::vsmgr_lerp_power_up_down, 0 );
}
precache_models()
{
}
elecswitchbuildable()
{
lever = getent( "powerswitch_p6_zm_buildable_pswitch_lever", "targetname" );
hand = getent( "powerswitch_p6_zm_buildable_pswitch_hand", "targetname" );
hand linkto( lever );
hand hide();
getent( "powerswitch_p6_zm_buildable_pswitch_body", "targetname" ) hide();
lever hide();
wait_for_buildable( "powerswitch" );
}
electricswitch()
{
flag_init( "switches_on" );
level thread wait_for_power();
trig = getent( "powerswitch_buildable_trigger_power", "targetname" );
trig setinvisibletoall();
elecswitchbuildable();
master_switch = getent( "powerswitch_p6_zm_buildable_pswitch_lever", "targetname" );
while ( 1 )
{
trig sethintstring( &"ZOMBIE_ELECTRIC_SWITCH" );
trig setvisibletoall();
trig waittill( "trigger", user );
trig setinvisibletoall();
master_switch rotateroll( -90, 0,3 );
master_switch playsound( "zmb_switch_flip" );
master_switch waittill( "rotatedone" );
playfx( level._effect[ "switch_sparks" ], getstruct( "elec_switch_fx", "targetname" ).origin );
master_switch playsound( "zmb_turn_on" );
level.power_event_in_progress = 1;
level thread power_event_rumble_and_quake();
flag_set( "switches_on" );
clientnotify( "pwr" );
level thread avogadro_show_vox( user );
level waittill( "power_event_complete" );
clientnotify( "pwr" );
flag_set( "power_on" );
level.power_event_in_progress = 0;
level thread bus_station_pa_vox();
if ( isDefined( user ) )
{
user maps/mp/zombies/_zm_stats::increment_client_stat( "power_turnedon", 0 );
user maps/mp/zombies/_zm_stats::increment_player_stat( "power_turnedon" );
}
trig sethintstring( &"ZOMBIE_ELECTRIC_SWITCH_OFF" );
trig setvisibletoall();
trig waittill( "trigger", user );
trig setinvisibletoall();
master_switch rotateroll( 90, 0,3 );
master_switch playsound( "zmb_switch_flip" );
master_switch waittill( "rotatedone" );
level.power_event_in_progress = 1;
level thread power_event_rumble_and_quake();
flag_clear( "switches_on" );
level waittill( "power_event_complete" );
clientnotify( "pwo" );
flag_clear( "power_on" );
level.power_event_in_progress = 0;
level.power_cycled = 1;
if ( isDefined( user ) )
{
user maps/mp/zombies/_zm_stats::increment_client_stat( "power_turnedoff", 0 );
user maps/mp/zombies/_zm_stats::increment_player_stat( "power_turnedoff" );
}
}
}
vsmgr_lerp_power_up_down( player, opt_param_1, opt_param_2 )
{
self vsmgr_set_state_active( player, opt_param_1 );
}
power_event_vision_set_post_event()
{
self endon( "end_vision_set_power" );
level endon( "end_game" );
self endon( "disconnect" );
if ( flag( "power_on" ) )
{
return;
}
level waittill( "power_event_complete" );
maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_power_high_low", self, 0 );
}
power_event_vision_set()
{
self endon( "end_vision_set_power" );
level endon( "end_game" );
level endon( "power_event_complete" );
self endon( "disconnect" );
if ( flag( "power_on" ) )
{
return;
}
duration = 2;
startgoal = 1;
endgoal = 0;
self power_event_vision_set_lerp( duration, startgoal, endgoal );
while ( 1 )
{
if ( randomint( 100 ) > 50 )
{
duration = randomintrange( 2, 6 ) / 5;
startgoal = endgoal;
if ( startgoal > 0,6 )
{
endgoal = randomfloatrange( 0, 0,5 );
}
else
{
endgoal = 1;
}
self power_event_vision_set_lerp( duration, startgoal, endgoal );
}
else if ( randomint( 100 ) > 75 )
{
x = 2;
while ( x > 0 )
{
duration = 0,2;
startgoal = endgoal;
if ( startgoal > 0,6 )
{
endgoal = 0;
}
else
{
endgoal = 1;
}
self power_event_vision_set_lerp( duration, startgoal, endgoal );
x--;
}
}
else duration = 0,4;
startgoal = endgoal;
if ( startgoal > 0,6 )
{
endgoal = randomfloatrange( 0, 0,5 );
}
else
{
endgoal = randomfloatrange( 0,5, 1 );
}
self power_event_vision_set_lerp( duration, startgoal, endgoal );
wait 0,05;
}
}
power_event_vision_set_lerp( duration, startgoal, endgoal )
{
self endon( "end_vision_set_power" );
level endon( "end_game" );
level endon( "power_event_complete" );
self endon( "disconnect" );
incs = int( duration / 0,05 );
if ( incs == 0 )
{
incs = 1;
}
incsgoal = ( endgoal - startgoal ) / incs;
currentgoal = startgoal;
i = 0;
while ( i < incs )
{
currentgoal += incsgoal;
maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_power_high_low", self, currentgoal );
wait 0,05;
i++;
}
maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_power_high_low", self, endgoal );
}
power_event_rumble_and_quake( power_on )
{
level endon( "end_game" );
while ( isDefined( level.power_event_in_progress ) && level.power_event_in_progress )
{
players = get_players();
_a284 = players;
_k284 = getFirstArrayKey( _a284 );
while ( isDefined( _k284 ) )
{
player = _a284[ _k284 ];
if ( !is_player_valid( player ) )
{
}
else if ( player maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_prr", 1 ) || player maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_pcr", 1 ) )
{
if ( isDefined( player.power_rumble_active ) && !player.power_rumble_active )
{
player thread power_event_rumble_and_quake_player();
}
}
else
{
if ( isDefined( player.power_rumble_active ) && player.power_rumble_active )
{
player setclientfieldtoplayer( "power_rumble", 0 );
player.power_rumble_active = 0;
}
}
_k284 = getNextArrayKey( _a284, _k284 );
}
wait 1;
}
players = get_players();
_a311 = players;
_k311 = getFirstArrayKey( _a311 );
while ( isDefined( _k311 ) )
{
player = _a311[ _k311 ];
player setclientfieldtoplayer( "power_rumble", 0 );
player notify( "end_vision_set_power" );
maps/mp/_visionset_mgr::vsmgr_deactivate( "visionset", "zm_power_high_low", player );
_k311 = getNextArrayKey( _a311, _k311 );
}
}
power_event_rumble_and_quake_player()
{
self endon( "disconnect" );
self.power_rumble_active = 1;
self setclientfieldtoplayer( "power_rumble", 1 );
self thread power_event_vision_set();
self thread power_event_vision_set_post_event();
while ( !self maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_prr", 1 ) && self maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_pcr", 1 ) && isDefined( level.power_event_in_progress ) && level.power_event_in_progress )
{
wait 1;
}
self.power_rumble_active = 0;
self notify( "end_vision_set_power" );
self setclientfieldtoplayer( "power_rumble", 0 );
}
avogadroreleasefromchamberevent()
{
exploder( 500 );
level.zones[ "zone_prr" ].is_spawning_allowed = 0;
level.zones[ "zone_pcr" ].is_spawning_allowed = 0;
level thread killzombiesinpowerstation();
while ( !flag( "power_on" ) )
{
waittime = randomfloatrange( 1,5, 4,5 );
players = get_players();
_a354 = players;
_k354 = getFirstArrayKey( _a354 );
while ( isDefined( _k354 ) )
{
player = _a354[ _k354 ];
if ( player maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_prr", 1 ) )
{
player setelectrified( waittime - 1 );
player shellshock( "electrocution", waittime );
wait 0,05;
}
_k354 = getNextArrayKey( _a354, _k354 );
}
waittime += 1,5;
level waittill_notify_or_timeout( "power_on", waittime );
}
players = get_players();
_a372 = players;
_k372 = getFirstArrayKey( _a372 );
while ( isDefined( _k372 ) )
{
player = _a372[ _k372 ];
if ( player maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_prr", 1 ) )
{
player setelectrified( 0,25 );
player shellshock( "electrocution", 1,5 );
wait 0,05;
}
_k372 = getNextArrayKey( _a372, _k372 );
}
level.zones[ "zone_prr" ].is_spawning_allowed = 1;
level.zones[ "zone_pcr" ].is_spawning_allowed = 1;
stop_exploder( 500 );
}
killzombiesinpowerstation()
{
level endon( "power_on" );
radiussq = 122500;
while ( 1 )
{
zombies = getaiarray( level.zombie_team );
_a401 = zombies;
_k401 = getFirstArrayKey( _a401 );
while ( isDefined( _k401 ) )
{
zombie = _a401[ _k401 ];
if ( !isDefined( zombie ) )
{
}
else if ( isDefined( zombie.is_avogadro ) && zombie.is_avogadro )
{
}
else
{
if ( distancesquared( ( 11344, 7590, -729 ), zombie.origin ) < radiussq )
{
break;
}
else
{
if ( isDefined( zombie ) || zombie maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_prr", 1 ) && isDefined( zombie.zone_name ) && zombie.zone_name == "zone_prr" )
{
if ( isDefined( zombie.has_been_damaged_by_player ) && !zombie.has_been_damaged_by_player )
{
level.zombie_total++;
}
zombie dodamage( zombie.health + 100, zombie.origin );
wait randomfloatrange( 0,05, 0,15 );
}
}
}
_k401 = getNextArrayKey( _a401, _k401 );
}
wait 1;
}
}
wait_for_power()
{
while ( 1 )
{
flag_wait( "power_on" );
maps/mp/zombies/_zm_perks::perk_unpause_all_perks();
wait_network_frame();
level setclientfield( "zombie_power_on", 1 );
enable_morse_code();
raisepowerplantgates();
flag_waitopen( "power_on" );
level setclientfield( "zombie_power_on", 0 );
disable_morse_code();
}
}
raisepowerplantgates()
{
gate1 = [];
gate2 = [];
gate1 = getentarray( "security_booth_gate", "targetname" );
gate2 = getentarray( "security_booth_gate_2", "targetname" );
while ( isDefined( gate1 ) )
{
i = 0;
while ( i < gate1.size )
{
gate1[ i ] thread raisegate( -90 );
i++;
}
}
while ( isDefined( gate2 ) )
{
i = 0;
while ( i < gate2.size )
{
gate2[ i ] thread raisegate( 90 );
i++;
}
}
level.the_bus notify( "OnPowerOn" );
}
raisegate( degrees )
{
self rotatepitch( degrees, 4 );
}
powerevent()
{
reactor_core_mover = getent( "core_mover", "targetname" );
reactor_core_audio = spawn( "script_origin", reactor_core_mover.origin );
if ( !isDefined( reactor_core_mover ) )
{
return;
}
thread blockstairs();
thread linkentitiestocoremover( reactor_core_mover );
while ( 1 )
{
flag_wait( "switches_on" );
thread dropreactordoors();
thread raisereactordoors();
power_event_time = 30;
reactor_core_mover playsound( "zmb_power_rise_start" );
reactor_core_mover playloopsound( "zmb_power_rise_loop", 0,75 );
reactor_core_mover thread coremove( power_event_time );
if ( isDefined( level.avogadro ) && isDefined( level.avogadro.state ) && level.avogadro.state == "chamber" )
{
level thread avogadroreleasefromchamberevent();
}
wait power_event_time;
reactor_core_mover stoploopsound( 0,5 );
reactor_core_audio playloopsound( "zmb_power_on_loop", 2 );
reactor_core_mover playsound( "zmb_power_rise_stop" );
level notify( "power_event_complete" );
flag_waitopen( "switches_on" );
thread dropreactordoors();
thread raisereactordoors();
playsoundatposition( "zmb_power_off_quad", ( 0, 0, 0 ) );
reactor_core_mover playsound( "zmb_power_rise_start" );
reactor_core_mover playloopsound( "zmb_power_rise_loop", 0,75 );
reactor_core_mover thread coremove( power_event_time, 1 );
wait power_event_time;
reactor_core_mover stoploopsound( 0,5 );
reactor_core_audio stoploopsound( 0,5 );
reactor_core_mover playsound( "zmb_power_rise_stop" );
level notify( "power_event_complete" );
}
}
corerotate( time )
{
self rotateyaw( 180, time );
}
coremove( time, down )
{
if ( isDefined( down ) && down )
{
self movez( -160, time );
}
else
{
self movez( 160, time );
}
}
blockstairs()
{
stairs_blocker = getent( "reactor_core_stairs_blocker", "targetname" );
if ( !isDefined( stairs_blocker ) )
{
return;
}
stairs_blocker movez( -128, 1 );
}
linkentitiestocoremover( reactor_core_mover )
{
core_entities = getentarray( "core_entity", "script_noteworthy" );
i = 0;
while ( i < core_entities.size )
{
next_ent = core_entities[ i ];
if ( next_ent.classname == "trigger_use_touch" )
{
next_ent enablelinkto();
}
next_ent linkto( reactor_core_mover, "tag_origin" );
i++;
}
}
dropreactordoors()
{
doors = getentarray( "reactor_core_door", "targetname" );
if ( doors.size == 0 )
{
return;
}
i = 0;
while ( i < doors.size )
{
next_door = doors[ i ];
next_door movez( -128, 1 );
next_door disconnectpaths();
i++;
}
}
raisereactordoors()
{
level waittill( "power_event_complete" );
doors = getentarray( "reactor_core_door", "targetname" );
if ( doors.size == 0 )
{
return;
}
i = 0;
while ( i < doors.size )
{
next_door = doors[ i ];
next_door movez( 128, 1 );
next_door connectpaths();
i++;
}
}
avogadro_show_vox( user )
{
wait 1;
if ( isDefined( user ) )
{
user thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "power", "power_on" );
}
wait 8;
players = get_players();
players = array_randomize( players );
_a655 = players;
_k655 = getFirstArrayKey( _a655 );
while ( isDefined( _k655 ) )
{
player = _a655[ _k655 ];
if ( player maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_prr", 1 ) || player maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_pcr", 1 ) )
{
player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "power", "power_core" );
break;
}
else
{
_k655 = getNextArrayKey( _a655, _k655 );
}
}
wait 15;
players = get_players();
players = array_randomize( players );
_a668 = players;
_k668 = getFirstArrayKey( _a668 );
while ( isDefined( _k668 ) )
{
player = _a668[ _k668 ];
if ( player maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_prr", 1 ) || player maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_pcr", 1 ) )
{
player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "avogadro_reveal" );
return;
}
else
{
_k668 = getNextArrayKey( _a668, _k668 );
}
}
}
bus_station_pa_vox()
{
level endon( "power_off" );
while ( 1 )
{
level.station_pa_vox = array_randomize( level.station_pa_vox );
_a686 = level.station_pa_vox;
_k686 = getFirstArrayKey( _a686 );
while ( isDefined( _k686 ) )
{
line = _a686[ _k686 ];
playsoundatposition( line, ( -6848, 5056, 56 ) );
wait randomintrange( 12, 15 );
_k686 = getNextArrayKey( _a686, _k686 );
}
wait 1;
}
}

63
zm_transit_dr_patch/maps/mp/zm_transit_turned_diner.gsc Normal file
View File

@ -0,0 +1,63 @@
#include maps/mp/gametypes_zm/zcleansed;
#include maps/mp/zombies/_zm_game_module;
#include maps/mp/gametypes_zm/_zm_gametype;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
precache()
{
}
main()
{
getspawnpoints();
maps/mp/gametypes_zm/_zm_gametype::setup_standard_objects( "diner" );
if ( getDvar( "ui_gametype" ) == "zcleansed" )
{
maps/mp/zombies/_zm_game_module::set_current_game_module( level.game_module_cleansed_index );
}
else
{
maps/mp/zombies/_zm_game_module::set_current_game_module( level.game_module_turned_index );
}
setdvar( "aim_target_player_enabled", 1 );
diner_front_door = getentarray( "auto2278", "targetname" );
array_thread( diner_front_door, ::self_delete );
diner_side_door = getentarray( "auto2278", "targetname" );
array_thread( diner_side_door, ::self_delete );
garage_all_door = getentarray( "auto2279", "targetname" );
array_thread( garage_all_door, ::self_delete );
level.cleansed_loadout = getgametypesetting( "cleansedLoadout" );
if ( level.cleansed_loadout )
{
level.humanify_custom_loadout = ::maps/mp/gametypes_zm/zcleansed::gunprogressionthink;
level.cleansed_zombie_round = 5;
}
else
{
level.humanify_custom_loadout = ::maps/mp/gametypes_zm/zcleansed::shotgunloadout;
level.cleansed_zombie_round = 2;
}
collision = spawn( "script_model", ( -5000, -6700, 0 ), 1 );
collision setmodel( "zm_collision_transit_diner_survival" );
collision disconnectpaths();
}
getspawnpoints()
{
level._turned_zombie_respawnpoints = getstructarray( "initial_spawn_points", "targetname" );
level._turned_powerup_spawnpoints = [];
level._turned_powerup_spawnpoints[ 0 ] = spawnstruct();
level._turned_powerup_spawnpoints[ 0 ].origin = ( -6072, -7808, 8 );
level._turned_powerup_spawnpoints[ 1 ] = spawnstruct();
level._turned_powerup_spawnpoints[ 1 ].origin = ( -5408, -6824, -53,5431 );
level._turned_powerup_spawnpoints[ 2 ] = spawnstruct();
level._turned_powerup_spawnpoints[ 2 ].origin = ( -4760, -7144, -64 );
level._turned_powerup_spawnpoints[ 3 ] = spawnstruct();
level._turned_powerup_spawnpoints[ 3 ].origin = ( -4864, -7864, -62,35 );
}
onendgame()
{
}

613
zm_transit_dr_patch/maps/mp/zm_transit_utility.gsc Normal file
View File

@ -0,0 +1,613 @@
#include maps/mp/_compass;
#include maps/mp/zombies/_zm_zonemgr;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm_unitrigger;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
playercanafford( player, cost )
{
if ( !player usebuttonpressed() )
{
return 0;
}
if ( player in_revive_trigger() )
{
return 0;
}
if ( isDefined( cost ) )
{
if ( player.score < cost )
{
return 0;
}
player maps/mp/zombies/_zm_score::minus_to_player_score( cost );
}
return 1;
}
setinvisibletoall()
{
players = get_players();
playerindex = 0;
while ( playerindex < players.size )
{
self setinvisibletoplayer( players[ playerindex ] );
playerindex++;
}
}
spawnandlinkfxtotag( effect, ent, tag )
{
fxent = spawn( "script_model", ent gettagorigin( tag ) );
fxent setmodel( "tag_origin" );
fxent linkto( ent, tag );
wait_network_frame();
playfxontag( effect, fxent, "tag_origin" );
return fxent;
}
spawnandlinkfxtooffset( effect, ent, offsetorigin, offsetangles )
{
fxent = spawn( "script_model", ( 0, 0, 0 ) );
fxent setmodel( "tag_origin" );
fxent linkto( ent, "", offsetorigin, offsetangles );
wait_network_frame();
playfxontag( effect, fxent, "tag_origin" );
return fxent;
}
custom_weapon_wall_prices()
{
if ( !isDefined( level.zombie_include_weapons ) )
{
return;
}
weapon_spawns = [];
weapon_spawns = getentarray( "weapon_upgrade", "targetname" );
i = 0;
while ( i < weapon_spawns.size )
{
if ( !isDefined( level.zombie_weapons[ weapon_spawns[ i ].zombie_weapon_upgrade ] ) )
{
i++;
continue;
}
else
{
if ( isDefined( weapon_spawns[ i ].script_int ) )
{
cost = weapon_spawns[ i ].script_int;
level.zombie_weapons[ weapon_spawns[ i ].zombie_weapon_upgrade ].cost = cost;
}
}
i++;
}
}
pause_zombie_spawning()
{
if ( !isDefined( level.spawnpausecount ) )
{
level.spawnpausecount = 0;
}
level.spawnpausecount++;
flag_clear( "spawn_zombies" );
}
try_resume_zombie_spawning()
{
if ( !isDefined( level.spawnpausecount ) )
{
level.spawnpausecount = 0;
}
level.spawnpausecount--;
if ( level.spawnpausecount <= 0 )
{
level.spawnpausecount = 0;
flag_set( "spawn_zombies" );
}
}
triggerweaponslockerwatch()
{
unitrigger_stub = spawnstruct();
unitrigger_stub.origin = ( 8236, -6844, 144 );
unitrigger_stub.angles = vectorScale( ( 0, 0, 0 ), 30 );
unitrigger_stub.script_length = 16;
unitrigger_stub.script_width = 32;
unitrigger_stub.script_height = 64;
unitrigger_stub.origin -= anglesToRight( unitrigger_stub.angles ) * ( unitrigger_stub.script_length / 2 );
unitrigger_stub.targetname = "weapon_locker";
unitrigger_stub.cursor_hint = "HINT_NOICON";
unitrigger_stub.script_unitrigger_type = "unitrigger_box_use";
unitrigger_stub.clientfieldname = "weapon_locker";
maps/mp/zombies/_zm_unitrigger::unitrigger_force_per_player_triggers( unitrigger_stub, 1 );
unitrigger_stub.prompt_and_visibility_func = ::triggerweaponslockerthinkupdateprompt;
maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::triggerweaponslockerthink );
}
triggerweaponslockerisvalidweapon( weaponname )
{
if ( is_offhand_weapon( weaponname ) || is_limited_weapon( weaponname ) )
{
return 0;
}
return 1;
}
triggerweaponslockerisvalidweaponpromptupdate( player, weaponname )
{
retrievingweapon = player maps/mp/zombies/_zm_stats::has_stored_weapondata();
if ( !sessionmodeisonlinegame() )
{
if ( isDefined( player.stored_weapon_data ) )
{
retrievingweapon = 1;
}
}
if ( !retrievingweapon )
{
if ( !triggerweaponslockerisvalidweapon( weaponname ) )
{
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_DENY" );
}
else
{
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_STORE" );
}
}
else
{
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_GRAB" );
}
}
triggerweaponslockerthinkupdateprompt( player )
{
self triggerweaponslockerisvalidweaponpromptupdate( player, player getcurrentweapon() );
return 1;
}
triggerweaponslockerthink()
{
self.parent_player thread triggerweaponslockerweaponchangethink( self );
online_game = sessionmodeisonlinegame();
while ( 1 )
{
self waittill( "trigger", player );
retrievingweapon = player maps/mp/zombies/_zm_stats::has_stored_weapondata();
if ( !online_game )
{
if ( isDefined( player.stored_weapon_data ) )
{
retrievingweapon = 1;
}
}
if ( !retrievingweapon )
{
curweapon = player getcurrentweapon();
curweapon = player maps/mp/zombies/_zm_weapons::switch_from_alt_weapon( curweapon );
while ( !triggerweaponslockerisvalidweapon( curweapon ) )
{
continue;
}
weapondata = player maps/mp/zombies/_zm_weapons::get_player_weapondata( player );
player maps/mp/zombies/_zm_stats::set_stored_weapondata( weapondata );
if ( !online_game )
{
player.stored_weapon_data = weapondata;
}
/#
assert( curweapon == weapondata[ "name" ], "weapon data does not match" );
#/
player takeweapon( curweapon );
primaries = player getweaponslistprimaries();
if ( isDefined( primaries[ 0 ] ) )
{
player switchtoweapon( primaries[ 0 ] );
}
else
{
player maps/mp/zombies/_zm_weapons::give_fallback_weapon();
}
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_GRAB" );
player playsoundtoplayer( "evt_fridge_locker_close", player );
}
else
{
curweapon = player getcurrentweapon();
primaries = player getweaponslistprimaries();
weapondata = player maps/mp/zombies/_zm_stats::get_stored_weapondata();
weapontogive = player maps/mp/zombies/_zm_stats::get_map_weaponlocker_stat( "name" );
if ( !online_game )
{
if ( isDefined( player.stored_weapon_data ) )
{
weapondata = player.stored_weapon_data;
weapontogive = weapondata[ "name" ];
}
}
curweap_base = maps/mp/zombies/_zm_weapons::get_base_weapon_name( curweapon, 1 );
weap_base = maps/mp/zombies/_zm_weapons::get_base_weapon_name( weapontogive, 1 );
while ( player has_weapon_or_upgrade( weap_base ) && weap_base != curweap_base )
{
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_DENY" );
wait 3;
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_GRAB" );
}
if ( isDefined( player.weaponplusperkon ) && player.weaponplusperkon )
{
maxweapons = 3;
}
else
{
maxweapons = 2;
}
if ( isDefined( primaries ) || primaries.size >= maxweapons && weapontogive == curweapon )
{
curweapon = player maps/mp/zombies/_zm_weapons::switch_from_alt_weapon( curweapon );
while ( !triggerweaponslockerisvalidweapon( curweapon ) )
{
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_DENY" );
wait 3;
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_GRAB" );
}
curweapondata = player maps/mp/zombies/_zm_weapons::get_player_weapondata( player );
player takeweapon( curweapondata[ "name" ] );
player maps/mp/zombies/_zm_weapons::weapondata_give( weapondata );
player maps/mp/zombies/_zm_stats::clear_stored_weapondata();
player maps/mp/zombies/_zm_stats::set_stored_weapondata( curweapondata );
if ( !online_game )
{
player.stored_weapon_data = curweapondata;
}
player switchtoweapon( weapondata[ "name" ] );
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_GRAB" );
}
else
{
player maps/mp/zombies/_zm_stats::clear_stored_weapondata();
if ( !online_game )
{
player.stored_weapon_data = undefined;
}
player maps/mp/zombies/_zm_weapons::weapondata_give( weapondata );
player switchtoweapon( weapondata[ "name" ] );
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_STORE" );
}
player playsoundtoplayer( "evt_fridge_locker_open", player );
}
wait 0,5;
}
}
oldtriggerweaponslockerthink()
{
self.parent_player thread triggerweaponslockerweaponchangethink( self );
while ( 1 )
{
self waittill( "trigger", who );
curweapon = who getcurrentweapon();
weapontogive = who maps/mp/zombies/_zm_stats::get_map_weaponlocker_stat( "name" );
clipammotogive = who maps/mp/zombies/_zm_stats::get_map_weaponlocker_stat( "clip" );
lh_clipammotogive = who maps/mp/zombies/_zm_stats::get_map_weaponlocker_stat( "lh_clip" );
stockammotogive = who maps/mp/zombies/_zm_stats::get_map_weaponlocker_stat( "stock" );
retrievingweapon = 1;
if ( isstring( weapontogive ) || weapontogive == "" && isint( weapontogive ) && weapontogive == 0 )
{
retrievingweapon = 0;
}
if ( !retrievingweapon && !triggerweaponslockerisvalidweapon( curweapon ) )
{
continue;
}
juststoredweapon = 0;
if ( !retrievingweapon )
{
weapontogive = undefined;
clipammotogive = undefined;
lh_clipammotogive = undefined;
stockammotogive = undefined;
}
primaries = who getweaponslistprimaries();
if ( isDefined( who.weaponplusperkon ) && who.weaponplusperkon )
{
maxweapons = 3;
}
else
{
maxweapons = 2;
}
haswallweapon = undefined;
if ( maps/mp/zombies/_zm_weapons::is_weapon_upgraded( weapontogive ) )
{
if ( isDefined( weapontogive ) )
{
haswallweapon = who maps/mp/zombies/_zm_weapons::has_weapon_or_upgrade( maps/mp/zombies/_zm_weapons::get_base_weapon_name( weapontogive ) );
}
}
else
{
if ( isDefined( weapontogive ) )
{
haswallweapon = who maps/mp/zombies/_zm_weapons::has_weapon_or_upgrade( weapontogive );
}
}
if ( haswallweapon || isDefined( primaries ) && primaries.size < maxweapons )
{
storedweapon = undefined;
storedammoclip = undefined;
storedammolhclip = undefined;
storedammostock = undefined;
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_STORE" );
who playsoundtoplayer( "evt_fridge_locker_open", who );
}
else
{
storedweapon = who getcurrentweapon();
dual_wield_name = weapondualwieldweaponname( storedweapon );
juststoredweapon = 1;
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "name", storedweapon );
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "clip", who getweaponammoclip( storedweapon ) );
if ( dual_wield_name != "none" )
{
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "lh_clip", who getweaponammoclip( weapondualwieldweaponname( storedweapon ) ) );
}
else
{
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "lh_clip", 0 );
}
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "stock", who getweaponammostock( storedweapon ) );
who takeweapon( storedweapon );
if ( !isDefined( weapontogive ) )
{
primaries = who getweaponslistprimaries();
who switchtoweapon( primaries[ 0 ] );
}
self sethintstring( &"ZOMBIE_WEAPON_LOCKER_GRAB" );
who playsoundtoplayer( "evt_fridge_locker_close", who );
}
if ( isDefined( weapontogive ) )
{
dual_wield_name = weapondualwieldweaponname( weapontogive );
if ( haswallweapon )
{
curretclipammo = who getweaponammoclip( weapontogive );
if ( isDefined( curretclipammo ) )
{
stockammotogive += curretclipammo;
}
curretstockammo = who getweaponammostock( weapontogive );
if ( isDefined( curretstockammo ) )
{
stockammotogive += curretstockammo;
}
who setweaponammostock( weapontogive, stockammotogive );
}
else
{
who giveweapon( weapontogive, 0 );
who setweaponammoclip( weapontogive, clipammotogive );
if ( dual_wield_name != "none" )
{
who setweaponammoclip( weapondualwieldweaponname( weapontogive ), lh_clipammotogive );
}
who setweaponammostock( weapontogive, stockammotogive );
who switchtoweapon( weapontogive );
who playsoundtoplayer( "evt_fridge_locker_open", who );
if ( !is_offhand_weapon( weapontogive ) )
{
who maps/mp/zombies/_zm_weapons::take_fallback_weapon();
}
}
if ( !is_true( juststoredweapon ) )
{
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "name", "" );
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "clip", 0 );
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "lh_clip", 0 );
who maps/mp/zombies/_zm_stats::set_map_weaponlocker_stat( "stock", 0 );
}
}
else
{
primaries = who getweaponslistprimaries();
if ( primaries.size > 0 )
{
who switchtoweapon( primaries[ 0 ] );
}
}
wait 0,5;
}
}
triggerweaponslockerweaponchangethink( trigger )
{
self endon( "disconnect" );
self endon( "death" );
trigger endon( "kill_trigger" );
while ( 1 )
{
self waittill( "weapon_change", newweapon );
trigger triggerweaponslockerisvalidweaponpromptupdate( self, newweapon );
}
}
automatonspeak( category, type, response, force_variant, override )
{
if ( isDefined( level.automaton ) && !is_true( level.automaton.disabled_by_emp ) )
{
/#
if ( getDvar( #"6DF184E8" ) == "" )
{
iprintlnbold( "Automaton VO: " + type );
#/
}
if ( type != "leaving" && type != "leaving_warning" )
{
level.automaton notify( "want_to_be_speaking" );
level.automaton waittill( "startspeaking" );
}
level.automaton maps/mp/zombies/_zm_audio::create_and_play_dialog( category, type, response, force_variant, override );
}
}
is_thedouche()
{
return self.characterindex == 0;
}
is_theconspiracytheorist()
{
return self.characterindex == 1;
}
is_thefarmersdaughter()
{
return self.characterindex == 2;
}
is_theelectricalengineer()
{
return self.characterindex == 3;
}
get_random_encounter_match( location )
{
match_pool = [];
/#
assert( match_pool.size > 0, "Could not find a random encounters match for " + location );
#/
return random( match_pool );
}
transit_breakable_glass_init()
{
glass = getentarray( "transit_glass", "targetname" );
if ( level.splitscreen && getDvarInt( "splitscreen_playerCount" ) > 2 )
{
array_delete( glass );
return;
}
array_thread( glass, ::transit_breakable_glass );
}
transit_breakable_glass()
{
level endon( "intermission" );
self.health = 99999;
self setcandamage( 1 );
self.damage_state = 0;
while ( 1 )
{
self waittill( "damage", amount, attacker, direction, point, dmg_type );
if ( isplayer( attacker ) )
{
if ( self.damage_state == 0 )
{
self glass_gets_destroyed();
self.damage_state = 1;
self playsound( "fly_glass_break" );
}
}
}
}
glass_gets_destroyed()
{
if ( isDefined( level._effect[ "glass_impact" ] ) )
{
playfx( level._effect[ "glass_impact" ], self.origin, anglesToForward( self.angles ) );
}
wait 0,1;
if ( isDefined( self.model ) && self.damage_state == 0 )
{
self setmodel( self.model + "_broken" );
self.damage_state = 1;
return;
}
else
{
self delete();
return;
}
}
solo_tombstone_removal()
{
if ( getnumexpectedplayers() > 1 )
{
return;
}
level notify( "tombstone_removed" );
level thread maps/mp/zombies/_zm_perks::perk_machine_removal( "specialty_scavenger" );
}
sparking_power_lines()
{
lines = getentarray( "power_line_sparking", "targetname" );
}
disconnect_door_zones( zone_a, zone_b, flag_name )
{
level endon( "intermission" );
level endon( "end_game" );
while ( 1 )
{
flag_wait( flag_name );
azone = level.zones[ zone_a ].adjacent_zones[ zone_b ];
azone maps/mp/zombies/_zm_zonemgr::door_close_disconnect( flag_name );
}
}
enable_morse_code()
{
level clientnotify( "mc1" );
}
disable_morse_code()
{
level clientnotify( "mc0" );
}
transit_pathnode_spawning()
{
precachemodel( "collision_wall_128x128x10_standard" );
precachemodel( "collision_wall_256x256x10_standard" );
precachemodel( "collision_clip_64x64x256" );
minimap_upperl = spawn( "script_origin", ( -12248, 9496, 552 ) );
minimap_upperl.targetname = "minimap_corner";
minimap_lowerr = spawn( "script_origin", ( 14472, -8496, -776 ) );
minimap_lowerr.targetname = "minimap_corner";
maps/mp/_compass::setupminimap( "compass_map_zm_transit" );
flag_wait( "start_zombie_round_logic" );
collision1 = spawn( "script_model", ( 2273, -126, 143 ) );
collision1 setmodel( "collision_wall_128x128x10_standard" );
collision1.angles = ( 0, 0, 0 );
collision1 ghost();
collision2 = spawn( "script_model", ( 2096, -126, 143 ) );
collision2 setmodel( "collision_wall_128x128x10_standard" );
collision2.angles = ( 0, 0, 0 );
collision2 ghost();
collision3 = spawn( "script_model", ( 1959, -126, 143 ) );
collision3 setmodel( "collision_wall_128x128x10_standard" );
collision3.angles = ( 0, 0, 0 );
collision3 ghost();
collision4 = spawn( "script_model", ( 12239, 8509, -688 ) );
collision4 setmodel( "collision_wall_128x128x10_standard" );
collision4.angles = ( 0, 0, 0 );
collision4 ghost();
collision5 = spawn( "script_model", ( 8320, -6679, 362 ) );
collision5 setmodel( "collision_wall_256x256x10_standard" );
collision5.angles = vectorScale( ( 0, 0, 0 ), 300 );
collision5 ghost();
collision5 = spawn( "script_model", ( 10068, 7272, -67 ) );
collision5 setmodel( "collision_clip_64x64x256" );
collision5.angles = ( 0, 0, 0 );
collision5 ghost();
}

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)" );
#/
}

Some files were not shown because too many files have changed in this diff Show More