1193 lines
30 KiB
Plaintext
1193 lines
30 KiB
Plaintext
#include maps\mp\_utility;
|
|
#include common_scripts\utility;
|
|
|
|
main()
|
|
{
|
|
maps\mp\mp_lonestar_precache::main();
|
|
maps\createart\mp_lonestar_art::main();
|
|
maps\mp\mp_lonestar_fx::main();
|
|
|
|
level thread maps\mp\_movers::main();
|
|
level thread maps\mp\_movable_cover::init();
|
|
level thread quakes();
|
|
|
|
maps\mp\_load::main();
|
|
thread maps\mp\_fx::func_glass_handler(); // Text on glass
|
|
|
|
maps\mp\_compass::setupMiniMap( "compass_map_mp_lonestar" );
|
|
|
|
// SSAO Optimization
|
|
SetDvar( "r_ssaofadedepth", 384 );
|
|
SetDvar( "r_ssaorejectdepth", 1152 );
|
|
|
|
// dvar_name current_gen_val next_gen_val
|
|
setdvar_cg_ng( "r_specularColorScale", 3 , 15 );
|
|
setdvar_cg_ng( "r_diffuseColorScale" , 1.25 , 3.5 );
|
|
|
|
SetDvar( "r_lightGridEnableTweaks", 1 );
|
|
SetDvar( "r_lightGridIntensity" , 1.33 );
|
|
|
|
if ( level.ps3 )
|
|
{
|
|
SetDvar( "sm_sunShadowScale", "0.5" ); // ps3 optimization
|
|
SetDvar( "sm_sunsamplesizenear", ".19" );
|
|
}
|
|
else if ( level.xenon )
|
|
{
|
|
SetDvar( "sm_sunShadowScale", "0.8" ); // ps3 optimization
|
|
SetDvar( "sm_sunsamplesizenear", ".25" );
|
|
}
|
|
else
|
|
{
|
|
SetDvar( "sm_sunShadowScale", "0.9" ); // optimization
|
|
}
|
|
|
|
game[ "attackers" ] = "allies";
|
|
game[ "defenders" ] = "axis";
|
|
|
|
level thread exploder_triggers();
|
|
|
|
/#
|
|
level thread exploder_test();
|
|
#/
|
|
|
|
//level thread location_callouts();
|
|
level thread initExtraCollision();
|
|
}
|
|
|
|
initExtraCollision()
|
|
{
|
|
collision1 = GetEnt( "clip128x128x128", "targetname" );
|
|
collision1Ent = spawn( "script_model", (-714, -2022, 102) );
|
|
collision1Ent.angles = ( 0, 0, 0);
|
|
collision1Ent CloneBrushmodelToScriptmodel( collision1 );
|
|
|
|
collision2 = GetEnt( "clip128x128x128", "targetname" );
|
|
collision2Ent = spawn( "script_model", (-828, -2160, 80) );
|
|
collision2Ent.angles = ( 0, 0, 0);
|
|
collision2Ent CloneBrushmodelToScriptmodel( collision2 );
|
|
|
|
collision3 = GetEnt( "clip256x256x256", "targetname" );
|
|
collision3Ent = spawn( "script_model", (-2048, -336, 112) );
|
|
collision3Ent.angles = ( 0, 0, 0);
|
|
collision3Ent CloneBrushmodelToScriptmodel( collision3 );
|
|
|
|
collision4 = GetEnt( "player32x32x256", "targetname" );
|
|
collision4Ent = spawn( "script_model", (-572, -822, 276) );
|
|
collision4Ent.angles = ( 0, 0, 0);
|
|
collision4Ent CloneBrushmodelToScriptmodel( collision4 );
|
|
|
|
collision5 = GetEnt( "clip64x64x128", "targetname" );
|
|
collision5Ent = spawn( "script_model", (-990, -209.5, 323) );
|
|
collision5Ent.angles = ( 90, 0, 0);
|
|
collision5Ent CloneBrushmodelToScriptmodel( collision5 );
|
|
}
|
|
|
|
/#
|
|
exploder_test()
|
|
{
|
|
dvar_name = "test_exploder";
|
|
default_value = -1;
|
|
SetDevDvarIfUninitialized( dvar_name, default_value );
|
|
while ( 1 )
|
|
{
|
|
value = GetDvarInt( dvar_name, default_value );
|
|
if ( value < 0 )
|
|
{
|
|
waitframe();
|
|
}
|
|
else
|
|
{
|
|
exploder( value );
|
|
SetDvar( dvar_name, default_value );
|
|
}
|
|
}
|
|
}
|
|
#/
|
|
|
|
exploder_triggers()
|
|
{
|
|
triggers = GetEntArray( "exploder_trigger", "targetname" );
|
|
foreach ( trigger in triggers )
|
|
{
|
|
if ( !IsDefined( trigger.script_index ) )
|
|
continue;
|
|
|
|
trigger thread exploder_trigger_run();
|
|
}
|
|
}
|
|
|
|
exploder_trigger_run()
|
|
{
|
|
self endon( "death" );
|
|
|
|
sounds_for_exploder = [];
|
|
sounds_for_exploder[3] = "scn_mp_lonestar_bat";
|
|
sounds_for_exploder[4] = "scn_mp_lonestar_bat";
|
|
|
|
while ( 1 )
|
|
{
|
|
self waittill( "trigger" );
|
|
exploder( self.script_index );
|
|
|
|
if(IsDefined(sounds_for_exploder[self.script_index]) && IsDefined(self.target))
|
|
{
|
|
sound_origins = getstructarray(self.target, "targetname");
|
|
foreach(org in sound_origins)
|
|
{
|
|
playSoundAtPos(org.origin, sounds_for_exploder[self.script_index]);
|
|
}
|
|
}
|
|
|
|
wait RandomFloatRange( 60 * 1, 60 * 2 );
|
|
}
|
|
}
|
|
|
|
#using_animtree( "animated_props" );
|
|
quakes()
|
|
{
|
|
/#
|
|
if ( GetDvar( "r_reflectionProbeGenerate" ) == "1" )
|
|
{
|
|
return;
|
|
}
|
|
#/
|
|
|
|
//precache
|
|
PrecacheMpAnim( "mp_lonestar_bat_effect_path" );
|
|
level._effect[ "bats" ] = LoadFX( "fx/animals/bats_swarm" );
|
|
|
|
level._effect[ "gas_leak" ] = LoadFX( "fx/fire/heat_lamp_distortion" );
|
|
level._effect[ "gas_leak_fire" ] = LoadFX( "fx/maps/mp_lonestar/mp_ls_gaspipe_fire" );
|
|
|
|
level.quake_anims = [];
|
|
level.quake_anims[ "ground_collapse" ] = "mp_lonestar_road_slab_quake";
|
|
level.quake_anims[ "ground_collapse_start_idle" ] = "mp_lonestar_road_slab_quake_idle";
|
|
level.quake_anims[ "pole_fall_on_police_car" ] = "mp_lonestar_police_car_crush_pole";
|
|
level.quake_anims[ "police_car_hit_by_pole" ] = "mp_lonestar_police_car_crush_car";
|
|
level.quake_anims[ "wire_shake" ] = "mp_lonestar_earthquake_wire_shake";
|
|
level.quake_anims[ "hanging_cable_loop" ] = "mp_lonestar_hanging_wire_loop";
|
|
level.quake_anims[ "hanging_cable" ] = "mp_lonestar_hanging_wire_earthquake";
|
|
|
|
level.quake_anims_ref = [];
|
|
level.quake_anims_ref[ "hanging_cable" ] = %mp_lonestar_hanging_wire_earthquake;
|
|
|
|
foreach ( key, value in level.quake_anims )
|
|
{
|
|
PrecacheMpAnim( value );
|
|
}
|
|
|
|
level.pre_quake_scriptables = [];
|
|
level.quake_scriptables = [];
|
|
add_quake_scriptable( "qauke_script_hanging_wire", GetAnimLength( %mp_lonestar_hanging_wire_earthquake ), false );
|
|
add_quake_scriptable( "qauke_script_telephone_wire", GetAnimLength( %mp_lonestar_earthquake_wire_shake ), true );
|
|
|
|
level.quake_anim_funcs[ "police_car_hit_by_pole" ] = [];
|
|
level.quake_anim_funcs[ "police_car_hit_by_pole" ][ 0 ] = ::quake_event_pole_fall_on_car;
|
|
|
|
level.quake_anim_init_funcs[ "police_car_hit_by_pole" ] = [];
|
|
level.quake_anim_init_funcs[ "police_car_hit_by_pole" ][ 0 ] = ::quake_event_pole_fall_on_car_init;
|
|
|
|
waitframe();
|
|
|
|
if ( level.createFX_enabled )
|
|
return;
|
|
|
|
start_time = GetTime();
|
|
quake_events = quake_events();
|
|
|
|
quake = getstruct( "quake", "targetname" );
|
|
|
|
num_quakes = 3;
|
|
|
|
|
|
quake_event_lists = [];
|
|
list_order = [];
|
|
for ( i = 0;i < num_quakes;i++ )
|
|
{
|
|
quake_event_lists[ i ] = [];
|
|
list_order[ i ] = i;
|
|
}
|
|
|
|
quake_events = array_randomize( quake_events );
|
|
foreach ( event in quake_events )
|
|
{
|
|
if ( event.count > 0 )
|
|
{
|
|
list_order = array_shift( list_order );
|
|
}
|
|
for ( i = 0;i < list_order.size && event.count!= 0;i++ )
|
|
{
|
|
o = list_order[ i ];
|
|
quake_event_lists[ o ][ quake_event_lists[ o ].size ] = event;
|
|
event.count--;
|
|
}
|
|
}
|
|
quake_event_lists = array_randomize( quake_event_lists );
|
|
|
|
time_limit = max( 5, getTimeLimit() ); //Handle short or forever matches
|
|
quake_times = [];
|
|
for ( i = 0;i < num_quakes;i++ )
|
|
{
|
|
min_time = ( 1 / num_quakes ) * ( i + 0.2 );
|
|
max_time = ( 1 / num_quakes ) * ( i + 0.8 );
|
|
quake_times[ i ] = RandomFloatRange( min_time, max_time ) * time_limit * 60;
|
|
}
|
|
|
|
for ( i = 0;i < num_quakes;i++ )
|
|
{
|
|
time = quake_times[ i ];
|
|
earthqauke_wait( time );
|
|
quake thread quake_run( quake_event_lists[ i ] );
|
|
}
|
|
}
|
|
|
|
earthqauke_wait( time )
|
|
{
|
|
level endon( "earthquake_start" );
|
|
/#
|
|
level thread earthqauke_wait_dvar();
|
|
#/
|
|
|
|
wait time;
|
|
level notify( "earthquake_start" );
|
|
}
|
|
|
|
/#
|
|
earthqauke_wait_dvar()
|
|
{
|
|
level endon( "earthquake_start" );
|
|
|
|
dvar_name = "trigger_earthquake";
|
|
default_value = 0;
|
|
SetDevDvarIfUninitialized( dvar_name, default_value );
|
|
while ( 1 )
|
|
{
|
|
|
|
value = GetDvarInt( dvar_name, default_value );
|
|
if ( value == default_value )
|
|
{
|
|
waitframe();
|
|
}
|
|
else
|
|
{
|
|
SetDvar( dvar_name, default_value );
|
|
level notify( "earthquake_start" );
|
|
}
|
|
}
|
|
}
|
|
|
|
#/
|
|
|
|
array_shift( array )
|
|
{
|
|
new_array = [];
|
|
for ( i = 0;i < array.size - 1;i++ )
|
|
{
|
|
new_array[ i ] = array[ i + 1 ];
|
|
}
|
|
new_array[ new_array.size ] = array[ 0 ];
|
|
return new_array;
|
|
}
|
|
|
|
add_quake_scriptable( targetname, animTime, is_pre_quake )
|
|
{
|
|
scriptables = GetScriptableArray( targetname, "targetname" );
|
|
|
|
foreach ( thing in scriptables )
|
|
{
|
|
thing.quake_scriptable_time = animTime;
|
|
}
|
|
|
|
if ( is_pre_quake )
|
|
{
|
|
level.pre_quake_scriptables = array_combine( level.pre_quake_scriptables, scriptables );
|
|
}
|
|
else
|
|
{
|
|
level.quake_scriptables = array_combine( level.quake_scriptables, scriptables );
|
|
}
|
|
|
|
}
|
|
|
|
quake_run_scriptables( scriptables )
|
|
{
|
|
foreach ( scriptable in scriptables )
|
|
{
|
|
scriptable SetScriptablePartState( "main", "quake" );
|
|
|
|
scriptable delayCall( scriptable.quake_scriptable_time, ::SetScriptablePartState, "main", "idle" );
|
|
}
|
|
}
|
|
|
|
quake_run( quake_events )
|
|
{
|
|
quake_run_scriptables( level.pre_quake_scriptables );
|
|
|
|
// start the wire shake 4 seconds before the screen shake
|
|
wire_event = undefined;
|
|
foreach ( event in quake_events )
|
|
{
|
|
if ( IsDefined( event.script_noteworthy ) && ( event.script_noteworthy == "wires" ) )
|
|
{
|
|
wire_event = event;
|
|
wire_event thread quake_event_trigger( 0, wire_event quake_event_wait() );
|
|
break;
|
|
}
|
|
}
|
|
|
|
wait( 4.0 );
|
|
|
|
quake_run_scriptables( level.quake_scriptables );
|
|
|
|
duration = RandomFloatRange( 7, 9 );
|
|
|
|
playSoundAtPos( ( 0, 0, 0 ), "mp_earthquake_lr" );
|
|
Earthquake( 0.3, duration, self.origin, self.radius );
|
|
|
|
//VFX Trigger
|
|
exploder( 1 );
|
|
|
|
foreach ( event in quake_events )
|
|
{
|
|
if ( !IsDefined( wire_event ) || event != wire_event )
|
|
{
|
|
event thread quake_event_trigger( duration, event quake_event_wait() );
|
|
}
|
|
}
|
|
}
|
|
|
|
quake_event_trigger( duration, waitTime )
|
|
{
|
|
if ( IsDefined( waitTime ) && waitTime > 0 )
|
|
wait waitTime;
|
|
|
|
self notify( "trigger", duration );
|
|
}
|
|
|
|
quake_event_wait()
|
|
{
|
|
if ( IsDefined( self.script_wait ) )
|
|
return self.script_wait;
|
|
else if ( IsDefined( self.script_wait_min ) && IsDefined( self.script_wait_max ) )
|
|
return RandomFloatRange( self.script_wait_min, self.script_wait_max );
|
|
|
|
return 0;
|
|
}
|
|
|
|
quake_event_trigger_wait( func, var1, var2, var3, var4, var5, var6 )
|
|
{
|
|
while ( 1 )
|
|
{
|
|
self waittill( "trigger", quakeTime );
|
|
if ( IsDefined( var6 ) )
|
|
self thread [[ func ]]( quakeTime, var1, var2, var3, var4, var5, var6 );
|
|
else if ( IsDefined( var5 ) )
|
|
self thread [[ func ]]( quakeTime, var1, var2, var3, var4, var5 );
|
|
else if ( IsDefined( var4 ) )
|
|
self thread [[ func ]]( quakeTime, var1, var2, var3, var4 );
|
|
else if ( IsDefined( var3 ) )
|
|
self thread [[ func ]]( quakeTime, var1, var2, var3 );
|
|
else if ( IsDefined( var2 ) )
|
|
self thread [[ func ]]( quakeTime, var1, var2 );
|
|
else if ( IsDefined( var1 ) )
|
|
self thread [[ func ]]( quakeTime, var1 );
|
|
else
|
|
self thread [[ func ]]( quakeTime );
|
|
}
|
|
}
|
|
|
|
quake_events()
|
|
{
|
|
events = getstructarray( "quake_event", "targetname" );
|
|
array_thread( events, ::quake_event_init );
|
|
return events;
|
|
}
|
|
|
|
quake_event_init()
|
|
{
|
|
ents = GetEntArray( self.target, "targetname" );
|
|
|
|
if(IsDefined(self.script_noteworthy))
|
|
{
|
|
extra_targets = StrTok( self.script_noteworthy, "," );
|
|
foreach(script_noteworthy_target in extra_targets)
|
|
{
|
|
extra_target_ents = GetEntArray(script_noteworthy_target, "targetname");
|
|
ents = array_combine(ents, extra_target_ents);
|
|
}
|
|
}
|
|
|
|
foreach ( ent in ents )
|
|
{
|
|
if ( ent maps\mp\_movers::script_mover_is_script_mover() )
|
|
{
|
|
self thread quake_event_trigger_wait( ::quake_event_send_notify, ent, "trigger" );
|
|
continue;
|
|
}
|
|
|
|
quake_event_init_ent( ent );
|
|
|
|
if ( !IsDefined( ent.script_noteworthy ) )
|
|
continue;
|
|
|
|
tokens = StrTok( ent.script_noteworthy, "," );
|
|
|
|
foreach ( token in tokens )
|
|
{
|
|
switch ( token )
|
|
{
|
|
case "ground_collapse":
|
|
self thread quake_event_trigger_wait( ::quake_event_move_to, ent, 1, undefined, 1, 0, true );
|
|
break;
|
|
case "shake":
|
|
self thread quake_event_trigger_wait( ::quake_event_shake, ent );
|
|
break;
|
|
case "hurt":
|
|
if ( !IsDefined( ent.script_damage ) )
|
|
ent.script_damage = 25;
|
|
if ( !IsDefined( ent.script_delay ) )
|
|
ent.script_delay = 1;
|
|
self thread quake_event_trigger_wait( ::quake_event_hurt, ent, ent.script_delay, ent.script_damage );
|
|
break;
|
|
case "hurt_fire":
|
|
self thread quake_event_trigger_wait( ::quake_event_hurt, ent, 1, 25 );
|
|
break;
|
|
case "delete":
|
|
self thread quake_event_trigger_wait( ::quake_event_delete, ent );
|
|
break;
|
|
case "animate":
|
|
if ( IsDefined( ent.script_animation ) )
|
|
{
|
|
if ( IsDefined( level.quake_anim_init_funcs[ ent.script_animation ] ) )
|
|
{
|
|
foreach ( func in level.quake_anim_init_funcs[ ent.script_animation ] )
|
|
{
|
|
level thread [[ func ]]( ent );
|
|
}
|
|
}
|
|
|
|
if ( IsDefined( level.quake_anims[ ent.script_animation + "_start_idle" ] ) )
|
|
{
|
|
ent ScriptModelPlayAnim( level.quake_anims[ ent.script_animation + "_start_idle" ] );
|
|
}
|
|
|
|
if ( IsDefined( level.quake_anims[ ent.script_animation + "_loop" ] ) )
|
|
{
|
|
ent ScriptModelPlayAnim( level.quake_anims[ ent.script_animation + "_loop" ] );
|
|
}
|
|
|
|
if ( IsDefined( level.quake_anims[ ent.script_animation ] ) )
|
|
{
|
|
self thread quake_event_trigger_wait( ::quake_event_animate, ent, ent.script_animation );
|
|
}
|
|
}
|
|
break;
|
|
case "show":
|
|
ent Hide();
|
|
self thread quake_event_trigger_wait( ::quake_event_show, ent );
|
|
break;
|
|
case "move_to_end":
|
|
move_time = 1;
|
|
if ( IsDefined( ent.script_parameters ) )
|
|
move_time = Float( ent.script_parameters );
|
|
self thread quake_event_trigger_wait( ::quake_event_move_to, ent, .5, ent.script_delay );
|
|
break;
|
|
case "gas_leak":
|
|
if ( IsDefined( self.target ) )
|
|
{
|
|
ent.fx_location = getstruct( ent.target, "targetname" );
|
|
ent.hurt_trigger = GetEnt( ent.target, "targetname" );
|
|
|
|
self thread quake_event_trigger_wait( ::quake_event_gas_leak, ent );
|
|
}
|
|
break;
|
|
case "sound":
|
|
self thread quake_event_trigger_wait( ::quake_event_playSound, ent );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
structs = getstructarray( self.target, "targetname" );
|
|
foreach ( struct in structs )
|
|
{
|
|
if ( !IsDefined( struct.script_noteworthy ) )
|
|
continue;
|
|
|
|
switch ( struct.script_noteworthy )
|
|
{
|
|
case "fx":
|
|
if ( !IsDefined( struct.script_parameters ) )
|
|
struct.script_parameters = "gas_leak";
|
|
if ( !IsDefined( struct.angles ) )
|
|
struct.angles = ( 0, 0, 0 );
|
|
|
|
fx_ent = SpawnFx( level._effect[ struct.script_parameters ], struct.origin, AnglesToForward( struct.angles ) );
|
|
self thread quake_event_trigger_wait( ::quake_event_fx, fx_ent );
|
|
break;
|
|
case "exploder":
|
|
exploder_id = struct.script_prefab_exploder;
|
|
if ( !IsDefined( exploder_id ) )
|
|
exploder_id = struct.script_exploder;
|
|
if ( IsDefined( exploder_id ) )
|
|
{
|
|
self thread quake_event_trigger_wait( ::quake_event_exploder, exploder_id );
|
|
}
|
|
break;
|
|
case "sound":
|
|
self thread quake_event_trigger_wait( ::quake_event_playSound, struct );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
nodes = GetVehicleNodeArray( self.target, "targetname" );
|
|
foreach ( node in nodes )
|
|
{
|
|
if ( !IsDefined( node.script_noteworthy ) )
|
|
continue;
|
|
|
|
switch ( node.script_noteworthy )
|
|
{
|
|
case "bats":
|
|
self thread quake_event_trigger_wait( ::quake_event_bats, node );
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
linked_nodes = getLinknameNodes();
|
|
foreach ( node in linked_nodes )
|
|
{
|
|
if ( !IsDefined( node.script_noteworthy ) )
|
|
continue;
|
|
|
|
switch ( node.script_noteworthy )
|
|
{
|
|
case "connect_traverse":
|
|
disconnect_traverse( node );
|
|
self thread quake_event_trigger_wait( ::quake_event_connect_traverse, node );
|
|
break;
|
|
case "disconnect_traverse":
|
|
self thread quake_event_trigger_wait( ::quake_event_disconnect_traverse, node );
|
|
break;
|
|
case "connect":
|
|
node DisconnectNode();
|
|
self thread quake_event_trigger_wait( ::quake_event_connect_node, node );
|
|
break;
|
|
case "disconnect":
|
|
self thread quake_event_trigger_wait( ::quake_event_disconnect_node, node );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !IsDefined( self.count ) )
|
|
self.count = 1;
|
|
}
|
|
|
|
is_dynamic_path()
|
|
{
|
|
return IsDefined(self.spawnflags) && self.spawnflags&1;
|
|
}
|
|
|
|
quake_event_init_ent( ent )
|
|
{
|
|
ent.move_ent = ent;
|
|
|
|
if ( !IsDefined( ent.target ) )
|
|
return;
|
|
|
|
structs = getstructarray( ent.target, "targetname" );
|
|
ents = GetEntArray( ent.target, "targetname" );
|
|
|
|
targets = array_combine( structs, ents );
|
|
|
|
foreach ( target in targets )
|
|
{
|
|
if ( !IsDefined( target.script_noteworthy ) )
|
|
continue;
|
|
|
|
switch ( target.script_noteworthy )
|
|
{
|
|
case "link":
|
|
target LinkTo( ent );
|
|
break;
|
|
case "origin":
|
|
ent.move_ent = Spawn( "script_model", target.origin );
|
|
ent.move_ent.angles = ( 0, 0, 0 );
|
|
if ( IsDefined( target.angles ) )
|
|
ent.move_ent.angles = target.angles;
|
|
ent.move_ent SetModel( "tag_origin" );
|
|
ent LinkTo( ent.move_ent );
|
|
break;
|
|
case "end":
|
|
ent.end_location = target;
|
|
break;
|
|
case "start":
|
|
if( ent is_dynamic_path())
|
|
ent ConnectPaths();
|
|
ent.origin = target.origin;
|
|
if ( IsDefined( target.angles ) )
|
|
ent.angles = target.angles;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
quake_event_move_to( quakeTime, ent, time, delay, accel, decel, delete_at_end )
|
|
{
|
|
if ( !IsDefined( ent.end_location ) )
|
|
return;
|
|
|
|
if ( !IsDefined( accel ) )
|
|
accel = 0;
|
|
if ( !IsDefined( decel ) )
|
|
decel = 0;
|
|
if ( !IsDefined( delete_at_end ) )
|
|
delete_at_end = false;
|
|
|
|
if ( IsDefined( delay ) && delay > 0 )
|
|
wait delay;
|
|
|
|
if ( ent.end_location.origin != ent.origin )
|
|
{
|
|
ent.move_ent MoveTo( ent.end_location.origin, time, accel, decel );
|
|
}
|
|
|
|
if ( IsDefined( ent.end_location.angles ) && ent.end_location.angles != ent.angles )
|
|
{
|
|
ent.move_ent RotateTo( ent.end_location.angles, time, accel, decel );
|
|
}
|
|
|
|
wait time;
|
|
|
|
if( ent is_dynamic_path() )
|
|
{
|
|
ent DisconnectPaths();
|
|
}
|
|
|
|
if ( delete_at_end )
|
|
{
|
|
ent.move_ent Delete();
|
|
if ( IsDefined( ent ) ) //Need to check becasue ent.move_ent might be the same as ent
|
|
ent Delete();
|
|
}
|
|
|
|
}
|
|
|
|
quake_event_shake( quakeTime, ent )
|
|
{
|
|
// shakeTime = int(quakeTime) + RandomFloatRange(4,6);
|
|
//
|
|
// period = RandomFloatRange(.9,1.1);
|
|
// max_angle = RandomFloatRange(7,10);
|
|
//
|
|
// num_shakes = shakeTime/period;
|
|
//
|
|
// for(i=0;i<num_shakes;i++)
|
|
// {
|
|
// angle = max_angle * (1.0 - (i/num_shakes));
|
|
// ent.move_ent RotatePitch(angle, period/2, period/4, period/4);
|
|
// wait period/2;
|
|
// ent.move_ent RotatePitch(-1*angle, period/2, period/4, period/4);
|
|
// wait period/2;
|
|
// }
|
|
}
|
|
|
|
#using_animtree( "animated_props" );
|
|
quake_event_bats( quakeTime, start_node )
|
|
{
|
|
bat_origin = (752, -3536, 132);
|
|
bat_model = Spawn( "script_model", bat_origin );
|
|
bat_model.angles = ( 0, 0, 0 );
|
|
bat_model SetModel( "generic_prop_raven" );
|
|
|
|
waitframe();
|
|
|
|
bat_sound_ent = Spawn( "script_model", bat_origin );
|
|
bat_sound_ent SetModel("tag_origin");
|
|
bat_sound_ent LinkTo( bat_model, "j_prop_2" );
|
|
|
|
waitframe();
|
|
|
|
PlayFXOnTag( level._effect[ "bats" ], bat_model, "j_prop_2" );
|
|
|
|
bat_model ScriptModelPlayAnimDeltaMotion( "mp_lonestar_bat_effect_path" );
|
|
bat_sound_ent PlayLoopSound( "mp_quake_bat_lp" );
|
|
|
|
|
|
wait( GetAnimLength( %mp_lonestar_bat_effect_path ) );
|
|
|
|
bat_sound_ent Delete();
|
|
bat_model Delete();
|
|
}
|
|
|
|
quake_event_hurt( quakeTime, hurt_trigger, damage_rate, damage )
|
|
{
|
|
thread quake_hurt_trigger( hurt_trigger, damage_rate, damage );
|
|
}
|
|
|
|
quake_hurt_trigger( hurt_trigger, damage_rate, damage )
|
|
{
|
|
self endon( "stop_hurt_trigger" );
|
|
|
|
ent_num = hurt_trigger GetEntityNumber();
|
|
damage_rate_ms = damage_rate * 1000;
|
|
|
|
while ( 1 )
|
|
{
|
|
hurt_trigger waittill( "trigger", player );
|
|
|
|
if ( !IsDefined( player.quake_hurt_time ) )
|
|
player.quake_hurt_time = [];
|
|
|
|
if ( !IsDefined( player.quake_hurt_time[ ent_num ] ) )
|
|
player.quake_hurt_time[ ent_num ] = -1 * damage_rate_ms;
|
|
|
|
if ( player.quake_hurt_time[ ent_num ] + damage_rate_ms > GetTime() )
|
|
continue;
|
|
|
|
player.quake_hurt_time[ ent_num ] = GetTime();
|
|
|
|
player DoDamage( damage, hurt_trigger.origin );
|
|
//RadiusDamage( ( hurt_trigger.origin + ( 0, 0, 50 ) ), 10, damage, damage );
|
|
}
|
|
}
|
|
|
|
quake_event_show( quakeTime, ent )
|
|
{
|
|
ent Show();
|
|
}
|
|
|
|
quake_event_delete( quakeTime, ent )
|
|
{
|
|
ent Delete();
|
|
}
|
|
|
|
quake_event_fx( quakeTime, fx_ent )
|
|
{
|
|
TriggerFX( fx_ent );
|
|
}
|
|
|
|
quake_event_exploder( quakeTime, exploder_id )
|
|
{
|
|
exploder( exploder_id );
|
|
}
|
|
|
|
quake_event_send_notify( quakeTime, ent, note )
|
|
{
|
|
ent notify( note );
|
|
}
|
|
|
|
quake_event_animate( quakeTime, ent, anim_name )
|
|
{
|
|
ent ScriptModelPlayAnimDeltaMotion( level.quake_anims[ anim_name ] );
|
|
|
|
if ( IsDefined( level.quake_anim_funcs[ anim_name ] ) )
|
|
{
|
|
foreach ( func in level.quake_anim_funcs[ anim_name ] )
|
|
{
|
|
level thread [[ func ]]( quakeTime, ent );
|
|
}
|
|
}
|
|
|
|
//restart loop after quake anim
|
|
if ( IsDefined( level.quake_anims[ anim_name + "_loop" ] ) && IsDefined( level.quake_anims_ref[ anim_name ] ) )
|
|
{
|
|
anim_length = GetAnimLength( level.quake_anims_ref[ anim_name ] );
|
|
wait anim_length;
|
|
ent ScriptModelPlayAnim( level.quake_anims[ ent.script_animation + "_loop" ] );
|
|
}
|
|
}
|
|
|
|
quake_event_gas_leak( quakeTime, ent )
|
|
{
|
|
|
|
//ent SetCanDamage( true );
|
|
|
|
while ( 1 )
|
|
{
|
|
fire_fx = SpawnFx( level._effect[ "gas_leak_fire" ], ent.fx_location.origin, AnglesToForward( ent.fx_location.angles ) );
|
|
TriggerFX( fire_fx );
|
|
ent PlayLoopSound( "emt_lone_gas_pipe_fire_lp" );
|
|
|
|
self thread quake_hurt_trigger( ent.hurt_trigger, .25, 10 );
|
|
|
|
wait 30;
|
|
|
|
self notify( "stop_hurt_trigger" );
|
|
fire_fx Delete();
|
|
ent StopLoopSound( "emt_lone_gas_pipe_fire_lp" );
|
|
|
|
gas_fx = SpawnFx( level._effect[ "gas_leak" ], ent.fx_location.origin, AnglesToForward( ent.fx_location.angles ) );
|
|
TriggerFX( gas_fx );
|
|
|
|
ent waittill_notify_or_timeout( "trigger", 30 );
|
|
|
|
gas_fx Delete();
|
|
}
|
|
}
|
|
|
|
quake_event_pole_unlink_nodes()
|
|
{
|
|
nodes = getnodearray( "dog_pole_vault", "script_noteworthy" );
|
|
if ( IsDefined( nodes ) )
|
|
{
|
|
assert( nodes.size == 2 );
|
|
DisconnectNodePair( nodes[0], nodes[1] );
|
|
}
|
|
|
|
nodes2 = getnodearray( "dog_pole_vault2", "script_noteworthy" );
|
|
if ( IsDefined( nodes2 ) )
|
|
{
|
|
assert( nodes2.size == 2 );
|
|
DisconnectNodePair( nodes2[0], nodes2[1] );
|
|
}
|
|
}
|
|
|
|
quake_event_pole_link_nodes()
|
|
{
|
|
nodes = getnodearray( "dog_pole_vault", "script_noteworthy" );
|
|
if ( IsDefined( nodes ) )
|
|
{
|
|
assert( nodes.size == 2 );
|
|
if ( IsDefined( nodes[0].target ) && IsDefined( nodes[1].targetname ) && nodes[0].target == nodes[1].targetname )
|
|
ConnectNodePair( nodes[0], nodes[1], true );
|
|
else
|
|
ConnectNodePair( nodes[1], nodes[0], true );
|
|
}
|
|
|
|
nodes2 = getnodearray( "dog_pole_vault2", "script_noteworthy" );
|
|
if ( IsDefined( nodes2 ) )
|
|
{
|
|
assert( nodes2.size == 2 );
|
|
if ( IsDefined( nodes2[0].target ) && IsDefined( nodes2[1].targetname ) && nodes2[0].target == nodes2[1].targetname )
|
|
ConnectNodePair( nodes2[0], nodes2[1], true );
|
|
else
|
|
ConnectNodePair( nodes2[1], nodes2[0], true );
|
|
}
|
|
}
|
|
|
|
//Ent is the cop car
|
|
quake_event_pole_fall_on_car_init( ent )
|
|
{
|
|
broken_base = GetEnt("pole_that_falls_on_cop_car_base", "targetname");
|
|
if(IsDefined(broken_base))
|
|
broken_base hide();
|
|
|
|
pole = GetEnt( "pole_that_falls_on_cop_car", "targetname" );
|
|
if ( !IsDefined( pole ) )
|
|
return;
|
|
|
|
clips = GetEntArray( pole.target, "targetname" );
|
|
foreach ( clip in clips )
|
|
{
|
|
if ( clip.script_noteworthy == "clip_up" )
|
|
{
|
|
clip LinkTo( pole );
|
|
pole.clip_up = clip;
|
|
}
|
|
else if ( clip.script_noteworthy == "clip_down" )
|
|
{
|
|
clip ConnectPaths();
|
|
clip trigger_off();
|
|
pole.clip_down = clip;
|
|
}
|
|
}
|
|
|
|
quake_event_pole_unlink_nodes();
|
|
}
|
|
|
|
//Ent is the cop car
|
|
//Need to get the cop car, its a hard coded target name so I dont have to stamp the prefabs
|
|
quake_event_pole_fall_on_car( quakeTime, ent )
|
|
{
|
|
broken_base = GetEnt("pole_that_falls_on_cop_car_base", "targetname");
|
|
if(IsDefined(broken_base))
|
|
broken_base Show();
|
|
|
|
pole = GetEnt( "pole_that_falls_on_cop_car", "targetname" );
|
|
if ( !IsDefined( pole ) )
|
|
return;
|
|
|
|
pole SetModel("ls_telephone_pole_snap");
|
|
|
|
pole PlaySound( "scn_pole_fall" );
|
|
|
|
animated_prop = Spawn( "script_model", pole.origin );
|
|
animated_prop SetModel( "generic_prop_raven" );
|
|
animated_prop.angles = pole.angles;
|
|
|
|
pole LinkTo( animated_prop, "j_prop_1" );
|
|
|
|
animated_prop ScriptModelPlayAnimDeltaMotion( "mp_lonestar_police_car_crush_pole" );
|
|
|
|
car_swap = GetNotetrackTimes( %mp_lonestar_police_car_crush_pole, "car_swap" );
|
|
anim_length = GetAnimLength( %mp_lonestar_police_car_crush_pole );
|
|
|
|
wait car_swap[ 0 ] * anim_length;
|
|
|
|
ent PlaySound( "scn_police_car_crush" );
|
|
|
|
exploder( 7 );
|
|
|
|
pole.clip_down trigger_on();
|
|
pole.clip_down DisconnectPaths();
|
|
quake_event_pole_link_nodes();
|
|
pole.clip_up Delete();
|
|
ent SetModel( "ls_police_sedan_smashed" );
|
|
|
|
foreach ( character in level.characters )
|
|
{
|
|
if ( character IsTouching( pole.clip_down ) )
|
|
{
|
|
character maps\mp\_movers::mover_suicide();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
quake_event_playSound( quakeTime, ent )
|
|
{
|
|
if ( !IsDefined( ent.script_sound ) )
|
|
return;
|
|
playSoundAtPos( ent.origin, ent.script_sound );
|
|
}
|
|
|
|
quake_event_disconnect_node( quakeTime, node )
|
|
{
|
|
node DisconnectNode();
|
|
}
|
|
|
|
quake_event_connect_node( quakeTime, node )
|
|
{
|
|
node ConnectNode();
|
|
}
|
|
|
|
quake_event_disconnect_traverse( quakeTime, begin_node )
|
|
{
|
|
disconnect_traverse( begin_node );
|
|
}
|
|
|
|
disconnect_traverse( begin_node )
|
|
{
|
|
if ( !IsDefined( begin_node.end_nodes ) )
|
|
{
|
|
begin_node.end_nodes = GetNodeArray( begin_node.target, "targetname" );
|
|
}
|
|
|
|
foreach ( end_node in begin_node.end_nodes )
|
|
{
|
|
DisconnectNodePair( begin_node, end_node, true );
|
|
}
|
|
}
|
|
|
|
quake_event_connect_traverse( quakeTime, begin_node )
|
|
{
|
|
connect_traverse( begin_node );
|
|
}
|
|
|
|
connect_traverse( begin_node )
|
|
{
|
|
if ( !IsDefined( begin_node.end_nodes ) )
|
|
{
|
|
begin_node.end_nodes = GetNodeArray( begin_node.target, "targetname" );
|
|
}
|
|
|
|
foreach ( end_node in begin_node.end_nodes )
|
|
{
|
|
ConnectNodePair( begin_node, end_node, true );
|
|
}
|
|
}
|
|
|
|
//location_callouts()
|
|
//{
|
|
// level.location_callouts = [];
|
|
// level.location_callouts["car_wash"] = &"MP_LONESTAR_CALLOUT_CAR_WASH";
|
|
// level.location_callouts["heli_crash"] = &"MP_LONESTAR_CALLOUT_HELI_CRASH";
|
|
// level.location_callouts["fema_tent"] = &"MP_LONESTAR_CALLOUT_FEMA_TENT";
|
|
// level.location_callouts["gas_main"] = &"MP_LONESTAR_CALLOUT_GAS_MAIN";
|
|
// level.location_callouts["kiosks"] = &"MP_LONESTAR_CALLOUT_KIOSKS";
|
|
// level.location_callouts["parking_garage"] = &"MP_LONESTAR_CALLOUT_PARKING_GARAGE";
|
|
// level.location_callouts["burned"] = &"MP_LONESTAR_CALLOUT_BURNED";
|
|
// level.location_callouts["gas_station"] = &"MP_LONESTAR_CALLOUT_GAS_STATION";
|
|
// level.location_callouts["rehab_south"] = &"MP_LONESTAR_CALLOUT_REHAB_SOUTH";
|
|
// level.location_callouts["rehab_north"] = &"MP_LONESTAR_CALLOUT_REHAB_NOTH";
|
|
// level.location_callouts["rehab_roof"] = &"MP_LONESTAR_CALLOUT_REHAB_ROOF";
|
|
// level.location_callouts["insurance"] = &"MP_LONESTAR_CALLOUT_INSURANCE";
|
|
// level.location_callouts["insurance_roof"] = &"MP_LONESTAR_CALLOUT_INSURANCE_ROOF";
|
|
// level.location_callouts["solar"] = &"MP_LONESTAR_CALLOUT_SOLAR";
|
|
// level.location_callouts["service"] = &"MP_LONESTAR_CALLOUT_AMBULANCE_SERVICE";
|
|
// level.location_callouts["hog_garage"] = &"MP_LONESTAR_CALLOUT_HOG_GARAGE";
|
|
// level.location_callouts["childrens_hospital"] = &"MP_LONESTAR_CALLOUT_CHILD_HOSP";
|
|
// level.location_callouts["childrens_hospital_lobby"] = &"MP_LONESTAR_CALLOUT_CHILD_HOSP_LOBBY";
|
|
// level.location_callouts["emergency_entrance"] = &"MP_LONESTAR_CALLOUT_EMERGENCY";
|
|
// level.location_callouts["treatment"] = &"MP_LONESTAR_CALLOUT_TREATMENT";
|
|
// level.location_callouts["trash"] = &"MP_LONESTAR_CALLOUT_TRASH";
|
|
// level.location_callouts["courtyard"] = &"MP_LONESTAR_CALLOUT_COURTYARD";
|
|
// level.location_callouts["skybridge"] = &"MP_LONESTAR_CALLOUT_SKYBIRDGE";
|
|
//
|
|
// location_trigger = GetEntArray("location_callout", "targetname");
|
|
//
|
|
// array_thread(location_trigger, ::location_callouts_init);
|
|
// level thread location_callouts_update_players();
|
|
//
|
|
//}
|
|
//
|
|
//location_callouts_init()
|
|
//{
|
|
//
|
|
// if(!IsDefined(self.script_noteworthy))
|
|
// {
|
|
// Print("Location callout trigger at " + self.origin + " missing script_noteworthy\n");
|
|
// return;
|
|
// }
|
|
//
|
|
// self.callout_name = level.location_callouts[self.script_noteworthy];
|
|
// if(!IsDefined(self.callout_name))
|
|
// {
|
|
// Print("Location callout trigger at " + self.origin + " has script_noteworthy ('" +self.script_noteworthy + "') not defined in level.location_callouts\n");
|
|
// }
|
|
//
|
|
// self.priority = self.script_index;
|
|
// if(!IsDefined(self.priority))
|
|
// self.priority = 1;
|
|
//
|
|
// self thread location_callout_run();
|
|
//}
|
|
//
|
|
//location_callout_run()
|
|
//{
|
|
// while(1)
|
|
// {
|
|
// self waittill("trigger", player);
|
|
//
|
|
// if(!IsPlayer(player))
|
|
// continue;
|
|
//
|
|
// if(isAI(player))
|
|
// continue;
|
|
//
|
|
// new = player.location_callout_new;
|
|
// if(!IsDefined(new) || self.priority>new.priority)
|
|
// {
|
|
// player.location_callout_new = self;
|
|
// }
|
|
// }
|
|
//}
|
|
//
|
|
//location_callouts_update_players()
|
|
//{
|
|
// while(!IsDefined(level.players))
|
|
// waitframe();
|
|
//
|
|
// while(1)
|
|
// {
|
|
// foreach(player in level.players)
|
|
// {
|
|
// player.location_callout_new = undefined;
|
|
// }
|
|
//
|
|
// waittillframeend; //player.location_callout_new will be updated in location_callout_run(), if there are any
|
|
//
|
|
// foreach(player in level.players)
|
|
// {
|
|
// if(isAI(player))
|
|
// continue;
|
|
//
|
|
// location_callouts_set_player_trigger(player, player.location_callout_new);
|
|
// }
|
|
// waitframe();
|
|
// }
|
|
//}
|
|
//
|
|
//location_callouts_set_player_trigger(player, new_trigger)
|
|
//{
|
|
// old_trigger = player.location_callout_current;
|
|
//
|
|
// if(!IsDefined(old_trigger) && !IsDefined(new_trigger))
|
|
// return;
|
|
//
|
|
// if(IsDefined(old_trigger) && IsDefined(new_trigger) && old_trigger==new_trigger)
|
|
// return;
|
|
//
|
|
// player.location_callout_current = new_trigger;
|
|
// if(IsDefined(new_trigger))
|
|
// {
|
|
// if(!IsDefined(player.location_callout_hud))
|
|
// {
|
|
// player.location_callout_hud = location_callouts_hud_create(player);
|
|
// player.location_callout_hud.alpha = 0;
|
|
// }
|
|
//
|
|
// player.location_callout_hud thread location_callouts_hud_set_text(new_trigger.callout_name);
|
|
// }
|
|
// else if(IsDefined(old_trigger))
|
|
// {
|
|
// if(IsDefined(player.location_callout_hud))
|
|
// {
|
|
// player.location_callout_hud notify("end_visible_time");
|
|
// }
|
|
// }
|
|
//}
|
|
//
|
|
//location_callouts_hud_create(player)
|
|
//{
|
|
// fontElem = newClientHudElem( player );
|
|
// fontElem.elemType = "font";
|
|
// fontElem.font = "default";
|
|
// fontElem.fontscale = 1.2;
|
|
// fontElem.width = 0;
|
|
// fontElem.height = int( level.fontHeight * fontElem.fontscale );
|
|
// fontElem.children = [];
|
|
// fontElem maps\mp\gametypes\_hud_util::setParent( level.uiParent );
|
|
//
|
|
// fontElem maps\mp\gametypes\_hud_util::SetPoint("TOPLEFT", undefined, 10, 110);
|
|
//
|
|
// return fontElem;
|
|
//}
|
|
//
|
|
//location_callouts_hud_set_text(callout_str)
|
|
//{
|
|
// self notify("location_callouts_hud_set_text");
|
|
//
|
|
// self endon("location_callouts_hud_set_text");
|
|
// self endon("death");
|
|
//
|
|
// default_fade_in_time = .5;
|
|
// default_visiable_time = 3;
|
|
// default_fade_out_time = 1.0;
|
|
//
|
|
// self SetText(callout_str);
|
|
//
|
|
// scaled_fade_in_time = (1-self.alpha)*default_fade_in_time;
|
|
// if(scaled_fade_in_time>0)
|
|
// {
|
|
// self FadeOverTime(scaled_fade_in_time);
|
|
// self.alpha = 1;
|
|
// wait scaled_fade_in_time;
|
|
// }
|
|
//
|
|
// location_callouts_hud_visible_wait(default_visiable_time);
|
|
//
|
|
// self FadeOverTime(default_fade_out_time);
|
|
// self.alpha = 0;
|
|
// wait default_fade_out_time;
|
|
//
|
|
// self Destroy();
|
|
//}
|
|
//
|
|
//location_callouts_hud_visible_wait(waitTime)
|
|
//{
|
|
// self endon("end_visible_time");
|
|
//
|
|
// wait waitTime;
|
|
//} |