mirror of
https://github.com/reaaLx/nx1-gsc-dump.git
synced 2025-04-22 17:15:48 +00:00
1712 lines
39 KiB
Plaintext
1712 lines
39 KiB
Plaintext
#include common_scripts\utility;
|
|
#include maps\_utility;
|
|
#include maps\_hud_util;
|
|
/*
|
|
Functions called only from _utility
|
|
*/
|
|
|
|
linetime_proc( start, end, color, timer )
|
|
{
|
|
for ( i = 0; i < timer * 20; i++ )
|
|
{
|
|
Line( start, end, color );
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
|
|
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_code( start, end )
|
|
{
|
|
waittillframeend;// give every other waitspreader in this frame a chance to increment wait_spreaders
|
|
|
|
Assert( level._wait_spreaders >= 1 );
|
|
|
|
allotment = [];
|
|
|
|
if ( level._wait_spreaders == 1 )
|
|
{
|
|
allotment[ 0 ] = RandomFloatRange( start, end );
|
|
level._wait_spreader_allotment = allotment;
|
|
level._active_wait_spread = undefined;
|
|
return;
|
|
}
|
|
|
|
allotment[ 0 ] = start;
|
|
allotment[ allotment.size ] = end;
|
|
|
|
for ( i = 1; i < level._wait_spreaders - 1; i++ )
|
|
{
|
|
allotment = waitSpread_insert( allotment );
|
|
}
|
|
|
|
level._wait_spreader_allotment = array_randomize( allotment );
|
|
level._active_wait_spread = undefined;
|
|
}
|
|
|
|
waitSpread_insert( allotment )
|
|
{
|
|
gapIndex = -1;
|
|
gap = 0;
|
|
// get the largest waitspread gap
|
|
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 );
|
|
}
|
|
}
|
|
|
|
wait_for_trigger_think( ent )
|
|
{
|
|
self endon( "death" );
|
|
ent endon( "trigger" );
|
|
self waittill( "trigger" );
|
|
|
|
ent notify( "trigger" );
|
|
}
|
|
|
|
wait_for_trigger( msg, type )
|
|
{
|
|
triggers = GetEntArray( msg, type );
|
|
ent = SpawnStruct();
|
|
|
|
array_thread( triggers, ::wait_for_trigger_think, ent );
|
|
ent waittill( "trigger" );
|
|
}
|
|
|
|
|
|
ent_waits_for_level_notify( msg )
|
|
{
|
|
level waittill( msg );
|
|
self notify( "done" );
|
|
}
|
|
|
|
ent_waits_for_notify( ent, msg )
|
|
{
|
|
ent 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.unique_id;
|
|
self waittill( "death" );
|
|
level._debug_color_friendlies[ num ] = undefined;
|
|
|
|
// updates the debug color friendlies info
|
|
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;
|
|
}
|
|
// updates the debug color friendlies info
|
|
level notify( "updated_color_friendlies" );
|
|
}
|
|
|
|
insure_player_does_not_set_forcecolor_twice_in_one_frame()
|
|
{
|
|
/#
|
|
AssertEx( !isdefined( self.setforcecolor ), "Tried to set forceColor on an ai twice in one frame. Don't spam set_force_color." );
|
|
self.setforcecolor = true;
|
|
waittillframeend;
|
|
if ( !isalive( self ) )
|
|
return;
|
|
self.setforcecolor = undefined;
|
|
#/
|
|
}
|
|
|
|
|
|
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" );
|
|
|
|
// insure we're only getting one color change, multiple in one frame will get overwritten.
|
|
waittillframeend;
|
|
waittillframeend;
|
|
|
|
if ( IsDefined( self.script_forcecolor ) )
|
|
{
|
|
// grab the current colorCode that AI of this color are forced to, if there is one
|
|
self.currentColorCode = level._currentColorForced[ self maps\_colors::get_team() ][ self.script_forcecolor ];
|
|
if ( IsDefined( self.dontColorMove ) )
|
|
self.dontColorMove = undefined;
|
|
else
|
|
self thread maps\_colors::goto_current_ColorIndex();
|
|
}
|
|
|
|
self.new_force_color_being_set = undefined;
|
|
self notify( "done_setting_new_color" );
|
|
/#
|
|
update_debug_friendlycolor( self.unique_id );
|
|
#/
|
|
}
|
|
|
|
radio_queue_thread( msg )
|
|
{
|
|
queueTime = GetTime();
|
|
for ( ;; )
|
|
{
|
|
if ( !isdefined( self._radio_queue ) )
|
|
break;
|
|
|
|
self waittill( "finished_radio" );
|
|
if ( GetTime() > queueTime + 7500 )
|
|
return;
|
|
}
|
|
|
|
self._radio_queue = true;
|
|
|
|
wait_for_buffer_time_to_pass( level._last_mission_sound_time, 0.5 );
|
|
|
|
level._player play_sound_on_entity( level._scr_radio[ msg ] );
|
|
self._radio_queue = undefined;
|
|
level._last_mission_sound_time = GetTime();
|
|
|
|
self notify( "finished_radio" );
|
|
}
|
|
|
|
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 );
|
|
}
|
|
}
|
|
|
|
hint_timeout( timeout )
|
|
{
|
|
wait( timeout );
|
|
self.timed_out = true;
|
|
}
|
|
|
|
HintPrint( string, breakfunc, parm1, parm2, parm3, timeout )
|
|
{
|
|
Assert( IsPlayer( self ) );
|
|
|
|
if ( !isalive( self ) )
|
|
return;
|
|
|
|
MYFADEINTIME = 1.0;
|
|
MYFLASHTIME = 0.75;
|
|
MYALPHAHIGH = 0.95;
|
|
MYALPHALOW = 0.4;
|
|
|
|
if ( isdefined( self.current_global_hint ) )
|
|
{
|
|
if ( self.current_global_hint == string )
|
|
return;
|
|
}
|
|
|
|
ent_flag_waitopen( "global_hint_in_use" );
|
|
if ( isdefined( self.current_global_hint ) )
|
|
{
|
|
if ( self.current_global_hint == string )
|
|
return;
|
|
}
|
|
|
|
ent_flag_set( "global_hint_in_use" );
|
|
|
|
self.current_global_hint = string;
|
|
|
|
Hint = createClientFontString( "default", 2 );
|
|
|
|
thread destroy_hint_on_friendlyfire( hint );
|
|
level endon( "friendlyfire_mission_fail" );
|
|
|
|
//Hint.color = ( 1, 1, .5 ); //remove color so that color highlighting on PC can show up.
|
|
|
|
Hint.color = ( getdvarfloat( "color_neutral_r" ), getdvarfloat( "color_neutral_g" ), getdvarfloat( "color_neutral_b" ) );
|
|
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.hidewheninmenu = true;
|
|
Hint.hintstring = true;
|
|
|
|
Hint SetText( string );
|
|
|
|
Hint.alpha = 0;
|
|
Hint FadeOverTime( MYFADEINTIME );
|
|
Hint.alpha = MYALPHAHIGH;
|
|
HintPrintWait( MYFADEINTIME, breakfunc );
|
|
|
|
parms = 0;
|
|
if ( IsDefined( parm3 ) )
|
|
parms = 3;
|
|
else
|
|
if ( IsDefined( parm2 ) )
|
|
parms = 2;
|
|
else
|
|
if ( IsDefined( parm1 ) )
|
|
parms = 1;
|
|
|
|
timeout_ent = SpawnStruct();
|
|
timeout_ent.timed_out = false;
|
|
if ( IsDefined( timeout ) )
|
|
{
|
|
timeout_ent thread hint_timeout( timeout );
|
|
}
|
|
|
|
if ( IsDefined( breakfunc ) )
|
|
{
|
|
for ( ;; )
|
|
{
|
|
|
|
Hint FadeOverTime( MYFLASHTIME );
|
|
Hint.alpha = MYALPHALOW;
|
|
HintPrintWait( MYFLASHTIME, breakfunc );
|
|
|
|
if ( parms == 3 )
|
|
{
|
|
if ( [[ breakfunc ]]( parm1, parm2, parm3 ) )
|
|
break;
|
|
}
|
|
else
|
|
if ( parms == 2 )
|
|
{
|
|
if ( [[ breakfunc ]]( parm1, parm2 ) )
|
|
break;
|
|
}
|
|
else
|
|
if ( parms == 1 )
|
|
{
|
|
if ( [[ breakfunc ]]( parm1 ) )
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( [[ breakfunc ]]() )
|
|
break;
|
|
}
|
|
|
|
Hint FadeOverTime( MYFLASHTIME );
|
|
Hint.alpha = MYALPHAHIGH;
|
|
HintPrintWait( MYFLASHTIME, breakfunc );
|
|
|
|
if ( timeout_ent.timed_out )
|
|
break;
|
|
|
|
if ( parms == 3 )
|
|
{
|
|
if ( [[ breakfunc ]]( parm1, parm2, parm3 ) )
|
|
break;
|
|
}
|
|
else
|
|
if ( parms == 2 )
|
|
{
|
|
if ( [[ breakfunc ]]( parm1, parm2 ) )
|
|
break;
|
|
}
|
|
else
|
|
if ( parms == 1 )
|
|
{
|
|
if ( [[ breakfunc ]]( parm1 ) )
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( [[ breakfunc ]]() )
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0; i < 1; i++ )
|
|
{
|
|
Hint FadeOverTime( MYFLASHTIME );
|
|
Hint.alpha = MYALPHALOW;
|
|
HintPrintWait( MYFLASHTIME, breakfunc );
|
|
|
|
Hint FadeOverTime( MYFLASHTIME );
|
|
Hint.alpha = MYALPHAHIGH;
|
|
HintPrintWait( MYFLASHTIME, breakfunc );
|
|
}
|
|
}
|
|
|
|
hint notify( "destroying" );
|
|
self.current_global_hint = undefined;
|
|
Hint Destroy();
|
|
ent_flag_clear( "global_hint_in_use" );
|
|
}
|
|
|
|
destroy_hint_on_friendlyfire( hint )
|
|
{
|
|
hint endon( "destroying" );
|
|
|
|
level waittill( "friendlyfire_mission_fail" );
|
|
|
|
if ( !isdefined( hint ) )
|
|
return;
|
|
|
|
self.current_global_hint = undefined;
|
|
hint Destroy();
|
|
ent_flag_clear( "global_hint_in_use" );
|
|
}
|
|
|
|
|
|
ShowHintPrint_struct( struct )
|
|
{
|
|
struct.timed_out = false;
|
|
Assert( IsPlayer( self ) );
|
|
|
|
if ( !isalive( self ) )
|
|
return;
|
|
|
|
MYFADEINTIME = 1.0;
|
|
MYFLASHTIME = 0.75;
|
|
MYALPHAHIGH = 0.95;
|
|
MYALPHALOW = 0.4;
|
|
|
|
ent_flag_waitopen( "global_hint_in_use" );
|
|
ent_flag_set( "global_hint_in_use" );
|
|
|
|
// could have been stopped while waiting for the hint area to open
|
|
if ( struct.timed_out )
|
|
return;
|
|
|
|
if ( IsDefined( struct.timeout ) )
|
|
{
|
|
struct thread hint_timeout( struct.timeout );
|
|
}
|
|
|
|
Hint = createClientFontString( "objective", 2 );
|
|
|
|
//Hint.color = ( 1, 1, .5 ); //remove color so that color highlighting on PC can show up.
|
|
Hint.alpha = 0.9;
|
|
Hint.x = 0;
|
|
Hint.y = -38;
|
|
Hint.alignx = "center";
|
|
Hint.aligny = "middle";
|
|
Hint.horzAlign = "center";
|
|
Hint.vertAlign = "middle";
|
|
Hint.foreground = false;
|
|
Hint.hidewhendead = true;
|
|
|
|
Hint SetText( struct.string );
|
|
|
|
Hint.alpha = 0;
|
|
Hint FadeOverTime( MYFADEINTIME );
|
|
Hint.alpha = MYALPHAHIGH;
|
|
HintPrintWait( MYFADEINTIME );
|
|
|
|
for ( ;; )
|
|
{
|
|
Hint FadeOverTime( MYFLASHTIME );
|
|
Hint.alpha = MYALPHALOW;
|
|
HintPrintWait( MYFLASHTIME );
|
|
|
|
if ( struct.timed_out )
|
|
break;
|
|
|
|
Hint FadeOverTime( MYFLASHTIME );
|
|
Hint.alpha = MYALPHAHIGH;
|
|
HintPrintWait( MYFLASHTIME );
|
|
|
|
if ( struct.timed_out )
|
|
break;
|
|
}
|
|
|
|
Hint Destroy();
|
|
ent_flag_clear( "global_hint_in_use" );
|
|
}
|
|
|
|
lerp_player_view_to_tag_internal( player, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo )
|
|
{
|
|
if ( IsDefined( self.first_frame_time ) && self.first_frame_time == GetTime() )
|
|
{
|
|
// the base ai / vehicle / model just was put into the first frame and it takes a server frame for the
|
|
// tags to get into position
|
|
wait( 0.10 );
|
|
}
|
|
|
|
origin = self GetTagOrigin( tag );
|
|
angles = self GetTagAngles( tag );
|
|
player lerp_player_view_to_position( origin, angles, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo );
|
|
|
|
if ( hit_geo )
|
|
return;
|
|
|
|
player PlayerLinkTo( self, tag, fraction, right_arc, left_arc, top_arc, bottom_arc, false );
|
|
}
|
|
|
|
lerp_player_view_to_tag_oldstyle_internal( player, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo )
|
|
{
|
|
if ( IsDefined( self.first_frame_time ) && self.first_frame_time == GetTime() )
|
|
{
|
|
// the base ai / vehicle / model just was put into the first frame and it takes a server frame for the
|
|
// tags to get into position
|
|
wait( 0.10 );
|
|
}
|
|
|
|
origin = self GetTagOrigin( tag );
|
|
angles = self GetTagAngles( tag );
|
|
player lerp_player_view_to_position_oldstyle( origin, angles, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, true );
|
|
|
|
if ( hit_geo )
|
|
return;
|
|
|
|
player PlayerLinkToDelta( self, tag, fraction, right_arc, left_arc, top_arc, bottom_arc, false );
|
|
}
|
|
|
|
function_stack_wait( localentity )
|
|
{
|
|
self endon( "death" );
|
|
localentity waittill_either( "function_done", "death" );
|
|
}
|
|
|
|
function_stack_wait_finish( localentity )
|
|
{
|
|
function_stack_wait( localentity );
|
|
|
|
if ( !isdefined( self ) )
|
|
return false;
|
|
|
|
//if isdefined but not sentient -> good enough
|
|
if ( !issentient( self ) )
|
|
return true;
|
|
|
|
//if is defined and is sentient and is alive -> good
|
|
if ( IsAlive( self ) )
|
|
return true;
|
|
|
|
//if is defined and is sentient but dead -> false
|
|
return false;
|
|
}
|
|
|
|
function_stack_proc( caller, func, param1, param2, param3, param4, param5 )
|
|
{
|
|
self endon( "death" );
|
|
|
|
if ( !isdefined( caller.function_stack ) )
|
|
caller.function_stack = [];
|
|
|
|
caller.function_stack[ caller.function_stack.size ] = self;
|
|
|
|
self thread function_stack_self_death( caller );
|
|
function_stack_caller_waits_for_turn( caller );
|
|
|
|
if ( IsDefined( caller ) && IsDefined( caller.function_stack ) )
|
|
{
|
|
self.function_stack_func_begun = true;
|
|
self notify( "function_stack_func_begun" );
|
|
|
|
if ( IsDefined( param5 ) )
|
|
caller [[ func ]]( param1, param2, param3, param4, param5 );
|
|
else
|
|
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 ) && IsDefined( caller.function_stack ) )
|
|
{
|
|
caller.function_stack = array_remove( caller.function_stack, self );
|
|
caller notify( "level_function_stack_ready" );
|
|
}
|
|
}
|
|
|
|
if ( IsDefined( self ) )
|
|
{
|
|
self.function_stack_func_begun = false;
|
|
self notify( "function_done" );
|
|
}
|
|
}
|
|
|
|
function_stack_self_death( caller )
|
|
{
|
|
self endon( "function_done" );
|
|
|
|
self waittill( "death" );
|
|
|
|
if ( IsDefined( caller ) )
|
|
{
|
|
caller.function_stack = array_remove( caller.function_stack, self );
|
|
caller notify( "level_function_stack_ready" );
|
|
}
|
|
}
|
|
|
|
|
|
function_stack_caller_waits_for_turn( caller )
|
|
{
|
|
caller endon( "death" );
|
|
self endon( "death" );
|
|
caller endon( "clear_function_stack" );
|
|
|
|
while ( caller.function_stack[ 0 ] != self )
|
|
caller waittill( "level_function_stack_ready" );
|
|
}
|
|
|
|
unflash_flag( seconds )
|
|
{
|
|
level endon( "player_flashed" );
|
|
wait( seconds );
|
|
flag_clear( "player_flashed" );
|
|
}
|
|
|
|
wait_for_sounddone_or_death( org )
|
|
{
|
|
self endon( "death" );
|
|
org waittill( "sounddone" );
|
|
return true;
|
|
}
|
|
|
|
init_vision_set( visionset )
|
|
{
|
|
level._lvl_visionset = visionset;
|
|
|
|
if ( !isdefined( level._vision_cheat_enabled ) )
|
|
level._vision_cheat_enabled = false;
|
|
|
|
return level._vision_cheat_enabled;
|
|
}
|
|
|
|
array_waitlogic1( ent, msg, timeout )
|
|
{
|
|
self array_waitlogic2( ent, msg, timeout );
|
|
|
|
self._array_wait = false;
|
|
self notify( "_array_wait" );
|
|
}
|
|
|
|
array_waitlogic2( ent, msg, timeout )
|
|
{
|
|
ent endon( msg );
|
|
ent endon( "death" );
|
|
|
|
if ( IsDefined( timeout ) )
|
|
wait timeout;
|
|
else
|
|
ent waittill( msg );
|
|
}
|
|
|
|
exec_call( func )
|
|
{
|
|
if ( func.parms.size == 0 )
|
|
{
|
|
func.caller call [[ func.func ]]();
|
|
}
|
|
else
|
|
if ( func.parms.size == 1 )
|
|
{
|
|
func.caller call [[ func.func ]]( func.parms[ 0 ] );
|
|
}
|
|
else
|
|
if ( func.parms.size == 2 )
|
|
{
|
|
func.caller call [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ] );
|
|
}
|
|
else
|
|
if ( func.parms.size == 3 )
|
|
{
|
|
func.caller call [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ] );
|
|
}
|
|
if ( func.parms.size == 4 )
|
|
{
|
|
func.caller call [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ], func.parms[ 3 ] );
|
|
}
|
|
if ( func.parms.size == 5 )
|
|
{
|
|
func.caller call [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ], func.parms[ 3 ], func.parms[ 4 ] );
|
|
}
|
|
}
|
|
|
|
exec_call_noself( func )
|
|
{
|
|
if ( func.parms.size == 0 )
|
|
{
|
|
call [[ func.func ]]();
|
|
}
|
|
else
|
|
if ( func.parms.size == 1 )
|
|
{
|
|
call [[ func.func ]]( func.parms[ 0 ] );
|
|
}
|
|
else
|
|
if ( func.parms.size == 2 )
|
|
{
|
|
call [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ] );
|
|
}
|
|
else
|
|
if ( func.parms.size == 3 )
|
|
{
|
|
call [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ] );
|
|
}
|
|
if ( func.parms.size == 4 )
|
|
{
|
|
call [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ], func.parms[ 3 ] );
|
|
}
|
|
if ( func.parms.size == 5 )
|
|
{
|
|
call [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ], func.parms[ 3 ], func.parms[ 4 ] );
|
|
}
|
|
}
|
|
|
|
exec_func( func, endons )
|
|
{
|
|
if ( !isdefined( func.caller ) )
|
|
return;
|
|
|
|
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 ] );
|
|
}
|
|
if ( func.parms.size == 4 )
|
|
{
|
|
func.caller [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ], func.parms[ 3 ] );
|
|
}
|
|
if ( func.parms.size == 5 )
|
|
{
|
|
func.caller [[ func.func ]]( func.parms[ 0 ], func.parms[ 1 ], func.parms[ 2 ], func.parms[ 3 ], func.parms[ 4 ] );
|
|
}
|
|
}
|
|
|
|
waittill_func_ends( func, endons )
|
|
{
|
|
self endon( "all_funcs_ended" );
|
|
self endon( "any_funcs_aborted" );
|
|
exec_func( func, endons );
|
|
self.count--;
|
|
self notify( "func_ended" );
|
|
}
|
|
|
|
waittill_abort_func_ends( func, endons )
|
|
{
|
|
self endon( "all_funcs_ended" );
|
|
self endon( "any_funcs_aborted" );
|
|
exec_func( func, endons );
|
|
self.abort_count--;
|
|
self notify( "abort_func_ended" );
|
|
}
|
|
|
|
do_abort( array )
|
|
{
|
|
self endon( "all_funcs_ended" );
|
|
|
|
if ( !array.size )
|
|
return;
|
|
|
|
count_to_reach = 0;
|
|
self.abort_count = array.size;
|
|
endons = [];
|
|
|
|
self array_levelthread( array, ::waittill_abort_func_ends, endons );
|
|
|
|
for ( ;; )
|
|
{
|
|
if ( self.abort_count <= count_to_reach )
|
|
break;
|
|
self waittill( "abort_func_ended" );
|
|
}
|
|
self notify( "any_funcs_aborted" );
|
|
}
|
|
|
|
|
|
translate_local_on_ent( entity )
|
|
{
|
|
if ( IsDefined( self.forward ) )
|
|
{
|
|
forward = AnglesToForward( entity.angles );
|
|
entity.origin += forward * self.forward;
|
|
}
|
|
if ( IsDefined( self.right ) )
|
|
{
|
|
right = AnglesToRight( entity.angles );
|
|
entity.origin += right * self.right;
|
|
}
|
|
if ( IsDefined( self.up ) )
|
|
{
|
|
up = AnglesToUp( entity.angles );
|
|
entity.origin += up * self.up;
|
|
}
|
|
|
|
if ( IsDefined( self.yaw ) )
|
|
{
|
|
entity AddYaw( self.yaw );
|
|
}
|
|
if ( IsDefined( self.pitch ) )
|
|
{
|
|
entity AddPitch( self.pitch );
|
|
}
|
|
if ( IsDefined( self.roll ) )
|
|
{
|
|
entity AddRoll( self.roll );
|
|
}
|
|
}
|
|
|
|
dynamic_run_speed_proc( pushdist, sprintdist, stopdist, jogdist, group )
|
|
{
|
|
self notify( "start_dynamic_run_speed" );
|
|
|
|
self endon( "death" );
|
|
self endon( "stop_dynamic_run_speed" );
|
|
self endon( "start_dynamic_run_speed" );
|
|
level endon( "_stealth_spotted" );
|
|
|
|
if ( self ent_flag_exist( "_stealth_custom_anim" ) )
|
|
self ent_flag_waitopen( "_stealth_custom_anim" );
|
|
|
|
if ( !self ent_flag_exist( "dynamic_run_speed_stopped" ) )
|
|
{
|
|
self ent_flag_init( "dynamic_run_speed_stopped" );
|
|
self ent_flag_init( "dynamic_run_speed_stopping" );
|
|
}
|
|
else
|
|
{
|
|
self ent_flag_clear( "dynamic_run_speed_stopping" );
|
|
self ent_flag_clear( "dynamic_run_speed_stopped" );
|
|
}
|
|
|
|
self.run_speed_state = "";
|
|
self.old_moveplaybackrate = self.moveplaybackrate;
|
|
|
|
self thread stop_dynamic_run_speed();
|
|
|
|
//MUCH faster to do distancesquared checks than distance
|
|
pushdist2rd = pushdist * pushdist;
|
|
sprintdist2rd = sprintdist * sprintdist;
|
|
stopdist2rd = stopdist * stopdist;
|
|
jogdist2rd = jogdist * jogdist;
|
|
|
|
while ( 1 )
|
|
{
|
|
wait .05;
|
|
|
|
//the player that is the closest to us should have the most effect on us, therefore
|
|
//the player closest to us will determine if we run, jog, or stop. sprinting to catch up
|
|
//is actually done through both this test and a second test to see if the player further
|
|
//away is actually ahead of us (that's done in dynamic_run_ahead test ) which uses the
|
|
//wait_for_player function in go_to_node in _spawner
|
|
|
|
player = level._players[ 0 ];
|
|
foreach ( value in level._players )
|
|
{
|
|
if ( DistanceSquared( player.origin, self.origin ) > DistanceSquared( value.origin, self.origin ) )
|
|
player = value;
|
|
}
|
|
|
|
vec = AnglesToForward( self.angles );
|
|
vec2 = VectorNormalize( ( player.origin - self.origin ) );
|
|
vecdot = VectorDot( vec, vec2 );
|
|
|
|
//how far is the player
|
|
dist2rd = DistanceSquared( self.origin, player.origin );
|
|
dist2rd_group = dist2rd;
|
|
|
|
if ( IsDefined( group ) )
|
|
{
|
|
//not worrying about supporting multiple players since coop is not a priority
|
|
key = getClosest( player.origin, group );
|
|
dist2rd_group = DistanceSquared( key.origin, player.origin );
|
|
}
|
|
|
|
//is the player actually ahead of us, even though we're not facing him?
|
|
ahead = false;
|
|
if ( IsDefined( self.last_set_goalent ) )
|
|
ahead = [[ level._drs_ahead_test ]]( self.last_set_goalent, sprintdist );
|
|
else if ( IsDefined( self.last_set_goalnode ) )
|
|
ahead = [[ level._drs_ahead_test ]]( self.last_set_goalnode, sprintdist );
|
|
|
|
if ( IsDefined( self.cqbwalking ) && self.cqbwalking && !self.dontChangeMovePlaybackRate )
|
|
self.moveplaybackrate = 1;
|
|
|
|
if ( dist2rd < sprintdist2rd || vecdot > - .25 || ahead )
|
|
{
|
|
dynamic_run_set( "sprint" );
|
|
wait .5;
|
|
continue;
|
|
}
|
|
|
|
else if ( dist2rd < pushdist2rd || vecdot > - .25 )
|
|
{
|
|
dynamic_run_set( "run" );
|
|
wait .5;
|
|
continue;
|
|
}
|
|
|
|
//noticed when didn't check the current movement - guys would jump out of cover to a kneal (which is default for stopping on the run )
|
|
else if ( dist2rd_group > stopdist2rd )
|
|
{
|
|
if ( self.a.movement != "stop" )
|
|
{
|
|
dynamic_run_set( "stop" );
|
|
wait .5;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
else if ( dist2rd > jogdist2rd )
|
|
{
|
|
dynamic_run_set( "jog" );
|
|
wait .5;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
stop_dynamic_run_speed()
|
|
{
|
|
self endon( "start_dynamic_run_speed" );
|
|
self endon( "death" );
|
|
|
|
self stop_dynamic_run_speed_wait();
|
|
|
|
if ( !self.dontChangeMovePlaybackRate )
|
|
self.moveplaybackrate = self.old_moveplaybackrate;
|
|
|
|
if ( IsDefined( level._scr_anim[ "generic" ][ "DRS_run" ] ) )
|
|
{
|
|
if ( IsArray( level._scr_anim[ "generic" ][ "DRS_run" ] ) )
|
|
self set_generic_run_anim_array( "DRS_run" );
|
|
else
|
|
self set_generic_run_anim( "DRS_run" );
|
|
}
|
|
else
|
|
self clear_run_anim();
|
|
|
|
self notify( "stop_loop" );
|
|
self ent_flag_clear( "dynamic_run_speed_stopping" );
|
|
self ent_flag_clear( "dynamic_run_speed_stopped" );
|
|
}
|
|
|
|
stop_dynamic_run_speed_wait()
|
|
{
|
|
level endon( "_stealth_spotted" );
|
|
self waittill( "stop_dynamic_run_speed" );
|
|
}
|
|
|
|
dynamic_run_ahead_test( node, dist )
|
|
{
|
|
//only nodes and structs dont have classnames - ents do
|
|
if ( !isdefined( node.classname ) )
|
|
{
|
|
//only structs don't have types, nodes do
|
|
if ( !isdefined( node.type ) )
|
|
getfunc = maps\_spawner::get_target_structs;
|
|
else
|
|
getfunc = maps\_spawner::get_target_nodes;
|
|
}
|
|
else
|
|
getfunc = maps\_spawner::get_target_ents;
|
|
|
|
return maps\_spawner::go_to_node_wait_for_player( node, getfunc, dist );
|
|
}
|
|
|
|
dynamic_run_set( speed )
|
|
{
|
|
if ( self.run_speed_state == speed )
|
|
return;
|
|
|
|
self.run_speed_state = speed;
|
|
|
|
switch( speed )
|
|
{
|
|
case "sprint":
|
|
if ( IsDefined( self.cqbwalking ) && self.cqbwalking && !self.dontChangeMovePlaybackRate )
|
|
self.moveplaybackrate = 1;
|
|
else if ( !self.dontChangeMovePlaybackRate )
|
|
self.moveplaybackrate = 1.15;
|
|
|
|
if ( IsArray( level._scr_anim[ "generic" ][ "DRS_sprint" ] ) )
|
|
self set_generic_run_anim_array( "DRS_sprint" );
|
|
else
|
|
self set_generic_run_anim( "DRS_sprint" );
|
|
//self AllowedStances( "stand", "crouch", "prone" );
|
|
|
|
self notify( "stop_loop" );
|
|
self anim_stopanimscripted();
|
|
self ent_flag_clear( "dynamic_run_speed_stopped" );
|
|
break;
|
|
case "run":
|
|
if ( !self.dontChangeMovePlaybackRate )
|
|
self.moveplaybackrate = self.old_moveplaybackrate;
|
|
|
|
if ( IsDefined( level._scr_anim[ "generic" ][ "DRS_run" ] ) )
|
|
{
|
|
if ( IsArray( level._scr_anim[ "generic" ][ "DRS_run" ] ) )
|
|
self set_generic_run_anim_array( "DRS_run" );
|
|
else
|
|
self set_generic_run_anim( "DRS_run" );
|
|
}
|
|
else
|
|
self clear_run_anim();
|
|
//self AllowedStances( "stand", "crouch", "prone" );
|
|
|
|
self notify( "stop_loop" );
|
|
self anim_stopanimscripted();
|
|
self ent_flag_clear( "dynamic_run_speed_stopped" );
|
|
break;
|
|
case "stop":
|
|
self thread dynamic_run_speed_stopped();
|
|
break;
|
|
case "jog":
|
|
if ( !self.dontChangeMovePlaybackRate )
|
|
self.moveplaybackrate = self.old_moveplaybackrate;
|
|
|
|
if ( IsDefined( level._scr_anim[ "generic" ][ "DRS_combat_jog" ] ) )
|
|
{
|
|
if ( IsArray( level._scr_anim[ "generic" ][ "DRS_combat_jog" ] ) )
|
|
self set_generic_run_anim_array( "DRS_combat_jog" );
|
|
else
|
|
self set_generic_run_anim( "DRS_combat_jog" );
|
|
}
|
|
else
|
|
self clear_run_anim();
|
|
//self AllowedStances( "stand", "crouch", "prone" );
|
|
|
|
self notify( "stop_loop" );
|
|
self anim_stopanimscripted();
|
|
self ent_flag_clear( "dynamic_run_speed_stopped" );
|
|
break;
|
|
case "crouch":
|
|
assertmsg( "thought this was depricated...come grab me - mo" );
|
|
/*
|
|
if ( !self.dontChangeMovePlaybackRate )
|
|
self.moveplaybackrate = self.old_moveplaybackrate;
|
|
|
|
self clear_run_anim();
|
|
//self AllowedStances( "crouch" );
|
|
|
|
self notify( "stop_loop" );
|
|
self anim_stopanimscripted();
|
|
self ent_flag_clear( "dynamic_run_speed_stopped" );
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
dynamic_run_speed_stopped()
|
|
{
|
|
self endon( "death" );
|
|
|
|
if ( self ent_flag( "dynamic_run_speed_stopped" ) )
|
|
return;
|
|
if ( self ent_flag( "dynamic_run_speed_stopping" ) )
|
|
return;
|
|
|
|
self endon( "stop_dynamic_run_speed" );
|
|
|
|
self ent_flag_set( "dynamic_run_speed_stopping" );
|
|
self ent_flag_set( "dynamic_run_speed_stopped" );
|
|
|
|
self endon( "dynamic_run_speed_stopped" );
|
|
|
|
//->turned this off because I think checking the current movement would fix whatever this was trying to
|
|
//if( self ent_flag_exist( "_stealth_stance_handler" ) )
|
|
// self ent_flag_waitopen( "_stealth_stance_handler" );
|
|
|
|
stop = "DRS_run_2_stop";
|
|
self maps\_anim::anim_generic_custom_animmode( self, "gravity", stop );
|
|
self ent_flag_clear( "dynamic_run_speed_stopping" );// this flag gets cleared if we endon
|
|
|
|
//if he's already playing a looping animation - we can assume its part of level logic and
|
|
//it makes sense not to play a stopping animation or play dialogue to tell you to catch up
|
|
if ( IsDefined( self.loops ) && self.loops > 0 )
|
|
return;
|
|
|
|
while ( self ent_flag( "dynamic_run_speed_stopped" ) )
|
|
{
|
|
//->turned this off because I think checking the current movement would fix whatever this was trying to
|
|
//if( self ent_flag_exist( "_stealth_stance_handler" ) )
|
|
// self ent_flag_waitopen( "_stealth_stance_handler" );
|
|
|
|
idle = "DRS_stop_idle";
|
|
self thread maps\_anim::anim_generic_loop( self, idle );
|
|
|
|
if ( IsDefined( level._scr_anim[ "generic" ][ "signal_go" ] ) )
|
|
self handsignal( "go" );
|
|
|
|
wait RandomFloatRange( 12, 20 );
|
|
|
|
if ( self ent_flag_exist( "_stealth_stance_handler" ) )
|
|
self ent_flag_waitopen( "_stealth_stance_handler" );
|
|
|
|
self notify( "stop_loop" );
|
|
|
|
if ( !self ent_flag( "dynamic_run_speed_stopped" ) )
|
|
return;
|
|
|
|
if ( IsDefined( level._dynamic_run_speed_dialogue ) )
|
|
{
|
|
string = random( level._dynamic_run_speed_dialogue );
|
|
level thread radio_dialogue_queue( string );
|
|
}
|
|
|
|
if ( IsDefined( level._scr_anim[ "generic" ][ "signal_go" ] ) )
|
|
self handsignal( "go" );
|
|
}
|
|
}
|
|
|
|
g_speed_get_func()
|
|
{
|
|
return Int( GetDvar( "g_speed" ) );
|
|
}
|
|
|
|
g_speed_set_func( goalspeed )
|
|
{
|
|
SetSavedDvar( "g_speed", Int( goalspeed ) );
|
|
}
|
|
|
|
movespeed_get_func()
|
|
{
|
|
return self.movespeedscale;
|
|
}
|
|
|
|
movespeed_set_func( scale )
|
|
{
|
|
self.movespeedscale = scale;
|
|
self SetMoveSpeedScale( scale );
|
|
}
|
|
|
|
autosave_tactical_setup()
|
|
{
|
|
if ( flag_exist( "autosave_tactical_player_nade" ) )
|
|
return;
|
|
|
|
flag_init( "autosave_tactical_player_nade" );
|
|
level._autosave_tactical_player_nades = 0;
|
|
NotifyOnCommand( "autosave_player_nade", "+frag" );
|
|
NotifyOnCommand( "autosave_player_nade", "-smoke" );
|
|
NotifyOnCommand( "autosave_player_nade", "+smoke" );
|
|
|
|
array_thread( level._players, ::autosave_tactical_grenade_check );
|
|
}
|
|
|
|
autosave_tactical_grenade_check()
|
|
{
|
|
while ( 1 )
|
|
{
|
|
//this one hit's as soon as the button is pressed - that's why we want
|
|
//to set the flag here and not after the grenade has left the hand
|
|
//with "grenade fire"
|
|
self waittill( "autosave_player_nade" );
|
|
flag_set( "autosave_tactical_player_nade" );
|
|
|
|
self waittill( "grenade_fire", grenade );
|
|
thread autosave_tactical_grenade_check_dieout( grenade );
|
|
}
|
|
}
|
|
|
|
autosave_tactical_grenade_check_dieout( grenade )
|
|
{
|
|
level._autosave_tactical_player_nades++;
|
|
grenade waittill_notify_or_timeout( "death", 10 );
|
|
level._autosave_tactical_player_nades--;
|
|
|
|
//give stealth a chance to notify of any issues because of the grenade before we clear the flag
|
|
//so that the system checking for saving the game can verify those notifies first
|
|
waittillframeend;
|
|
|
|
if ( !level._autosave_tactical_player_nades )
|
|
flag_clear( "autosave_tactical_player_nade" );
|
|
}
|
|
|
|
autosave_tactical_proc()
|
|
{
|
|
level notify( "autosave_tactical_proc" );
|
|
level endon( "autosave_tactical_proc" );
|
|
|
|
level thread notify_delay( "kill_save", 5 );
|
|
level endon( "kill_save" );
|
|
|
|
level endon( "autosave_tactical_player_nade" );
|
|
if ( flag( "autosave_tactical_player_nade" ) )
|
|
{
|
|
flag_waitopen_or_timeout( "autosave_tactical_player_nade", 4 );
|
|
|
|
//we still have nades?
|
|
if ( flag( "autosave_tactical_player_nade" ) )
|
|
return;
|
|
}
|
|
|
|
enemies = GetAIArray( "axis" );
|
|
foreach ( ai in enemies )
|
|
{
|
|
if ( IsDefined( ai.enemy ) && IsPlayer( ai.enemy ) )
|
|
return;
|
|
}
|
|
|
|
waittillframeend;// give endon's a chance to register
|
|
autosave_by_name();
|
|
}
|
|
|
|
music_play_internal_stop_with_fade_then_call( name, fade_time, numtimestoplay, timescale, overrideCheat )
|
|
{
|
|
music_stop( fade_time );
|
|
|
|
level endon( "stop_music" );
|
|
|
|
wait fade_time;
|
|
thread music_play( name, undefined, numtimestoplay, timescale, overrideCheat );
|
|
}
|
|
|
|
music_loop_internal_stop_with_fade_then_call( name, length, fade_time, numtimestoplay, timescale, overrideCheat, stop_for_stealth )
|
|
{
|
|
music_stop( fade_time );
|
|
|
|
level endon( "stop_music" );
|
|
|
|
wait fade_time;
|
|
thread music_loop_internal( name, length, undefined, numtimestoplay, timescale, overrideCheat, stop_for_stealth );
|
|
}
|
|
|
|
music_loop_internal( name, post_music_delay, fade_time, numtimestoplay, timescale, overrideCheat, stop_for_stealth )
|
|
{
|
|
if ( IsDefined( fade_time ) && fade_time > 0 )
|
|
{
|
|
thread music_loop_internal_stop_with_fade_then_call( name, post_music_delay, fade_time, numtimestoplay, timescale, overrideCheat, stop_for_stealth );
|
|
return;
|
|
}
|
|
music_stop();
|
|
|
|
level endon( "stop_music" );
|
|
|
|
MusicPlayWrapper( name, timescale, overrideCheat );
|
|
|
|
if ( IsDefined( stop_for_stealth ) && stop_for_stealth == true && flag_exist( "_stealth_spotted" ) )
|
|
{
|
|
level endon( "_stealth_spotted" );
|
|
thread music_loop_stealth_pause( name, post_music_delay, fade_time, numtimestoplay );
|
|
}
|
|
|
|
delay = musicLength( name );
|
|
|
|
if ( post_music_delay <= 10 )
|
|
{
|
|
delay += post_music_delay;
|
|
}
|
|
|
|
wait delay;
|
|
music_loop( name, post_music_delay, fade_time, timescale, overrideCheat );
|
|
}
|
|
|
|
music_loop_stealth_pause( name, length, fade_time, numtimestoplay )
|
|
{
|
|
level endon( "stop_music" );
|
|
|
|
flag_wait( "_stealth_spotted" );
|
|
MusicStop( .5 );
|
|
|
|
while ( flag( "_stealth_spotted" ) )
|
|
{
|
|
flag_waitopen( "_stealth_spotted" );
|
|
wait 1;
|
|
}
|
|
|
|
thread music_loop( name, length, fade_time, numtimestoplay );
|
|
}
|
|
|
|
DoSlide( slideModel, allowedAcceleration, dampening )
|
|
{
|
|
self endon( "death" );
|
|
self endon( "stop_sliding" );
|
|
|
|
player = self;
|
|
|
|
entNum = undefined;
|
|
/#
|
|
entNum = slidemodel getEntNum();
|
|
#/
|
|
|
|
|
|
while ( 1 )
|
|
{
|
|
movement = player GetNormalizedMovement();
|
|
forward = AnglesToForward( player.angles );
|
|
right = AnglesToRight( player.angles );
|
|
|
|
movement = ( movement[ 1 ] * right[ 0 ] + movement[ 0 ] * forward[ 0 ], movement[ 1 ] * right[ 1 ] + movement[ 0 ] * forward[ 1 ], 0 );
|
|
|
|
// maybe we should plant movement to be perpendicular to ground normal?
|
|
|
|
slideModel.slideVelocity += movement * allowedAcceleration;
|
|
|
|
wait .05;
|
|
|
|
slideModel.slideVelocity *= 1 - dampening;
|
|
}
|
|
}
|
|
|
|
kill_deathflag_proc( time )
|
|
{
|
|
self endon( "death" );
|
|
if ( IsDefined( time ) )
|
|
wait( RandomFloat( time ) );
|
|
|
|
PlayFXOnTag( getfx( "flesh_hit" ), self, "tag_eye" );
|
|
self Kill( level._player.origin );
|
|
}
|
|
|
|
update_rumble_intensity( player )
|
|
{
|
|
self endon( "death" );
|
|
for ( ;; )
|
|
{
|
|
intensity = 1 - self.intensity;
|
|
intensity *= 1000;
|
|
self.origin = player.origin + ( 0, 0, intensity );
|
|
/#
|
|
if( is_coop() )
|
|
PrintLn( "^3Warning! Using get_rumble_ent will cause the same rumbles to apply to all of the coop players!" );
|
|
#/
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
|
|
start_glow( model )
|
|
{
|
|
ent = Spawn( "script_model", self.origin );
|
|
self.glow_model = ent;
|
|
ent.angles = self.angles;
|
|
ent SetModel( model );
|
|
ent endon( "death" );
|
|
self waittill( "death" );
|
|
ent Delete();
|
|
}
|
|
|
|
blend_default_dof( progress, start, end )
|
|
{
|
|
foreach ( key, value in level._dofDefault )
|
|
{
|
|
level._dofDefault[ key ] = start[ key ] * ( 1 - progress ) + end[ key ] * progress;
|
|
}
|
|
}
|
|
|
|
process_blend( func, caller, var1, var2, var3 )
|
|
{
|
|
waittillframeend;// wait for the blend settings to get set;
|
|
AssertEx( IsDefined( self.time ), "Blend needs a .time set to know how long to blend over." );
|
|
if ( !isdefined( self.start ) )
|
|
self.start = 0;
|
|
if ( !isdefined( self.end ) )
|
|
self.end = 1;
|
|
if ( !isdefined( self.base ) )
|
|
self.base = 0;
|
|
|
|
frames = self.time * 20;
|
|
range = self.end - self.start;
|
|
|
|
if ( IsDefined( var3 ) )
|
|
{
|
|
for ( i = 0; i <= frames; i++ )
|
|
{
|
|
value = self.base + ( i * range / frames );
|
|
caller thread [[ func ]]( value, var1, var2, var3 );
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
else
|
|
if ( IsDefined( var2 ) )
|
|
{
|
|
for ( i = 0; i <= frames; i++ )
|
|
{
|
|
value = self.base + ( i * range / frames );
|
|
caller thread [[ func ]]( value, var1, var2 );
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
else
|
|
if ( IsDefined( var1 ) )
|
|
{
|
|
for ( i = 0; i <= frames; i++ )
|
|
{
|
|
value = self.base + ( i * range / frames );
|
|
caller thread [[ func ]]( value, var1 );
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0; i <= frames; i++ )
|
|
{
|
|
value = self.base + ( i * range / frames );
|
|
caller thread [[ func ]]( value );
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
}
|
|
|
|
add_trace_fx_proc( name )
|
|
{
|
|
waittillframeend;// give the scripts that set the params a chance to do so
|
|
if ( !isdefined( level._trace_fx ) )
|
|
{
|
|
level._trace_fx = [];
|
|
}
|
|
|
|
AssertEx( IsDefined( self.surface ), "Tracefx for " + name + " has no .surface" );
|
|
if ( !isdefined( level._trace_fx ) )
|
|
{
|
|
level._trace_fx[ name ] = [];
|
|
}
|
|
|
|
if ( IsDefined( self.fx ) )
|
|
level._trace_fx[ name ][ self.surface ][ "fx" ] = self.fx;
|
|
|
|
if ( IsDefined( self.fx_array ) )
|
|
level._trace_fx[ name ][ self.surface ][ "fx_array" ] = self.fx_array;
|
|
|
|
if ( IsDefined( self.sound ) )
|
|
level._trace_fx[ name ][ self.surface ][ "sound" ] = self.sound;
|
|
|
|
if ( IsDefined( self.rumble ) )
|
|
level._trace_fx[ name ][ self.surface ][ "rumble" ] = self.rumble;
|
|
|
|
if ( !isdefined( level._trace_fx[ name ][ "default" ] ) )
|
|
{
|
|
level._trace_fx[ name ][ "default" ] = level._trace_fx[ name ][ self.surface ];
|
|
}
|
|
}
|
|
|
|
put_interactive_in_volume( toy )
|
|
{
|
|
ent = SpawnStruct();
|
|
PreCacheModel( toy.model );
|
|
ent.toy_model = toy.model;
|
|
ent.origin = toy.origin;
|
|
ent.angles = toy.angles;
|
|
ent.script_noteworthy = toy.script_noteworthy;
|
|
ent.target = toy.target;
|
|
ent.targetname = toy.targetname;
|
|
|
|
self.interactives[ self.interactives.size ] = ent;
|
|
|
|
toy Delete();
|
|
}
|
|
|
|
put_toy_in_volume( toy )
|
|
{
|
|
ent = SpawnStruct();
|
|
PreCacheModel( toy.model );
|
|
ent.toy_model = toy.model;
|
|
ent.origin = toy.origin;
|
|
ent.angles = toy.angles;
|
|
ent.script_noteworthy = toy.script_noteworthy;
|
|
ent.target = toy.target;
|
|
ent.destructible_type = toy.destructible_type;
|
|
ent.script_noflip = toy.script_noflip;
|
|
|
|
self.destructibles[ self.destructibles.size ] = ent;
|
|
|
|
toy Delete();
|
|
}
|
|
|
|
get_color_info_from_trigger()
|
|
{
|
|
/#
|
|
if ( IsDefined( self.script_color_allies ) )
|
|
{
|
|
AssertEx( !isdefined( self.script_color_axis ), "trigger had axis and allies" );
|
|
}
|
|
else
|
|
if ( IsDefined( self.script_color_axis ) )
|
|
{
|
|
AssertEx( !isdefined( self.script_color_allies ), "trigger had axis and allies" );
|
|
}
|
|
else
|
|
AssertMsg( "Trigger didnt have allies or axis" );
|
|
#/
|
|
|
|
team = "allies";
|
|
if ( IsDefined( self.script_color_axis ) )
|
|
team = "axis";
|
|
|
|
team = maps\_colors::get_team( team );// to cast team3
|
|
|
|
colorCodes = [];
|
|
if ( team == "allies" )
|
|
{
|
|
array = maps\_colors::get_colorcodes_from_trigger( self.script_color_allies, "allies" );
|
|
colorCodes = array[ "colorCodes" ];
|
|
}
|
|
else
|
|
{
|
|
array = maps\_colors::get_colorcodes_from_trigger( self.script_color_axis, "axis" );
|
|
colorCodes = array[ "colorCodes" ];
|
|
}
|
|
|
|
AssertEx( colorCodes.size, "Tried to get codes from trigger but there were none" );
|
|
|
|
info = [];
|
|
info[ "team" ] = team;
|
|
info[ "codes" ] = colorCodes;
|
|
|
|
return info;
|
|
}
|
|
|
|
|
|
delayThread_proc( func, timer, param1, param2, param3, param4, param5 )
|
|
{
|
|
self endon( "death" );
|
|
|
|
wait( timer );
|
|
if ( !IsDefined( param1 ) )
|
|
{
|
|
assertex( !isdefined( param2 ), "Delaythread does not support vars after undefined." );
|
|
assertex( !isdefined( param3 ), "Delaythread does not support vars after undefined." );
|
|
assertex( !isdefined( param4 ), "Delaythread does not support vars after undefined." );
|
|
assertex( !isdefined( param5 ), "Delaythread does not support vars after undefined." );
|
|
thread [[ func ]]();
|
|
}
|
|
else
|
|
if ( !IsDefined( param2 ) )
|
|
{
|
|
assertex( !isdefined( param3 ), "Delaythread does not support vars after undefined." );
|
|
assertex( !isdefined( param4 ), "Delaythread does not support vars after undefined." );
|
|
assertex( !isdefined( param5 ), "Delaythread does not support vars after undefined." );
|
|
thread [[ func ]]( param1 );
|
|
}
|
|
else
|
|
if ( !IsDefined( param3 ) )
|
|
{
|
|
assertex( !isdefined( param4 ), "Delaythread does not support vars after undefined." );
|
|
assertex( !isdefined( param5 ), "Delaythread does not support vars after undefined." );
|
|
thread [[ func ]]( param1, param2 );
|
|
}
|
|
else
|
|
if ( !IsDefined( param4 ) )
|
|
{
|
|
assertex( !isdefined( param5 ), "Delaythread does not support vars after undefined." );
|
|
thread [[ func ]]( param1, param2, param3 );
|
|
}
|
|
else
|
|
if ( !IsDefined( param5 ) )
|
|
{
|
|
thread [[ func ]]( param1, param2, param3, param4 );
|
|
}
|
|
else
|
|
{
|
|
thread [[ func ]]( param1, param2, param3, param4, param5 );
|
|
}
|
|
}
|
|
|
|
add_wait_asserter()
|
|
{
|
|
level notify( "kill_add_wait_asserter" );
|
|
level endon( "kill_add_wait_asserter" );
|
|
|
|
// wait until the end of the frame
|
|
for ( i = 0; i < 20; i++ )
|
|
{
|
|
waittillframeend;
|
|
}
|
|
AssertMsg( "Added a wait or func and then didn't do_wait immediately." );
|
|
}
|
|
|
|
update_battlechatter_hud()
|
|
{
|
|
/#
|
|
if ( getdvar( "loc_warnings", 0 ) == "1" )
|
|
return;
|
|
|
|
if ( getdvarint( "debug_hud" ) != 1 )
|
|
return;
|
|
|
|
if ( !isdefined( level._bcs_hud ) )
|
|
{
|
|
x = -50;
|
|
y = 460;
|
|
x_offset = 22;
|
|
|
|
hud = newHudElem();
|
|
hud.x = x;
|
|
hud.y = y;
|
|
hud.color = ( 0.4, 0.55, 0.9 );
|
|
level._bcs_hud = hud;
|
|
}
|
|
|
|
msg = "BCS enabled: ";
|
|
count = 0;
|
|
|
|
// just gonna ignore team3 and neutral since it doesnt apply often
|
|
teams = [];
|
|
teams[ "allies" ] = level._battlechatter[ "allies" ];
|
|
teams[ "axis" ] = level._battlechatter[ "axis" ];
|
|
|
|
foreach ( team, val in teams )
|
|
{
|
|
if ( val )
|
|
{
|
|
msg = msg + team + " ";
|
|
}
|
|
count++;
|
|
}
|
|
|
|
if ( count )
|
|
{
|
|
level._bcs_hud settext( msg );
|
|
}
|
|
else
|
|
{
|
|
level._bcs_hud settext( "BCS disabled" );
|
|
}
|
|
#/
|
|
}
|
|
|
|
compareSizesFx( org, array, dist, compareFunc )
|
|
{
|
|
if ( !array.size )
|
|
return undefined;
|
|
if ( IsDefined( dist ) )
|
|
{
|
|
struct = undefined;
|
|
keys = GetArrayKeys( array );
|
|
for ( i = 0; i < keys.size; i++ )
|
|
{
|
|
newdist = Distance( array[ keys[ i ] ].v[ "origin" ], org );
|
|
if ( [[ compareFunc ]]( newDist, dist ) )
|
|
continue;
|
|
dist = newdist;
|
|
struct = array[ keys[ i ] ];
|
|
}
|
|
return struct;
|
|
}
|
|
|
|
keys = GetArrayKeys( array );
|
|
struct = array[ keys[ 0 ] ];
|
|
dist = Distance( struct.v[ "origin" ], org );
|
|
for ( i = 1; i < keys.size; i++ )
|
|
{
|
|
newdist = Distance( array[ keys[ i ] ].v[ "origin" ], org );
|
|
if ( [[ compareFunc ]]( newDist, dist ) )
|
|
continue;
|
|
dist = newdist;
|
|
struct = array[ keys[ i ] ];
|
|
}
|
|
return struct;
|
|
}
|