INSANEMODE/IL-GSC
1
0
Fork 0
mirror of https://github.com/InfinityLoader/IL-GSC.git synced 2025-06-07 17:17:50 -05:00
Code Issues Packages Projects Releases Wiki Activity
IL-GSC/BO1/PC/ZM/maps/_utility.gsc
InfinityLoader b53c55f0c0 Added BO1 ZM rawfiles
2024-02-18 17:32:07 -05:00

8103 lines
186 KiB
Plaintext
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include common_scripts\utility;
#include maps\_utility_code;
array_levelthread( array, process, var1, var2, var3, var4 )
{
keys = getArrayKeys( array );
if( IsDefined( var4 ) )
{
for( i = 0 ; i < keys.size ; i++ )
{
thread [[ process ]]( array[ keys[ i ] ], var1, var2, var3, var4 );
}
return;
}
if( IsDefined( var3 ) )
{
for( i = 0 ; i < keys.size ; i++ )
{
thread [[ process ]]( array[ keys[ i ] ], var1, var2, var3 );
}
return;
}
if( IsDefined( var2 ) )
{
for( i = 0 ; i < keys.size ; i++ )
{
thread [[ process ]]( array[ keys[ i ] ], var1, var2 );
}
return;
}
if( IsDefined( var1 ) )
{
for( i = 0 ; i < keys.size ; i++ )
{
thread [[ process ]]( array[ keys[ i ] ], var1 );
}
return;
}
for( i = 0 ; i < keys.size ; i++ )
{
thread [[ process ]]( array[ keys[ i ] ] );
}
}
set_vision_set( visionset, transition_time )
{
if ( init_vision_set( visionset ) )
{
return;
}
if ( !IsDefined( transition_time ) )
{
transition_time = 1;
}
visionSetNaked( visionset, transition_time );
}
ent_flag_wait( msg )
{
self endon("death");
while( !self.ent_flag[ msg ] )
{
self waittill( msg );
}
}
ent_flag_wait_either( flag1, flag2 )
{
self endon("death");
for( ;; )
{
if( ent_flag( flag1 ) )
{
return;
}
if( ent_flag( flag2 ) )
{
return;
}
self waittill_either( flag1, flag2 );
}
}
ent_flag_wait_or_timeout( flagname, timer )
{
self endon("death");
start_time = gettime();
for( ;; )
{
if( self.ent_flag[ flagname ] )
{
break;
}
if( gettime() >= start_time + timer * 1000 )
{
break;
}
self ent_wait_for_flag_or_time_elapses( flagname, timer );
}
}
ent_flag_waitopen( msg )
{
self endon("death");
while( self.ent_flag[ msg ] )
{
self waittill( msg );
}
}
ent_flag_init( message, val )
{
if( !IsDefined( self.ent_flag ) )
{
self.ent_flag = [];
self.ent_flags_lock = [];
}
if ( !IsDefined( level.first_frame ) )
{
assertEx( !IsDefined( self.ent_flag[ message ] ), "Attempt to reinitialize existing flag '" + message + "' on entity.");
}
if (is_true(val))
{
self.ent_flag[ message ] = true;
}
else
{
self.ent_flag[ message ] = false;
}
}
ent_flag_set_delayed( message, delay )
{
wait( delay );
self ent_flag_set( message );
}
ent_flag_set( message )
{
self.ent_flag[ message ] = true;
self notify( message );
}
ent_flag_toggle( message )
{
if (self ent_flag(message))
{
self ent_flag_clear(message);
}
else
{
self ent_flag_set(message);
}
}
ent_flag_clear( message )
{
if( self.ent_flag[ message ] )
{
self.ent_flag[ message ] = false;
self notify( message );
}
}
ent_flag_clear_delayed( message, delay )
{
wait( delay );
self ent_flag_clear( message );
}
ent_flag( message )
{
AssertEx( IsDefined( message ), "Tried to check flag but the flag was not defined." );
AssertEx( IsDefined( self.ent_flag[ message ] ), "Tried to check entity flag '" + message + "', but the flag was not initialized.");
if( !self.ent_flag[ message ] )
{
return false;
}
return true;
}
ent_flag_init_ai_standards()
{
message_array = [];
message_array[ message_array.size ] = "goal";
message_array[ message_array.size ] = "damage";
for( i = 0; i < message_array.size; i++)
{
self ent_flag_init( message_array[ i ] );
self thread ent_flag_wait_ai_standards( message_array[ i ] );
}
}
ent_flag_wait_ai_standards( message )
{
self endon("death");
self waittill( message );
self.ent_flag[ message ] = true;
}
flag_wait_either( flag1, flag2 )
{
for( ;; )
{
if( flag( flag1 ) )
{
return;
}
if( flag( flag2 ) )
{
return;
}
level waittill_either( flag1, flag2 );
}
}
flag_wait_any( flag1, flag2, flag3, flag4 )
{
array = [];
if( IsDefined( flag4 ) )
{
array[ array.size ] = flag1;
array[ array.size ] = flag2;
array[ array.size ] = flag3;
array[ array.size ] = flag4;
}
else if( IsDefined( flag3 ) )
{
array[ array.size ] = flag1;
array[ array.size ] = flag2;
array[ array.size ] = flag3;
}
else if( IsDefined( flag2 ) )
{
flag_wait_either( flag1, flag2 );
return;
}
else
{
assertmsg( "flag_wait_any() needs at least 2 flags passed to it" );
return;
}
for( ;; )
{
for(i=0; i<array.size; i++)
{
if( flag( array[i] ) )
{
return;
}
}
level waittill_any( flag1, flag2, flag3, flag4 );
}
}
flag_wait_all( flag1, flag2, flag3, flag4 )
{
if( IsDefined( flag1 ) )
{
flag_wait( flag1 );
}
if( IsDefined( flag2 ) )
{
flag_wait( flag2 );
}
if( IsDefined( flag3 ) )
{
flag_wait( flag3 );
}
if( IsDefined( flag4 ) )
{
flag_wait( flag4 );
}
}
flag_wait_on( flagname )
{
while( !level flag_exists( flagname ) )
{
wait 0.05;
}
flag_wait( flagname );
}
flag_wait_or_timeout( flagname, timer )
{
start_time = gettime();
for( ;; )
{
if( level.flag[ flagname ] )
{
break;
}
if( gettime() >= start_time + timer * 1000 )
{
break;
}
wait_for_flag_or_time_elapses( flagname, timer );
}
}
flag_waitopen_or_timeout( flagname, timer )
{
start_time = gettime();
for( ;; )
{
if( !level.flag[ flagname ] )
{
break;
}
if( gettime() >= start_time + timer * 1000 )
{
break;
}
wait_for_flag_or_time_elapses( flagname, timer );
}
}
flag_trigger_init( message, trigger, continuous )
{
flag_init( message );
if( !IsDefined( continuous ) )
{
continuous = false;
}
assert( isSubStr( trigger.classname, "trigger" ) );
trigger thread _flag_wait_trigger( message, continuous );
return trigger;
}
flag_triggers_init( message, triggers, all )
{
flag_init( message );
if( !IsDefined( all ) )
{
all = false;
}
for( index = 0; index < triggers.size; index ++ )
{
assert( isSubStr( triggers[ index ].classname, "trigger" ) );
triggers[ index ] thread _flag_wait_trigger( message, false );
}
return triggers;
}
flag_assert( msg )
{
assertEx( !flag( msg ), "Flag " + msg + " set too soon!" );
}
flag_set_delayed( message, delay )
{
wait( delay );
flag_set( message );
}
flag_clear_delayed( message, delay )
{
wait( delay );
flag_clear( message );
}
_flag_wait_trigger( message, continuous )
{
self endon( "death" );
for( ;; )
{
self waittill( "trigger", other );
flag_set( message );
if( !continuous )
{
return;
}
while( other isTouching( self ) )
{
wait( 0.05 );
}
flag_clear( message );
}
}
wait_endon( waitTime, endOnString, endonString2, endonString3 )
{
self endon ( endOnString );
if ( isDefined( endonString2 ) )
self endon ( endonString2 );
if ( isDefined( endonString3 ) )
self endon ( endonString3 );
wait ( waitTime );
}
level_end_save()
{
if( level.missionfailed )
{
return;
}
if ( flag( "game_saving" ) )
{
return;
}
players = get_players();
if( !IsAlive( players[0] ) )
{
return;
}
flag_set( "game_saving" );
imagename = "levelshots / autosave / autosave_" + level.script + "end";
saveGame( "levelend", &"AUTOSAVE_AUTOSAVE", imagename, true );
flag_clear( "game_saving" );
}
autosave_by_name( name )
{
thread autosave_by_name_thread( name );
}
autosave_by_name_thread( name, timeout )
{
if( !IsDefined( level.curAutoSave ) )
{
level.curAutoSave = 1;
}
imageName = "levelshots / autosave / autosave_" + level.script + level.curAutoSave;
result = level maps\_autosave::try_auto_save( level.curAutoSave, "autosave", imagename, timeout );
if( IsDefined( result ) && result )
{
level.curAutoSave++;
}
}
error( message )
{
println( "^c * ERROR * ", message );
wait 0.05;
}
error2( message )
{
println( "^c * ERROR * ", message );
wait 0.05;
}
debug_message( message, origin, duration )
{
if( !IsDefined( duration ) )
{
duration = 5;
}
for( time = 0; time < ( duration * 20 );time ++ )
{
print3d( ( origin + ( 0, 0, 45 ) ), message, ( 0.48, 9.4, 0.76 ), 0.85 );
wait 0.05;
}
}
debug_message_clear( message, origin, duration, extraEndon )
{
if( IsDefined( extraEndon ) )
{
level notify( message + extraEndon );
level endon( message + extraEndon );
}
else
{
level notify( message );
level endon( message );
}
if( !IsDefined( duration ) )
{
duration = 5;
}
for( time = 0; time < ( duration * 20 );time ++ )
{
print3d( ( origin + ( 0, 0, 45 ) ), message, ( 0.48, 9.4, 0.76 ), 0.85 );
wait 0.05;
}
}
precache( model )
{
ent = spawn( "script_model", ( 0, 0, 0 ) );
ent.origin = get_players()[0] getorigin();
ent setmodel( model );
ent delete();
}
closerFunc( dist1, dist2 )
{
return dist1 >= dist2;
}
fartherFunc( dist1, dist2 )
{
return dist1 <= dist2;
}
getClosest( org, array, dist )
{
return compareSizes( org, array, dist, ::closerFunc );
}
getFarthest( org, array, dist )
{
return compareSizes( org, array, dist, ::fartherFunc );
}
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;
}
compareSizes( org, array, dist, compareFunc )
{
if( !array.size )
{
return undefined;
}
if( IsDefined( dist ) )
{
ent = undefined;
keys = GetArrayKeys( array );
for( i = 0; i < keys.size; i++ )
{
newdist = distance( array[ keys[ i ] ].origin, org );
if( [[ compareFunc ]]( newDist, dist ) )
{
continue;
}
dist = newdist;
ent = array[ keys[ i ] ];
}
return ent;
}
keys = GetArrayKeys( array );
ent = array[ keys[ 0 ] ];
dist = Distance( ent.origin, org );
for( i = 1; i < keys.size; i++ )
{
newdist = distance( array[ keys[ i ] ].origin, org );
if( [[ compareFunc ]]( newDist, dist ) )
{
continue;
}
dist = newdist;
ent = array[ keys[ i ] ];
}
return ent;
}
get_closest_point( origin, points, maxDist )
{
assert( points.size );
closestPoint = points[ 0 ];
dist = Distance( origin, closestPoint );
for( index = 0; index < points.size; index ++ )
{
testDist = distance( origin, points[ index ] );
if( testDist >= dist )
{
continue;
}
dist = testDist;
closestPoint = points[ index ];
}
if( !IsDefined( maxDist ) || dist <= maxDist )
{
return closestPoint;
}
return undefined;
}
get_within_range( org, array, dist )
{
guys = [];
for( i = 0; i < array.size; i++ )
{
if( distance( array[ i ].origin, org ) <= dist )
{
guys[ guys.size ] = array[ i ];
}
}
return guys;
}
get_outside_range( org, array, dist )
{
guys = [];
for( i = 0; i < array.size; i++ )
{
if( distance( array[ i ].origin, org ) > dist )
{
guys[ guys.size ] = array[ i ];
}
}
return guys;
}
get_closest_living( org, array, dist )
{
if( !IsDefined( dist ) )
{
dist = 9999999;
}
if( array.size < 1 )
{
return;
}
ent = undefined;
for( i = 0;i < array.size;i++ )
{
if( !isalive( array[ i ] ) )
{
continue;
}
newdist = distance( array[ i ].origin, org );
if( newdist >= dist )
{
continue;
}
dist = newdist;
ent = array[ i ];
}
return ent;
}
get_highest_dot( start, end, array )
{
if( !array.size )
{
return;
}
ent = undefined;
angles = VectorToAngles( end - start );
dotforward = AnglesToForward( angles );
dot = -1;
for( i = 0;i < array.size;i++ )
{
angles = vectorToAngles( array[ i ].origin - start );
forward = AnglesToForward( angles );
newdot = VectorDot( dotforward, forward );
if( newdot < dot )
{
continue;
}
dot = newdot;
ent = array[ i ];
}
return ent;
}
get_closest_index( org, array, dist )
{
if( !IsDefined( dist ) )
{
dist = 9999999;
}
if( array.size < 1 )
{
return;
}
index = undefined;
for( i = 0;i < array.size;i++ )
{
newdist = distance( array[ i ].origin, org );
if( newdist >= dist )
{
continue;
}
dist = newdist;
index = i;
}
return index;
}
get_farthest( org, array )
{
if( array.size < 1 )
{
return;
}
dist = Distance( array[0].origin, org );
ent = array[0];
for( i = 1; i < array.size; i++ )
{
newdist = Distance( array[i].origin, org );
if( newdist <= dist )
{
continue;
}
dist = newdist;
ent = array[i];
}
return ent;
}
get_closest_exclude( org, ents, excluders )
{
if( !IsDefined( ents ) )
{
return undefined;
}
range = 0;
if( IsDefined( excluders ) && excluders.size )
{
exclude = [];
for( i = 0;i < ents.size;i++ )
{
exclude[ i ] = false;
}
for( i = 0;i < ents.size;i++ )
{
for( p = 0;p < excluders.size;p ++ )
{
if( ents[ i ] == excluders[ p ] )
{
exclude[ i ] = true;
}
}
}
found_unexcluded = false;
for( i = 0;i < ents.size;i++ )
{
if( ( !exclude[ i ] ) && ( IsDefined( ents[ i ] ) ) )
{
found_unexcluded = true;
range = distance( org, ents[ i ].origin );
ent = i;
i = ents.size + 1;
}
}
if( !found_unexcluded )
{
return( undefined );
}
}
else
{
for( i = 0;i < ents.size;i++ )
{
if( IsDefined( ents[ i ] ) )
{
range = distance( org, ents[ 0 ].origin );
ent = i;
i = ents.size + 1;
}
}
}
ent = undefined;
for( i = 0;i < ents.size;i++ )
{
if( IsDefined( ents[ i ] ) )
{
exclude = false;
if( IsDefined( excluders ) )
{
for( p = 0;p < excluders.size;p ++ )
{
if( ents[ i ] == excluders[ p ] )
{
exclude = true;
}
}
}
if( !exclude )
{
newrange = distance( org, ents[ i ].origin );
if( newrange <= range )
{
range = newrange;
ent = i;
}
}
}
}
if( IsDefined( ent ) )
{
return ents[ ent ];
}
else
{
return undefined;
}
}
get_closest_ai( org, team )
{
if( IsDefined( team ) )
{
ents = GetAiArray( team );
}
else
{
ents = GetAiArray();
}
if( ents.size == 0 )
{
return undefined;
}
return getClosest( org, ents );
}
get_array_of_closest( org, array, excluders, max, maxdist )
{
if( !IsDefined( max ) )
{
max = array.size;
}
if( !IsDefined( excluders ) )
{
excluders = [];
}
maxdists2rd = undefined;
if( IsDefined( maxdist ) )
{
maxdists2rd = maxdist * maxdist;
}
dist = [];
index = [];
for( i = 0;i < array.size;i++ )
{
excluded = false;
for( p = 0;p < excluders.size;p ++ )
{
if( array[ i ] != excluders[ p ] )
{
continue;
}
excluded = true;
break;
}
if( excluded )
{
continue;
}
if( !IsDefined(array[ i ]) )
{
continue;
}
length = distancesquared( org, array[ i ].origin );
if( IsDefined( maxdists2rd ) && maxdists2rd < length )
{
continue;
}
dist[ dist.size ] = length;
index[ index.size ] = i;
}
for( ;; )
{
change = false;
for( i = 0;i < dist.size - 1;i++ )
{
if( dist[ i ] <= dist[ i + 1 ] )
{
continue;
}
change = true;
temp = dist[ i ];
dist[ i ] = dist[ i + 1 ];
dist[ i + 1 ] = temp;
temp = index[ i ];
index[ i ] = index[ i + 1 ];
index[ i + 1 ] = temp;
}
if( !change )
{
break;
}
}
newArray = [];
if( max > dist.size )
{
max = dist.size;
}
for( i = 0;i < max;i++ )
{
newArray[ i ] = array[ index[ i ] ];
}
return newArray;
}
get_array_of_farthest( org, array, excluders, max )
{
sorted_array = get_array_of_closest( org, array, excluders, max );
sorted_array = array_reverse( sorted_array );
return( sorted_array );
}
get_closest_ai_exclude( org, team, excluders )
{
if( IsDefined( team ) )
{
ents = GetAiArray( team );
}
else
{
ents = GetAiArray();
}
if( ents.size == 0 )
{
return undefined;
}
return get_closest_exclude( org, ents, excluders );
}
stop_magic_bullet_shield()
{
if ( IsAI(self) )
{
self BloodImpact( "normal" );
}
self.attackerAccuracy = 1;
self notify("stop_magic_bullet_shield");
self.magic_bullet_shield = undefined;
self._mbs = undefined;
}
magic_bullet_shield()
{
if (!is_true(self.magic_bullet_shield))
{
if( IsAI(self) || IsPlayer(self))
{
self.magic_bullet_shield = true;
if (!IsDefined(self._mbs))
{
self._mbs = SpawnStruct();
}
if ( IsAI(self) )
{
AssertEx( IsAlive( self ), "Tried to do magic_bullet_shield on a dead or undefined guy." );
self._mbs.last_pain_time = 0;
self._mbs.ignore_time = 5;
self._mbs.turret_ignore_time = 5;
self BloodImpact( "hero" );
}
self.attackerAccuracy = 0.1;
}
else
{
if (self is_vehicle())
{
AssertMsg("Use veh_magic_bullet_shield for vehicles.");
}
else
{
AssertMsg("magic_bullet_shield does not support entity of classname '" + self.classname + "'.");
}
}
}
}
debug_magic_bullet_shield_death(guy)
{
targetname = "none";
if (IsDefined(guy.targetname))
{
targetname = guy.targetname;
}
guy endon("stop_magic_bullet_shield");
guy waittill("death");
AssertEx(!IsDefined(guy), "Guy died with magic bullet shield on with targetname: " + targetname);
}
disable_long_death()
{
assertex( isalive( self ), "Tried to disable long death on a non living thing" );
self.a.disableLongDeath = true;
}
enable_long_death()
{
assertex( isalive( self ), "Tried to enable long death on a non living thing" );
self.a.disableLongDeath = false;
}
get_ignoreme()
{
return self.ignoreme;
}
set_ignoreme( val )
{
assertex( IsSentient( self ), "Non ai tried to set ignoreme" );
self.ignoreme = val;
}
set_ignoreall( val )
{
assertEx( isSentient( self ), "Non ai tried to set ignoraell" );
self.ignoreall = val;
}
get_pacifist()
{
return self.pacifist;
}
set_pacifist( val )
{
assertex( IsSentient( self ), "Non ai tried to set pacifist" );
self.pacifist = val;
}
ignore_me_timer( time, endon_msg )
{
self notify("ignore_me_timer");
self.ignore_me_timer_old = self get_ignoreme();
if( !self.ignore_me_timer_old )
{
ai = GetAiArray( "axis" );
for( i = 0; i < ai.size; i++ )
{
guy = ai[ i ];
if( IsAlive( guy.enemy ) && guy.enemy == self )
{
guy notify( "enemy" );
}
}
}
self endon( "death" );
self endon( "ignore_me_timer" );
self set_ignoreme(true);
waittill_any_or_timeout( time, endon_msg );
self set_ignoreme(self.ignore_me_timer_old);
}
turret_ignore_me_timer( time )
{
self endon( "death" );
self endon( "pain" );
self.turretInvulnerability = true;
wait time;
self.turretInvulnerability = false;
}
exploder_damage()
{
if( IsDefined( self.v[ "delay" ] ) )
{
delay = self.v[ "delay" ];
}
else
{
delay = 0;
}
if( IsDefined( self.v[ "damage_radius" ] ) )
{
radius = self.v[ "damage_radius" ];
}
else
{
radius = 128;
}
damage = self.v[ "damage" ];
origin = self.v[ "origin" ];
wait( delay );
self.model RadiusDamage( origin, radius, damage, damage / 3 );
}
exploder( num )
{
[[ level.exploderFunction ]]( num );
}
exploder_before_load( num )
{
waittillframeend;
waittillframeend;
activate_exploder( num );
}
exploder_after_load( num )
{
activate_exploder( num );
}
activate_exploder_on_clients(num)
{
if(!IsDefined(level._exploder_ids[num]))
{
return;
}
if(!IsDefined(level._client_exploders[num]))
{
level._client_exploders[num] = 1;
}
if(!IsDefined(level._client_exploder_ids[num]))
{
level._client_exploder_ids[num] = 1;
}
ActivateClientExploder(level._exploder_ids[num]);
}
delete_exploder_on_clients(num)
{
if(!IsDefined(level._exploder_ids[num]))
{
return;
}
if(!IsDefined(level._client_exploders[num]))
{
return;
}
level._client_exploders[num] = undefined;
level._client_exploder_ids[num] = undefined;
DeactivateClientExploder(level._exploder_ids[num]);
}
activate_exploder( num )
{
num = int( num );
client_send = true;
prof_begin( "activate_exploder" );
for( i = 0;i < level.createFXent.size;i++ )
{
ent = level.createFXent[ i ];
if( !IsDefined( ent ) )
{
continue;
}
if( ent.v[ "type" ] != "exploder" )
{
continue;
}
if( !IsDefined( ent.v[ "exploder" ] ) )
{
continue;
}
if( ent.v[ "exploder" ] != num )
{
continue;
}
if(IsDefined(ent.v["exploder_server"]))
{
client_send = false;
}
ent activate_individual_exploder();
}
if(level.clientScripts)
{
if(!level.createFX_enabled && client_send == true)
{
activate_exploder_on_clients(num);
}
}
prof_end( "activate_exploder" );
}
stop_exploder( num )
{
num = int( num );
if(level.clientScripts)
{
if(!level.createFX_enabled)
{
delete_exploder_on_clients(num);
}
}
for( i = 0;i < level.createFXent.size;i++ )
{
ent = level.createFXent[ i ];
if( !IsDefined( ent ) )
{
continue;
}
if( ent.v[ "type" ] != "exploder" )
{
continue;
}
if( !IsDefined( ent.v[ "exploder" ] ) )
{
continue;
}
if( ent.v[ "exploder" ] != num )
{
continue;
}
if ( !IsDefined( ent.looper ) )
{
continue;
}
ent.looper delete();
}
}
activate_individual_exploder()
{
level notify("exploder" + self.v["exploder"]);
if(level.createFX_enabled || !level.clientScripts || !IsDefined(level._exploder_ids[int(self.v["exploder"])] ) || IsDefined(self.v["exploder_server"]))
{
if( IsDefined( self.v[ "firefx" ] ) )
{
self thread fire_effect();
}
if( IsDefined( self.v[ "fxid" ] ) && self.v[ "fxid" ] != "No FX" )
{
self thread cannon_effect();
}
else if( IsDefined( self.v[ "soundalias" ] ) )
{
self thread sound_effect();
}
if( IsDefined( self.v[ "earthquake" ] ) )
{
self thread exploder_earthquake();
}
if( IsDefined( self.v[ "rumble" ] ) )
{
self thread exploder_rumble();
}
}
if( IsDefined( self.v[ "trailfx" ] ) )
{
self thread trail_effect();
}
if( IsDefined( self.v[ "damage" ] ) )
{
self thread exploder_damage();
}
if( self.v[ "exploder_type" ] == "exploder" )
{
self thread brush_show();
}
else if( ( self.v[ "exploder_type" ] == "exploderchunk" ) || ( self.v[ "exploder_type" ] == "exploderchunk visible" ) )
{
self thread brush_throw();
}
else
{
self thread brush_delete();
}
}
loop_sound_Delete( ender, ent )
{
ent endon( "death" );
self waittill( ender );
ent Delete();
}
loop_fx_sound( alias, origin, ender, timeout )
{
org = Spawn( "script_origin", ( 0, 0, 0 ) );
if( IsDefined( ender ) )
{
thread loop_sound_Delete( ender, org );
self endon( ender );
}
org.origin = origin;
org PlayLoopSound( alias );
if( !IsDefined( timeout ) )
{
return;
}
wait( timeout );
}
brush_delete()
{
num = self.v[ "exploder" ];
if( IsDefined( self.v[ "delay" ] ) )
{
wait( self.v[ "delay" ] );
}
else
{
wait( .05 );
}
if( !IsDefined( self.model ) )
{
return;
}
assert( IsDefined( self.model ) );
if( self.model has_spawnflag(level.SPAWNFLAG_MODEL_DYNAMIC_PATH) )
{
self.model ConnectPaths();
}
if( level.createFX_enabled )
{
if( IsDefined( self.exploded ) )
{
return;
}
self.exploded = true;
self.model Hide();
self.model NotSolid();
wait( 3 );
self.exploded = undefined;
self.model Show();
self.model Solid();
return;
}
if( !IsDefined( self.v[ "fxid" ] ) || self.v[ "fxid" ] == "No FX" )
{
self.v[ "exploder" ] = undefined;
}
waittillframeend;
self.model Delete();
}
brush_Show()
{
if( IsDefined( self.v[ "delay" ] ) )
{
wait( self.v[ "delay" ] );
}
assert( IsDefined( self.model ) );
self.model Show();
self.model Solid();
if( self.model has_spawnflag(level.SPAWNFLAG_MODEL_DYNAMIC_PATH) )
{
if( !IsDefined( self.model.disconnect_paths ) )
{
self.model ConnectPaths();
}
else
{
self.model DisconnectPaths();
}
}
if( level.createFX_enabled )
{
if( IsDefined( self.exploded ) )
{
return;
}
self.exploded = true;
wait( 3 );
self.exploded = undefined;
self.model Hide();
self.model NotSolid();
}
}
brush_throw()
{
if( IsDefined( self.v[ "delay" ] ) )
{
wait( self.v[ "delay" ] );
}
ent = undefined;
if( IsDefined( self.v[ "target" ] ) )
{
ent = getent( self.v[ "target" ], "targetname" );
}
if( !IsDefined( ent ) )
{
ent = GetStruct( self.v["target"], "targetname" );
if( !IsDefined( ent ) )
{
self.model Delete();
return;
}
}
self.model Show();
startorg = self.v[ "origin" ];
startang = self.v[ "angles" ];
org = ent.origin;
temp_vec = ( org - self.v[ "origin" ] );
x = temp_vec[ 0 ];
y = temp_vec[ 1 ];
z = temp_vec[ 2 ];
physics = IsDefined( self.v[ "physics" ] );
if ( physics )
{
target = undefined;
if ( IsDefined( ent.target ) )
{
target = getent( ent.target, "targetname" );
}
if ( !IsDefined( target ) )
{
contact_point = startorg;
throw_vec = ent.origin;
}
else
{
contact_point = ent.origin;
throw_vec = vector_scale(target.origin - ent.origin, self.v[ "physics" ]);
}
self.model physicslaunch( contact_point, throw_vec );
return;
}
else
{
self.model RotateVelocity( ( x, y, z ), 12 );
self.model moveGravity( ( x, y, z ), 12 );
}
if( level.createFX_enabled )
{
if( IsDefined( self.exploded ) )
{
return;
}
self.exploded = true;
wait( 3 );
self.exploded = undefined;
self.v[ "origin" ] = startorg;
self.v[ "angles" ] = startang;
self.model Hide();
return;
}
self.v[ "exploder" ] = undefined;
wait( 6 );
self.model Delete();
}
shock_onpain()
{
self endon( "death" );
self endon( "disconnect" );
if( GetDvar( #"blurpain" ) == "" )
{
SetDvar( "blurpain", "on" );
}
while( 1 )
{
oldhealth = self.health;
self waittill( "damage", damage, attacker, direction_vec, point, mod );
if( IsDefined( level.shock_onpain ) && !level.shock_onpain )
{
continue;
}
if( IsDefined( self.shock_onpain ) && !self.shock_onpain )
{
continue;
}
if( self.health < 1 )
{
continue;
}
if( mod == "MOD_PROJECTILE" || mod == "MOD_PROJECTILE_SPLASH" )
{
continue;
}
else if( mod == "MOD_GRENADE_SPLASH" || mod == "MOD_GRENADE" || mod == "MOD_EXPLOSIVE" )
{
self shock_onexplosion( damage );
}
else
{
if( GetDvar( #"blurpain" ) == "on" )
{
self ShellShock( "pain", 0.5 );
}
}
}
}
shock_onexplosion( damage )
{
time = 0;
multiplier = self.maxhealth / 100;
scaled_damage = damage * multiplier;
if( scaled_damage >= 90 )
{
time = 4;
}
else if( scaled_damage >= 50 )
{
time = 3;
}
else if( scaled_damage >= 25 )
{
time = 2;
}
else if( scaled_damage > 10 )
{
time = 1;
}
if( time )
{
self ShellShock( "explosion", time );
}
}
shock_ondeath()
{
self waittill( "death" );
if( IsDefined( level.shock_ondeath ) && !level.shock_ondeath )
{
return;
}
if( IsDefined( self.shock_ondeath ) && !self.shock_ondeath )
{
return;
}
if( IsDefined( self.specialDeath ) )
{
return;
}
if( GetDvar( #"r_texturebits" ) == "16" )
{
return;
}
}
delete_on_death( ent )
{
ent endon( "death" );
self waittill( "death" );
if( IsDefined( ent ) )
{
ent delete();
}
}
delete_on_death_wait_sound( ent, sounddone )
{
ent endon( "death" );
self waittill( "death" );
if( IsDefined( ent ) )
{
if ( ent iswaitingonsound() )
{
ent waittill( sounddone );
}
ent Delete();
}
}
is_dead_sentient()
{
return isSentient( self ) && !isalive( self );
}
play_sound_on_tag( alias, tag, ends_on_death )
{
if ( is_dead_sentient() )
{
return;
}
org = Spawn( "script_origin", ( 0, 0, 0 ) );
org endon( "death" );
thread delete_on_death_wait_sound( org, "sounddone" );
if ( IsDefined( tag ) )
{
org LinkTo( self, tag, ( 0, 0, 0 ), ( 0, 0, 0 ) );
}
else
{
org.origin = self.origin;
org.angles = self.angles;
org LinkTo( self );
}
org PlaySound( alias, "sounddone" );
if ( IsDefined( ends_on_death ) )
{
assertex( ends_on_death, "ends_on_death must be true or undefined" );
wait_for_sounddone_or_death( org );
if(is_dead_sentient())
{
org StopSounds();
}
wait( 0.05 );
}
else
{
org waittill( "sounddone" );
}
org Delete();
}
play_sound_on_tag_endon_death( alias, tag )
{
play_sound_on_tag( alias, tag, true );
}
play_sound_on_entity( alias )
{
play_sound_on_tag( alias );
}
play_loop_sound_on_tag( alias, tag, bStopSoundOnDeath )
{
org = Spawn( "script_origin", ( 0, 0, 0 ) );
org endon( "death" );
if ( !IsDefined( bStopSoundOnDeath ) )
{
bStopSoundOnDeath = true;
}
if ( bStopSoundOnDeath )
{
thread delete_on_death( org );
}
if( IsDefined( tag ) )
{
org LinkTo( self, tag, ( 0, 0, 0 ), ( 0, 0, 0 ) );
}
else
{
org.origin = self.origin;
org.angles = self.angles;
org LinkTo( self );
}
org PlayLoopSound( alias );
self waittill( "stop sound" + alias );
org StopLoopSound( alias );
org Delete();
}
stop_loop_sound_on_entity( alias )
{
self notify( "stop sound" + alias );
}
play_loop_sound_on_entity( alias, offset )
{
org = Spawn( "script_origin", ( 0, 0, 0 ) );
org endon( "death" );
thread delete_on_death( org );
if( IsDefined( offset ) )
{
org.origin = self.origin + offset;
org.angles = self.angles;
org LinkTo( self );
}
else
{
org.origin = self.origin;
org.angles = self.angles;
org LinkTo( self );
}
org PlayLoopSound( alias );
self waittill( "stop sound" + alias );
org StopLoopSound( 0.1 );
org Delete();
}
play_sound_in_space( alias, origin, master )
{
org = Spawn( "script_origin", ( 0, 0, 1 ) );
if( !IsDefined( origin ) )
{
origin = self.origin;
}
org.origin = origin;
if( IsDefined( master ) && master )
{
org PlaySoundAsMaster( alias, "sounddone" );
}
else
{
org PlaySound( alias, "sounddone" );
}
org waittill( "sounddone" );
if( IsDefined( org ) )
{
org Delete();
}
}
spawn_failed( spawn )
{
if ( IsDefined(spawn) && IsAlive(spawn) )
{
if ( !IsDefined(spawn.finished_spawning) )
{
spawn waittill("finished spawning");
}
waittillframeend;
if ( IsAlive(spawn) )
{
return false;
}
}
return true;
}
spawn_setcharacter( data )
{
codescripts\character::precache( data );
self waittill( "spawned", spawn );
if( maps\_utility::spawn_failed( spawn ) )
{
return;
}
println( "Size is ", data[ "attach" ].size );
spawn codescripts\character::new();
spawn codescripts\character::load( data );
}
assign_animtree(animname)
{
if( IsDefined( animname ) )
{
self.animname = animname;
}
assertEx( IsDefined( level.scr_animtree[ self.animname ] ), "There is no level.scr_animtree for animname " + self.animname );
animtree = level.scr_animtree[ self.animname ];
self UseAnimTree(animtree);
}
assign_model(animname)
{
if (!IsDefined(animname))
{
animname = self.animname;
}
assertEx( IsDefined( level.scr_model[ animname ] ), "There is no level.scr_model for animname " + animname );
self SetModel( level.scr_model[ animname ] );
}
spawn_anim_model( animname, origin, angles, is_simple_prop )
{
if ( !IsDefined( origin ) )
{
origin = ( 0, 0, 0 );
}
model = spawn( "script_model", origin );
model assign_model(animname);
model init_anim_model(animname, is_simple_prop);
if(!isDefined(angles))
{
angles = (0,0,0);
}
model.angles = angles;
return model;
}
init_anim_model(animname, is_simple_prop)
{
if (!IsDefined(animname))
{
animname = self.animname;
}
AssertEx(IsDefined(animname), "Trying to init anim model with no animname.");
self.animname = animname;
if (is_true(is_simple_prop))
{
if (!IsDefined(self.anim_link))
{
self.anim_link = Spawn("script_model", self.origin);
self.anim_link SetModel("tag_origin_animate");
level thread delete_anim_link_on_death(self, self.anim_link);
}
self.anim_link.animname = animname;
self.anim_link assign_animtree();
self Unlink();
self.anim_link.angles = self.angles;
self.anim_link.origin = self.origin;
self LinkTo(self.anim_link, "origin_animate_jnt");
}
else
{
self assign_animtree();
}
}
delete_anim_link_on_death(ent, anim_link)
{
anim_link endon("death");
ent waittill("death");
anim_link Delete();
}
triggerOff()
{
if (!isdefined (self.realOrigin))
{
self.realOrigin = self.origin;
}
if (self.origin == self.realorigin)
{
self.origin += (0, 0, -10000);
}
}
triggerOn()
{
if (isDefined (self.realOrigin) )
{
self.origin = self.realOrigin;
}
}
trigger_use( strName, strKey, ent )
{
if( !IsDefined( strKey ) )
{
strKey = "targetname";
}
if( !IsDefined( ent ) )
{
ent = get_players()[0];
}
eTrigger = GetEnt( strName, strKey );
if( !IsDefined( eTrigger ) )
{
assertmsg( "trigger not found: " + strName + " key: " + strKey );
return;
}
eTrigger UseBy( ent );
level notify( strName, ent );
return eTrigger;
}
set_flag_on_notify( notifyStr, strFlag )
{
if( !level.flag[ strFlag ] )
{
self waittill( notifyStr );
flag_set( strFlag );
}
}
set_flag_on_trigger( eTrigger, strFlag )
{
if( !level.flag[ strFlag ] )
{
eTrigger waittill( "trigger", eOther );
flag_set( strFlag );
return eOther;
}
}
set_flag_on_targetname_trigger( msg )
{
assert( IsDefined( level.flag[ msg ] ) );
if( flag( msg ) )
{
return;
}
trigger = GetEnt( msg, "targetname" );
trigger waittill( "trigger" );
flag_set( msg );
}
waittill_dead( guys, num, timeoutLength )
{
allAlive = true;
for( i = 0;i < guys.size;i++ )
{
if( isalive( guys[ i ] ) )
{
continue;
}
allAlive = false;
break;
}
assertex( allAlive, "Waittill_Dead was called with dead or removed AI in the array, meaning it will never pass." );
if( !allAlive )
{
newArray = [];
for( i = 0;i < guys.size;i++ )
{
if( isalive( guys[ i ] ) )
{
newArray[ newArray.size ] = guys[ i ];
}
}
guys = newArray;
}
ent = SpawnStruct();
if( IsDefined( timeoutLength ) )
{
ent endon( "thread_timed_out" );
ent thread waittill_dead_timeout( timeoutLength );
}
ent.count = guys.size;
if( IsDefined( num ) && num < ent.count )
{
ent.count = num;
}
array_thread( guys, ::waittill_dead_thread, ent );
while( ent.count > 0 )
{
ent waittill( "waittill_dead guy died" );
}
}
waittill_dead_or_dying( guys, num, timeoutLength )
{
newArray = [];
for( i = 0;i < guys.size;i++ )
{
if( isalive( guys[ i ] ) && !guys[ i ].ignoreForFixedNodeSafeCheck )
{
newArray[ newArray.size ] = guys[ i ];
}
}
guys = newArray;
ent = spawnStruct();
if( IsDefined( timeoutLength ) )
{
ent endon( "thread_timed_out" );
ent thread waittill_dead_timeout( timeoutLength );
}
ent.count = guys.size;
if( IsDefined( num ) && num < ent.count )
{
ent.count = num;
}
array_thread( guys, ::waittill_dead_or_dying_thread, ent );
while( ent.count > 0 )
{
ent waittill( "waittill_dead_guy_dead_or_dying" );
}
}
waittill_dead_thread( ent )
{
self waittill( "death" );
ent.count-- ;
ent notify( "waittill_dead guy died" );
}
waittill_dead_or_dying_thread( ent )
{
self waittill_either( "death", "pain_death" );
ent.count-- ;
ent notify( "waittill_dead_guy_dead_or_dying" );
}
waittill_dead_timeout( timeoutLength )
{
wait( timeoutLength );
self notify( "thread_timed_out" );
}
set_ai_group_cleared_count(aigroup, count)
{
maps\_spawner::aigroup_init(aigroup);
level._ai_group[aigroup].cleared_count = count;
}
waittill_ai_group_cleared( aigroup )
{
AssertEx(IsDefined(level._ai_group[aigroup]), "The aigroup "+aigroup+" does not exist");
flag_wait(aigroup + "_cleared");
}
waittill_ai_group_count( aigroup, count )
{
while( level._ai_group[ aigroup ].spawnercount + level._ai_group[ aigroup ].aicount > count )
{
wait( 0.25 );
}
}
waittill_ai_group_ai_count( aigroup, count )
{
while( level._ai_group[ aigroup ].aicount > count )
{
wait( 0.25 );
}
}
waittill_ai_group_spawner_count( aigroup, count )
{
while( level._ai_group[ aigroup ].spawnercount > count )
{
wait( 0.25 );
}
}
waittill_ai_group_amount_killed( aigroup, amount_killed )
{
while( level._ai_group[ aigroup ].killed_count < amount_killed )
{
wait( 0.25 );
}
}
get_ai_group_count( aigroup )
{
return( level._ai_group[ aigroup ].spawnercount + level._ai_group[ aigroup ].aicount );
}
get_ai_group_sentient_count( aigroup )
{
return( level._ai_group[ aigroup ].aicount );
}
get_ai_group_ai( aigroup )
{
aiSet = [];
for( index = 0; index < level._ai_group[ aigroup ].ai.size; index ++ )
{
if( !isAlive( level._ai_group[ aigroup ].ai[ index ] ) )
{
continue;
}
aiSet[ aiSet.size ] = level._ai_group[ aigroup ].ai[ index ];
}
return( aiSet );
}
get_ai( name, type )
{
array = get_ai_array( name, type );
if( array.size > 1 )
{
assertMsg( "get_ai used for more than one living ai of type " + type + " called " + name + "." );
return undefined;
}
return array[0];
}
get_ai_array(name, type)
{
ai = GetAIArray();
if (!IsDefined(type))
{
type = "script_noteworthy";
}
array = [];
for(i=0; i<ai.size; i++)
{
switch(type)
{
case "targetname":
if(IsDefined(ai[i].targetname) && ai[i].targetname == name)
{
array[array.size] = ai[i];
}
break;
case "script_noteworthy":
if(IsDefined(ai[i].script_noteworthy) && ai[i].script_noteworthy == name)
{
array[array.size] = ai[i];
}
break;
case "classname":
if(IsDefined(ai[i].classname) && ai[i].classname == name)
{
array[array.size] = ai[i];
}
break;
}
}
return array;
}
get_aispecies( name, type, breed )
{
array = get_ai_array( name, type, breed );
if( array.size > 1 )
{
assertMsg( "get_aispecies used for more than one living ai of type " + type + " called " + name + "." );
return undefined;
}
return array[0];
}
get_aispecies_array(name, type, breed)
{
if( !IsDefined( breed ) )
{
breed = "all";
}
ai = getaispeciesarray("allies", breed);
ai = array_combine(ai, getaispeciesarray("axis", breed) );
array = [];
for(i=0; i<ai.size; i++)
{
switch(type)
{
case "targetname":
if(IsDefined(ai[i].targetname) && ai[i].targetname == name)
{
array[array.size] = ai[i];
}
break;
case "script_noteworthy":
if(IsDefined(ai[i].script_noteworthy) && ai[i].script_noteworthy == name)
{
array[array.size] = ai[i];
}
break;
}
}
return array;
}
set_environment( env )
{
animscripts\utility::setEnv( env );
}
getchar( num )
{
if( num == 0 )
{
return "0";
}
if( num == 1 )
{
return "1";
}
if( num == 2 )
{
return "2";
}
if( num == 3 )
{
return "3";
}
if( num == 4 )
{
return "4";
}
if( num == 5 )
{
return "5";
}
if( num == 6 )
{
return "6";
}
if( num == 7 )
{
return "7";
}
if( num == 8 )
{
return "8";
}
if( num == 9 )
{
return "9";
}
}
waittill_either( msg1, msg2 )
{
self endon( msg1 );
self waittill( msg2 );
}
array_merge_links( array1, array2 )
{
if( !array1.size )
{
return array2;
}
if( !array2.size )
{
return array1;
}
linkMap = [];
for( i = 0; i < array1.size; i++ )
{
node = array1[ i ];
linkMap[ node.script_linkname ] = true;
}
for( i = 0; i < array2.size; i++ )
{
node = array2[ i ];
if( IsDefined( linkMap[ node.script_linkname ] ) )
{
continue;
}
linkMap[ node.script_linkname ] = true;
array1[ array1.size ] = node;
}
return array1;
}
flat_angle( angle )
{
rangle = ( 0, angle[ 1 ], 0 );
return rangle;
}
flat_origin( org )
{
rorg = ( org[ 0 ], org[ 1 ], 0 );
return rorg;
}
plot_points( plotpoints, r, g, b, timer )
{
lastpoint = plotpoints[ 0 ];
if( !IsDefined( r ) )
{
r = 1;
}
if( !IsDefined( g ) )
{
g = 1;
}
if( !IsDefined( b ) )
{
b = 1;
}
if( !IsDefined( timer ) )
{
timer = 0.05;
}
for( i = 1;i < plotpoints.size;i++ )
{
thread draw_line_for_time( lastpoint, plotpoints[ i ], r, g, b, timer );
lastpoint = plotpoints[ i ];
}
}
draw_line_for_time( org1, org2, r, g, b, timer )
{
timer = gettime() + ( timer * 1000 );
while( GetTime() < timer )
{
line( org1, org2, ( r, g, b ), 1 );
wait .05;
}
}
draw_point( org, scale, color, timer )
{
timer = gettime() + ( timer * 1000 );
range = 10*scale;
rt = (range,0,0);
ot = (0,range,0);
up = (0,0,range);
v1_1 = org + rt;
v2_1 = org + ot;
v3_1 = org + up;
v1_2 = org - rt;
v2_2 = org - ot;
v3_2 = org - up;
while( GetTime() < timer )
{
line( v1_1, v1_2, color, 1 );
line( v2_1, v2_2, color, 1 );
line( v3_1, v3_2, color, 1 );
wait .05;
}
}
draw_line_to_ent_for_time( org1, ent, r, g, b, timer )
{
timer = gettime() + ( timer * 1000 );
while( GetTime() < timer )
{
line( org1, ent.origin, ( r, g, b ), 1 );
wait .05;
}
}
draw_line_from_ent_for_time( ent, org, r, g, b, timer )
{
draw_line_to_ent_for_time( org, ent, r, g, b, timer );
}
draw_line_from_ent_to_ent_for_time( ent1, ent2, r, g, b, timer )
{
ent1 endon( "death" );
ent2 endon( "death" );
timer = gettime() + ( timer * 1000 );
while( gettime() < timer )
{
line( ent1.origin, ent2.origin, ( r, g, b ), 1 );
wait .05;
}
}
draw_line_from_ent_to_ent_until_notify( ent1, ent2, r, g, b, notifyEnt, notifyString )
{
assert( IsDefined( notifyEnt ) );
assert( IsDefined( notifyString ) );
ent1 endon( "death" );
ent2 endon( "death" );
notifyEnt endon( notifyString );
while( 1 )
{
line( ent1.origin, ent2.origin, ( r, g, b ), 0.05 );
wait .05;
}
}
draw_line_until_notify( org1, org2, r, g, b, notifyEnt, notifyString )
{
assert( IsDefined( notifyEnt ) );
assert( IsDefined( notifyString ) );
notifyEnt endon( notifyString );
while( 1 )
{
draw_line_for_time( org1, org2, r, g, b, 0.05 );
}
}
draw_arrow_time( start, end, color, duration )
{
level endon( "newpath" );
pts = [];
angles = VectorToAngles( start - end );
right = AnglesToRight( angles );
forward = AnglesToForward( angles );
up = AnglesToUp( angles );
dist = Distance( start, end );
arrow = [];
range = 0.1;
arrow[ 0 ] = start;
arrow[ 1 ] = start + vector_scale( right, dist * ( range ) ) + vector_scale( forward, dist * - 0.1 );
arrow[ 2 ] = end;
arrow[ 3 ] = start + vector_scale( right, dist * ( - 1 * range ) ) + vector_scale( forward, dist * - 0.1 );
arrow[ 4 ] = start;
arrow[ 5 ] = start + vector_scale( up, dist * ( range ) ) + vector_scale( forward, dist * - 0.1 );
arrow[ 6 ] = end;
arrow[ 7 ] = start + vector_scale( up, dist * ( - 1 * range ) ) + vector_scale( forward, dist * - 0.1 );
arrow[ 8 ] = start;
r = color[ 0 ];
g = color[ 1 ];
b = color[ 2 ];
plot_points( arrow, r, g, b, duration );
}
draw_arrow( start, end, color )
{
level endon( "newpath" );
pts = [];
angles = VectorToAngles( start - end );
right = AnglesToRight( angles );
forward = AnglesToForward( angles );
dist = Distance( start, end );
arrow = [];
range = 0.05;
arrow[ 0 ] = start;
arrow[ 1 ] = start + vector_scale( right, dist * ( range ) ) + vector_scale( forward, dist * - 0.2 );
arrow[ 2 ] = end;
arrow[ 3 ] = start + vector_scale( right, dist * ( - 1 * range ) ) + vector_scale( forward, dist * - 0.2 );
for( p = 0;p < 4;p++ )
{
nextpoint = p + 1;
if( nextpoint >= 4 )
{
nextpoint = 0;
}
line( arrow[ p ], arrow[ nextpoint ], color, 1.0 );
}
}
battlechatter_off( team )
{
maps\_dds::dds_disable( team );
return;
}
battlechatter_on( team )
{
maps\_dds::dds_enable( team );
return;
}
dds_set_player_character_name( hero_name )
{
if( !IsPlayer( self ) )
{
PrintLn( "dds 'dds_set_player_character_name' function was not called on a player. No changes made." );
return;
}
switch( hero_name )
{
case "mason":
case "hudson":
case "reznov":
level.dds.player_character_name = GetSubStr( hero_name, 0, 3 );
PrintLn( "dds setting player name to '" + level.dds.player_character_name + "'" );
break;
default:
printLn( "dds: '" + hero_name + "' not a valid player name; setting to 'mason' (mas)" );
level.dds.player_character_name = "mas";
break;
}
self.dds_characterID = level.dds.player_character_name;
}
dds_exclude_this_ai()
{
if( IsAI( self ) && IsAlive( self ) )
{
self.dds_characterID = undefined;
}
else
{
PrintLn( "Tried to mark an entity for DDS removal that was not an AI or not alive." );
}
}
debugorigin()
{
self notify( "Debug origin" );
self endon( "Debug origin" );
self endon( "death" );
for( ;; )
{
forward = AnglesToForward( self.angles );
forwardFar = vector_scale( forward, 30 );
forwardClose = vector_scale( forward, 20 );
right = AnglesToRight( self.angles );
left = vector_scale( right, -10 );
right = vector_scale( right, 10 );
line( self.origin, self.origin + forwardFar, ( 0.9, 0.7, 0.6 ), 0.9 );
line( self.origin + forwardFar, self.origin + forwardClose + right, ( 0.9, 0.7, 0.6 ), 0.9 );
line( self.origin + forwardFar, self.origin + forwardClose + left, ( 0.9, 0.7, 0.6 ), 0.9 );
wait( 0.05 );
}
}
get_links()
{
return Strtok( self.script_linkTo, " " );
}
get_linked_ents()
{
array = [];
if ( IsDefined( self.script_linkto ) )
{
linknames = get_links();
for ( i = 0; i < linknames.size; i++ )
{
ent = getent( linknames[ i ], "script_linkname" );
if ( IsDefined( ent ) )
{
array[ array.size ] = ent;
}
}
}
return array;
}
get_linked_structs()
{
array = [];
if ( IsDefined( self.script_linkto ) )
{
linknames = get_links();
for ( i = 0; i < linknames.size; i++ )
{
ent = getstruct( linknames[ i ], "script_linkname" );
if ( IsDefined( ent ) )
{
array[ array.size ] = ent;
}
}
}
return array;
}
get_last_ent_in_chain( sEntityType )
{
ePathpoint = self;
while ( IsDefined(ePathpoint.target) )
{
wait (0.05);
if ( IsDefined( ePathpoint.target ) )
{
switch ( sEntityType )
{
case "vehiclenode":
ePathpoint = getvehiclenode( ePathpoint.target, "targetname" );
break;
case "pathnode":
ePathpoint = getnode( ePathpoint.target, "targetname" );
break;
case "ent":
ePathpoint = getent( ePathpoint.target, "targetname" );
break;
default:
assertmsg("sEntityType needs to be 'vehiclenode', 'pathnode' or 'ent'");
}
}
else
{
break;
}
}
ePathend = ePathpoint;
return ePathend;
}
timeout( timeout )
{
self endon( "death" );
wait( timeout );
self notify( "timeout" );
}
set_forcegoal()
{
if( IsDefined( self.set_forcedgoal ) )
{
return;
}
self.oldfightdist = self.pathenemyfightdist;
self.oldmaxdist = self.pathenemylookahead;
self.oldmaxsight = self.maxsightdistsqrd;
self.pathenemyfightdist = 8;
self.pathenemylookahead = 8;
self.maxsightdistsqrd = 1;
self.set_forcedgoal = true;
}
unset_forcegoal()
{
if( !IsDefined( self.set_forcedgoal ) )
{
return;
}
self.pathenemyfightdist = self.oldfightdist;
self.pathenemylookahead = self.oldmaxdist;
self.maxsightdistsqrd = self.oldmaxsight;
self.set_forcedgoal = undefined;
}
array_removeDead_keepkeys( array )
{
newArray = [];
keys = getarraykeys( array );
for( i = 0; i < keys.size; i++ )
{
key = keys[ i ];
if( !isalive( array[ key ] ) )
{
continue;
}
newArray[ key ] = array[ key ];
}
return newArray;
}
array_removeDead( array )
{
newArray = [];
if( !IsDefined( array ) )
{
return undefined;
}
for( i = 0; i < array.size; i++ )
{
if( !isalive( array[ i ] ) || ( isDefined( array[i].isacorpse) && array[i].isacorpse) )
{
continue;
}
newArray[ newArray.size ] = array[ i ];
}
return newArray;
}
struct_arraySpawn()
{
struct = SpawnStruct();
struct.array = [];
struct.lastindex = 0;
return struct;
}
structarray_add( struct, object )
{
assert( !IsDefined( object.struct_array_index ) );
struct.array[ struct.lastindex ] = object;
object.struct_array_index = struct.lastindex;
struct.lastindex ++ ;
}
structarray_remove( struct, object )
{
structarray_swaptolast( struct, object );
struct.array[ struct.lastindex - 1 ] = undefined;
struct.lastindex -- ;
}
structarray_swaptolast( struct, object )
{
struct structarray_swap( struct.array[ struct.lastindex - 1 ], object );
}
structarray_shuffle( struct, shuffle )
{
for( i = 0;i < shuffle;i++ )
{
struct structarray_swap( struct.array[ i ], struct.array[ randomint( struct.lastindex ) ] );
}
}
custom_battlechatter( string )
{
excluders = [];
excluders[ 0 ] = self;
buddy = get_closest_ai_exclude( self.origin, self.team, excluders );
if( IsDefined( buddy ) && Distance( buddy.origin, self.origin ) > 384 )
{
buddy = undefined;
}
self animscripts\battlechatter_ai::beginCustomEvent();
tokens = Strtok( string, "_" );
if( !tokens.size )
{
return;
}
if( tokens[ 0 ] == "move" )
{
if( tokens.size > 1 )
{
modifier = tokens[ 1 ];
}
else
{
modifier = "generic";
}
self animscripts\battlechatter_ai::addGenericAliasEx( "order", "move", modifier );
}
else if( tokens[ 0 ] == "infantry" )
{
self animscripts\battlechatter_ai::addGenericAliasEx( "threat", "infantry", tokens[ 1 ] );
if( tokens.size > 2 && tokens[ 2 ] != "inbound" )
{
self animscripts\battlechatter_ai::addGenericAliasEx( "direction", "relative", tokens[ 2 ] );
}
else if( tokens.size > 2 )
{
self animscripts\battlechatter_ai::addGenericAliasEx( "direction", "inbound", tokens[ 3 ] );
}
}
else if( tokens[ 0 ] == "vehicle" )
{
self animscripts\battlechatter_ai::addGenericAliasEx( "threat", "vehicle", tokens[ 1 ] );
if( tokens.size > 2 && tokens[ 2 ] != "inbound" )
{
self animscripts\battlechatter_ai::addGenericAliasEx( "direction", "relative", tokens[ 2 ] );
}
else if( tokens.size > 2 )
{
self animscripts\battlechatter_ai::addGenericAliasEx( "direction", "inbound", tokens[ 3 ] );
}
}
self animscripts\battlechatter_ai::endCustomEvent( 2000 );
}
buildbcalias( action, type, modifier )
{
if( IsDefined( modifier ) )
{
return( self.countryID + "_" + self.npcID + "_" + action + "_" + type + "_" + modifier );
}
else
{
return( self.countryID + "_" + self.npcID + "_" + action + "_" + type );
}
}
get_stop_watch( time, othertime )
{
watch = NewHudElem();
if( level.console )
{
watch.x = 68;
watch.y = 35;
}
else
{
watch.x = 58;
watch.y = 95;
}
watch.alignx = "center";
watch.aligny = "middle";
watch.horzAlign = "left";
watch.vertAlign = "middle";
if( IsDefined( othertime ) )
{
timer = othertime;
}
else
{
timer = level.explosiveplanttime;
}
watch setClock( timer, time, "hudStopwatch", 64, 64 );
return watch;
}
missionfailedwrapper( fail_hint, shader, iWidth, iHeight, fDelay, x, y )
{
if( level.missionfailed )
{
return;
}
if ( IsDefined( level.nextmission ) )
{
return;
}
if ( GetDvar( #"failure_disabled" ) == "1" )
{
return;
}
screen_message_delete();
if( IsDefined( fail_hint ) )
{
SetDvar( "ui_deadquote", fail_hint );
}
if( IsDefined( shader ) )
{
get_players()[0] thread maps\_load_common::special_death_indicator_hudelement( shader, iWidth, iHeight, fDelay, x, y );
}
level.missionfailed = true;
flag_set( "missionfailed" );
MissionFailed();
}
nextmission()
{
maps\_endmission::_nextmission();
}
prefetchnext()
{
maps\_endmission::prefetch_next();
}
script_delay()
{
if( IsDefined( self.script_delay ) )
{
wait( self.script_delay );
return true;
}
else if( IsDefined( self.script_delay_min ) && IsDefined( self.script_delay_max ) )
{
wait( RandomFloatrange( self.script_delay_min, self.script_delay_max ) );
return true;
}
return false;
}
script_wait( called_from_spawner )
{
if (!IsDefined(called_from_spawner))
{
called_from_spawner = false;
}
coop_scalar = 1;
if ( called_from_spawner )
{
players = get_players();
if (players.size == 2)
{
coop_scalar = 0.7;
}
else if (players.size == 3)
{
coop_scalar = 0.4;
}
else if (players.size == 4)
{
coop_scalar = 0.1;
}
}
startTime = GetTime();
if( IsDefined( self.script_wait ) )
{
wait( self.script_wait * coop_scalar);
if( IsDefined( self.script_wait_add ) )
{
self.script_wait += self.script_wait_add;
}
}
else if( IsDefined( self.script_wait_min ) && IsDefined( self.script_wait_max ) )
{
wait( RandomFloatrange( self.script_wait_min, self.script_wait_max ) * coop_scalar);
if( IsDefined( self.script_wait_add ) )
{
self.script_wait_min += self.script_wait_add;
self.script_wait_max += self.script_wait_add;
}
}
return( GetTime() - startTime );
}
enter_vehicle( vehicle, tag )
{
self maps\_vehicle_aianim::vehicle_enter( vehicle, tag );
}
guy_array_enter_vehicle( guy, vehicle )
{
maps\_vehicle_aianim::guy_array_enter( guy, vehicle );
}
run_to_vehicle_load(vehicle, bGodDriver, seat_tag)
{
self maps\_vehicle_aianim::run_to_vehicle( vehicle, bGodDriver, seat_tag );
}
vehicle_unload(delay)
{
self maps\_vehicle::do_unload(delay);
}
vehicle_override_anim(action, tag, animation)
{
self maps\_vehicle_aianim::override_anim(action, tag, animation);
}
set_wait_for_players(seat_tag, player_array)
{
vehicleanim = level.vehicle_aianims[ self.vehicletype ];
for(i = 0; i < vehicleanim.size; i++)
{
if(vehicleanim[i].sittag == seat_tag)
{
vehicleanim[i].wait_for_player = [];
for(j = 0; j < player_array.size; j++)
{
vehicleanim[i].wait_for_player[j] = player_array[j];
}
break;
}
}
}
set_wait_for_notify(seat_tag, custom_notify)
{
vehicleanim = level.vehicle_aianims[ self.vehicletype ];
for(i = 0; i < vehicleanim.size; i++)
{
if(vehicleanim[i].sittag == seat_tag)
{
vehicleanim[i].wait_for_notify = custom_notify;
break;
}
}
}
is_on_vehicle(vehicle)
{
if(!IsDefined(self.viewlockedentity))
{
return false;
}
else if(self.viewlockedentity == vehicle)
{
return true;
}
if(!IsDefined(self.groundentity))
{
return false;
}
else if(self.groundentity == vehicle)
{
return true;
}
return false;
}
get_force_color_guys( team, color )
{
ai = GetAiArray( team );
guys = [];
for( i = 0; i < ai.size; i++ )
{
guy = ai[ i ];
if( !IsDefined( guy.script_forceColor ) )
{
continue;
}
if( guy.script_forceColor != color )
{
continue;
}
guys[ guys.size ] = guy;
}
return guys;
}
get_all_force_color_friendlies()
{
ai = GetAiArray( "allies" );
guys = [];
for( i = 0; i < ai.size; i++ )
{
guy = ai[ i ];
if( !IsDefined( guy.script_forceColor ) )
{
continue;
}
guys[ guys.size ] = guy;
}
return guys;
}
enable_ai_color()
{
if( IsDefined( self.script_forceColor ) )
{
return;
}
if( !IsDefined( self.old_forceColor ) )
{
return;
}
set_force_color( self.old_forcecolor );
self.old_forceColor = undefined;
}
disable_ai_color()
{
if( IsDefined( self.new_force_color_being_set ) )
{
self endon( "death" );
self waittill( "done_setting_new_color" );
}
self clearFixedNodeSafeVolume();
if( !IsDefined( self.script_forceColor ) )
{
return;
}
assertEx( !IsDefined( self.old_forcecolor ), "Tried to disable forcecolor on a guy that somehow had a old_forcecolor already. Investigate!!!" );
self.old_forceColor = self.script_forceColor;
level.arrays_of_colorForced_ai[ self.team ][ self.script_forcecolor ] = array_remove( level.arrays_of_colorForced_ai[ self.team ][ self.script_forcecolor ], self );
maps\_colors::left_color_node();
self.script_forceColor = undefined;
self.currentColorCode = undefined;
}
clear_force_color()
{
disable_ai_color();
}
check_force_color( _color )
{
color = level.colorCheckList[ tolower( _color ) ];
if( IsDefined( self.script_forcecolor ) && color == self.script_forcecolor )
{
return true;
}
else
{
return false;
}
}
get_force_color()
{
color = self.script_forceColor;
return color;
}
shortenColor( color )
{
assertEx( IsDefined( level.colorCheckList[ tolower( color ) ] ), "Tried to set force color on an undefined color: " + color );
return level.colorCheckList[ tolower( color ) ];
}
set_force_color( _color )
{
color = shortenColor( _color );
assertEx( maps\_colors::colorIsLegit( color ), "Tried to set force color on an undefined color: " + color );
if( !isAI( self ) )
{
set_force_color_spawner( color );
return;
}
assertEx( isalive( self ), "Tried to set force color on a dead / undefined entity." );
if( self.team == "allies" )
{
self.fixedNode = true;
self.fixedNodeSafeRadius = 64;
self.pathEnemyFightDist = 0;
self.pathEnemyLookAhead = 0;
}
self.script_color_axis = undefined;
self.script_color_allies = undefined;
self.old_forcecolor = undefined;
if( IsDefined( self.script_forcecolor ) )
{
level.arrays_of_colorForced_ai[ self.team ][ self.script_forcecolor ] = array_remove( level.arrays_of_colorForced_ai[ self.team ][ self.script_forcecolor ], self );
}
self.script_forceColor = color;
level.arrays_of_colorForced_ai[ self.team ][ self.script_forceColor ] = array_add( level.arrays_of_colorForced_ai[ self.team ][ self.script_forceColor ], self );
thread new_color_being_set( color );
}
set_force_color_spawner( color )
{
self.script_forceColor = color;
self.old_forceColor = undefined;
}
issue_color_orders( color_team, team )
{
colorCodes = Strtok( color_team, " " );
colors = [];
colorCodesByColorIndex = [];
for( i = 0;i < colorCodes.size;i++ )
{
color = undefined;
if( issubstr( colorCodes[ i ], "r" ) )
{
color = "r";
}
else if( issubstr( colorCodes[ i ], "b" ) )
{
color = "b";
}
else if( issubstr( colorCodes[ i ], "y" ) )
{
color = "y";
}
else if( issubstr( colorCodes[ i ], "c" ) )
{
color = "c";
}
else if( issubstr( colorCodes[ i ], "g" ) )
{
color = "g";
}
else if( issubstr( colorCodes[ i ], "p" ) )
{
color = "p";
}
else if( issubstr( colorCodes[ i ], "o" ) )
{
color = "o";
}
else
{
assertEx( 0, "Trigger at origin " + self getorigin() + " had strange color index " + colorCodes[ i ] );
}
colorCodesByColorIndex[ color ] = colorCodes[ i ];
colors[ colors.size ] = color;
}
assert( colors.size == colorCodes.size );
for( i = 0;i < colorCodes.size;i++ )
{
level.arrays_of_colorCoded_spawners[ team ][ colorCodes[ i ] ] = array_removeUndefined( level.arrays_of_colorCoded_spawners[ team ][ colorCodes[ i ] ] );
assertex( IsDefined( level.arrays_of_colorCoded_spawners[ team ][ colorCodes[ i ] ] ), "Trigger refer to a color# that does not exist in any node for this team." );
for( p = 0;p < level.arrays_of_colorCoded_spawners[ team ][ colorCodes[ i ] ].size;p ++ )
{
level.arrays_of_colorCoded_spawners[ team ][ colorCodes[ i ] ][ p ].currentColorCode = colorCodes[ i ];
}
}
for( i = 0;i < colors.size;i++ )
{
level.arrays_of_colorForced_ai[ team ][ colors[ i ] ] = array_removeDead( level.arrays_of_colorForced_ai[ team ][ colors[ i ] ] );
level.currentColorForced[ team ][ colors[ i ] ] = colorCodesByColorIndex[ colors[ i ] ];
}
for( i = 0;i < colorCodes.size;i++ )
{
ai_array = [];
ai_array = maps\_colors::issue_leave_node_order_to_ai_and_get_ai( colorCodes[ i ], colors[ i ], team );
maps\_colors::issue_color_order_to_ai( colorCodes[ i ], colors[ i ], team, ai_array );
}
}
disable_replace_on_death()
{
self.replace_on_death = undefined;
self notify( "_disable_reinforcement" );
}
createLoopEffect( fxid )
{
ent = maps\_createfx::createEffect( "loopfx", fxid );
ent.v[ "delay" ] = 0.5;
return ent;
}
createOneshotEffect( fxid )
{
ent = maps\_createfx::createEffect( "oneshotfx", fxid );
ent.v[ "delay" ] = -15;
return ent;
}
reportExploderIds()
{
if(!IsDefined(level._exploder_ids))
{
return;
}
keys = GetArrayKeys( level._exploder_ids );
println("Server Exploder dictionary : ");
for( i = 0; i < keys.size; i++ )
{
println(keys[i] + " : " + level._exploder_ids[keys[i]]);
}
}
getExploderId( ent )
{
if(!IsDefined(level._exploder_ids))
{
level._exploder_ids = [];
level._exploder_id = 1;
}
if(!IsDefined(level._exploder_ids[ent.v["exploder"]]))
{
level._exploder_ids[ent.v["exploder"]] = level._exploder_id;
level._exploder_id ++;
}
return level._exploder_ids[ent.v["exploder"]];
}
createExploder( fxid )
{
ent = maps\_createfx::createEffect( "exploder", fxid );
ent.v[ "delay" ] = 0;
ent.v[ "exploder_type" ] = "normal";
return ent;
}
vehicle_detachfrompath()
{
maps\_vehicle::vehicle_pathDetach();
}
vehicle_resumepath()
{
thread maps\_vehicle::vehicle_resumepathvehicle();
}
vehicle_land()
{
maps\_vehicle::vehicle_landvehicle();
}
vehicle_liftoff( height )
{
maps\_vehicle::vehicle_liftoffvehicle( height );
}
vehicle_dynamicpath( node, bwaitforstart )
{
maps\_vehicle::vehicle_paths( node, bwaitforstart );
}
groundpos( origin )
{
return bullettrace( origin, ( origin + ( 0, 0, -100000 ) ), 0, self )[ "position" ];
}
playergroundpos(origin)
{
return playerphysicstrace(origin, ( origin + ( 0, 0, -100000 ) ));
}
getvehiclespawner( targetname )
{
spawner = getent( targetname + "_vehiclespawner", "targetname" );
return spawner;
}
getvehiclespawnerarray( targetname )
{
spawner = getentarray( targetname + "_vehiclespawner", "targetname" );
return spawner;
}
player_fudge_moveto( dest, moverate )
{
if( !IsDefined( moverate ) )
{
moverate = 200;
}
org = Spawn( "script_origin", self.origin );
org.angles = self.angles;
self LinkTo( org );
dist = Distance( self.origin, dest );
movetime = dist/moverate;
org MoveTo( dest, dist/moverate, .05, .05 );
wait( movetime );
self UnLink();
org Delete();
}
add_start( msg, func, loc_string )
{
assertex( !IsDefined( level._loadStarted ), "Can't create starts after _load" );
if( !IsDefined( level.start_functions ) )
{
level.start_functions = [];
}
msg = tolower( msg );
level.start_functions[ msg ] = func;
if( IsDefined(loc_string) )
{
precachestring(loc_string);
level.start_loc_string[ msg ] = loc_string;
}
else
{
level.start_loc_string[ msg ] = &"MISSING_LOC_STRING";
}
}
default_start( func, bSplash )
{
level.default_start = func;
}
start_teleport_players( start_name, coop_sort )
{
players = get_players();
if( IsDefined( coop_sort ) && coop_sort )
{
starts = get_sorted_starts( start_name );
}
else
{
starts = getstructarray( start_name, "targetname" );
}
assertex( starts.size >= players.size, "Need more start positions for players!" );
for (i = 0; i < players.size; i++)
{
players[i] setOrigin( starts[i].origin );
if( IsDefined( starts[i].angles ) )
{
players[i] setPlayerAngles( starts[i].angles );
}
}
set_breadcrumbs(starts);
}
get_sorted_starts( start_name )
{
player_starts = getstructarray( start_name, "targetname" );
for( i = 0; i < player_starts.size; i++ )
{
for( j = i; j < player_starts.size; j++ )
{
assertex( IsDefined( player_starts[j].script_int ), "start at: " + player_starts[j].origin + " must have a script_int set for coop spawning" );
assertex( IsDefined( player_starts[i].script_int ), "start at: " + player_starts[i].origin + " must have a script_int set for coop spawning" );
if( player_starts[j].script_int < player_starts[i].script_int )
{
temp = player_starts[i];
player_starts[i] = player_starts[j];
player_starts[j] = temp;
}
}
}
return player_starts;
}
start_teleport_ai( start_name, ai_names )
{
friendly_ai = get_ai_array( ai_names, "script_noteworthy" );
ai_starts = getstructarray( start_name + "_ai", "targetname");
assertex( ai_starts.size >= friendly_ai.size, "Need more start positions for ai!" );
for (i = 0; i < friendly_ai.size; i++)
{
start_i = 0;
if (IsDefined(friendly_ai[i].script_int))
{
for (j = 0; j < ai_starts.size; j++)
{
if (IsDefined(ai_starts[j].script_int))
{
if (ai_starts[j].script_int == friendly_ai[i].script_int)
{
start_i = j;
break;
}
}
}
}
friendly_ai[i] start_teleport_single_ai(ai_starts[start_i]);
ai_starts = array_remove(ai_starts, ai_starts[start_i]);
}
}
start_teleport_single_ai(ai_start)
{
if( IsDefined( ai_start.angles ) )
{
self forceteleport( ai_start.origin, ai_start.angles );
}
else
{
self forceteleport( ai_start.origin );
}
if (IsDefined(ai_start.target))
{
node = GetNode(ai_start.target, "targetname");
if (IsDefined(node))
{
self SetGoalNode(node);
return;
}
}
self SetGoalPos(ai_start.origin);
}
start_teleport( start_name, ai_names, coop_sort )
{
if( IsDefined( ai_names ) )
{
start_teleport_ai( start_name, ai_names );
}
start_teleport_players( start_name, coop_sort );
}
within_fov( start_origin, start_angles, end_origin, fov )
{
normal = VectorNormalize( end_origin - start_origin );
forward = AnglesToForward( start_angles );
dot = VectorDot( forward, normal );
return dot >= fov;
}
wait_for_buffer_time_to_pass( last_queue_time, buffer_time )
{
timer = buffer_time * 1000 - ( gettime() - last_queue_time );
timer *= 0.001;
if ( timer > 0 )
{
wait( timer );
}
}
dialogue_queue( msg )
{
self maps\_anim::anim_single_queue( self, msg );
}
hint_position_internal( bgAlpha )
{
if( level.console )
{
self.elm.fontScale = 2;
}
else
{
self.elm.fontScale = 1.6;
}
self.elm.x = 0;
self.elm.y = -40;
self.elm.alignX = "center";
self.elm.alignY = "bottom";
self.elm.horzAlign = "center";
self.elm.vertAlign = "middle";
self.elm.sort = 1;
self.elm.alpha = 0.8;
if( !IsDefined( self.bg ) )
{
return;
}
self.bg.x = 0;
self.bg.y = -40;
self.bg.alignX = "center";
self.bg.alignY = "middle";
self.bg.horzAlign = "center";
self.bg.vertAlign = "middle";
self.bg.sort = -1;
if( level.console )
{
self.bg SetShader( "popmenu_bg", 650, 52 );
}
else
{
self.bg SetShader( "popmenu_bg", 650, 42 );
}
if ( !IsDefined( bgAlpha ) )
{
bgAlpha = 0.5;
}
self.bg.alpha = bgAlpha;
}
string( num )
{
return( "" + num );
}
clear_threatbias( group1, group2 )
{
SetThreatBias( group1, group2, 0 );
SetThreatBias( group2, group1, 0 );
}
add_global_spawn_function( team, function, param1, param2, param3 )
{
assertEx( IsDefined( level.spawn_funcs ), "Tried to add_global_spawn_function before calling _load" );
func = [];
func[ "function" ] = function;
func[ "param1" ] = param1;
func[ "param2" ] = param2;
func[ "param3" ] = param3;
level.spawn_funcs[ team ][ level.spawn_funcs[ team ].size ] = func;
}
remove_global_spawn_function( team, function )
{
assertEx( IsDefined( level.spawn_funcs ), "Tried to remove_global_spawn_function before calling _load" );
array = [];
for( i = 0; i < level.spawn_funcs[ team ].size; i++ )
{
if( level.spawn_funcs[ team ][ i ][ "function" ] != function )
{
array[ array.size ] = level.spawn_funcs[ team ][ i ];
}
}
assertEx( level.spawn_funcs[ team ].size != array.size, "Tried to remove a function from level.spawn_funcs, but that function didn't exist!" );
level.spawn_funcs[ team ] = array;
}
add_spawn_function( function, param1, param2, param3, param4 )
{
AssertEx( !IsDefined( level._loadStarted ) || !IsAlive( self ), "Tried to add_spawn_function to a living guy." );
func = [];
func[ "function" ] = function;
func[ "param1" ] = param1;
func[ "param2" ] = param2;
func[ "param3" ] = param3;
func[ "param4" ] = param4;
if (!IsDefined(self.spawn_funcs))
{
self.spawn_funcs = [];
}
self.spawn_funcs[ self.spawn_funcs.size ] = func;
}
add_spawn_function_veh( veh_targetname, function, param1, param2, param3, param4 )
{
assertEx( IsDefined(level.vehicleSpawners), "Tried to add_spawn_function_veh before vehicle spawners were inited");
func = [];
func[ "function" ] = function;
func[ "param1" ] = param1;
func[ "param2" ] = param2;
func[ "param3" ] = param3;
func[ "param4" ] = param4;
func_count_added = 0;
for( i = 0; func_count_added < level.vehicleSpawners.size; i++ )
{
if(!IsDefined(level.vehicleSpawners[i]))
{
continue;
}
else
{
for( j = 0; j < level.vehicleSpawners[i].size; j++ )
{
if( IsDefined(level.vehicleSpawners[i][j].targetname) && level.vehicleSpawners[i][j].targetname == veh_targetname + "_vehiclespawner" )
{
if(!IsDefined( level.vehicleSpawners[i][j].spawn_funcs ))
{
level.vehicleSpawners[i][j].spawn_funcs = [];
}
level.vehicleSpawners[i][j].spawn_funcs[ level.vehicleSpawners[i][j].spawn_funcs.size ] = func;
}
}
func_count_added++;
}
}
}
add_spawn_function_veh_by_type( veh_type, function, param1, param2, param3, param4 )
{
assertEx( IsDefined(level.vehicleSpawners), "Tried to add_spawn_function_veh_by_type before vehicle spawners were inited");
func = [];
func[ "function" ] = function;
func[ "param1" ] = param1;
func[ "param2" ] = param2;
func[ "param3" ] = param3;
func[ "param4" ] = param4;
func_count_added = 0;
for( i = 0; func_count_added < level.vehicleSpawners.size; i++ )
{
if(!IsDefined(level.vehicleSpawners[i]))
{
continue;
}
else
{
for( j = 0; j < level.vehicleSpawners[i].size; j++ )
{
if( IsDefined(level.vehicleSpawners[i][j].vehicletype) && level.vehicleSpawners[i][j].vehicletype == veh_type )
{
if(!IsDefined( level.vehicleSpawners[i][j].spawn_funcs ))
{
level.vehicleSpawners[i][j].spawn_funcs = [];
}
level.vehicleSpawners[i][j].spawn_funcs[ level.vehicleSpawners[i][j].spawn_funcs.size ] = func;
}
}
func_count_added++;
}
}
}
ignore_triggers( timer )
{
self endon( "death" );
self.ignoreTriggers = true;
if( IsDefined( timer ) )
{
wait( timer );
}
else
{
wait( 0.5 );
}
self.ignoreTriggers = false;
}
delayThread( timer, func, param1, param2, param3, param4 )
{
thread delayThread_proc( func, timer, param1, param2, param3, param4 );
}
activate_trigger_with_targetname( msg )
{
trigger = getent( msg, "targetname" );
trigger activate_trigger();
}
activate_trigger_with_noteworthy( msg )
{
trigger = getent( msg, "script_noteworthy" );
trigger activate_trigger();
}
disable_trigger_with_targetname( msg )
{
trigger = getent( msg, "targetname" );
trigger trigger_off();
}
disable_trigger_with_noteworthy( msg )
{
trigger = getent( msg, "script_noteworthy" );
trigger trigger_off();
}
enable_trigger_with_targetname( msg )
{
trigger = getent( msg, "targetname" );
trigger trigger_on();
}
enable_trigger_with_noteworthy( msg )
{
trigger = getent( msg, "script_noteworthy" );
trigger trigger_on();
}
is_hero()
{
return IsDefined( level.hero_list[ get_ai_number() ] );
}
get_ai_number()
{
if( !IsDefined( self.ai_number ) )
{
set_ai_number();
}
return self.ai_number;
}
set_ai_number()
{
self.ai_number = level.ai_number;
level.ai_number ++ ;
}
make_hero()
{
self magic_bullet_shield();
level.hero_list[ self.ai_number ] = self;
self.ikpriority = 5;
self thread unmake_hero_on_death();
}
unmake_hero_on_death()
{
self waittill("death");
level.hero_list[ self.ai_number ] = undefined;
}
unmake_hero()
{
self thread stop_magic_bullet_shield();
level.hero_list[ self.ai_number ] = undefined;
self.ikpriority = 0;
}
get_heroes()
{
return level.hero_list;
}
replace_on_death()
{
maps\_colors::colorNode_replace_on_death();
}
spawn_reinforcement( classname, color )
{
maps\_colors::colorNode_spawn_reinforcement( classname, color );
}
clear_promotion_order()
{
level.current_color_order = [];
}
set_promotion_order( deadguy, replacer )
{
if( !IsDefined( level.current_color_order ) )
{
level.current_color_order = [];
}
deadguy = shortenColor( deadguy );
replacer = shortenColor( replacer );
level.current_color_order[ deadguy ] = replacer;
if( !IsDefined( level.current_color_order[ replacer ] ) )
{
set_empty_promotion_order( replacer );
}
}
set_empty_promotion_order( deadguy )
{
if( !IsDefined( level.current_color_order ) )
{
level.current_color_order = [];
}
level.current_color_order[ deadguy ] = "none";
}
remove_dead_from_array( array )
{
newarray = [];
for( i = 0; i < array.size; i++ )
{
if( !isalive( array[ i ] ) )
{
continue;
}
newarray[ newarray.size ] = array[ i ];
}
return newarray;
}
remove_heroes_from_array( array )
{
newarray = [];
for( i = 0; i < array.size; i++ )
{
if( array[ i ] is_hero() )
{
continue;
}
newarray[ newarray.size ] = array[ i ];
}
return newarray;
}
remove_all_animnamed_guys_from_array( array )
{
newarray = [];
for( i = 0; i < array.size; i++ )
{
if( IsDefined( array[ i ].animname ) )
{
continue;
}
newarray[ newarray.size ] = array[ i ];
}
return newarray;
}
remove_color_from_array( array, color )
{
newarray = [];
for( i = 0; i < array.size; i++ )
{
guy = array[ i ];
if( !IsDefined( guy.script_forceColor ) )
{
continue;
}
if( guy.script_forceColor == color )
{
continue;
}
newarray[ newarray.size ] = guy;
}
return newarray;
}
remove_noteworthy_from_array( array, noteworthy )
{
newarray = [];
for( i = 0; i < array.size; i++ )
{
guy = array[ i ];
if( IsDefined( guy.script_noteworthy ) && guy.script_noteworthy == noteworthy )
{
continue;
}
newarray[ newarray.size ] = guy;
}
return newarray;
}
get_closest_colored_friendly( color, origin )
{
allies = get_force_color_guys( "allies", color );
allies = remove_heroes_from_array( allies );
if( !IsDefined( origin ) )
{
players = get_players();
friendly_origin = players[0].origin;
}
else
{
friendly_origin = origin;
}
return getclosest( friendly_origin, allies );
}
remove_without_classname( array, classname )
{
newarray = [];
for( i = 0; i < array.size; i++ )
{
if( !issubstr( array[ i ].classname, classname ) )
{
continue;
}
newarray[ newarray.size ] = array[ i ];
}
return newarray;
}
remove_without_model( array, model )
{
newarray = [];
for( i = 0; i < array.size; i++ )
{
if( !issubstr( array[ i ].model, model ) )
{
continue;
}
newarray[ newarray.size ] = array[ i ];
}
return newarray;
}
get_closest_colored_friendly_with_classname( color, classname, origin )
{
allies = get_force_color_guys( "allies", color );
allies = remove_heroes_from_array( allies );
if( !IsDefined( origin ) )
{
players = get_players();
friendly_origin = players[0].origin;
}
else
{
friendly_origin = origin;
}
allies = remove_without_classname( allies, classname );
return getclosest( friendly_origin, allies );
}
promote_nearest_friendly( colorFrom, colorTo )
{
for( ;; )
{
friendly = get_closest_colored_friendly( colorFrom );
if( !IsAlive( friendly ) )
{
wait( 1 );
continue;
}
friendly set_force_color( colorTo );
return;
}
}
instantly_promote_nearest_friendly( colorFrom, colorTo )
{
for( ;; )
{
friendly = get_closest_colored_friendly( colorFrom );
if( !IsAlive( friendly ) )
{
assertex( 0, "Instant promotion from " + colorFrom + " to " + colorTo + " failed!" );
return;
}
friendly set_force_color( colorTo );
return;
}
}
instantly_promote_nearest_friendly_with_classname( colorFrom, colorTo, classname )
{
for( ;; )
{
friendly = get_closest_colored_friendly_with_classname( colorFrom, classname );
if( !IsAlive( friendly ) )
{
assertex( 0, "Instant promotion from " + colorFrom + " to " + colorTo + " failed!" );
return;
}
friendly set_force_color( colorTo );
return;
}
}
promote_nearest_friendly_with_classname( colorFrom, colorTo, classname )
{
for( ;; )
{
friendly = get_closest_colored_friendly_with_classname( colorFrom, classname );
if( !isalive( friendly ) )
{
wait( 1 );
continue;
}
friendly set_force_color( colorTo );
return;
}
}
instantly_set_color_from_array_with_classname( array, color, classname )
{
foundGuy = false;
newArray = [];
for( i = 0; i < array.size; i++ )
{
guy = array[ i ];
if( foundGuy || !isSubstr( guy.classname, classname ) )
{
newArray[ newArray.size ] = guy;
continue;
}
foundGuy = true;
guy set_force_color( color );
}
return newArray;
}
instantly_set_color_from_array( array, color )
{
foundGuy = false;
newArray = [];
for( i = 0; i < array.size; i++ )
{
guy = array[ i ];
if( foundGuy )
{
newArray[ newArray.size ] = guy;
continue;
}
foundGuy = true;
guy set_force_color( color );
}
return newArray;
}
wait_for_flag_or_timeout( msg, timer )
{
if( flag( msg ) )
{
return;
}
ent = SpawnStruct();
ent thread ent_waits_for_level_notify( msg );
ent thread ent_times_out( timer );
ent waittill( "done" );
}
wait_for_trigger_or_timeout( timer )
{
ent = SpawnStruct();
ent thread ent_waits_for_trigger( self );
ent thread ent_times_out( timer );
ent waittill( "done" );
}
wait_for_either_trigger( msg1, msg2 )
{
ent = SpawnStruct();
array = [];
array = array_combine( array, GetEntArray( msg1, "targetname" ) );
array = array_combine( array, GetEntArray( msg2, "targetname" ) );
for( i = 0; i < array.size; i++ )
{
ent thread ent_waits_for_trigger( array[ i ] );
}
ent waittill( "done" );
}
dronespawn( spawner )
{
drone = maps\_spawner::spawner_dronespawn( spawner );
assert( IsDefined( drone ) );
return drone;
}
make_real_ai( drone )
{
return maps\_spawner::spawner_make_real_ai( drone );
}
get_trigger_flag(flag_name_override)
{
if (IsDefined(flag_name_override))
{
return flag_name_override;
}
if( IsDefined( self.script_flag ) )
{
return self.script_flag;
}
if( IsDefined( self.script_noteworthy ) )
{
return self.script_noteworthy;
}
assertex( 0, "Flag trigger at " + self.origin + " has no script_flag set." );
}
is_spawner()
{
return (is_true(self.is_spawner));
}
set_default_pathenemy_settings()
{
if( self.team == "allies" )
{
self.pathEnemyLookAhead = 350;
self.pathEnemyFightDist = 350;
return;
}
if( self.team == "axis" )
{
self.pathEnemyLookAhead = 350;
self.pathEnemyFightDist = 350;
return;
}
}
enable_heat()
{
self thread call_overloaded_func( "animscripts\anims_table", "setup_heat_anim_array" );
}
disable_heat()
{
self thread call_overloaded_func( "animscripts\anims_table", "reset_heat_anim_array" );
}
enable_cqbwalk()
{
self.cqbwalking = true;
level thread call_overloaded_func( "animscripts\cqb", "findCQBPointsOfInterest" );
self thread call_overloaded_func( "animscripts\anims_table", "setup_cqb_anim_array" );
}
disable_cqbwalk()
{
if(!IsDefined(self) && (!IsAlive(self)) )
{
return;
}
self.cqbwalking = false;
self.sprint = false;
self.cqb_point_of_interest = undefined;
self thread call_overloaded_func( "animscripts\anims_table", "reset_cqb_anim_array" );
}
enable_cqbsprint()
{
if( !( self animscripts\utility::isCQBWalking() ) )
self enable_cqbwalk();
self.sprint = true;
}
disable_cqbsprint()
{
self.sprint = false;
}
cqb_aim( the_target )
{
if( !IsDefined( the_target ) )
{
self.cqb_target = undefined;
}
else
{
self.cqb_target = the_target;
if( !IsDefined( the_target.origin ) )
{
assertmsg( "target passed into cqb_aim does not have an origin!" );
}
}
}
set_force_cover( val )
{
assertex( val == "hide" || val == "none" || val == "show", "invalid force cover set on guy" );
assertex( IsAlive( self ), "Tried to set force cover on a dead guy" );
self.a.forced_cover = val;
}
waittill_notify_or_timeout( msg, timer )
{
self endon( msg );
wait( timer );
}
waittill_any_or_timeout( timer, string1, string2, string3, string4, string5 )
{
assert( IsDefined( string1 ) );
self endon( string1 );
if ( IsDefined( string2 ) )
{
self endon( string2 );
}
if ( IsDefined( string3 ) )
{
self endon( string3 );
}
if ( IsDefined( string4 ) )
{
self endon( string4 );
}
if ( IsDefined( string5 ) )
{
self endon( string5 );
}
wait( timer );
}
scrub_guy()
{
self SetThreatBiasGroup( self.team );
self.script_accuracy = 1;
self.perfectAim = false;
set_default_pathenemy_settings();
maps\_gameskill::grenadeAwareness();
self clear_force_color();
maps\_spawner::set_default_covering_fire();
self.interval = 96;
self.disableArrivals = undefined;
self.ignoreme = false;
self.threatbias = 0;
self.pacifist = false;
self.pacifistWait = 20;
self.IgnoreRandomBulletDamage = false;
self.playerPushable = true;
self.precombatrunEnabled = true;
self.accuracystationarymod = 1;
self.allowdeath = false;
self.anglelerprate = 540;
self.badplaceawareness = 0.75;
self.chainfallback = 0;
self.dontavoidplayer = 0;
self.drawoncompass = 1;
self.activatecrosshair = true;
self.dropweapon = 1;
self.goalradius = level.default_goalradius;
self.goalheight = level.default_goalheight;
self.ignoresuppression = 0;
self PushPlayer( false );
if ( IsDefined( self.magic_bullet_shield ) && self.magic_bullet_shield )
{
stop_magic_bullet_shield();
}
self disable_replace_on_death();
self.maxsightdistsqrd = 8192*8192;
if( WeaponClass( self.weapon ) == "gas" )
{
self.maxSightDistSqrd = 1024 * 1024;
}
self.script_forceGrenade = 0;
self.walkdist = 16;
self unmake_hero();
self.pushable = true;
call_overloaded_func( "animscripts\init", "set_anim_playback_rate" );
self.fixednode = self.team == "allies";
if( IsDefined( self.script_grenades ) )
{
self.grenadeAmmo = self.script_grenades;
}
else
{
self.grenadeAmmo = 3;
}
}
send_notify( msg )
{
self notify( msg );
}
getfx( fx )
{
assertEx( IsDefined( level._effect[ fx ] ), "Fx " + fx + " is not defined in level._effect." );
return level._effect[ fx ];
}
getanim( anime )
{
assertex( IsDefined( self.animname ), "Called getanim on a guy with no animname" );
assertEx( IsDefined( level.scr_anim[ self.animname ][ anime ] ), "Called getanim on an inexistent anim" );
return level.scr_anim[ self.animname ][ anime ];
}
getanim_from_animname( anime, animname )
{
assertEx( IsDefined( animname ), "Must supply an animname" );
assertEx( IsDefined( level.scr_anim[ animname ][ anime ] ), "Called getanim on an inexistent anim" );
return level.scr_anim[ animname ][ anime ];
}
getanim_generic( anime )
{
assertEx( IsDefined( level.scr_anim[ "generic" ][ anime ] ), "Called getanim_generic on an inexistent anim" );
return level.scr_anim[ "generic" ][ anime ];
}
add_hint_string( name, string, optionalFunc )
{
assertex( IsDefined( level.trigger_hint_string ), "Tried to add a hint string before _load was called." );
assertex( IsDefined( name ), "Set a name for the hint string. This should be the same as the script_hint on the trigger_hint." );
assertex( IsDefined( string ), "Set a string for the hint string. This is the string you want to appear when the trigger is hit." );
level.trigger_hint_string[ name ] = string;
precachestring( string );
if( IsDefined( optionalFunc ) )
{
level.trigger_hint_func[ name ] = optionalFunc;
}
}
ThrowGrenadeAtPlayerASAP()
{
players = get_players();
if ( players.size > 0 )
{
best_target = undefined;
closest_dist = 99999999;
for (i=0;i<players.size;i++)
{
if ( IsDefined(players[i]) )
{
dist = DistanceSquared( self.origin, players[i].origin );
if ( dist < closest_dist )
{
best_target = players[i];
closest_dist = dist;
}
}
}
if ( IsDefined(best_target) )
{
animscripts\combat_utility::ThrowGrenadeAtPlayerASAP_combat_utility(best_target);
}
}
}
is_ai_in_revive()
{
assertEX(IsAI(self), "Can only call this function on an AI character");
if( IsAlive(self) )
{
return animscripts\revive::isReviverOrBleeder();
}
}
disable_ai_revive()
{
Assert(IsDefined(level.reviveFeature), "level.reviveFeature is not defined, call this function after maps\_load::main().");
level.reviveFeature = false;
}
enable_ai_revive()
{
Assert(IsDefined(level.reviveFeature), "level.reviveFeature is not defined, call this function after maps\_load::main().");
Assert((level.reviveFeature == false), "Revive Feature is already enabled.");
level.reviveFeature = true;
}
disable_ai_bleeder()
{
assertEX(IsAI(self), "Can only call this function on an AI character");
assertEX(IsDefined(self.a.canBleed), "Can only call this function on an AI character");
self.a.canBleed = false;
}
enable_ai_bleeder()
{
assertEX(IsAI(self), "Can only call this function on an AI character");
assertEX(IsDefined(self.a.canBleed), "Can only call this function on an AI character");
self.a.canBleed = true;
}
disable_ai_reviver()
{
assertEX(IsAI(self), "Can only call this function on an AI character");
assertEX(IsDefined(self.a.canRevive), "Can only call this function on an AI character");
self.a.canRevive = false;
}
enable_ai_reviver()
{
assertEX(IsAI(self), "Can only call this function on an AI character");
assertEX(IsDefined(self.a.canRevive), "Can only call this function on an AI character");
self.a.canRevive = true;
}
switch_weapon_ASAP()
{
assertEX(IsAI(self), "Can only call this function on an AI character");
if( IsAlive(self) && !self.a.weapon_switch_ASAP )
self.a.weapon_switch_ASAP = true;
}
sg_precachemodel( model )
{
script_gen_dump_addline( "precachemodel( \"" + model + "\" );", "xmodel_" + model );
}
sg_precacheitem( item )
{
script_gen_dump_addline( "precacheitem( \"" + item + "\" );", "item_" + item );
}
sg_precachemenu( menu )
{
script_gen_dump_addline( "precachemenu( \"" + menu + "\" );", "menu_" + menu );
}
sg_precacherumble( rumble )
{
script_gen_dump_addline( "precacherumble( \"" + rumble + "\" );", "rumble_" + rumble );
}
sg_precacheshader( shader )
{
script_gen_dump_addline( "precacheshader( \"" + shader + "\" );", "shader_" + shader );
}
sg_precacheshellshock( shock )
{
script_gen_dump_addline( "precacheshellshock( \"" + shock + "\" );", "shock_" + shock );
}
sg_precachestring( string )
{
script_gen_dump_addline( "precachestring( \"" + string + "\" );", "string_" + string );
}
sg_precacheturret( turret )
{
script_gen_dump_addline( "precacheturret( \"" + turret + "\" );", "turret_" + turret );
}
sg_precachevehicle( vehicle )
{
script_gen_dump_addline( "precachevehicle( \"" + vehicle + "\" );", "vehicle_" + vehicle );
}
sg_getanim( animation )
{
return level.sg_anim[ animation ];
}
sg_getanimtree( animtree )
{
return level.sg_animtree[ animtree ];
}
sg_precacheanim( animation, animtree )
{
if( !IsDefined( animtree ) )
{
animtree = "generic_human";
}
sg_csv_addtype( "xanim", animation );
if( !IsDefined( level.sg_precacheanims ) )
{
level.sg_precacheanims = [];
}
if( !IsDefined( level.sg_precacheanims[ animtree ] ) )
{
level.sg_precacheanims[ animtree ] = [];
}
level.sg_precacheanims[ animtree ][ animation ] = true;
}
sg_getfx( fx )
{
return level.sg_effect[ fx ];
}
sg_precachefx( fx )
{
script_gen_dump_addline( "level.sg_effect[ \"" + fx + "\" ] = loadfx( \"" + fx + "\" );", "fx_" + fx );
}
sg_wait_dump()
{
flag_wait( "scriptgen_done" );
}
sg_standard_includes()
{
sg_csv_addtype( "ignore", "code_post_gfx" );
sg_csv_addtype( "ignore", "common" );
sg_csv_addtype( "col_map_sp", "maps/" + tolower( GetDvar( #"mapname" ) ) + ".d3dbsp" );
sg_csv_addtype( "gfx_map", "maps/" + tolower( GetDvar( #"mapname" ) ) + ".d3dbsp" );
sg_csv_addtype( "rawfile", "maps/" + tolower( GetDvar( #"mapname" ) ) + ".gsc" );
sg_csv_addtype( "rawfile", "maps / scriptgen/" + tolower( GetDvar( #"mapname" ) ) + "_scriptgen.gsc" );
sg_csv_soundadd( "us_battlechatter", "all_sp" );
sg_csv_soundadd( "ab_battlechatter", "all_sp" );
sg_csv_soundadd( "voiceovers", "all_sp" );
sg_csv_soundadd( "common", "all_sp" );
sg_csv_soundadd( "generic", "all_sp" );
sg_csv_soundadd( "requests", "all_sp" );
}
sg_csv_soundadd( type, loadspec )
{
script_gen_dump_addline( "nowrite Sound CSV entry: " + type, "sound_" + type + ", " + tolower( GetDvar( #"mapname" ) ) + ", " + loadspec );
}
sg_csv_addtype( type, string )
{
script_gen_dump_addline( "nowrite CSV entry: " + type + ", " + string, type + "_" + string );
}
array_combine_keys( array1, array2 )
{
if( !array1.size )
{
return array2;
}
keys = getarraykeys( array2 );
for( i = 0;i < keys.size;i++ )
{
array1[ keys[ i ] ] = array2[ keys[ i ] ];
}
return array1;
}
set_ignoreSuppression( val )
{
self.ignoreSuppression = val;
}
set_goalradius( radius )
{
self.goalradius = radius;
}
set_allowdeath( val )
{
self.allowdeath = val;
}
set_run_anim( anime, alwaysRunForward )
{
assertEx( IsDefined( anime ), "Tried to set run anim but didn't specify which animation to ues" );
assertEx( IsDefined( self.animname ), "Tried to set run anim on a guy that had no anim name" );
assertEx( IsDefined( level.scr_anim[ self.animname ][ anime ] ), "Tried to set run anim but the anim was not defined in the maps _anim file" );
if( IsDefined( alwaysRunForward ) )
{
self.alwaysRunForward = alwaysRunForward;
}
else
{
self.alwaysRunForward = true;
}
self.a.combatrunanim = level.scr_anim[ self.animname ][ anime ];
self.run_noncombatanim = self.a.combatrunanim;
self.walk_combatanim = self.a.combatrunanim;
self.walk_noncombatanim = self.a.combatrunanim;
self.preCombatRunEnabled = false;
}
set_generic_run_anim( anime, alwaysRunForward )
{
assertEx( IsDefined( anime ), "Tried to set generic run anim but didn't specify which animation to ues" );
assertEx( IsDefined( level.scr_anim[ "generic" ][ anime ] ), "Tried to set generic run anim but the anim was not defined in the maps _anim file" );
if ( IsDefined( alwaysRunForward ) )
{
if ( alwaysRunForward )
{
self.alwaysRunForward = alwaysRunForward;
}
else
{
self.alwaysRunForward = undefined;
}
}
else
{
self.alwaysRunForward = true;
}
self.a.combatrunanim = level.scr_anim[ "generic" ][ anime ];
self.run_noncombatanim = self.a.combatrunanim;
self.walk_combatanim = self.a.combatrunanim;
self.walk_noncombatanim = self.a.combatrunanim;
self.preCombatRunEnabled = false;
}
clear_run_anim()
{
self.alwaysRunForward = undefined;
self.a.combatrunanim = undefined;
self.run_noncombatanim = undefined;
self.walk_combatanim = undefined;
self.walk_noncombatanim = undefined;
self.preCombatRunEnabled = true;
}
physicsjolt_proximity( outer_radius, inner_radius, force )
{
self endon( "death" );
self endon( "stop_physicsjolt" );
if( !IsDefined( outer_radius ) || !IsDefined( inner_radius ) || !IsDefined( force ) )
{
outer_radius = 400;
inner_radius = 256;
force = ( 0, 0, 0.075 );
}
fade_distance = outer_radius * outer_radius;
fade_speed = 3;
base_force = force;
while( true )
{
wait 0.1;
force = base_force;
if( self.classname == "script_vehicle" )
{
speed = self getspeedMPH();
if( speed < fade_speed )
{
scale = speed / fade_speed;
force = vector_scale( base_force, scale );
}
}
dist = distancesquared( self.origin, get_players()[0].origin );
scale = fade_distance / dist;
if( scale > 1 )
{
scale = 1;
}
force = vector_scale( force, scale );
total_force = force[ 0 ] + force[ 1 ] + force[ 2 ];
}
}
set_goal_entity( ent )
{
self setGoalEntity( ent );
}
activate_trigger()
{
assertEx( !IsDefined( self.trigger_off ), "Tried to activate trigger that is OFF( either from trigger_off or from flags set on it through shift - G menu" );
if( IsDefined( self.script_color_allies ) )
{
self.activated_color_trigger = true;
maps\_colors::activate_color_trigger( "allies" );
}
if( IsDefined( self.script_color_axis ) )
{
self.activated_color_trigger = true;
maps\_colors::activate_color_trigger( "axis" );
}
self notify( "trigger" );
}
self_delete()
{
if (IsDefined(self))
{
self delete();
}
}
remove_noColor_from_array( ai )
{
newarray = [];
for( i = 0; i < ai.size; i++ )
{
guy = ai[ i ];
if( guy has_color() )
{
newarray[ newarray.size ] = guy;
}
}
return newarray;
}
has_color()
{
if( self.team == "axis" )
{
return IsDefined( self.script_color_axis ) || IsDefined( self.script_forceColor );
}
return IsDefined( self.script_color_allies ) || IsDefined( self.script_forceColor );
}
clear_colors()
{
clear_team_colors( "axis" );
clear_team_colors( "allies" );
}
clear_team_colors( team )
{
level.currentColorForced[ team ][ "r" ] = undefined;
level.currentColorForced[ team ][ "b" ] = undefined;
level.currentColorForced[ team ][ "c" ] = undefined;
level.currentColorForced[ team ][ "y" ] = undefined;
level.currentColorForced[ team ][ "p" ] = undefined;
level.currentColorForced[ team ][ "o" ] = undefined;
level.currentColorForced[ team ][ "g" ] = undefined;
}
get_script_palette()
{
rgb = [];
rgb[ "r" ] = ( 1, 0, 0 );
rgb[ "o" ] = ( 1, 0.5, 0 );
rgb[ "y" ] = ( 1, 1, 0 );
rgb[ "g" ] = ( 0, 1, 0 );
rgb[ "c" ] = ( 0, 1, 1 );
rgb[ "b" ] = ( 0, 0, 1 );
rgb[ "p" ] = ( 1, 0, 1 );
return rgb;
}
notify_delay( sNotifyString, fDelay )
{
assert( IsDefined( self ) );
assert( IsDefined( sNotifyString ) );
assert( IsDefined( fDelay ) );
self endon( "death" );
if( fDelay > 0 )
{
wait fDelay;
}
if( !IsDefined( self ) )
{
return;
}
self notify( sNotifyString );
}
gun_remove()
{
self animscripts\shared::placeWeaponOn( self.weapon, "none" );
}
gun_switchto( weaponName, whichHand )
{
self animscripts\shared::placeWeaponOn( weaponName, whichHand );
}
gun_recall()
{
self animscripts\shared::placeWeaponOn( self.weapon, "right" );
}
custom_ai_weapon_loadout( primary, secondary, sidearm )
{
self animscripts\shared::detachAllWeaponModels();
if( IsDefined(self.primaryweapon) && self.primaryweapon != "" )
{
self animscripts\shared::detachWeapon(self.primaryweapon);
}
if( IsDefined(self.secondaryweapon) && self.secondaryweapon != "" )
{
self animscripts\shared::detachWeapon(self.secondaryweapon);
}
if( IsDefined(self.sideArm) && self.sideArm != "" )
{
self animscripts\shared::detachWeapon(self.sideArm);
}
self.primaryweapon = "";
self.secondaryweapon = "";
self.sidearm = "";
if( IsDefined(primary) )
{
if( GetWeaponModel(primary) != "" )
{
self.primaryweapon = primary;
self call_overloaded_func( "animscripts\init", "initWeapon", self.primaryweapon );
self animscripts\shared::placeWeaponOn( self.primaryweapon, "right");
}
else
{
assertex( false, "custom_ai_weapon_loadout: primary weapon " + primary + " is not in a csv or isn't precached" );
}
}
if( IsDefined(secondary) )
{
if( GetWeaponModel(secondary) != "" )
{
self.secondaryweapon = secondary;
self call_overloaded_func( "animscripts\init", "initWeapon", self.secondaryweapon );
self animscripts\shared::placeWeaponOn( self.secondaryweapon, "back");
}
else
{
assertex( false, "custom_ai_weapon_loadout: secondary weapon " + secondary + " is not in a csv or isn't precached" );
}
}
if( IsDefined(sidearm) )
{
if( GetWeaponModel(sidearm) != "" )
{
self.sidearm = sidearm;
self call_overloaded_func( "animscripts\init", "initWeapon", self.sidearm );
}
else
{
assertex( false, "custom_ai_weapon_loadout: sidearm weapon " + sidearm + " is not in a csv or isn't precached" );
}
}
self.weapon = self.primaryweapon;
self animscripts\weaponList::RefillClip();
self.isSniper = animscripts\combat_utility::isSniperRifle( self.weapon );
}
lerp_player_view_to_tag( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc )
{
if( IsPlayer( self ) )
{
self endon( "disconnect" );
}
lerp_player_view_to_tag_internal( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, undefined );
}
lerp_player_view_to_tag_and_hit_geo( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc )
{
if( IsPlayer( self ) )
{
self endon( "disconnect" );
}
lerp_player_view_to_tag_internal( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, true );
}
lerp_player_view_to_position( origin, angles, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo )
{
if( IsPlayer( self ) )
{
self endon( "disconnect" );
}
linker = spawn( "script_origin", ( 0, 0, 0 ) );
linker.origin = self.origin;
linker.angles = self getplayerangles();
if( IsDefined( hit_geo ) )
{
self playerlinkto( linker, "", fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo );
}
else if( IsDefined( right_arc ) )
{
self playerlinkto( linker, "", fraction, right_arc, left_arc, top_arc, bottom_arc );
}
else if( IsDefined( fraction ) )
{
self playerlinkto( linker, "", fraction );
}
else
{
self playerlinkto( linker );
}
linker moveto( origin, lerptime, lerptime * 0.25 );
linker rotateto( angles, lerptime, lerptime * 0.25 );
linker waittill( "movedone" );
linker delete();
}
lerp_player_view_to_tag_oldstyle( tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc )
{
lerp_player_view_to_tag_oldstyle_internal( tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, false );
}
lerp_player_view_to_position_oldstyle( origin, angles, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo )
{
if( IsPlayer( self ) )
{
self endon( "disconnect" );
}
linker = spawn( "script_origin", ( 0, 0, 0 ) );
linker.origin = get_player_feet_from_view();
linker.angles = self getplayerangles();
if( IsDefined( hit_geo ) )
{
self playerlinktodelta( linker, "", fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo );
}
else if( IsDefined( right_arc ) )
{
self playerlinktodelta( linker, "", fraction, right_arc, left_arc, top_arc, bottom_arc );
}
else if( IsDefined( fraction ) )
{
self playerlinktodelta( linker, "", fraction );
}
else
{
self playerlinktodelta( linker );
}
linker moveto( origin, lerptime, lerptime * 0.25 );
linker rotateto( angles, lerptime, lerptime * 0.25 );
linker waittill( "movedone" );
linker delete();
}
lerp_player_view_to_moving_position_oldstyle( ent, tag, lerptime, fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo )
{
if( IsPlayer( self ) )
{
self endon( "disconnect" );
}
linker = spawn( "script_origin", ( 0, 0, 0 ) );
linker.origin = self.origin;
linker.angles = self getplayerangles();
if( IsDefined( hit_geo ) )
{
self playerlinktodelta( linker, "", fraction, right_arc, left_arc, top_arc, bottom_arc, hit_geo );
}
else if( IsDefined( right_arc ) )
{
self playerlinktodelta( linker, "", fraction, right_arc, left_arc, top_arc, bottom_arc );
}
else if( IsDefined( fraction ) )
{
self playerlinktodelta( linker, "", fraction );
}
else
{
self playerlinktodelta( linker );
}
max_count=lerptime/0.0167;
count=0;
while (count < max_count)
{
origin = ent gettagorigin( tag );
angles = ent gettagangles( tag );
linker moveto( origin, 0.0167*(max_count-count) );
linker rotateto( angles, 0.0167*(max_count-count) );
wait( 0.0167 );
count++;
}
linker delete();
}
timer( time )
{
wait( time );
}
waittill_either_function( func1, parm1, func2, parm2 )
{
ent = spawnstruct();
thread waittill_either_function_internal( ent, func1, parm1 );
thread waittill_either_function_internal( ent, func2, parm2 );
ent waittill( "done" );
}
waittill_msg( msg )
{
if( IsPlayer( self ) )
{
self endon( "disconnect" );
}
self waittill( msg );
}
display_hint( hint )
{
if ( GetDvar( #"chaplincheat" ) == "1" )
{
return;
}
if( IsDefined( level.trigger_hint_func[ hint ] ) )
{
if( [[ level.trigger_hint_func[ hint ] ]]() )
{
return;
}
HintPrint( level.trigger_hint_string[ hint ], level.trigger_hint_func[ hint ] );
}
else
{
HintPrint( level.trigger_hint_string[ hint ] );
}
}
getGenericAnim( anime )
{
assertex( IsDefined( level.scr_anim[ "generic" ][ anime ] ), "Generic anim " + anime + " was not defined in your _anim file." );
return level.scr_anim[ "generic" ][ anime ];
}
enable_careful()
{
assertex( isai( self ), "Tried to make an ai careful but it wasn't called on an AI" );
self.script_careful = true;
}
disable_careful()
{
assertex( isai( self ), "Tried to unmake an ai careful but it wasn't called on an AI" );
self.script_careful = false;
self notify( "stop_being_careful" );
}
set_fixednode_true()
{
self.fixednode = true;
}
set_fixednode_false()
{
self.fixednode = true;
}
spawn_ai()
{
ai = undefined;
if( IsDefined( self.lastSpawnTime ) && self.lastSpawnTime >= GetTime() )
{
wait(0.05);
}
no_enemy_info = is_true(self.script_noenemyinfo);
if ( IsDefined( self.script_forcespawn ) )
{
ai = self StalingradSpawn(no_enemy_info);
}
else
{
ai = self DoSpawn(no_enemy_info);
}
if( IsDefined( ai ) )
{
self.lastSpawnTime = GetTime();
}
return ai;
}
kill_spawnernum( number )
{
spawners = GetSpawnerArray();
for( i = 0; i < spawners.size; i++ )
{
if( !IsDefined( spawners[i].script_killspawner ) )
{
continue;
}
if( number != spawners[i].script_killspawner )
{
continue;
}
spawners[i] Delete();
}
}
function_stack( func, param1, param2, param3, param4 )
{
self endon( "death" );
localentity = spawnstruct();
localentity thread function_stack_proc( self, func, param1, param2, param3, param4 );
localentity waittill_either( "function_done", "death" );
}
set_goal_node( node )
{
self.last_set_goalnode = node;
self.last_set_goalpos = undefined;
self.last_set_goalent = undefined;
self SetGoalNode( node );
}
set_goal_pos( origin )
{
self.last_set_goalnode = undefined;
self.last_set_goalpos = origin;
self.last_set_goalent = undefined;
self SetGoalPos( origin );
}
set_goal_ent( target )
{
set_goal_pos( target.origin );
self.last_set_goalent = target;
}
run_thread_on_targetname( msg, func, param1, param2, param3 )
{
array = getentarray( msg, "targetname" );
array_thread( array, func, param1, param2, param3 );
}
run_thread_on_noteworthy( msg, func, param1, param2, param3 )
{
array = getentarray( msg, "script_noteworthy" );
array_thread( array, func, param1, param2, param3 );
}
handsignal( action, end_on, wait_till )
{
if ( IsDefined( end_on ) )
{
level endon( end_on );
}
if ( IsDefined( wait_till ) )
{
level waittill( wait_till );
}
switch ( action )
{
case "go":
self maps\_anim::anim_generic(self, "signal_go");
break;
case "onme":
self maps\_anim::anim_generic(self, "signal_onme");
break;
case "stop":
self maps\_anim::anim_generic(self, "signal_stop");
break;
case "moveup":
self maps\_anim::anim_generic(self, "signal_moveup");
break;
case "moveout":
self maps\_anim::anim_generic(self, "signal_moveout");
break;
}
}
add_dialogue_line( name, msg, blocking )
{
}
add_dialogue_line_internal( name, msg )
{
if( GetDvarInt( #"loc_warnings") )
{
return;
}
if ( !IsDefined( level.dialogue_huds ) )
{
level.dialogue_huds = [];
}
for ( index = 0;; index++ )
{
if ( !IsDefined( level.dialogue_huds[ index ] ) )
{
break;
}
}
level.dialogue_huds[ index ] = true;
hudelem = maps\_hud_util::createFontString( "default", 1.5 );
hudelem.location = 0;
hudelem.alignX = "left";
hudelem.alignY = "top";
hudelem.foreground = 1;
hudelem.sort = 20;
hudelem.alpha = 0;
hudelem fadeOverTime( 0.5 );
hudelem.alpha = 1;
hudelem.x = 40;
hudelem.y = 260 + index * 18;
hudelem.label = "<" + name + "> " + msg;
hudelem.color = (1,1,0);
wait( 2 );
timer = 2 * 20;
hudelem fadeOverTime( 6 );
hudelem.alpha = 0;
for ( i = 0; i < timer; i++ )
{
hudelem.color = ( 1, 1, 1 / ( timer - i ) );
wait( 0.05 );
}
wait( 4 );
hudelem destroy();
level.dialogue_huds[ index ] = undefined;
}
alphabetize( array )
{
if ( array.size <= 1 )
{
return array;
}
count = 0;
for ( ;; )
{
changed = false;
for ( i = 0; i < array.size - 1; i++ )
{
if ( is_later_in_alphabet( array[ i ], array[ i + 1 ] ) )
{
val = array[ i ];
array[ i ] = array[ i + 1 ];
array[ i + 1 ] = val;
changed = true;
count++;
if ( count >= 10 )
{
count = 0;
wait( 0.05 );
}
}
}
if ( !changed )
{
return array;
}
}
return array;
}
set_grenadeammo( count )
{
self.grenadeammo = count;
}
get_player_feet_from_view()
{
tagorigin = self.origin;
upvec = anglestoup( self getplayerangles() );
height = self GetPlayerViewHeight();
player_eye = tagorigin + (0,0,height);
player_eye_fake = tagorigin + vector_scale( upvec, height );
diff_vec = player_eye - player_eye_fake;
fake_origin = tagorigin + diff_vec;
return fake_origin;
}
set_console_status()
{
if ( !IsDefined( level.Console ) )
{
level.Console = GetDvar( #"consoleGame" ) == "true";
}
else
{
assertex( level.Console == ( GetDvar( #"consoleGame" ) == "true" ), "Level.console got set incorrectly." );
}
if ( !IsDefined( level.Consolexenon ) )
{
level.xenon = GetDvar( #"xenonGame" ) == "true";
}
else
{
assertex( level.xenon == ( GetDvar( #"xenonGame" ) == "true" ), "Level.xenon got set incorrectly." );
}
}
autosave_now( optional_useless_string, suppress_print )
{
return maps\_autosave::autosave_game_now( suppress_print );
}
set_generic_deathanim( deathanim )
{
self.deathanim = getgenericanim( deathanim );
}
set_deathanim( deathanim )
{
self.deathanim = getanim( deathanim );
}
clear_deathanim()
{
self.deathanim = undefined;
}
lerp_fov_overtime( time, destfov, use_camera_tween )
{
level endon("stop_lerping_thread");
if( !IsDefined( use_camera_tween ) )
{
basefov = GetDvarFloat( #"cg_fov" );
incs = int( time/.05 );
incfov = ( destfov - basefov ) / incs ;
currentfov = basefov;
if(incfov == 0)
{
return;
}
for ( i = 0; i < incs; i++ )
{
currentfov += incfov;
self SetClientDvar( "cg_fov", currentfov );
wait .05;
}
self SetClientDvar( "cg_fov", destfov );
}
else
{
self StartCameraTween( time );
self SetClientDvar( "cg_fov", destfov );
}
}
apply_fog()
{
maps\_load_common::set_fog_progress( 0 );
}
apply_end_fog()
{
maps\_load_common::set_fog_progress( 1 );
}
anim_stopanimscripted(blend_time)
{
anim_ent = get_anim_ent();
anim_ent StopAnimScripted(blend_time);
anim_ent notify( "single anim", "end" );
anim_ent notify( "looping anim", "end" );
if (IsDefined(anim_ent.anim_loop_ender))
{
anim_ent notify( anim_ent.anim_loop_ender );
}
anim_ent notify("_anim_stopped");
}
get_anim_ent()
{
if (IsDefined(self.anim_link))
{
self.anim_link.animname = self.animname;
return self.anim_link;
}
return self;
}
enable_additive_pain( enable_regular_pain_on_low_health )
{
AssertEx( IsAI( self ), "Enable_additive_pain should be called on AI only." );
self thread call_overloaded_func( "animscripts\pain", "additive_pain_think", enable_regular_pain_on_low_health );
}
disable_pain()
{
assertex( isalive( self ), "Tried to disable pain on a non ai" );
self.a.disablePain = true;
self.allowPain = false;
}
enable_pain()
{
assertex( isalive( self ), "Tried to enable pain on a non ai" );
self.a.disablePain = false;
self.allowPain = true;
}
disable_react()
{
assertex( isalive( self ), "Tried to disable react on a non ai" );
self.a.disableReact = true;
self.allowReact = false;
}
enable_react()
{
assertex( isalive( self ), "Tried to enable react on a non ai" );
self.a.disableReact = false;
self.allowReact = true;
}
enable_rambo()
{
if( IsDefined( level.norambo ) )
{
level.norambo = undefined;
}
}
disable_rambo()
{
level.norambo = 1;
}
die()
{
self dodamage( self.health + 150, (0,0,0) );
}
getmodel( str )
{
assertex( IsDefined( level.scr_model[ str ] ), "Tried to getmodel on model " + str + " but level.scr_model[ " + str + " was not defined." );
return level.scr_model[ str ];
}
isADS( player )
{
return ( player playerADS() > 0.5 );
}
enable_auto_adjust_threatbias(player)
{
level.auto_adjust_threatbias = true;
if ( level.gameskill >= 2 )
{
player.threatbias = int( maps\_gameskill::get_locked_difficulty_val( "threatbias", 1 ) );
return;
}
level.auto_adjust_difficulty_frac = GetDvarInt( #"autodifficulty_frac" );
current_frac = level.auto_adjust_difficulty_frac * 0.01;
players = get_players();
level.coop_player_threatbias_scalar = maps\_gameskill::getCoopValue( "coopFriendlyThreatBiasScalar", players.size );
if (!IsDefined(level.coop_player_threatbias_scalar))
{
level.coop_player_threatbias_scalar = 1;
}
player.threatbias = int( maps\_gameskill::get_blended_difficulty( "threatbias", current_frac ) * level.coop_player_threatbias_scalar);
}
disable_auto_adjust_threatbias()
{
level.auto_adjust_threatbias = false;
}
waittill_player_looking_at(origin, dot, do_trace)
{
while (!is_player_looking_at(origin, dot, do_trace))
{
wait .05;
}
}
is_player_looking_at(origin, dot, do_trace)
{
AssertEx(IsPlayer(self), "player_looking_at must be called on a player.");
if (!IsDefined(dot))
{
dot = .7;
}
if (!IsDefined(do_trace))
{
do_trace = true;
}
eye = self get_eye();
delta_vec = AnglesToForward(VectorToAngles(origin - eye));
view_vec = AnglesToForward(self GetPlayerAngles());
new_dot = VectorDot( delta_vec, view_vec );
if ( new_dot >= dot )
{
if (do_trace)
{
return BulletTracePassed( origin, eye, false, undefined );
}
else
{
return true;
}
}
return false;
}
look_at(origin_or_ent, tween, force, tag, offset)
{
if (is_true(force))
{
self FreezeControls(true);
}
if (IsDefined(tween))
{
self StartCameraTween(tween);
}
self notify("look_at_begin");
origin = origin_or_ent;
if (!IsVec(origin_or_ent))
{
ent = origin_or_ent;
if (IsDefined(tag))
{
origin = ent GetTagOrigin(tag);
}
else if (IsAI(origin_or_ent) && !IsDefined(offset))
{
origin = ent get_eye();
}
else
{
origin = ent.origin;
}
}
if (IsDefined(offset))
{
origin = origin + offset;
}
player_org = self get_eye();
vec_to_pt = origin - player_org;
self SetPlayerAngles(VectorToAngles(vec_to_pt));
wait tween;
if (is_true(force))
{
self FreezeControls(false);
}
self notify("look_at_end");
}
add_wait( func, parm1, parm2, parm3 )
{
ent = spawnstruct();
ent.caller = self;
ent.func = func;
ent.parms = [];
if ( IsDefined( parm1 ) )
{
ent.parms[ ent.parms.size ] = parm1;
}
if ( IsDefined( parm2 ) )
{
ent.parms[ ent.parms.size ] = parm2;
}
if ( IsDefined( parm3 ) )
{
ent.parms[ ent.parms.size ] = parm3;
}
level.wait_any_func_array[ level.wait_any_func_array.size ] = ent;
}
do_wait_any()
{
assertex( IsDefined( level.wait_any_func_array ), "Tried to do a do_wait without addings funcs first" );
assertex( level.wait_any_func_array.size > 0, "Tried to do a do_wait without addings funcs first" );
do_wait( level.wait_any_func_array.size - 1 );
}
do_wait( count_to_reach )
{
if ( !IsDefined( count_to_reach ) )
{
count_to_reach = 0;
}
assertex( IsDefined( level.wait_any_func_array ), "Tried to do a do_wait without addings funcs first" );
ent = spawnstruct();
array = level.wait_any_func_array;
endons = level.do_wait_endons_array;
after_array = level.run_func_after_wait_array;
level.wait_any_func_array = [];
level.run_func_after_wait_array = [];
level.do_wait_endons_array = [];
ent.count = array.size;
ent array_levelthread( array, ::waittill_func_ends, endons );
for ( ;; )
{
if ( ent.count <= count_to_reach )
{
break;
}
ent waittill( "func_ended" );
}
ent notify( "all_funcs_ended" );
array_levelthread( after_array, ::exec_func, [] );
}
waterfx( endflag )
{
if ( IsDefined( endflag ) )
{
flag_assert( endflag );
level endon( endflag );
}
for ( ;; )
{
wait( randomfloatrange( 0.15, 0.3 ) );
start = self.origin + (0,0,150);
end = self.origin - (0,0,150);
trace = BulletTrace( start, end, false, undefined );
if ( trace[ "surfacetype" ] != "water" )
{
continue;
}
fx = "water_movement";
if ( self == level.player )
{
if ( distance( level.player getvelocity(), (0,0,0) ) < 5 )
{
fx = "water_stop";
}
}
else if ( IsDefined( level._effect[ "water_" + self.a.movement ] ) )
{
fx = "water_" + self.a.movement;
}
playfx( getfx( fx ), trace[ "position" ], trace[ "normal" ] );
}
}
fail_on_friendly_fire()
{
if ( !IsDefined( level.friendlyfire_friendly_kill_points ) )
{
level.friendlyfire_friendly_kill_points = level.friendlyfire[ "friend_kill_points" ];
}
level.friendlyfire[ "friend_kill_points" ] = -60000;
}
giveachievement_wrapper( achievement, all_players )
{
if ( achievement == "" )
{
return;
}
if ( isCoopEPD() )
{
return;
}
if( !( maps\_cheat::is_cheating() ) && ! ( flag("has_cheated") ) )
{
if( IsDefined( all_players ) && all_players )
{
players = get_players();
for( i = 0; i < players.size; i++ )
{
players[i] GiveAchievement( achievement );
}
}
else
{
if( !IsPlayer( self ) )
{
println( "^1self needs to be a player for _utility::giveachievement_wrapper()" );
return;
}
self GiveAchievement( achievement );
}
}
}
slowmo_start()
{
flag_set( "disable_slowmo_cheat" );
}
slowmo_end()
{
maps\_cheat::slowmo_system_defaults();
flag_clear( "disable_slowmo_cheat" );
}
slowmo_setspeed_slow( speed )
{
if( !maps\_cheat::slowmo_check_system() )
{
return;
}
level.slowmo.speed_slow = speed;
}
slowmo_setspeed_norm( speed )
{
if( !maps\_cheat::slowmo_check_system() )
{
return;
}
level.slowmo.speed_norm = speed;
}
slowmo_setlerptime_in( time )
{
if( !maps\_cheat::slowmo_check_system() )
{
return;
}
level.slowmo.lerp_time_in = time;
}
slowmo_setlerptime_out( time )
{
if( !maps\_cheat::slowmo_check_system() )
{
return;
}
level.slowmo.lerp_time_out = time;
}
slowmo_lerp_in()
{
if( !flag( "disable_slowmo_cheat" ) )
{
return;
}
level.slowmo thread maps\_cheat::gamespeed_set( level.slowmo.speed_slow, level.slowmo.speed_current, level.slowmo.lerp_time_in );
}
slowmo_lerp_out()
{
if( !flag( "disable_slowmo_cheat" ) )
{
return;
}
level.slowmo thread maps\_cheat::gamespeed_reset();
}
arcademode_assignpoints( amountDvar, player )
{
if ( GetDvar( #"arcademode" ) != "1" )
{
return;
}
}
arcadeMode()
{
isArcadeMode = GetDvar( #"arcademode" ) == "1";
if ( GetDvar( #"zombiemode" ) == "1" )
{
isArcadeMode = false;
}
return isArcadeMode;
}
coopGame()
{
return (( GetDvar( #"systemlink" ) == "1" ) || (GetDvar( #"onlinegame" ) == "1" ) || IsSplitScreen() );
}
player_is_near_live_grenade()
{
grenades = getentarray( "grenade", "classname" );
for ( i = 0; i < grenades.size; i++ )
{
grenade = grenades[ i ];
players = get_players();
for( j = 0; j < players.size; j++ )
{
if( DistanceSquared( grenade.origin, players[j].origin ) < 250 * 250 )
{
return true;
}
}
}
return false;
}
player_died_recently()
{
return GetDvarInt( #"player_died_recently" ) > 0;
}
set_splitscreen_fog( start_dist, halfway_dist, halfway_height, base_height, red, green, blue, trans_time, cull_dist )
{
if( !IsSplitScreen() )
{
return;
}
if( !IsDefined( start_dist ) )
{
start_dist = 0;
}
if( !IsDefined( halfway_dist ) )
{
halfway_dist = 200;
}
if( !IsDefined( base_height ) )
{
base_height = -2000;
}
if( !IsDefined( red ) )
{
red = 1;
}
if( !IsDefined( green ) )
{
green = 1;
}
if( !IsDefined( blue ) )
{
blue = 0;
}
if( !IsDefined( trans_time ) )
{
trans_time = 0;
}
if( !IsDefined( cull_dist ) )
{
cull_dist = 2000;
}
halfway_height = base_height + 2000;
level.splitscreen_fog = true;
SetVolFog( start_dist, halfway_dist, halfway_height, base_height, red, green, blue, 0 );
SetCullDist( cull_dist );
}
default_fog_print()
{
wait_for_first_player();
}
share_screen( player, toggle, instant )
{
if( !IsSplitscreen() )
{
return;
}
time = 1;
if( IsDefined( instant ) && instant )
{
time = 0.1;
}
toggle = !toggle;
SplitViewAllowed( player GetEntityNumber(), toggle, time );
}
get_players(t)
{
if(IsDefined(t))
{
return(GetPlayers(t));
}
else
{
return(GetPlayers());
}
}
get_host()
{
players = get_players("all");
for( i = 0; i < players.size; i++ )
{
if( players[i] GetEntityNumber() == 0 )
{
return players[i];
}
}
}
is_coop()
{
players = get_players("all");
if( players.size > 1 )
{
return true;
}
return false;
}
any_player_IsTouching( ent, t )
{
players = [];
if(IsDefined(t))
{
players = get_players(t);
}
else
{
players = get_players();
}
for( i = 0; i < players.size; i++ )
{
if( IsAlive( players[i] ) && players[i] IsTouching( ent ) )
{
return true;
}
}
return false;
}
get_player_touching( ent, t )
{
players = [];
if(IsDefined(t))
{
players = get_players(t);
}
else
{
players = get_players();
}
for( i = 0; i < players.size; i++ )
{
if( IsAlive( players[i] ) && players[i] IsTouching( ent ) )
{
return players[i];
}
}
return undefined;
}
get_closest_player( org, t )
{
players = [];
if(IsDefined(t))
{
players = get_players(t);
}
else
{
players = get_players();
}
return GetClosest( org, players );
}
clear_player_spawnpoints()
{
level.player_spawnpoints = [];
}
freezecontrols_all( toggle, delay )
{
if( IsDefined( delay ) )
{
wait( delay );
}
players = get_players("all");
for( i = 0; i < players.size; i++ )
{
players[i] FreezeControls( toggle );
}
}
set_all_players_blur( amount, time )
{
wait_for_first_player();
flag_wait( "all_players_connected" );
players = get_players("all");
for( i = 0; i < players.size; i++ )
{
players[i] SetBlur( amount, time );
}
}
set_all_players_double_vision( amount, time )
{
wait_for_first_player();
flag_wait( "all_players_connected" );
players = get_players("all");
for( i = 0; i < players.size; i++ )
{
players[i] SetDoubleVision( amount, time );
}
}
set_all_players_shock( shellshock_file, time )
{
wait_for_first_player();
flag_wait( "all_players_connected" );
players = get_players("all");
for( i = 0; i < players.size; i++ )
{
players[i] Shellshock( shellshock_file, time );
}
}
set_all_players_visionset( vision_file, time )
{
wait_for_first_player();
flag_wait( "all_players_connected" );
players = get_players("all");
for( i = 0; i < players.size; i++ )
{
players[i] VisionSetNaked( vision_file, time );
}
}
player_flag_wait( msg )
{
while( !self.flag[msg] )
{
self waittill( msg );
}
}
player_flag_wait_either( flag1, flag2 )
{
for( ;; )
{
if( flag( flag1 ) )
{
return;
}
if( flag( flag2 ) )
{
return;
}
self waittill_either( flag1, flag2 );
}
}
player_flag_waitopen( msg )
{
while( self.flag[msg] )
{
self waittill( msg );
}
}
player_flag_init( message, trigger )
{
if( !IsDefined( self.flag ) )
{
self.flag = [];
self.flags_lock = [];
}
assertex( !IsDefined( self.flag[message] ), "Attempt to reinitialize existing message: " + message );
self.flag[message] = false;
}
player_flag_set_delayed( message, delay )
{
wait( delay );
player_flag_set( message );
}
player_flag_set( message )
{
self.flag[message] = true;
self notify( message );
}
player_flag_clear( message )
{
self.flag[message] = false;
self notify( message );
}
player_flag( message )
{
assertex( IsDefined( message ), "Tried to check flag but the flag was not defined." );
if( !self.flag[message] )
{
return false;
}
return true;
}
wait_for_first_player()
{
players = get_players("all");
if( !IsDefined( players ) || players.size == 0 )
{
level waittill( "first_player_ready" );
}
}
wait_for_all_players()
{
flag_wait( "all_players_connected" );
}
findBoxCenter( mins, maxs )
{
center = ( 0, 0, 0 );
center = maxs - mins;
center = ( center[0]/2, center[1]/2, center[2]/2 ) + mins;
return center;
}
expandMins( mins, point )
{
if ( mins[0] > point[0] )
{
mins = ( point[0], mins[1], mins[2] );
}
if ( mins[1] > point[1] )
{
mins = ( mins[0], point[1], mins[2] );
}
if ( mins[2] > point[2] )
{
mins = ( mins[0], mins[1], point[2] );
}
return mins;
}
expandMaxs( maxs, point )
{
if ( maxs[0] < point[0] )
{
maxs = ( point[0], maxs[1], maxs[2] );
}
if ( maxs[1] < point[1] )
{
maxs = ( maxs[0], point[1], maxs[2] );
}
if ( maxs[2] < point[2] )
{
maxs = ( maxs[0], maxs[1], point[2] );
}
return maxs;
}
get_ai_touching_volume( team, volume_name, volume )
{
if ( !IsDefined( volume ) )
{
volume = getent( volume_name, "targetname" );
assertEx( IsDefined( volume ), volume_name + " does not exist" );
}
guys = getaiarray( team );
guys_touching_volume = [];
for( i=0; i < guys.size; i++ )
{
if ( guys[i] isTouching( volume ) )
{
guys_touching_volume[guys_touching_volume.size] = guys[i];
}
}
return guys_touching_volume;
}
registerClientSys(sSysName)
{
if(!IsDefined(level._clientSys))
{
level._clientSys = [];
}
if(level._clientSys.size >= 32)
{
error("Max num client systems exceeded.");
return;
}
if(IsDefined(level._clientSys[sSysName]))
{
error("Attempt to re-register client system : " + sSysName);
return;
}
else
{
level._clientSys[sSysName] = spawnstruct();
level._clientSys[sSysName].sysID = ClientSysRegister(sSysName);
}
}
setClientSysState(sSysName, sSysState, player)
{
if(!IsDefined(level._clientSys))
{
error("setClientSysState called before registration of any systems.");
return;
}
if(!IsDefined(level._clientSys[sSysName]))
{
error("setClientSysState called on unregistered system " + sSysName);
return;
}
if(IsDefined(player))
{
player ClientSysSetState(level._clientSys[sSysName].sysID, sSysState);
}
else
{
ClientSysSetState(level._clientSys[sSysName].sysID, sSysState);
level._clientSys[sSysName].sysState = sSysState;
}
}
wait_network_frame()
{
if(NumRemoteClients())
{
snapshot_ids = getsnapshotindexarray();
acked = undefined;
while (!IsDefined(acked))
{
level waittill("snapacknowledged");
acked = snapshotacknowledged(snapshot_ids);
}
}
else
{
wait(0.1);
}
}
clientNotify(event)
{
if(level.clientscripts)
{
if(IsPlayer(self))
{
maps\_utility::setClientSysState("levelNotify", event, self);
}
else
{
maps\_utility::setClientSysState("levelNotify", event);
}
}
}
ok_to_spawn( max_wait_seconds )
{
if( IsDefined( max_wait_seconds ) )
{
timer = GetTime() + max_wait_seconds * 1000;
while( GetTime() < timer && !OkToSpawn() )
{
wait( 0.05 );
}
}
else
{
while( !OkToSpawn() )
{
wait( 0.05 );
}
}
}
set_breadcrumbs(starts)
{
if(!IsDefined(level._player_breadcrumbs))
{
maps\_callbackglobal::Player_BreadCrumb_Reset((0,0,0));
}
for(i = 0; i < starts.size; i++)
{
for(j = 0; j < starts.size; j++)
{
level._player_breadcrumbs[i][j].pos = starts[j].origin;
if(IsDefined(starts[j].angles))
{
level._player_breadcrumbs[i][j].ang = starts[j].angles;
}
else
{
level._player_breadcrumbs[i][j].ang = (0,0,0);
}
}
}
}
set_breadcrumbs_player_positions()
{
if(!IsDefined(level._player_breadcrumbs))
{
maps\_callbackglobal::Player_BreadCrumb_Reset((0,0,0));
}
players = get_players();
for(i = 0; i < players.size; i++)
{
level._player_breadcrumbs[i][0].pos = players[i].origin;
level._player_breadcrumbs[i][0].ang = players[i].angles;
}
}
spread_array_thread( entities, process, var1, var2, var3 )
{
keys = getArrayKeys( entities );
if ( IsDefined( var3 ) )
{
for( i = 0 ; i < keys.size ; i++ )
{
entities[ keys[ i ] ] thread [[ process ]]( var1, var2, var3 );
wait_network_frame();
}
return;
}
if ( IsDefined( var2 ) )
{
for( i = 0 ; i < keys.size ; i++ )
{
entities[ keys[ i ] ] thread [[ process ]]( var1, var2 );
wait_network_frame();
}
return;
}
if ( IsDefined( var1 ) )
{
for( i = 0 ; i < keys.size ; i++ )
{
entities[ keys[ i ] ] thread [[ process ]]( var1 );
wait_network_frame();
}
return;
}
for( i = 0 ; i < keys.size ; i++ )
{
entities[ keys[ i ] ] thread [[ process ]]();
wait_network_frame();
}
}
simple_floodspawn( name, spawn_func, spawn_func_2 )
{
spawners = getEntArray( name, "targetname" );
assertex( spawners.size, "no spawners with targetname " + name + " found!" );
if( IsDefined( spawn_func ) )
{
for( i = 0; i < spawners.size; i++ )
{
spawners[i] add_spawn_function( spawn_func );
}
}
if( IsDefined( spawn_func_2 ) )
{
for( i = 0; i < spawners.size; i++ )
{
spawners[i] add_spawn_function( spawn_func_2 );
}
}
for( i = 0; i < spawners.size; i++ )
{
if( i % 2 )
{
wait_network_frame();
}
spawners[i] thread maps\_spawner::flood_spawner_init();
spawners[i] thread maps\_spawner::flood_spawner_think();
}
}
simple_spawn( name_or_spawners, spawn_func, param1, param2, param3, param4, param5 )
{
spawners = [];
if (IsString(name_or_spawners))
{
spawners = GetEntArray( name_or_spawners, "targetname" );
AssertEx( spawners.size, "no spawners with targetname " + name_or_spawners + " found!" );
}
else
{
if (IsArray(name_or_spawners))
{
spawners = name_or_spawners;
}
else
{
spawners[0] = name_or_spawners;
}
}
ai_array = [];
for( i = 0; i < spawners.size; i++ )
{
spawners[i].spawning = true;
if( i % 2 )
{
wait_network_frame();
}
ai = spawners[i] spawn_ai();
if(!spawn_failed( ai ))
{
if (IsDefined( spawn_func ))
{
single_thread(ai, spawn_func, param1, param2, param3, param4, param5);
}
ai_array = add_to_array( ai_array, ai );
}
spawners[i].spawning = undefined;
}
return ai_array;
}
simple_spawn_single( name_or_spawner, spawn_func, param1, param2, param3, param4, param5 )
{
if (IsString(name_or_spawner))
{
spawner = GetEnt( name_or_spawner, "targetname" );
AssertEx( IsDefined( spawner ), "no spawner with targetname " + name_or_spawner + " found!" );
}
else if (IsArray(name_or_spawner))
{
AssertMsg("simple_spawn_single cannot be used on an array of spawners. use simple_spawn instead.");
}
ai = simple_spawn(name_or_spawner, spawn_func, param1, param2, param3, param4, param5);
AssertEx( ai.size <= 1, "simple_spawn called from simple_spawn_single somehow spawned more than one guy!" );
if (ai.size)
{
return ai[0];
}
}
CanSpawnThink()
{
level.canSpawnInOneFrame = 3;
for(;;)
{
level.canSpawnCount = 0;
wait_network_frame();
}
}
CanSpawn()
{
if(!isdefined(level.canSpawnInOneFrame))
{
thread CanSpawnThink();
}
return true;
}
SpawnThrottleEnableThread()
{
level notify ("spawn_throttle_enable_thread_ender");
level endon ("spawn_throttle_enable_thread_ender");
if (isdefined(level.flag["all_players_connected"]))
{
flag_wait("all_players_connected");
level.spawnThrottleEnable = true;
}
}
SpawnThrottleEnable()
{
if(!isdefined(level.spawnThrottleEnable) || (isdefined(level.spawnThrottleEnable) && level.spawnThrottleEnable == false) )
{
level.spawnThrottleEnable = false;
thread SpawnThrottleEnableThread();
}
return level.spawnThrottleEnable;
}
DoSpawn(no_enemy_info, targetname)
{
if(SpawnThrottleEnable())
{
while(!CanSpawn())
{
wait_network_frame();
}
}
if(isdefined(level.canSpawnCount))
{
level.canSpawnCount += 1;
}
if(!IsDefined(no_enemy_info))
{
return self CodeSpawnerSpawn();
}
else if(!IsDefined(targetname))
{
return self CodeSpawnerSpawn(no_enemy_info);
}
else
{
return self CodeSpawnerSpawn(no_enemy_info, targetname);
}
}
StalingradSpawn(no_enemy_info, targetname)
{
if(SpawnThrottleEnable())
{
while(!CanSpawn())
{
wait_network_frame();
}
}
if(isdefined(level.canSpawnCount))
{
level.canSpawnCount += 1;
}
if(!IsDefined(no_enemy_info))
{
return self CodeSpawnerForceSpawn();
}
else if(!IsDefined(targetname))
{
return self CodeSpawnerForceSpawn(no_enemy_info);
}
else
{
return self CodeSpawnerForceSpawn(no_enemy_info, targetname);
}
}
Spawn(classname, origin, flags, radius, height, destructibledef)
{
if(SpawnThrottleEnable())
{
while(!CanSpawn())
{
wait_network_frame();
}
}
if(isdefined(level.canSpawnCount))
{
level.canSpawnCount += 1;
}
if(IsDefined(destructibledef))
{
return CodeSpawn(classname, origin, flags, radius, height, destructibledef);
}
else if(IsDefined(height))
{
return CodeSpawn(classname, origin, flags, radius, height);
}
else if(IsDefined(radius))
{
return CodeSpawn(classname, origin, flags, radius);
}
else if(IsDefined(flags))
{
return CodeSpawn(classname, origin, flags);
}
else
{
return CodeSpawn(classname, origin);
}
}
SpawnVehicle( modelname, targetname, vehicletype, origin, angles, destructibledef )
{
if(SpawnThrottleEnable())
{
while(!CanSpawn())
{
wait_network_frame();
}
}
if(isdefined(level.canSpawnCount))
{
level.canSpawnCount += 1;
}
assert(IsDefined(targetname));
assert(IsDefined(vehicletype));
assert(IsDefined(origin));
assert(IsDefined(angles));
if(IsDefined(destructibledef))
{
return CodeSpawnVehicle( modelname, targetname, vehicletype, origin, angles, destructibledef );
}
else
{
return CodeSpawnVehicle( modelname, targetname, vehicletype, origin, angles );
}
}
SpawnTurret( classname, origin, weaponinfoname )
{
if(SpawnThrottleEnable())
{
while(!CanSpawn())
{
wait_network_frame();
}
}
if(isdefined(level.canSpawnCount))
{
level.canSpawnCount += 1;
}
return CodeSpawnTurret(classname, origin, weaponinfoname);
}
PlayLoopedFX( effectid, repeat, position, cull, forward, up )
{
if(SpawnThrottleEnable())
{
while(!CanSpawn())
{
wait_network_frame();
}
}
if(isdefined(level.canSpawnCount))
{
level.canSpawnCount += 1;
}
if(IsDefined(up))
{
return CodePlayLoopedFX(effectid, repeat, position, cull, forward, up);
}
else if(IsDefined(forward))
{
return CodePlayLoopedFX(effectid, repeat, position, cull, forward);
}
else if(IsDefined(cull))
{
return CodePlayLoopedFX(effectid, repeat, position, cull);
}
else
{
return CodePlayLoopedFX(effectid, repeat, position);
}
}
SpawnFx( effect, position, forward, up )
{
if(SpawnThrottleEnable())
{
while(!CanSpawn())
{
wait_network_frame();
}
}
if(isdefined(level.canSpawnCount))
{
level.canSpawnCount += 1;
}
if(IsDefined(up))
{
return CodeSpawnFx(effect, position, forward, up);
}
else if(IsDefined(forward))
{
return CodeSpawnFx(effect, position, forward);
}
else
{
return CodeSpawnFx(effect, position);
}
}
spawn_model(model_name, origin, angles)
{
if (!IsDefined(origin))
{
origin = (0, 0, 0);
}
model = Spawn( "script_model", origin );
model SetModel( model_name );
if( IsDefined( angles ) )
{
model.angles = angles;
}
return model;
}
is_plane()
{
if(self.vehicleclass == "plane")
{
return true;
}
return false;
}
is_boat()
{
if(self.vehicleclass == "boat")
{
return true;
}
return false;
}
is_helicopter()
{
if(self.vehicleclass == "helicopter")
{
return true;
}
return false;
}
is_tank()
{
if(self.vehicleclass == "tank")
{
return true;
}
return false;
}
is_artillery()
{
if(self.vehicleclass == "artillery")
{
return true;
}
return false;
}
is_4wheel()
{
if(self.vehicleclass == "4 wheel")
{
return true;
}
return false;
}
is_vehicle()
{
return (IsDefined(self.classname) && (self.classname == "script_vehicle"));
}
go_path(path_start)
{
self maps\_vehicle::getonpath(path_start);
self maps\_vehicle::gopath();
}
disable_driver_turret()
{
self notify( "stop_turret_shoot");
}
enable_driver_turret()
{
self notify( "stop_turret_shoot");
self thread maps\_vehicle::turret_attack_think();
}
set_switch_node(src_node, dst_node)
{
assert(IsDefined(src_node));
assert(IsDefined(dst_node));
self.bSwitchingNodes = true;
self.dst_node = dst_node;
self SetSwitchNode(src_node, dst_node);
}
create_billboard()
{
level.billboardBlack = newHudElem();
level.billboardBlack.x = 268;
level.billboardBlack.y = 20;
level.billboardBlack.horzAlign = "fullscreen";
level.billboardBlack.vertAlign = "fullscreen";
level.billboardBlack.sort = 0;
level.billboardBlack.alpha = .3;
level.billboardBlack setShader("black", 120, 55);
level.billboardWhite = newHudElem();
level.billboardWhite.x = 270;
level.billboardWhite.y = 22;
level.billboardWhite.horzAlign = "fullscreen";
level.billboardWhite.vertAlign = "fullscreen";
level.billboardWhite.sort = 1;
level.billboardWhite.alpha = .3;
level.billboardWhite setShader("white", 116, 50);
level.billboardName = NewHudElem();
level.billboardName.alignX = "left";
level.billboardName.x = 260;
level.billboardName.y = 25;
level.billboardName.sort = 2;
level.billboardName.fontscale = 1.0;
level.billboardName.color = ( 0, 0, 0 );
level.billboardType = NewHudElem();
level.billboardType.alignX = "left";
level.billboardType.x = 260;
level.billboardType.y = 40;
level.billboardType.sort = 2;
level.billboardType.fontscale = 1.0;
level.billboardType.color = ( 0, 0, 0 );
level.billboardSize = NewHudElem();
level.billboardSize.alignX = "left";
level.billboardSize.x = 260;
level.billboardSize.y = 55;
level.billboardSize.sort = 2;
level.billboardSize.fontscale = 1.0;
level.billboardSize.color = ( 0, 0, 0 );
level.billboardName setText("Name: ");
level.billboardType setText( "Type:" );
level.billboardSize setText( "Size:" );
}
destroy_billboard()
{
assertEx( IsDefined( level.billboardName ), "No billboard is created call create_billboard" );
level.billboardBlack destroy();
level.billboardWhite destroy();
level.billboardName destroy();
level.billboardType destroy();
level.billboardSize destroy();
}
update_billboard( event_name, event_type, event_size, event_state, disable_fade )
{
assertEx( IsDefined( level.billboardName ), "No billboard is created call create_billboard" );
if( !IsDefined(event_name) )
{
event_name = "undefined";
}
if( !IsDefined(event_type) )
{
event_type = "undefined";
}
if( !IsDefined(event_size) )
{
event_size = "undefined";
}
color = "black";
for(i = 0; i < 10; i++)
{
if(color == "black")
{
level.billboardName.color = ( 1, 0, 0);
level.billboardType.color = ( 1, 0, 0 );
level.billboardSize.color = ( 1, 0, 0 );
color = "red";
}
else
{
level.billboardName.color = ( 0, 0, 0);
level.billboardType.color = ( 0, 0, 0 );
level.billboardSize.color = ( 0, 0, 0 );
color = "black";
}
wait(0.1);
}
level.billboardBlack.alpha = 1;
level.billboardWhite.alpha = 1;
if( IsDefined(event_state))
{
level.billboardName setText( "Name: " + event_name + " (" + event_state + ")" );
}
else
{
level.billboardName setText( "Name: " + event_name );
}
level.billboardType setText( "Type: " + event_type );
level.billboardSize setText( "Size: " + event_size );
wait(3);
if(IsDefined(disable_fade) && disable_fade)
{
return;
}
deltaT = 0.7 / 60;
for(i = 0; i < 60; i++)
{
level.billboardBlack.alpha -= deltaT;
level.billboardWhite.alpha -= deltaT;
wait(0.05);
}
}
heli_toggle_main_rotor_fx( alternate )
{
if(alternate)
{
self SetClientFlag(0);
}
else
{
self ClearClientFlag(0);
}
}
veh_toggle_tread_fx( on )
{
if(!on)
{
self SetClientFlag(6);
}
else
{
self ClearClientFlag(6);
}
}
veh_toggle_exhaust_fx( on )
{
if(!on)
{
self SetClientFlag(8);
}
else
{
self ClearClientFlag(8);
}
}
veh_toggle_lights( on )
{
if(on)
{
self SetClientFlag(10);
}
else
{
self ClearClientFlag(10);
}
}
heli_toggle_rotor_fx( on )
{
if(!on)
{
self SetClientFlag(1);
}
else
{
self ClearClientFlag(1);
}
}
vehicle_toggle_sounds( on )
{
if(!on)
{
self SetClientFlag(2);
}
else
{
self ClearClientFlag(2);
}
}
spawn_manager_set_global_active_count( cnt )
{
AssertEx( cnt <= 32, "Max number of Active AI at a given time cant be more than 32" );
level.spawn_manager_max_ai = cnt;
}
sm_use_trig_when_complete( spawn_manager_targetname, trig_name, trig_key, once_only )
{
self thread sm_use_trig_when_complete_internal( spawn_manager_targetname, trig_name, trig_key, once_only );
}
sm_use_trig_when_complete_internal( spawn_manager_targetname, trig_name, trig_key, once_only )
{
if(IsDefined(once_only) && once_only )
{
trigger = GetEnt(trig_name, trig_key);
AssertEX(IsDefined(trigger), "The trigger " + trig_key + " / " + trig_name + " does not exist.");
trigger endon("trigger");
}
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
flag_wait("sm_" + spawn_manager_targetname + "_complete");
trigger_use(trig_name, trig_key);
}
else
{
AssertMsg("sm_use_trig_when_complete: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
sm_use_trig_when_cleared( spawn_manager_targetname, trig_name, trig_key, once_only )
{
self thread sm_use_trig_when_cleared_internal( spawn_manager_targetname, trig_name, trig_key, once_only );
}
sm_use_trig_when_cleared_internal( spawn_manager_targetname, trig_name, trig_key, once_only )
{
if(IsDefined(once_only) && once_only )
{
trigger = GetEnt(trig_name, trig_key);
AssertEX(IsDefined(trigger), "The trigger " + trig_key + " / " + trig_name + " does not exist.");
trigger endon("trigger");
}
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
flag_wait("sm_" + spawn_manager_targetname + "_cleared");
trigger_use(trig_name, trig_key);
}
else
{
AssertMsg("sm_use_trig_when_cleared: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
sm_use_trig_when_enabled( spawn_manager_targetname, trig_name, trig_key, once_only )
{
self thread sm_use_trig_when_enabled_internal( spawn_manager_targetname, trig_name, trig_key, once_only );
}
sm_use_trig_when_enabled_internal( spawn_manager_targetname, trig_name, trig_key, once_only )
{
if(IsDefined(once_only) && once_only )
{
trigger = GetEnt(trig_name, trig_key);
AssertEX(IsDefined(trigger), "The trigger " + trig_key + " / " + trig_name + " does not exist.");
trigger endon("trigger");
}
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
flag_wait("sm_" + spawn_manager_targetname + "_enabled");
trigger_use(trig_name, trig_key);
}
else
{
AssertMsg("sm_use_trig_when_cleared: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
sm_run_func_when_complete( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 )
{
self thread sm_run_func_when_complete_internal( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 );
}
sm_run_func_when_complete_internal( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 )
{
AssertEx(IsDefined(process), "sm_run_func_when_complete: the function is not defined");
AssertEx(level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ), "sm_run_func_when_complete: Spawn manager '" + spawn_manager_targetname + "' not found.");
waittill_spawn_manager_complete( spawn_manager_targetname );
single_func(ent, process, var1, var2, var3, var4, var5);
}
sm_run_func_when_cleared( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 )
{
self thread sm_run_func_when_cleared_internal( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 );
}
sm_run_func_when_cleared_internal( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 )
{
AssertEx(IsDefined(process), "sm_run_func_when_cleared: the function is not defined");
AssertEx(level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ), "sm_run_func_when_cleared: Spawn manager '" + spawn_manager_targetname + "' not found.");
waittill_spawn_manager_cleared(spawn_manager_targetname);
single_func(ent, process, var1, var2, var3, var4, var5);
}
sm_run_func_when_enabled( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 )
{
self thread sm_run_func_when_enabled_internal( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 );
}
sm_run_func_when_enabled_internal( spawn_manager_targetname, process, ent, var1, var2, var3, var4, var5 )
{
AssertEx(IsDefined(process), "sm_run_func_when_enabled: the function is not defined");
AssertEx(level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ), "sm_run_func_when_enabled: Spawn manager '" + spawn_manager_targetname + "' not found.");
waittill_spawn_manager_enabled( spawn_manager_targetname );
single_func(ent, process, var1, var2, var3, var4, var5);
}
spawn_manager_enable( spawn_manager_targetname, no_assert )
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
for (i = 0; i < level.spawn_managers.size; i++)
{
if (level.spawn_managers[i].sm_id == spawn_manager_targetname)
{
level.spawn_managers[i] notify("enable");
return;
}
}
}
else if (!is_true(no_assert))
{
AssertMsg("spawn_manager_enable: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
spawn_manager_disable( spawn_manager_targetname, no_assert )
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
for( i = 0; i < level.spawn_managers.size; i++ )
{
if( level.spawn_managers[i].sm_id == spawn_manager_targetname )
{
level.spawn_managers[i] notify("disable");
return;
}
}
}
else if (!is_true(no_assert))
{
AssertMsg("spawn_manager_disable: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
spawn_manager_kill( spawn_manager_targetname, no_assert )
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
for( i = 0; i < level.spawn_managers.size; i++ )
{
if( level.spawn_managers[i].sm_id == spawn_manager_targetname )
{
level.spawn_managers[i] notify("kill");
return;
}
}
}
else if (!is_true(no_assert))
{
AssertMsg("spawn_manager_kill: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
is_spawn_manager_enabled( spawn_manager_targetname )
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
if( flag( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
return true;
}
return false;
}
else
{
AssertMsg("is_spawn_manager_enabled: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
is_spawn_manager_complete( spawn_manager_targetname )
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
if( flag( "sm_" + spawn_manager_targetname + "_complete" ) )
{
return true;
}
return false;
}
else
{
AssertMsg("is_spawn_manager_complete: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
is_spawn_manager_cleared( spawn_manager_targetname )
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
if( flag( "sm_" + spawn_manager_targetname + "_cleared" ) )
{
return true;
}
return false;
}
else
{
AssertMsg("is_spawn_manager_cleared: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
is_spawn_manager_killed( spawn_manager_targetname )
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
if( flag( "sm_" + spawn_manager_targetname + "_killed" ) )
{
return true;
}
return false;
}
else
{
AssertMsg("is_spawn_manager_killed: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
waittill_spawn_manager_cleared(spawn_manager_targetname)
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
flag_wait("sm_" + spawn_manager_targetname + "_cleared");
}
else
{
AssertMsg("waittill_spawn_manager_cleared: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
waittill_spawn_manager_ai_remaining(spawn_manager_targetname, count_to_reach)
{
AssertEX( IsDefined(count_to_reach), "# of AI remaining not specified in _utility::waittill_spawn_manager_ai_remaining()");
AssertEX( count_to_reach, "# of AI remaining specified in _utility::waittill_spawn_manager_ai_remaining() is 0, use waittill_spawn_manager_cleared" );
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
flag_wait("sm_" + spawn_manager_targetname + "_complete");
}
else
{
AssertMsg("waittill_spawn_manager_ai_remaining: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
if( flag( "sm_" + spawn_manager_targetname + "_cleared" ) )
{
return;
}
spawn_manager = maps\_spawn_manager::get_spawn_manager_array( spawn_manager_targetname );
AssertEx( spawn_manager.size, "Somehow the spawn manager doesnt exist, but related flag existed before." );
AssertEx( ( spawn_manager.size == 1 ), "Found two spawn managers with same targetname." );
while( ( IsDefined( spawn_manager[0] ) ) && ( spawn_manager[0].activeAI.size > count_to_reach ) )
{
wait(0.1);
}
}
waittill_spawn_manager_complete(spawn_manager_targetname)
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
flag_wait("sm_" + spawn_manager_targetname + "_complete");
}
else
{
AssertMsg("waittill_spawn_manager_complete: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
waittill_spawn_manager_enabled(spawn_manager_targetname)
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
flag_wait("sm_" + spawn_manager_targetname + "_enabled");
}
else
{
AssertMsg("waittill_spawn_manager_enabled: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
}
waittill_spawn_manager_spawned_count( spawn_manager_targetname, count )
{
if( level flag_exists( "sm_" + spawn_manager_targetname + "_enabled" ) )
{
flag_wait("sm_" + spawn_manager_targetname + "_enabled");
}
else
{
AssertMsg("waittill_spawn_manager_spawned_count: Spawn manager '" + spawn_manager_targetname + "' not found.");
}
spawn_manager = maps\_spawn_manager::get_spawn_manager_array( spawn_manager_targetname );
AssertEx( spawn_manager.size, "Somehow the spawn manager doesnt exist, but related flag existed before." );
AssertEx( ( spawn_manager.size == 1 ), "Found two spawn managers with same targetname." );
Assert( spawn_manager[0].count > count, "waittill_spawn_manager_spawned_count : Count should be less than total count on the spawn manager." );
original_count = spawn_manager[0].count;
while(1)
{
if( IsDefined( spawn_manager[0].spawnCount ) && ( spawn_manager[0].spawnCount < count ) && !is_spawn_manager_killed( spawn_manager_targetname ) )
{
wait(0.5);
}
else
{
break;
}
}
return;
}
contextual_melee(melee_name, which_set)
{
self maps\_contextual_melee::main(melee_name, which_set);
}
add_meatshield_target(meatshield, scripted)
{
maps\_meatshield::add_target(meatshield, scripted);
}
add_meatshield_angle_limits(guy, leftarc, rightarc)
{
maps\_meatshield::add_angle_limits( guy, leftarc, rightarc );
}
veh_magic_bullet_shield( on )
{
assertex(!IsAI(self), "This is for vehicles, please use magic_bullet_shield for AI.");
assertex(!IsPlayer(self), "This is for vehicles, please use magic_bullet_shield for players.");
if(!on)
{
self maps\_vehicle::godoff();
}
else
{
self maps\_vehicle::godon();
}
}
OnFirstPlayerConnect_Callback(func)
{
maps\_callbackglobal::AddCallback("on_first_player_connect", func);
}
OnFirstPlayerConnect_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_first_player_connect", func);
}
OnPlayerConnect_Callback(func)
{
maps\_callbackglobal::AddCallback("on_player_connect", func);
}
OnPlayerConnect_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_player_connect", func);
}
OnPlayerDisconnect_Callback(func)
{
maps\_callbackglobal::AddCallback("on_player_disconnect", func);
}
OnPlayerDisconnect_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_player_disconnect", func);
}
OnPlayerDamage_Callback(func)
{
maps\_callbackglobal::AddCallback("on_player_damage", func);
}
OnPlayerDamage_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_player_damage", func);
}
OnPlayerLastStand_Callback(func)
{
maps\_callbackglobal::AddCallback("on_player_last_stand", func);
}
OnPlayerLastStand_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_player_last_stand", func);
}
OnPlayerKilled_Callback(func)
{
maps\_callbackglobal::AddCallback("on_player_killed", func);
}
OnPlayerKilled_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_player_killed", func);
}
OnActorDamage_Callback(func)
{
maps\_callbackglobal::AddCallback("on_actor_damage", func);
}
OnActorDamage_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_actor_damage", func);
}
OnActorKilled_Callback(func)
{
maps\_callbackglobal::AddCallback("on_actor_killed", func);
}
OnActorKilled_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_actor_killed", func);
}
OnVehicleDamage_Callback(func)
{
maps\_callbackglobal::AddCallback("on_vehicle_damage", func);
}
OnVehicleDamage_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_vehicle_damage", func);
}
OnSaveRestored_Callback(func)
{
maps\_callbackglobal::AddCallback("on_save_restored", func);
}
OnSaveRestored_CallbackRemove(func)
{
maps\_callbackglobal::RemoveCallback("on_save_restored", func);
}
aim_at_target(target, duration)
{
self endon("death");
self endon("stop_aim_at_target");
assert( IsDefined(target) );
if( !IsDefined(target) )
{
return;
}
self SetEntityTarget( target );
self.a.allow_shooting = false;
if( IsDefined(duration) && duration > 0 )
{
elapsed = 0;
while( elapsed < duration )
{
elapsed += 0.05;
wait(0.05);
}
stop_aim_at_target();
}
}
stop_aim_at_target()
{
self ClearEntityTarget();
self.a.allow_shooting = true;
self notify("stop_aim_at_target");
}
shoot_at_target(target, tag, fireDelay, duration)
{
self endon("death");
self endon("stop_shoot_at_target");
assert( IsDefined(target) );
if( !IsDefined(target) )
{
return;
}
if( IsDefined(tag) && tag != "" && tag != "tag_eye" && tag != "tag_head" )
{
self SetEntityTarget( target, 1, tag );
}
else
{
self SetEntityTarget( target );
}
self animscripts\weaponList::RefillClip();
if( IsDefined(fireDelay) && fireDelay > 0 )
{
self.a.allow_shooting = false;
wait( fireDelay );
}
self.a.allow_shooting = true;
self.cansee_override = true;
self call_overloaded_func( "animscripts\shoot_behavior", "setShootEnt", target );
self waittill("shoot");
if( IsDefined(duration) )
{
if( duration > 0)
{
elapsed = 0;
while( elapsed < duration )
{
elapsed += 0.05;
wait(0.05);
}
}
else if (duration == -1)
{
target waittill("death");
}
}
stop_shoot_at_target();
}
shoot_at_target_untill_dead(target, tag, fireDelay)
{
shoot_at_target(target, tag, fireDelay, -1);
}
stop_shoot_at_target()
{
self ClearEntityTarget();
self.cansee_override = false;
self notify("stop_shoot_at_target");
}
add_trigger_to_ent(ent)
{
if(!IsDefined(ent._triggers))
{
ent._triggers = [];
}
ent._triggers[self GetEntityNumber()] = 1;
}
remove_trigger_from_ent(ent)
{
if(!IsDefined(ent._triggers))
return;
if(!IsDefined(ent._triggers[self GetEntityNumber()]))
return;
ent._triggers[self GetEntityNumber()] = 0;
}
ent_already_in_trigger(trig)
{
if(!IsDefined(self._triggers))
return false;
if(!IsDefined(self._triggers[trig GetEntityNumber()]))
return false;
if(!self._triggers[trig GetEntityNumber()])
return false;
return true;
}
trigger_thread(ent, on_enter_payload, on_exit_payload)
{
ent endon("entityshutdown");
ent endon("death");
if(ent ent_already_in_trigger(self))
return;
self add_trigger_to_ent(ent);
endon_condition = "leave_trigger_" + self GetEntityNumber();
if(IsDefined(on_enter_payload))
{
self thread [[on_enter_payload]](ent, endon_condition);
}
while(IsDefined(ent) && ent IsTouching(self))
{
wait(0.01);
}
ent notify(endon_condition);
if(IsDefined(ent) && IsDefined(on_exit_payload))
{
self thread [[on_exit_payload]](ent);
}
if(IsDefined(ent))
{
self remove_trigger_from_ent(ent);
}
}
set_swimming_depth_of_field( toggle, set_values, near_start, near_end, far_start, far_end, near_blur, far_blur)
{
AssertEx(IsDefined(toggle), "toggle must be set to true or false");
if(toggle)
{
level._swimming.toggle_depth_of_field = true;
if(IsDefined(set_values) && set_values)
{
AssertEx(IsDefined(near_start), "Depth of Field value near_start undefined");
AssertEx(IsDefined(near_end), "Depth of Field value near_end undefined");
AssertEx(IsDefined(far_start), "Depth of Field value far_start undefined");
AssertEx(IsDefined(far_end), "Depth of Field value far_end undefined");
AssertEx(IsDefined(near_blur), "Depth of Field value near_blur undefined");
AssertEx(IsDefined(far_blur), "Depth of Field value far_blur undefined");
AssertEx(near_start < near_end, "Depth of Field value near_start must be < near_end");
AssertEx(far_start < far_end, "Depth of Field value far_start must be < far_end");
level._swimming.dof_near_start = near_start;
level._swimming.dof_near_end = near_end;
level._swimming.dof_far_start = far_start;
level._swimming.dof_far_end = far_end;
level._swimming.dof_near_blur = near_blur;
level._swimming.dof_far_blur = far_blur;
}
}
else if(!toggle)
{
level._swimming.toggle_depth_of_field = false;
}
}
disable_swimming()
{
self maps\_swimming::disable();
}
enable_swimming()
{
self maps\_swimming::enable();
}
hide_swimming_arms()
{
self ClientNotify("_swimming:hide_arms");
}
show_swimming_arms()
{
self ClientNotify("_swimming:show_arms");
}
delete_ents( mask, origin, radius )
{
ents = entsearch( mask, origin, radius );
for( i = 0; i < ents.size; i++ )
{
ents[i] delete();
}
}
set_drop_weapon(weapon_name)
{
AssertEx(IsDefined(weapon_name) && IsString(weapon_name), "_utility::set_drop_weapon: Invalid weapon name!");
self.script_dropweapon = weapon_name;
}
take_and_giveback_weapons(mynotify, no_autoswitch)
{
take_weapons();
self waittill (mynotify);
give_weapons(no_autoswitch);
}
take_weapons()
{
self.curweapon = self GetCurrentWeapon();
self.weapons_list = self GetWeaponsList();
self.offhand = self GetCurrentOffhand();
weapon_list_modified = [];
for ( i = 0; i < self.weapons_list.size; i++)
{
if( !is_weapon_attachment( self.weapons_list[i] ) )
weapon_list_modified[ weapon_list_modified.size ] = self.weapons_list[i];
}
self.weapons_list = weapon_list_modified;
if( is_weapon_attachment( self.curweapon ) )
{
self.curweapon = get_baseweapon_for_attachment( self.curweapon );
}
self.weapons_info = [];
for ( i = 0; i < self.weapons_list.size; i++)
{
self.weapons_info[i] = SpawnStruct();
if (IsDefined(self.offhand) && self.weapons_list[i] == self.offhand )
{
self.weapons_info[i]._ammo = 0;
self.weapons_info[i]._stock = self GetWeaponAmmoStock(self.weapons_list[i]);
}
else
{
self.weapons_info[i]._ammo = self GetWeaponAmmoClip(self.weapons_list[i]);
self.weapons_info[i]._stock = self GetWeaponAmmoStock(self.weapons_list[i]);
self.weapons_info[i]._renderOptions = self GetWeaponRenderOptions( self.weapons_list[i] );
}
}
self TakeAllWeapons();
}
give_weapons(no_autoswitch)
{
for (i=0; i < self.weapons_list.size; i++)
{
if( IsDefined( self.weapons_info[i]._renderOptions ) )
{
self GiveWeapon(self.weapons_list[i], 0, self.weapons_info[i]._renderOptions );
}
else
{
self GiveWeapon(self.weapons_list[i]);
}
self SetWeaponAmmoClip(self.weapons_list[i], self.weapons_info[i]._ammo);
self SetWeaponAmmoStock(self.weapons_list[i], self.weapons_info[i]._stock );
}
self.weapons_info = undefined;
if( IsDefined( self.curweapon ) && self.curweapon != "none" && !IsDefined(no_autoswitch) )
{
self SwitchToWeapon(self.curweapon);
}
}
is_weapon_attachment( weapon_name )
{
weapon_pieces = StrTok(weapon_name, "_");
if( weapon_pieces[0] == "ft" || weapon_pieces[0] == "mk" || weapon_pieces[0] == "gl" )
{
return true;
}
return false;
}
get_baseweapon_for_attachment( weapon_name )
{
Assert( is_weapon_attachment( weapon_name ) );
weapon_pieces = StrTok( weapon_name, "_" );
attachment = weapon_pieces[0];
Assert( weapon_pieces[0] == "ft" || weapon_pieces[0] == "mk" || weapon_pieces[0] == "gl" || weapon_pieces[0] == "db" );
weapon = weapon_pieces[1];
Assert( weapon_pieces[1] != "ft" && weapon_pieces[1] != "mk" && weapon_pieces[1] != "gl" && weapon_pieces[1] != "db" );
for ( i = 0; i < self.weapons_list.size; i++)
{
if( IsSubStr( self.weapons_list[i], weapon ) && IsSubStr( self.weapons_list[i], attachment ) )
return self.weapons_list[i];
}
return self.weapons_list[0];
}
set_near_plane(val)
{
self SetClientDvar("r_znear", val);
}
reset_near_plane()
{
self SetClientDvar("r_znear", 4);
}
average_origin( ent_array )
{
AssertEx( IsArray(ent_array), "_utility::average_position passed a non-array" );
AssertEx( ent_array.size > 0, "_utility::average_position passed a size zero array");
if(IsVec(ent_array[0]))
{
return(average_origin_internal( ent_array ));
}
org_array = [];
for(i=0; i<ent_array.size; i++)
{
org_array[i] = ent_array[i].origin;
}
return(average_origin_internal( org_array ));
}
average_origin_internal( org_array )
{
if(org_array.size == 1)
{
return org_array[0];
}
pos = (0,0,0);
for( i=0; i < org_array.size; i++ )
{
pos += org_array[i];
}
avg_pos = pos / org_array.size;
return avg_pos;
}
screen_message_create( string_message_1, string_message_2, string_message_3 )
{
if( IsDefined( level.missionfailed ) && level.missionfailed )
return;
if( GetDvarInt( "hud_missionFailed" ) == 1 )
return;
if( !IsDefined(level._screen_message_1) )
{
level._screen_message_1 = NewHudElem();
level._screen_message_1.elemType = "font";
level._screen_message_1.font = "objective";
level._screen_message_1.fontscale = 1.8;
level._screen_message_1.horzAlign = "center";
level._screen_message_1.vertAlign = "middle";
level._screen_message_1.alignX = "center";
level._screen_message_1.alignY = "middle";
level._screen_message_1.y = -60;
level._screen_message_1.sort = 2;
level._screen_message_1.color = ( 1, 1, 1 );
level._screen_message_1.alpha = 0.70;
level._screen_message_1.hidewheninmenu = true;
}
level._screen_message_1 SetText( string_message_1 );
if( IsDefined(string_message_2) )
{
if( !IsDefined(level._screen_message_2) )
{
level._screen_message_2 = NewHudElem();
level._screen_message_2.elemType = "font";
level._screen_message_2.font = "objective";
level._screen_message_2.fontscale = 1.8;
level._screen_message_2.horzAlign = "center";
level._screen_message_2.vertAlign = "middle";
level._screen_message_2.alignX = "center";
level._screen_message_2.alignY = "middle";
level._screen_message_2.y = -33;
level._screen_message_2.sort = 2;
level._screen_message_2.color = ( 1, 1, 1 );
level._screen_message_2.alpha = 0.70;
level._screen_message_2.hidewheninmenu = true;
}
level._screen_message_2 SetText( string_message_2 );
}
else if( IsDefined(level._screen_message_2) )
{
level._screen_message_2 Destroy();
}
if( IsDefined(string_message_3) )
{
if( !IsDefined(level._screen_message_3) )
{
level._screen_message_3 = NewHudElem();
level._screen_message_3.elemType = "font";
level._screen_message_3.font = "objective";
level._screen_message_3.fontscale = 1.8;
level._screen_message_3.horzAlign = "center";
level._screen_message_3.vertAlign = "middle";
level._screen_message_3.alignX = "center";
level._screen_message_3.alignY = "middle";
level._screen_message_3.y = -6;
level._screen_message_3.sort = 2;
level._screen_message_3.color = ( 1, 1, 1 );
level._screen_message_3.alpha = 0.70;
level._screen_message_3.hidewheninmenu = true;
}
level._screen_message_3 SetText( string_message_3 );
}
else if( IsDefined(level._screen_message_3) )
{
level._screen_message_3 Destroy();
}
}
screen_message_delete()
{
if( IsDefined(level._screen_message_1) )
{
level._screen_message_1 Destroy();
}
if( IsDefined(level._screen_message_2) )
{
level._screen_message_2 Destroy();
}
if( IsDefined(level._screen_message_3) )
{
level._screen_message_3 Destroy();
}
}
get_eye()
{
if (IsPlayer(self))
{
linked_ent = self GetLinkedEnt();
if (IsDefined(linked_ent) && (GetDvarInt( #"cg_cameraUseTagCamera") > 0))
{
camera = linked_ent GetTagOrigin("tag_camera");
if (IsDefined(camera))
{
return camera;
}
}
}
pos = self GetEye();
return pos;
}
vehicle_node_wait( strName, strKey )
{
if( !IsDefined( strKey ) )
{
strKey = "targetname";
}
nodes = GetVehicleNodeArray( strName, strKey );
AssertEX( IsDefined(nodes) && nodes.size > 0, "_utility::vehicle_node_wait - vehicle node not found: " + strName + " key: " + strKey );
ent = SpawnStruct();
array_thread( nodes, common_scripts\utility::trigger_wait_think, ent );
ent waittill( "trigger", eOther, node_hit );
level notify( strName, eOther );
if(IsDefined(node_hit))
{
node_hit.who = eother;
return node_hit;
}
else
{
return eOther;
}
}
timescale_tween(start, end, time, delay, step_time)
{
DEFAULT_STEP_TIME = .1;
if (!IsDefined(step_time))
{
step_time = DEFAULT_STEP_TIME;
}
num_steps = time / step_time;
time_scale_range = end - start;
time_scale_step = 0;
if (num_steps > 0)
{
time_scale_step = abs(time_scale_range) / num_steps;
}
if (IsDefined(delay))
{
wait delay;
}
level notify("timescale_tween");
level endon("timescale_tween");
time_scale = start;
SetTimeScale(time_scale);
while (time_scale != end)
{
wait(step_time);
if (time_scale_range > 0)
{
time_scale = min(time_scale + time_scale_step, end);
}
else if (time_scale_range < 0)
{
time_scale = max(time_scale - time_scale_step, end);
}
SetTimeScale(time_scale);
}
}
player_seek( delayed )
{
self endon("death");
self.ignoresuppression = 1;
if( IsDefined( self.target ) || IsDefined( self.script_spawner_targets ) )
{
self waittill("goal");
}
while(1)
{
if( IsDefined( delayed ) )
{
wait( RandomIntRange( 6, 12 ) );
}
else
{
wait( 0.05 );
}
if( self.goalradius > 100 )
{
self.goalradius = self.goalradius - 100;
}
self.pathenemyFightdist = self.goalradius;
closest_player = get_closest_player( self.origin );
self SetGoalEntity( closest_player );
self animscripts\combat_utility::FindCoverNearSelf();
}
}
set_spawner_targets(spawner_targets)
{
self thread maps\_spawner::go_to_spawner_target(StrTok(spawner_targets," "));
}
ragdoll_death()
{
self animscripts\utility::do_ragdoll_death();
}
is_destructible()
{
if (!IsDefined(self.script_noteworthy))
{
return false;
}
switch (self.script_noteworthy)
{
case "explodable_barrel":
return true;
}
return false;
}
register_overloaded_func( filename, funcname, func )
{
if ( !isDefined( level._overloaded_funcs ) )
{
level._overloaded_funcs = [];
}
if ( !isDefined( level._overloaded_funcs[filename] ) )
{
level._overloaded_funcs[filename] = [];
}
if ( isDefined( level._overloaded_funcs[filename][funcname] ) )
{
error( "Tried to call register_overloaded_func() on a previously registered filename['" + filename + "']/funcname['" + funcname + "'] combination." );
return;
}
level._overloaded_funcs[filename][funcname] = func;
}
call_overloaded_func( filename, funcname, var1, var2, var3, var4, var5 )
{
if ( !isDefined( level._overloaded_funcs ) )
{
if ( GetDvar( #"zombiemode" ) == "1" )
{
println( "call_overloaded_func: no overloaded_funcs registered." );
}
else
{
assertex( false, "call_overloaded_func: no overloaded_funcs registered." );
}
return false;
}
if ( !isDefined( level._overloaded_funcs[filename] ) )
{
if ( GetDvar( #"zombiemode" ) == "1" )
{
println( "call_overloaded_func: no overloaded_funcs registered for filename: '" + filename + "'." );
}
else
{
assertex( false, "call_overloaded_func: no overloaded_funcs registered for filename: '" + filename + "'." );
}
return false;
}
if ( !isDefined( level._overloaded_funcs[filename][funcname] ) )
{
if ( GetDvar( #"zombiemode" ) == "1" )
{
println( "call_overloaded_func: no overloaded_func registered for filename['" + filename + "']/funcname['" + funcname + "'] combination." );
}
else
{
assertex( false, "call_overloaded_func: no overloaded_func registered for filename['" + filename + "']/funcname['" + funcname + "'] combination." );
}
return false;
}
if ( IsDefined( var5 ) )
{
return self [[ level._overloaded_funcs[filename][funcname] ]]( var1, var2, var3, var4, var5 );
}
if ( IsDefined( var4 ) )
{
return self [[ level._overloaded_funcs[filename][funcname] ]]( var1, var2, var3, var4 );
}
if ( IsDefined( var3 ) )
{
return self [[ level._overloaded_funcs[filename][funcname] ]]( var1, var2, var3 );
}
if ( IsDefined( var2 ) )
{
return self [[ level._overloaded_funcs[filename][funcname] ]]( var1, var2 );
}
if ( IsDefined( var1 ) )
{
return self [[ level._overloaded_funcs[filename][funcname] ]]( var1 );
}
return self [[ level._overloaded_funcs[filename][funcname] ]]();
}
get_overloaded_func( filename, funcname )
{
if ( !isDefined( level._overloaded_funcs ) )
{
if ( GetDvar( #"zombiemode" ) == "1" )
{
println( "get_overloaded_func: no overloaded_funcs registered." );
}
else
{
assertex( false, "get_overloaded_func: no overloaded_funcs registered." );
}
return false;
}
if ( !isDefined( level._overloaded_funcs[filename] ) )
{
if ( GetDvar( #"zombiemode" ) == "1" )
{
println( "get_overloaded_func: no overloaded_funcs registered for filename: '" + filename + "'." );
}
else
{
assertex( false, "get_overloaded_func: no overloaded_funcs registered for filename: '" + filename + "'." );
}
return false;
}
if ( !isDefined( level._overloaded_funcs[filename][funcname] ) )
{
if ( GetDvar( #"zombiemode" ) == "1" )
{
println( "get_overloaded_func: no overloaded_func registered for filename['" + filename + "']/funcname['" + funcname + "'] combination." );
}
else
{
assertex( false, "get_overloaded_func: no overloaded_func registered for filename['" + filename + "']/funcname['" + funcname + "'] combination." );
}
return false;
}
return level._overloaded_funcs[filename][funcname];
}
waittill_not_moving()
{
self endon("death");
self endon( "disconnect" );
self endon( "detonated" );
level endon( "game_ended" );
prevorigin = self.origin;
while(1)
{
wait .15;
if ( self.origin == prevorigin )
break;
prevorigin = self.origin;
}
}
turn_off_friendly_player_look()
{
level._dont_look_at_player = true;
}
turn_on_friendly_player_look()
{
level._dont_look_at_player = false;
}
force_goal(node_or_org, radius, shoot, end_on, keep_colors)
{
self endon("death");
goalradius = self.goalradius;
if (IsDefined(radius))
{
self.goalradius = radius;
}
color_enabled = false;
if (!is_true(keep_colors))
{
if (IsDefined(get_force_color()))
{
color_enabled = true;
self disable_ai_color();
}
}
allowpain = self.allowpain;
allowreact = self.allowreact;
ignoreall = self.ignoreall;
ignoreme = self.ignoreme;
dontshootwhilemoving = self.dontshootwhilemoving;
ignoresuppression = self.ignoresuppression;
suppressionthreshold = self.suppressionthreshold;
nododgemove = self.nododgemove;
grenadeawareness = self.grenadeawareness;
pathenemylookahead = self.pathenemylookahead;
pathenemyfightdist = self.pathenemyfightdist;
meleeattackdist = self.meleeattackdist;
fixednodesaferadius = self.fixednodesaferadius;
if (is_false(shoot))
{
self set_ignoreall(true);
}
self.dontshootwhilemoving = undefined;
self.pathenemyfightdist = 0;
self.pathenemylookahead = 0;
self.ignoresuppression = true;
self.suppressionthreshold = 1;
self.nododgemove = true;
self.grenadeawareness = 0;
self.meleeattackdist = 0;
self.fixednodesaferadius = 0;
if ( GetDvar( #"zombiemode" ) != "1" )
{
self set_ignoreme(true);
self disable_react();
self disable_pain();
}
self PushPlayer(true);
if (IsDefined(node_or_org))
{
if (IsVec(node_or_org))
{
self set_goal_pos(node_or_org);
}
else
{
self set_goal_node(node_or_org);
}
}
if (IsDefined(end_on))
{
self waittill(end_on);
}
else
{
self waittill("goal");
}
if (color_enabled)
{
enable_ai_color();
}
self PushPlayer(false);
if ( GetDvar( #"zombiemode" ) == "1" )
{
if (IsDefined(radius))
{
self.goalradius = goalradius;
}
}
else
{
self.goalradius = goalradius;
self set_ignoreall(ignoreall);
self set_ignoreme(ignoreme);
if (allowpain)
{
self enable_pain();
}
if (allowreact)
{
self enable_react();
}
}
self.ignoresuppression = ignoresuppression;
self.suppressionthreshold = suppressionthreshold;
self.nododgemove = nododgemove;
self.dontshootwhilemoving = dontshootwhilemoving;
self.grenadeawareness = grenadeawareness;
self.pathenemylookahead = pathenemylookahead;
self.pathenemyfightdist = pathenemyfightdist;
self.meleeattackdist = meleeattackdist;
self.fixednodesaferadius = fixednodesaferadius;
}
restore_ik_headtracking_limits()
{
SetSavedDvar("ik_pitch_limit_thresh", 10);
SetSavedDvar("ik_pitch_limit_max", 60);
SetSavedDvar("ik_roll_limit_thresh", 30);
SetSavedDvar("ik_roll_limit_max", 100);
SetSavedDvar("ik_yaw_limit_thresh", 10);
SetSavedDvar("ik_yaw_limit_max", 90);
}
relax_ik_headtracking_limits()
{
SetSavedDvar("ik_pitch_limit_thresh", 110);
SetSavedDvar("ik_pitch_limit_max", 120);
SetSavedDvar("ik_roll_limit_thresh", 90);
SetSavedDvar("ik_roll_limit_max", 100);
SetSavedDvar("ik_yaw_limit_thresh", 80);
SetSavedDvar("ik_yaw_limit_max", 90);
}
do_notetracks(flag)
{
self animscripts\shared::DoNoteTracks(flag);
}
rumble_delay(delay, rumble)
{
wait delay;
self PlayRumbleOnEntity(rumble);
}
enable_random_weapon_drops()
{
level.rw_enabled = true;
}
disable_random_weapon_drops()
{
level.rw_enabled = false;
}
enable_random_alt_weapon_drops()
{
level.rw_attachments_allowed = true;
}
disable_random_alt_weapon_drops()
{
level.rw_attachments_allowed = false;
}
set_random_alt_weapon_drops( attachment_abbreviation, on_or_off )
{
AssertEX(IsDefined(attachment_abbreviation), "set_random_alt_weapon_drops called without passing in an attachment type");
AssertEX(IsDefined(on_or_off), "set_random_alt_weapon_drops called without telling the function whether it is on or off");
switch( attachment_abbreviation )
{
case "ft":
level.rw_ft_allowed = on_or_off;
break;
case "gl":
level.rw_gl_allowed = on_or_off;
break;
case "mk":
level.rw_mk_allowed = on_or_off;
break;
default:
AssertEX(false, "Weapon of type: " + attachment_abbreviation + " is not a valid attachment abbreviation." );
break;
}
}
button_held_think(which_button)
{
self endon("disconnect");
if (!IsDefined(self._holding_button))
{
self._holding_button = [];
}
self._holding_button[which_button] = false;
time_started = 0;
use_time = GetDvarInt("g_useholdtime");
while(1)
{
if(self._holding_button[which_button])
{
if(!self [[level._button_funcs[which_button]]]())
{
self._holding_button[which_button] = false;
}
}
else
{
if(self [[level._button_funcs[which_button]]]())
{
if(time_started == 0)
{
time_started = GetTime();
}
if((GetTime() - time_started) > use_time)
{
self._holding_button[which_button] = true;
}
}
else
{
if(time_started != 0)
{
time_started = 0;
}
}
}
wait(0.05);
}
}
use_button_held()
{
init_button_wrappers();
if(!IsDefined(self._use_button_think_threaded))
{
self thread button_held_think(level.BUTTON_USE);
self._use_button_think_threaded = true;
}
return self._holding_button[level.BUTTON_USE];
}
ads_button_held()
{
init_button_wrappers();
if(!IsDefined(self._ads_button_think_threaded))
{
self thread button_held_think(level.BUTTON_ADS);
self._ads_button_think_threaded = true;
}
return self._holding_button[level.BUTTON_ADS];
}
attack_button_held()
{
init_button_wrappers();
if(!IsDefined(self._attack_button_think_threaded))
{
self thread button_held_think(level.BUTTON_ATTACK);
self._attack_button_think_threaded = true;
}
return self._holding_button[level.BUTTON_ATTACK];
}
use_button_pressed()
{
return (self UseButtonPressed());
}
ads_button_pressed()
{
return (self AdsButtonPressed());
}
attack_button_pressed()
{
return (self AttackButtonPressed());
}
init_button_wrappers()
{
if (!IsDefined(level._button_funcs))
{
level.BUTTON_USE = 0;
level.BUTTON_ADS = 1;
level.BUTTON_ATTACK = 2;
level._button_funcs[level.BUTTON_USE] = ::use_button_pressed;
level._button_funcs[level.BUTTON_ADS] = ::ads_button_pressed;
level._button_funcs[level.BUTTON_ATTACK] = ::attack_button_pressed;
}
}
play_movie_on_surface(movie_name, is_looping, is_in_memory, start_on_notify, notify_when_done, notify_offset)
{
level endon("stop_movie");
if (!IsDefined(level.flag["movie_loaded"]))
{
flag_init("movie_loaded");
}
if (!IsDefined(is_looping))
{
is_looping = false;
}
if (!IsDefined(is_in_memory))
{
is_in_memory = true;
}
if (!IsDefined(notify_offset) || notify_offset < .3)
{
notify_offset = .3;
}
level thread load_movie(movie_name, is_looping, is_in_memory, IsDefined(start_on_notify));
if (IsDefined(start_on_notify))
{
level waittill(start_on_notify);
}
playsoundatposition(movie_name+"_movie",(0,0,0));
flag_wait("movie_loaded");
Pause3DCinematic(false);
waittill_movie_done(notify_when_done, notify_offset, is_looping);
flag_clear("movie_loaded");
}
start_movie_scene()
{
level notify("kill_scene_subs_thread");
level._scene_subs = [];
}
add_scene_line(scene_line, time, duration)
{
if(!IsDefined(level._scene_subs))
{
level._scene_subs = [];
}
sl = SpawnStruct();
sl.line = scene_line;
sl.time = time;
sl.duration = duration;
for(i = 0; i < level._scene_subs.size; i ++)
{
if(time < level._scene_subs[i].time)
{
PrintLn("*** ERROR: Cannot add an earlier line after a later one. Times must always increase.");
return;
}
}
level._scene_subs[level._scene_subs.size] = sl;
}
sub_fade(alpha, duration)
{
self notify("kill_fade");
self endon("kill_fade");
if(alpha == 1)
{
self.alpha = 0;
}
self fadeOverTime( duration );
self.alpha = alpha;
wait( duration );
}
do_scene_sub(sub_string, duration)
{
if(!GetDvarInt( #"cg_subtitles"))
return;
if (!IsDefined(level.vo_hud))
{
level.vo_hud = NewHudElem();
level.vo_hud.fontscale = 2;
level.vo_hud.horzAlign = "center";
level.vo_hud.vertAlign = "middle";
level.vo_hud.alignX = "center";
level.vo_hud.alignY = "middle";
level.vo_hud.y = 180;
level.vo_hud.sort = 0;
}
fade_duration = 0.2;
level.vo_hud thread sub_fade(1, fade_duration);
old_scale = level.vo_hud.fontscale;
level.vo_hud.fontscale = 1.5;
old_sort = level.vo_hud.sort;
level.vo_hud.sort = 1;
level.vo_hud SetText(sub_string);
wait (duration - fade_duration);
level.vo_hud sub_fade(0, fade_duration);
level.vo_hud SetText("");
level.vo_hud.sort = old_sort;
level.vo_hud.fontscale = old_scale;
}
playback_scene_subs()
{
if(!IsDefined(level._scene_subs))
{
return;
}
level notify("kill_scene_subs_thread");
level endon("kill_scene_subs_thread");
scene_start = GetTime();
for(i = 0; i < level._scene_subs.size; i ++)
{
level._scene_subs[i].time = scene_start + (level._scene_subs[i].time * 1000);
}
for(i = 0; i < level._scene_subs.size; i ++)
{
while(GetTime() < level._scene_subs[i].time)
{
wait(0.05);
}
do_scene_sub(level._scene_subs[i].line, level._scene_subs[i].duration);
}
level._scene_subs = undefined;
}
play_movie(movie_name, is_looping, is_in_memory, start_on_notify, use_fullscreen_trans, notify_when_done, notify_offset, snapshot)
{
level endon("stop_movie");
if (!IsDefined(level.flag["movie_loaded"]))
{
flag_init("movie_loaded");
}
if (!IsDefined(level.flag["movie_failed"]))
{
flag_init("movie_failed");
}
if (!IsDefined(is_looping))
{
is_looping = false;
}
if (!IsDefined(is_in_memory))
{
is_in_memory = true;
}
if (!IsDefined(notify_offset) || notify_offset < .3)
{
notify_offset = .3;
}
if(!IsDefined (snapshot))
{
snapshot = 0;
}
fullscreen_trans_in = "none";
fullscreen_trans_out = "none";
if (is_true(use_fullscreen_trans))
{
fullscreen_trans_in = "white";
fullscreen_trans_out = "white";
if (IsDefined(level.movie_trans_in))
{
fullscreen_trans_in = level.movie_trans_in;
}
if (IsDefined(level.movie_trans_out))
{
fullscreen_trans_out = level.movie_trans_out;
}
}
level thread load_movie(movie_name, is_looping, is_in_memory, IsDefined(start_on_notify));
if (IsDefined(start_on_notify))
{
level waittill(start_on_notify);
}
level thread playback_scene_subs();
level thread handle_movie_dvars();
vision_set = movie_fade_in(movie_name, fullscreen_trans_in);
hud = start_movie(movie_name, fullscreen_trans_in);
if (flag("movie_failed"))
{
if (IsDefined(notify_when_done))
{
wait .05;
level notify(notify_when_done);
if (IsDefined(notify_offset))
{
wait notify_offset;
}
}
}
else
{
waittill_movie_done(notify_when_done, notify_offset, is_looping);
}
clientNotify ("pmo");
flag_clear("movie_loaded");
flag_clear("movie_failed");
level.movie_trans_in = undefined;
level.movie_trans_out = undefined;
if (IsDefined(hud))
{
hud Destroy();
}
level thread movie_fade_out(movie_name, vision_set, fullscreen_trans_out);
level waittill_notify_or_timeout("cine_notify", 1);
}
handle_movie_dvars()
{
players = GetPlayers();
for (i=0;i<players.size;i++)
{
players[i]._hud_dvars = [];
players[i]._hud_dvars["cl_scoreDraw"] = Int(GetDvar("cl_scoreDraw"));
players[i]._hud_dvars["compass"] = Int(GetDvar("compass"));
players[i]._hud_dvars["hud_showstance"] = Int(GetDvar("hud_showstance"));
players[i]._hud_dvars["actionSlotsHide"] = Int(GetDvar("actionSlotsHide"));
players[i]._hud_dvars["ammoCounterHide"] = Int(GetDvar("ammoCounterHide"));
players[i]._hud_dvars["cg_cursorHints"] = Int(GetDvar("cg_cursorHints"));
players[i]._hud_dvars["hud_showobjectives"] = Int(GetDvar("hud_showobjectives"));
players[i]._hud_dvars["cg_drawFriendlyNames"] = Int(GetDvar("cg_drawfriendlynames"));
players[i] SetClientDvars( "cl_scoreDraw",0,"compass",0,"hud_showstance",0,"actionSlotsHide",1,"ammoCounterHide",1,"cg_cursorHints",0, "hud_showobjectives", 0, "cg_drawfriendlynames", 0);
}
flag_wait("movie_loaded");
waittill_either("movie_loaded", "stop_movie");
PrintLn("play_movie: resetting play movie dvars.");
players = GetPlayers();
for (i=0;i<players.size;i++)
{
keys = GetArrayKeys(players[i]._hud_dvars);
players[i] SetClientDvars( keys[0],players[i]._hud_dvars[keys[0]],keys[1],players[i]._hud_dvars[keys[1]],keys[2],players[i]._hud_dvars[keys[2]],keys[3],players[i]._hud_dvars[keys[3]],keys[4],players[i]._hud_dvars[keys[4]],keys[5],players[i]._hud_dvars[keys[5]], keys[6], players[i]._hud_dvars[keys[6]], keys[7], players[i]._hud_dvars[keys[7]]);
}
}
load_movie(movie_name, is_looping, is_in_memory, paused)
{
level endon("stop_movie");
Start3DCinematic(movie_name, is_looping, is_in_memory);
level thread load_movie_failsafe();
level waittill("cine_notify", num);
if (num == -1)
{
flag_set("movie_failed");
}
else if (is_true(paused))
{
Pause3DCinematic(true);
}
flag_set("movie_loaded");
}
load_movie_failsafe()
{
level endon("cine_notify");
wait 10;
Stop3DCinematic();
level notify("cine_notify", -1);
}
start_movie(movie_name, fullscreen_trans)
{
flag_wait("movie_loaded");
hud = undefined;
if ( !IsDefined(level.fullscreen_cin_hud) )
{
hud = create_movie_hud(fullscreen_trans);
}
if (!flag("movie_failed"))
{
PlaySoundAtPosition(movie_name+"_movie",(0,0,0));
Pause3DCinematic(false);
}
return hud;
}
stop_movie()
{
level endon("movie_loaded");
level notify("stop_movie");
Stop3DCinematic();
flag_clear("movie_loaded");
}
create_movie_hud(fullscreen_trans)
{
movie_hud = NewHudElem();
movie_hud.x = 0;
movie_hud.y = 0;
movie_hud.horzAlign = "fullscreen";
movie_hud.vertAlign = "fullscreen";
movie_hud.foreground = false;
movie_hud.sort = 0;
movie_hud.alpha = 1;
if (!is_true(level.flag["movie_failed"]))
{
movie_hud SetShader("cinematic", 640, 480);
}
else
{
if (fullscreen_trans == "black")
{
movie_hud SetShader("black", 640, 480);
}
else
{
movie_hud SetShader("white", 640, 480);
}
}
movie_hud thread destroy_when_movie_is_stopped();
return movie_hud;
}
destroy_when_movie_is_stopped()
{
level endon("movie_loaded");
level waittill("stop_movie");
if (IsDefined(self))
{
self Destroy();
}
}
movie_fade_in(movie_name, fullscreen_trans)
{
level endon("stop_movie");
current_vision_set = "";
if (fullscreen_trans != "none")
{
fade_hud = NewHudElem();
PlaySoundAtPosition(movie_name+"_fade_in",(0,0,0));
FADE_IN = .5;
if (IsDefined(level.movie_fade_in_time))
{
FADE_IN = level.movie_fade_in_time;
}
switch (fullscreen_trans)
{
case "white":
{
current_vision_set = get_players()[0] GetVisionSetNaked();
VisionSetNaked("int_frontend_char_trans", FADE_IN);
break;
}
case "whitehud":
{
fade_hud.x = 0;
fade_hud.y = 0;
fade_hud.horzAlign = "fullscreen";
fade_hud.vertAlign = "fullscreen";
fade_hud.foreground = false;
fade_hud.sort = 0;
fade_hud.alpha = 0;
fade_hud SetShader("white", 640, 480);
fade_hud FadeOverTime(FADE_IN);
fade_hud.alpha = 1;
break;
}
case "black":
{
fade_hud.x = 0;
fade_hud.y = 0;
fade_hud.horzAlign = "fullscreen";
fade_hud.vertAlign = "fullscreen";
fade_hud.foreground = false;
fade_hud.sort = 0;
fade_hud.alpha = 0;
fade_hud SetShader("black", 640, 480);
fade_hud FadeOverTime(FADE_IN);
fade_hud.alpha = 1;
break;
}
}
wait FADE_IN;
fade_hud Destroy();
}
return current_vision_set;
}
movie_fade_out(movie_name, vision_set, fullscreen_trans)
{
level endon("stop_movie");
if (fullscreen_trans != "none")
{
fade_hud = NewHudElem();
PlaySoundAtPosition(movie_name+"_fade_out",(0,0,0));
FADE_OUT = .5;
if (IsDefined(level.movie_fade_out_time))
{
FADE_OUT = level.movie_fade_out_time;
}
switch (fullscreen_trans)
{
case "white":
{
current_vision_set = get_players()[0] GetVisionSetNaked();
if (current_vision_set != "int_frontend_char_trans")
{
vision_set = current_vision_set;
}
VisionSetNaked("int_frontend_char_trans", 0);
wait .1;
VisionSetNaked(vision_set, FADE_OUT);
break;
}
case "whitehud":
{
fade_hud.x = 0;
fade_hud.y = 0;
fade_hud.horzAlign = "fullscreen";
fade_hud.vertAlign = "fullscreen";
fade_hud.foreground = false;
fade_hud.sort = 0;
fade_hud.alpha = 1;
fade_hud SetShader("white", 640, 480);
fade_hud FadeOverTime(FADE_OUT);
fade_hud.alpha = 0;
break;
}
case "black":
{
fade_hud.x = 0;
fade_hud.y = 0;
fade_hud.horzAlign = "fullscreen";
fade_hud.vertAlign = "fullscreen";
fade_hud.foreground = false;
fade_hud.sort = 0;
fade_hud.alpha = 1;
fade_hud SetShader("black", 640, 480);
fade_hud FadeOverTime(FADE_OUT);
fade_hud.alpha = 0;
current_vision_set = get_players()[0] GetVisionSetNaked();
if (current_vision_set == "int_frontend_char_trans")
{
VisionSetNaked(vision_set, 0);
}
break;
}
}
wait FADE_OUT;
fade_hud Destroy();
}
}
waittill_movie_done(notify_when_done, notify_offset, is_looping)
{
level endon("stop_movie");
cutoff_time = 0.2;
if ( is_true(is_looping))
{
level waittill ("stop_movie");
}
timeleft = GetCinematicTimeRemaining();
PrintLn(timeleft);
counter = 0;
while ( (timeleft < 0.05) && counter < 100 )
{
wait 0.05;
counter++;
timeleft = GetCinematicTimeRemaining();
PrintLn(timeleft);
}
oldtimeleft = GetCinematicTimeRemaining();
AssertEx(counter < 100, "Error: Bink movie never started playing even 5 seconds after calling waittill_movie_done");
if ((counter >= 100) && IsDefined(notify_when_done))
{
level notify(notify_when_done);
}
while (timeleft >= cutoff_time)
{
if (IsDefined(notify_when_done) && (timeleft <= notify_offset))
{
level notify(notify_when_done);
}
wait 0.05;
timeleft = GetCinematicTimeRemaining();
PrintLn(timeleft);
if (timeleft < oldtimeleft )
{
oldtimeleft = timeleft;
}
else
{
timeleft -= 0.05;
}
}
if (IsDefined(notify_when_done))
{
level notify(notify_when_done);
}
}
wont_disable_player_firing()
{
if(!IsDefined(self))
{
return;
}
self.NoFriendlyfire = true;
self.ignoreforfriendlyfire = 1;
}
allow_divetoprone( allowed )
{
if( !IsDefined( allowed ) )
{
return;
}
SetDvar( "dtp", allowed );
}
waittill_player_shoots(weapon_type, ender)
{
if(IsDefined(ender))
{
self endon (ender);
}
if(!IsDefined (weapon_type))
{
weapon_type = "any";
}
while(1)
{
self waittill ("weapon_fired");
gun = self GetCurrentWeapon();
if(weapon_type == "any")
{
return gun;
}
else if(weapon_type =="silenced")
{
if( IsSubStr(gun, "silencer"))
{
return gun;
}
}
else
{
if( !IsSubStr(gun, "silencer"))
{
return gun;
}
}
continue;
}
}
Reference in New Issue View Git Blame Copy Permalink