mirror of
https://github.com/InfinityLoader/IL-GSC.git
synced 2025-06-07 17:17:50 -05:00
626 lines
14 KiB
Plaintext
626 lines
14 KiB
Plaintext
#include common_scripts\utility;
|
||
#include maps\_utility;
|
||
#include maps\_hud_util;
|
||
structarray_swap( object1, object2 )
|
||
{
|
||
index1 = object1.struct_array_index;
|
||
index2 = object2.struct_array_index;
|
||
self.array[ index2 ] = object1;
|
||
self.array[ index1 ] = object2;
|
||
self.array[ index1 ].struct_array_index = index1;
|
||
self.array[ index2 ].struct_array_index = index2;
|
||
}
|
||
waitSpread_insert( allotment )
|
||
{
|
||
gapIndex = -1;
|
||
gap = 0;
|
||
for ( p = 0; p < allotment.size - 1; p++ )
|
||
{
|
||
newgap = allotment[ p + 1 ] - allotment[ p ];
|
||
if ( newgap <= gap )
|
||
{
|
||
continue;
|
||
}
|
||
gap = newgap;
|
||
gapIndex = p;
|
||
}
|
||
assert( gap > 0 );
|
||
newAllotment = [];
|
||
for ( i = 0; i < allotment.size; i++ )
|
||
{
|
||
if ( gapIndex == i - 1 )
|
||
{
|
||
newAllotment[ newAllotment.size ] = randomfloatrange( allotment[ gapIndex ], allotment[ gapIndex + 1 ] );
|
||
}
|
||
newAllotment[ newAllotment.size ] = allotment[ i ];
|
||
}
|
||
return newAllotment;
|
||
}
|
||
waittill_objective_event_proc( requireTrigger )
|
||
{
|
||
while ( level.deathSpawner[ self.script_deathChain ] > 0 )
|
||
{
|
||
level waittill( "spawner_expired" + self.script_deathChain );
|
||
}
|
||
if ( requireTrigger )
|
||
{
|
||
self waittill( "trigger" );
|
||
}
|
||
flag = self get_trigger_flag();
|
||
flag_set( flag );
|
||
}
|
||
wait_until_done_speaking()
|
||
{
|
||
self endon( "death" );
|
||
while ( self.isSpeaking )
|
||
{
|
||
wait( 0.05 );
|
||
}
|
||
}
|
||
ent_waits_for_level_notify( msg )
|
||
{
|
||
level waittill( msg );
|
||
self notify( "done" );
|
||
}
|
||
ent_waits_for_trigger( trigger )
|
||
{
|
||
trigger waittill( "trigger" );
|
||
self notify( "done" );
|
||
}
|
||
ent_times_out( timer )
|
||
{
|
||
wait( timer );
|
||
self notify( "done" );
|
||
}
|
||
update_debug_friendlycolor_on_death()
|
||
{
|
||
self notify( "debug_color_update" );
|
||
self endon( "debug_color_update" );
|
||
num = self.ai_number;
|
||
self waittill( "death" );
|
||
level.debug_color_friendlies[ num ] = undefined;
|
||
level notify( "updated_color_friendlies" );
|
||
}
|
||
update_debug_friendlycolor( num )
|
||
{
|
||
thread update_debug_friendlycolor_on_death();
|
||
if ( isdefined( self.script_forceColor ) )
|
||
{
|
||
level.debug_color_friendlies[ num ] = self.script_forceColor;
|
||
}
|
||
else
|
||
{
|
||
level.debug_color_friendlies[ num ] = undefined;
|
||
}
|
||
level notify( "updated_color_friendlies" );
|
||
}
|
||
insure_player_does_not_set_forcecolor_twice_in_one_frame()
|
||
{
|
||
}
|
||
new_color_being_set( color )
|
||
{
|
||
self notify( "new_color_being_set" );
|
||
self.new_force_color_being_set = true;
|
||
maps\_colors::left_color_node();
|
||
self endon( "new_color_being_set" );
|
||
self endon( "death" );
|
||
waittillframeend;
|
||
waittillframeend;
|
||
if ( isdefined( self.script_forceColor ) )
|
||
{
|
||
self.currentColorCode = level.currentColorForced[ self.team ][ self.script_forceColor ];
|
||
self thread maps\_colors::goto_current_ColorIndex();
|
||
}
|
||
self.new_force_color_being_set = undefined;
|
||
self notify( "done_setting_new_color" );
|
||
}
|
||
delayThread_proc( func, timer, param1, param2, param3, param4 )
|
||
{
|
||
self endon( "death" );
|
||
wait( timer );
|
||
if ( isdefined( param4 ) )
|
||
{
|
||
thread [[ func ]]( param1, param2, param3, param4 );
|
||
}
|
||
else if ( isdefined( param3 ) )
|
||
{
|
||
thread [[ func ]]( param1, param2, param3 );
|
||
}
|
||
else if ( isdefined( param2 ) )
|
||
{
|
||
thread [[ func ]]( param1, param2 );
|
||
}
|
||
else if ( isdefined( param1 ) )
|
||
{
|
||
thread [[ func ]]( param1 );
|
||
}
|
||
else
|
||
{
|
||
thread [[ func ]]();
|
||
}
|
||
}
|
||
wait_for_flag_or_time_elapses( flagname, timer )
|
||
{
|
||
level endon( flagname );
|
||
wait( timer );
|
||
}
|
||
ent_wait_for_flag_or_time_elapses( flagname, timer )
|
||
{
|
||
self endon( flagname );
|
||
wait( timer );
|
||
}
|
||
waittill_either_function_internal( ent, func, parm )
|
||
{
|
||
ent endon( "done" );
|
||
[[ func ]]( parm );
|
||
ent notify( "done" );
|
||
}
|
||
HintPrintWait( length, breakfunc )
|
||
{
|
||
if ( !isdefined( breakfunc ) )
|
||
{
|
||
wait( length );
|
||
return;
|
||
}
|
||
timer = length * 20;
|
||
for ( i = 0; i < timer; i++ )
|
||
{
|
||
if ( [[ breakfunc ]]() )
|
||
{
|
||
break;
|
||
}
|
||
wait( 0.05 );
|
||
}
|
||
}
|
||
HintPrint( string, breakfunc )
|
||
{
|
||
MYFADEINTIME = 1.0;
|
||
MYFLASHTIME = 0.75;
|
||
MYALPHAHIGH = 0.95;
|
||
MYALPHALOW = 0.4;
|
||
flag_waitopen( "global_hint_in_use" );
|
||
flag_set( "global_hint_in_use" );
|
||
Hint = createFontString( "objective", 2 );
|
||
Hint.alpha = 0.9;
|
||
Hint.x = 0;
|
||
Hint.y = -68;
|
||
Hint.alignx = "center";
|
||
Hint.aligny = "middle";
|
||
Hint.horzAlign = "center";
|
||
Hint.vertAlign = "middle";
|
||
Hint.foreground = false;
|
||
Hint.hidewhendead = true;
|
||
Hint setText( string );
|
||
Hint.alpha = 0;
|
||
Hint FadeOverTime( MYFADEINTIME );
|
||
Hint.alpha = MYALPHAHIGH;
|
||
HintPrintWait( MYFADEINTIME );
|
||
if ( isdefined( breakfunc ) )
|
||
{
|
||
for ( ;; )
|
||
{
|
||
Hint FadeOverTime( MYFLASHTIME );
|
||
Hint.alpha = MYALPHALOW;
|
||
HintPrintWait( MYFLASHTIME, breakfunc );
|
||
if ( [[ breakfunc ]]() )
|
||
{
|
||
break;
|
||
}
|
||
Hint FadeOverTime( MYFLASHTIME );
|
||
Hint.alpha = MYALPHAHIGH;
|
||
HintPrintWait( MYFLASHTIME );
|
||
if ( [[ breakfunc ]]() )
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for ( i = 0; i < 5; i++ )
|
||
{
|
||
Hint FadeOverTime( MYFLASHTIME );
|
||
Hint.alpha = MYALPHALOW;
|
||
HintPrintWait( MYFLASHTIME );
|
||
Hint FadeOverTime( MYFLASHTIME );
|
||
Hint.alpha = MYALPHAHIGH;
|
||
HintPrintWait( MYFLASHTIME );
|
||
}
|
||
}
|
||
Hint Destroy();
|
||
flag_clear( "global_hint_in_use" );
|
||
}
|
||
lerp_player_view_to_tag_internal( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo )
|
||
{
|
||
if( IsPlayer( self ) )
|
||
{
|
||
self endon( "disconnect" );
|
||
}
|
||
if ( isdefined( self.first_frame_time ) && ent.first_frame_time == gettime() )
|
||
{
|
||
wait( 0.10 );
|
||
}
|
||
origin = ent gettagorigin( tag );
|
||
angles = ent gettagangles( tag );
|
||
self lerp_player_view_to_position( origin, angles, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo );
|
||
if ( IsDefined(hit_geo) && hit_geo )
|
||
{
|
||
return;
|
||
}
|
||
if( IsDefined( right_arc ) )
|
||
{
|
||
self playerlinkto( ent, tag, fraction, right_arc, left_arc, top_arc, bottom_arc );
|
||
}
|
||
else if( IsDefined( fraction ) )
|
||
{
|
||
self playerlinkto( ent, tag, fraction );
|
||
}
|
||
else
|
||
{
|
||
self playerlinkto( ent );
|
||
}
|
||
}
|
||
lerp_player_view_to_tag_oldstyle_internal( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo )
|
||
{
|
||
if( IsPlayer( self ) )
|
||
{
|
||
self endon( "disconnect" );
|
||
}
|
||
if ( isdefined( ent.first_frame_time ) && ent.first_frame_time == gettime() )
|
||
{
|
||
wait( 0.10 );
|
||
}
|
||
origin = ent gettagorigin( tag );
|
||
angles = ent gettagangles( tag );
|
||
self lerp_player_view_to_position_oldstyle( origin, angles, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, true );
|
||
if ( hit_geo )
|
||
{
|
||
return;
|
||
}
|
||
self playerlinktodelta( ent, tag, fraction, right_arc, left_arc, top_arc, bottom_arc, false );
|
||
}
|
||
lerp_player_view_to_moving_tag_oldstyle_internal( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo )
|
||
{
|
||
if( IsPlayer( self ) )
|
||
{
|
||
self endon( "disconnect" );
|
||
}
|
||
if ( isdefined( ent.first_frame_time ) && ent.first_frame_time == gettime() )
|
||
{
|
||
wait( 0.10 );
|
||
}
|
||
self lerp_player_view_to_position_oldstyle( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, true );
|
||
if ( hit_geo )
|
||
{
|
||
return;
|
||
}
|
||
self playerlinkto( ent, tag, fraction, right_arc, left_arc, top_arc, bottom_arc, false );
|
||
}
|
||
function_stack_proc( caller, func, param1, param2, param3, param4 )
|
||
{
|
||
if ( !isdefined( caller.function_stack ) )
|
||
{
|
||
caller.function_stack = [];
|
||
}
|
||
caller.function_stack[ caller.function_stack.size ] = self;
|
||
function_stack_caller_waits_for_turn( caller );
|
||
if ( isdefined( caller ) )
|
||
{
|
||
if ( isdefined( param4 ) )
|
||
{
|
||
caller [[ func ]]( param1, param2, param3, param4 );
|
||
}
|
||
else if ( isdefined( param3 ) )
|
||
{
|
||
caller [[ func ]]( param1, param2, param3 );
|
||
}
|
||
else if ( isdefined( param2 ) )
|
||
{
|
||
caller [[ func ]]( param1, param2 );
|
||
}
|
||
else if ( isdefined( param1 ) )
|
||
{
|
||
caller [[ func ]]( param1 );
|
||
}
|
||
else
|
||
{
|
||
caller [[ func ]]();
|
||
}
|
||
if ( isdefined( caller ) )
|
||
{
|
||
caller.function_stack = array_remove( caller.function_stack, self );
|
||
caller notify( "level_function_stack_ready" );
|
||
}
|
||
}
|
||
if ( isdefined( self ) )
|
||
{
|
||
self notify( "function_done" );
|
||
}
|
||
}
|
||
function_stack_caller_waits_for_turn( caller )
|
||
{
|
||
caller endon( "death" );
|
||
self endon( "death" );
|
||
while ( caller.function_stack[ 0 ] != self )
|
||
{
|
||
caller waittill( "level_function_stack_ready" );
|
||
}
|
||
}
|
||
alphabet_compare( a, b )
|
||
{
|
||
list = [];
|
||
val = 1;
|
||
list[ "0" ] = val; val++;
|
||
list[ "1" ] = val; val++;
|
||
list[ "2" ] = val; val++;
|
||
list[ "3" ] = val; val++;
|
||
list[ "4" ] = val; val++;
|
||
list[ "5" ] = val; val++;
|
||
list[ "6" ] = val; val++;
|
||
list[ "7" ] = val; val++;
|
||
list[ "8" ] = val; val++;
|
||
list[ "9" ] = val; val++;
|
||
list[ "_" ] = val; val++;
|
||
list[ "a" ] = val; val++;
|
||
list[ "b" ] = val; val++;
|
||
list[ "c" ] = val; val++;
|
||
list[ "d" ] = val; val++;
|
||
list[ "e" ] = val; val++;
|
||
list[ "f" ] = val; val++;
|
||
list[ "g" ] = val; val++;
|
||
list[ "h" ] = val; val++;
|
||
list[ "i" ] = val; val++;
|
||
list[ "j" ] = val; val++;
|
||
list[ "k" ] = val; val++;
|
||
list[ "l" ] = val; val++;
|
||
list[ "m" ] = val; val++;
|
||
list[ "n" ] = val; val++;
|
||
list[ "o" ] = val; val++;
|
||
list[ "p" ] = val; val++;
|
||
list[ "q" ] = val; val++;
|
||
list[ "r" ] = val; val++;
|
||
list[ "s" ] = val; val++;
|
||
list[ "t" ] = val; val++;
|
||
list[ "u" ] = val; val++;
|
||
list[ "v" ] = val; val++;
|
||
list[ "w" ] = val; val++;
|
||
list[ "x" ] = val; val++;
|
||
list[ "y" ] = val; val++;
|
||
list[ "z" ] = val; val++;
|
||
a = tolower( a );
|
||
b = tolower( b );
|
||
val1 = 0;
|
||
if ( isdefined( list[ a ] ) )
|
||
{
|
||
val1 = list[ a ];
|
||
}
|
||
val2 = 0;
|
||
if ( isdefined( list[ b ] ) )
|
||
{
|
||
val2 = list[ b ];
|
||
}
|
||
if ( val1 > val2 )
|
||
{
|
||
return "1st";
|
||
}
|
||
if ( val1 < val2 )
|
||
{
|
||
return "2nd";
|
||
}
|
||
return "same";
|
||
}
|
||
is_later_in_alphabet( string1, string2 )
|
||
{
|
||
count = string1.size;
|
||
if ( count >= string2.size )
|
||
{
|
||
count = string2.size;
|
||
}
|
||
for ( i = 0; i < count; i++ )
|
||
{
|
||
val = alphabet_compare( string1[ i ], string2[ i ] );
|
||
if ( val == "1st" )
|
||
{
|
||
return true;
|
||
}
|
||
if ( val == "2nd" )
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return string1.size > string2.size;
|
||
}
|
||
wait_for_sounddone_or_death( org )
|
||
{
|
||
self endon( "death" );
|
||
org waittill( "sounddone" );
|
||
}
|
||
sound_effect()
|
||
{
|
||
self effect_soundalias();
|
||
}
|
||
effect_soundalias()
|
||
{
|
||
origin = self.v[ "origin" ];
|
||
alias = self.v[ "soundalias" ];
|
||
self exploder_delay();
|
||
play_sound_in_space( alias, origin );
|
||
}
|
||
cannon_effect()
|
||
{
|
||
if( isdefined( self.v[ "repeat" ] ) )
|
||
{
|
||
for( i = 0;i < self.v[ "repeat" ];i ++ )
|
||
{
|
||
playfx( level._effect[ self.v[ "fxid" ] ], self.v[ "origin" ], self.v[ "forward" ], self.v[ "up" ] );
|
||
self exploder_delay();
|
||
}
|
||
return;
|
||
}
|
||
self exploder_delay();
|
||
if ( isdefined( self.looper ) )
|
||
{
|
||
self.looper delete();
|
||
}
|
||
self.looper = spawnFx( getfx( self.v[ "fxid" ] ), self.v[ "origin" ], self.v[ "forward" ], self.v[ "up" ] );
|
||
triggerFx( self.looper );
|
||
exploder_playSound();
|
||
}
|
||
exploder_delay()
|
||
{
|
||
if( !isdefined( self.v[ "delay" ] ) )
|
||
{
|
||
self.v[ "delay" ] = 0;
|
||
}
|
||
min_delay = self.v[ "delay" ];
|
||
max_delay = self.v[ "delay" ] + 0.001;
|
||
if( isdefined( self.v[ "delay_min" ] ) )
|
||
{
|
||
min_delay = self.v[ "delay_min" ];
|
||
}
|
||
if( isdefined( self.v[ "delay_max" ] ) )
|
||
{
|
||
max_delay = self.v[ "delay_max" ];
|
||
}
|
||
if( min_delay > 0 )
|
||
{
|
||
wait( randomfloatrange( min_delay, max_delay ) );
|
||
}
|
||
}
|
||
exploder_earthquake()
|
||
{
|
||
earthquake_name = self.v[ "earthquake" ];
|
||
assertex(IsDefined(level.earthquake) && IsDefined(level.earthquake[earthquake_name]),
|
||
"No earthquake '" + earthquake_name + "' defined for exploder - call add_earthquake() in your level script.");
|
||
self exploder_delay();
|
||
eq = level.earthquake[earthquake_name];
|
||
earthquake( eq[ "magnitude" ], eq[ "duration" ], self.v[ "origin" ], eq[ "radius" ] );
|
||
}
|
||
exploder_rumble()
|
||
{
|
||
self exploder_delay();
|
||
level.player PlayRumbleonentity( self.v[ "rumble" ] );
|
||
}
|
||
exploder_playSound()
|
||
{
|
||
if( !isdefined( self.v[ "soundalias" ] ) || self.v[ "soundalias" ] == "nil" )
|
||
{
|
||
return;
|
||
}
|
||
play_sound_in_space( self.v[ "soundalias" ], self.v[ "origin" ] );
|
||
}
|
||
fire_effect()
|
||
{
|
||
forward = self.v[ "forward" ];
|
||
up = self.v[ "up" ];
|
||
org = undefined;
|
||
firefxSound = self.v[ "firefxsound" ];
|
||
origin = self.v[ "origin" ];
|
||
firefx = self.v[ "firefx" ];
|
||
ender = self.v[ "ender" ];
|
||
if( !isdefined( ender ) )
|
||
{
|
||
ender = "createfx_effectStopper";
|
||
}
|
||
timeout = self.v[ "firefxtimeout" ];
|
||
fireFxDelay = 0.5;
|
||
if( isdefined( self.v[ "firefxdelay" ] ) )
|
||
{
|
||
fireFxDelay = self.v[ "firefxdelay" ];
|
||
}
|
||
self exploder_delay();
|
||
if( isdefined( firefxSound ) )
|
||
{
|
||
level thread loop_fx_sound( firefxSound, origin, ender, timeout );
|
||
}
|
||
playfx( level._effect[ firefx ], self.v[ "origin" ], forward, up );
|
||
}
|
||
trail_effect()
|
||
{
|
||
self exploder_delay();
|
||
if( !IsDefined( self.v["trailfxtag"] ) )
|
||
{
|
||
self.v["trailfxtag"] = "tag_origin";
|
||
}
|
||
temp_ent = undefined;
|
||
if(self.v["trailfxtag"] == "tag_origin")
|
||
{
|
||
PlayFxOnTag( level._effect[self.v["trailfx"]], self.model, self.v["trailfxtag"] );
|
||
}
|
||
else
|
||
{
|
||
temp_ent = Spawn( "script_model", self.model.origin );
|
||
temp_ent SetModel( "tag_origin" );
|
||
temp_ent LinkTo( self.model );
|
||
PlayFxOnTag( level._effect[self.v["trailfx"]], temp_ent, self.v["trailfxtag"] );
|
||
}
|
||
if( IsDefined( self.v["trailfxsound"] ) )
|
||
{
|
||
if(!isdefined(temp_ent))
|
||
{
|
||
self.model PlayLoopSound( self.v["trailfxsound"] );
|
||
}
|
||
else
|
||
{
|
||
temp_ent PlayLoopSound( self.v["trailfxsound"] );
|
||
}
|
||
}
|
||
if( IsDefined( self.v[ "ender" ] ) )
|
||
{
|
||
}
|
||
if( !IsDefined( self.v["trailfxtimeout"] ) )
|
||
{
|
||
return;
|
||
}
|
||
wait( self.v["trailfxtimeout"] );
|
||
if(isdefined(temp_ent))
|
||
{
|
||
temp_ent Delete();
|
||
}
|
||
}
|
||
trail_effect_ender( ent, ender )
|
||
{
|
||
ent endon( "death" );
|
||
self waittill( ender );
|
||
ent Delete();
|
||
}
|
||
init_vision_set( visionset )
|
||
{
|
||
level.lvl_visionset = visionset;
|
||
if ( !isdefined ( level.vision_cheat_enabled ) )
|
||
{
|
||
level.vision_cheat_enabled = false;
|
||
}
|
||
return level.vision_cheat_enabled;
|
||
}
|
||
exec_func( func, endons )
|
||
{
|
||
for ( i = 0; i < endons.size; i++ )
|
||
{
|
||
endons[ i ].caller endon( endons[ i ].ender );
|
||
}
|
||
if ( func.parms.size == 0 )
|
||
{
|
||
func.caller [[ func.func ]]();
|
||
}
|
||
else if ( func.parms.size == 1 )
|
||
{
|
||
func.caller [[ func.func ]]( func.parms[ 0 ] );
|
||
}
|
||
else if ( func.parms.size == 2 )
|
||
{
|
||
func.caller [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ] );
|
||
}
|
||
else if ( func.parms.size == 3 )
|
||
{
|
||
func.caller [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ] );
|
||
}
|
||
}
|
||
waittill_func_ends( func, endons )
|
||
{
|
||
self endon( "all_funcs_ended" );
|
||
exec_func( func, endons );
|
||
self.count--;
|
||
self notify( "func_ended" );
|
||
}
|
||
|
||
|