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-10 10:47:58 -05:00
Code Issues Releases Wiki Activity

uploading 119 patch_mp scripts and 23 patch_zm scripts as a baseline

Browse Source
This commit is contained in:
JezuzLizard
2020-05-29 07:55:47 -07:00
parent b044bba3c2
commit 89fa02ab7f
144 changed files with 75534 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
patch_zm/codescripts/character_mp.gsc Normal file
View File

@ -0,0 +1,21 @@
#include codescripts/character;
setmodelfromarray( a )
{
self setmodel( a[ randomint( a.size ) ] );
}
precachemodelarray( a )
{
i = 0;
while ( i < a.size )
{
precachemodel( a[ i ] );
i++;
}
}
attachfromarray( a )
{
self attach( codescripts/character::randomelement( a ), "", 1 );
}

2011
patch_zm/common_scripts/utility.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

497
patch_zm/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
patch_zm/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
patch_zm/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
patch_zm/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
patch_zm/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;
}

2117
patch_zm/maps/mp/_challenges.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

67
patch_zm/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
patch_zm/maps/mp/_createfx.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

545
patch_zm/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
patch_zm/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
patch_zm/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
patch_zm/maps/mp/_fxanim.gsc Normal file
View File

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

60
patch_zm/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
patch_zm/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_dest_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
patch_zm/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
patch_zm/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
patch_zm/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
patch_zm/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
patch_zm/maps/mp/_utility.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

515
patch_zm/maps/mp/_visionset_mgr.gsc Normal file
View File

@ -0,0 +1,515 @@
#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();
if ( !isDefined( self.players[ player_entnum ] ) )
{
return;
}
self.players[ player_entnum ].active = 1;
self.players[ player_entnum ].lerp = lerp;
}
vsmgr_set_state_inactive( player )
{
player_entnum = player getentitynumber();
if ( !isDefined( self.players[ player_entnum ] ) )
{
return;
}
self.players[ player_entnum ].active = 0;
self.players[ player_entnum ].lerp = 0;
}
vsmgr_timeout_lerp_thread( timeout, opt_param_2 )
{
players = getplayers();
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 );
}

25
patch_zm/readme.md
View File

@ -81,6 +81,31 @@ patch_zm/maps/mp/zombies/_zm_weap_cymbal_monkey.gsc
```
### The following scripts are not checked yet, uploaded to setup a baseline:
```
patch_zm/maps/codescripts/character_mp.gsc
patch_zm/maps/common_scripts/utility.gsc
patch_zm/maps/mp/_art.gsc
patch_zm/maps/mp/_audio.gsc
patch_zm/maps/mp/_ballistic_knife.gsc
patch_zm/maps/mp/_bb.gsc
patch_zm/maps/mp/_busing.gsc
patch_zm/maps/mp/_challenges.gsc
patch_zm/maps/mp/_compass.gsc
patch_zm/maps/mp/_createfx.gsc
patch_zm/maps/mp/_createfxmenu.gsc
patch_zm/maps/mp/_createfxundo.gsc
patch_zm/maps/mp/_demo.gsc
patch_zm/maps/mp/_fx.gsc
patch_zm/maps/mp/_fxanim.gsc
patch_zm/maps/mp/_global_fx.gsc
patch_zm/maps/mp/_interactive_objects.gsc
patch_zm/maps/mp/_music.gsc
patch_zm/maps/mp/_script_gen.gsc
patch_zm/maps/mp/serverfaceanim_mp.gsc
patch_zm/maps/mp/_sticky_grenade.gsc
patch_zm/maps/mp/_utility.gsc
patch_zm/maps/mp/_visionset_mgr.gsc
patch_zm/maps/mp/gametypes_zm/_gameobjects.gsc
patch_zm/maps/mp/gametypes_zm/_globallogic_audio.gsc
patch_zm/maps/mp/gametypes_zm/_globallogic_defaults.gsc