909 lines
26 KiB
Plaintext
909 lines
26 KiB
Plaintext
#using scripts\codescripts\struct;
|
|
|
|
#using scripts\shared\fx_shared;
|
|
#using scripts\shared\sound_shared;
|
|
#using scripts\shared\system_shared;
|
|
#using scripts\shared\trigger_shared;
|
|
#using scripts\shared\util_shared;
|
|
|
|
|
|
|
|
#namespace exploder;
|
|
|
|
function autoexec __init__sytem__() { system::register("exploder",&__init__,&__main__,undefined); }
|
|
|
|
//TODO T7 make another pass when the system becomes string id only
|
|
//TODO T7 delete all server side functions that are now run on the client
|
|
function __init__()
|
|
{
|
|
level._client_exploders = [];
|
|
level._client_exploder_ids = [];
|
|
}
|
|
|
|
function __main__()
|
|
{
|
|
level.exploders = [];
|
|
|
|
// Hide exploder models.
|
|
ents = GetEntArray( "script_brushmodel", "classname" );
|
|
smodels = GetEntArray( "script_model", "classname" );
|
|
for ( i = 0; i < smodels.size; i++ )
|
|
{
|
|
ents[ents.size] = smodels[i];
|
|
}
|
|
|
|
for ( i = 0; i < ents.size; i++ )
|
|
{
|
|
if ( isdefined( ents[i].script_prefab_exploder ) )
|
|
{
|
|
ents[i].script_exploder = ents[i].script_prefab_exploder;
|
|
}
|
|
|
|
if ( isdefined( ents[i].script_exploder ) )
|
|
{
|
|
if ( ents[i].script_exploder < 10000 )
|
|
{
|
|
level.exploders[ents[i].script_exploder] = true; // nate. I wanted a list
|
|
}
|
|
|
|
if ( ( ents[i].model == "fx" ) &&( ( !isdefined( ents[i].targetname ) ) || ( ents[i].targetname != "exploderchunk" ) ) )
|
|
{
|
|
ents[i] Hide();
|
|
}
|
|
else if ( ( isdefined( ents[i].targetname ) ) &&( ents[i].targetname == "exploder" ) )
|
|
{
|
|
ents[i] Hide();
|
|
ents[i] NotSolid();
|
|
|
|
if( isdefined( ents[i].script_disconnectpaths ) )
|
|
{
|
|
ents[i] ConnectPaths();
|
|
}
|
|
}
|
|
else if ( ( isdefined( ents[i].targetname ) ) &&( ents[i].targetname == "exploderchunk" ) )
|
|
{
|
|
ents[i] Hide();
|
|
ents[i] NotSolid();
|
|
|
|
if( (isdefined(ents[i].spawnflags)&&((ents[i].spawnflags & 1) == 1)))
|
|
{
|
|
ents[i] ConnectPaths();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
script_exploders = [];
|
|
|
|
potentialExploders = GetEntArray( "script_brushmodel", "classname" );
|
|
for ( i = 0; i < potentialExploders.size; i++ )
|
|
{
|
|
if( isdefined( potentialExploders[i].script_prefab_exploder ) )
|
|
{
|
|
potentialExploders[i].script_exploder = potentialExploders[i].script_prefab_exploder;
|
|
}
|
|
|
|
if( isdefined( potentialExploders[i].script_exploder ) )
|
|
{
|
|
script_exploders[script_exploders.size] = potentialExploders[i];
|
|
}
|
|
}
|
|
|
|
/#println("Server : Potential exploders from brushmodels " + potentialExploders.size);#/
|
|
|
|
potentialExploders = GetEntArray( "script_model", "classname" );
|
|
for ( i = 0; i < potentialExploders.size; i++ )
|
|
{
|
|
if( isdefined( potentialExploders[i].script_prefab_exploder ) )
|
|
{
|
|
potentialExploders[i].script_exploder = potentialExploders[i].script_prefab_exploder;
|
|
}
|
|
|
|
if( isdefined( potentialExploders[i].script_exploder ) )
|
|
{
|
|
script_exploders[script_exploders.size] = potentialExploders[i];
|
|
}
|
|
}
|
|
|
|
/#println("Server : Potential exploders from script_model " + potentialExploders.size);#/
|
|
|
|
potentialExploders = GetEntArray( "item_health", "classname" );
|
|
for ( i = 0; i < potentialExploders.size; i++ )
|
|
{
|
|
if( isdefined( potentialExploders[i].script_prefab_exploder ) )
|
|
{
|
|
potentialExploders[i].script_exploder = potentialExploders[i].script_prefab_exploder;
|
|
}
|
|
|
|
if( isdefined( potentialExploders[i].script_exploder ) )
|
|
{
|
|
script_exploders[script_exploders.size] = potentialExploders[i];
|
|
}
|
|
}
|
|
|
|
/#println("Server : Potential exploders from item_health " + potentialExploders.size);#/
|
|
|
|
|
|
if( !isdefined( level.createFXent ) )
|
|
{
|
|
level.createFXent = [];
|
|
}
|
|
|
|
acceptableTargetnames = [];
|
|
acceptableTargetnames["exploderchunk visible"] = true;
|
|
acceptableTargetnames["exploderchunk"] = true;
|
|
acceptableTargetnames["exploder"] = true;
|
|
|
|
for ( i = 0; i < script_exploders.size; i ++ )
|
|
{
|
|
exploder = script_exploders[ i ];
|
|
ent = createExploder( exploder.script_fxid );
|
|
ent.v = [];
|
|
ent.v[ "origin" ] = exploder.origin;
|
|
ent.v[ "angles" ] = exploder.angles;
|
|
ent.v[ "delay" ] = exploder.script_delay;
|
|
ent.v[ "firefx" ] = exploder.script_firefx;
|
|
ent.v[ "firefxdelay" ] = exploder.script_firefxdelay;
|
|
ent.v[ "firefxsound" ] = exploder.script_firefxsound;
|
|
ent.v[ "firefxtimeout" ] = exploder.script_firefxtimeout;
|
|
ent.v[ "earthquake" ] = exploder.script_earthquake;
|
|
ent.v[ "damage" ] = exploder.script_damage;
|
|
ent.v[ "damage_radius" ] = exploder.script_radius;
|
|
ent.v[ "soundalias" ] = exploder.script_soundalias;
|
|
ent.v[ "repeat" ] = exploder.script_repeat;
|
|
ent.v[ "delay_min" ] = exploder.script_delay_min;
|
|
ent.v[ "delay_max" ] = exploder.script_delay_max;
|
|
ent.v[ "target" ] = exploder.target;
|
|
ent.v[ "ender" ] = exploder.script_ender;
|
|
ent.v[ "type" ] = "exploder";
|
|
// ent.v[ "worldfx" ] = true;
|
|
|
|
if ( !isdefined( exploder.script_fxid ) )
|
|
{
|
|
ent.v[ "fxid" ] = "No FX";
|
|
}
|
|
else
|
|
{
|
|
ent.v[ "fxid" ] = exploder.script_fxid;
|
|
}
|
|
|
|
ent.v[ "exploder" ] = exploder.script_exploder;
|
|
assert( isdefined( exploder.script_exploder ), "Exploder at origin " + exploder.origin + " has no script_exploder" );
|
|
|
|
if ( !isdefined( ent.v[ "delay" ] ) )
|
|
{
|
|
ent.v[ "delay" ] = 0;
|
|
}
|
|
|
|
if ( isdefined( exploder.target ) )
|
|
{
|
|
// BJoyal (1/12/12) - Added a check to see if the GetEnt returns undefined, in which case, use struct::get
|
|
e_target = GetEnt( ent.v[ "target" ], "targetname" );
|
|
if( !isdefined( e_target ) )
|
|
{
|
|
e_target = struct::get( ent.v[ "target" ], "targetname" );
|
|
}
|
|
|
|
org = e_target.origin;
|
|
ent.v[ "angles" ] = vectortoangles( org - ent.v[ "origin" ] );
|
|
// forward = anglestoforward( angles );
|
|
// up = anglestoup( angles );
|
|
}
|
|
|
|
// this basically determines if its a brush / model exploder or not
|
|
if ( exploder.classname == "script_brushmodel" || isdefined( exploder.model ) )
|
|
{
|
|
ent.model = exploder;
|
|
ent.model.disconnect_paths = exploder.script_disconnectpaths;
|
|
}
|
|
|
|
if ( isdefined( exploder.targetname ) && isdefined( acceptableTargetnames[ exploder.targetname ] ) )
|
|
{
|
|
ent.v[ "exploder_type" ] = exploder.targetname;
|
|
}
|
|
else
|
|
{
|
|
ent.v[ "exploder_type" ] = "normal";
|
|
}
|
|
}
|
|
|
|
level.createFXexploders = [];
|
|
|
|
for (i = 0; i < level.createFXent.size;i ++ )
|
|
{
|
|
ent = level.createFXent[i];
|
|
|
|
if(ent.v["type"] != "exploder")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ent.v["exploder_id"] = getExploderId( ent );
|
|
|
|
if (!isdefined(level.createFXexploders[ent.v["exploder"]]))
|
|
{
|
|
level.createFXexploders[ent.v["exploder"]] = [];
|
|
}
|
|
|
|
level.createFXexploders[ent.v["exploder"]][level.createFXexploders[ent.v["exploder"]].size] = ent;
|
|
|
|
}
|
|
|
|
level.radiantExploders = [];
|
|
|
|
|
|
reportExploderIds();
|
|
|
|
foreach ( trig in trigger::get_all() )
|
|
{
|
|
if ( isdefined( trig.script_prefab_exploder ) )
|
|
{
|
|
trig.script_exploder = trig.script_prefab_exploder;
|
|
}
|
|
|
|
if ( isdefined( trig.script_exploder ) )
|
|
{
|
|
level thread exploder_trigger( trig, trig.script_exploder );
|
|
}
|
|
|
|
if ( isdefined( trig.script_exploder_radiant ) )
|
|
{
|
|
level thread exploder_trigger( trig, trig.script_exploder_radiant );
|
|
}
|
|
|
|
if ( isdefined( trig.script_stop_exploder ) )
|
|
{
|
|
level trigger::add_function( trig, undefined, &stop_exploder, trig.script_stop_exploder );
|
|
}
|
|
|
|
if ( isdefined( trig.script_stop_exploder_radiant ) )
|
|
{
|
|
level trigger::add_function( trig, undefined, &stop_exploder, trig.script_stop_exploder_radiant );
|
|
}
|
|
}
|
|
}
|
|
|
|
function exploder_before_load( num )
|
|
{
|
|
// gotta wait twice because the createfx_init function waits once then inits all exploders. This guarentees
|
|
// that if an exploder is run on the first frame, it happens after the fx are init.
|
|
waittillframeend;
|
|
waittillframeend;
|
|
exploder( num );
|
|
}
|
|
|
|
function exploder( exploder_id )
|
|
{
|
|
if( IsInt( exploder_id ) )
|
|
{
|
|
activate_exploder( exploder_id );
|
|
}
|
|
else//This is a radiant exploder
|
|
{
|
|
activate_radiant_exploder( exploder_id );
|
|
}
|
|
}
|
|
|
|
function exploder_stop( num )
|
|
{
|
|
stop_exploder( num );
|
|
}
|
|
|
|
function exploder_sound()
|
|
{
|
|
if(isdefined(self.script_delay))
|
|
{
|
|
wait self.script_delay;
|
|
}
|
|
|
|
self playSound(level.scr_sound[self.script_sound]);
|
|
}
|
|
|
|
function cannon_effect()
|
|
{
|
|
if( isdefined( self.v[ "repeat" ] ) )
|
|
{
|
|
for( i = 0;i < self.v[ "repeat" ];i ++ )
|
|
{
|
|
playfx( level._effect[ self.v[ "fxid" ] ], self.v[ "origin" ], self.v[ "forward" ], self.v[ "up" ] );
|
|
//exploder_playSound();
|
|
self exploder_delay();
|
|
}
|
|
return;
|
|
}
|
|
|
|
self exploder_delay();
|
|
|
|
// playfx( level._effect[ self.v[ "fxid" ] ], self.v[ "origin" ], self.v[ "forward" ], self.v[ "up" ] );
|
|
if ( isdefined( self.looper ) )
|
|
{
|
|
self.looper delete();
|
|
}
|
|
|
|
self.looper = spawnFx( fx::get( self.v[ "fxid" ] ), self.v[ "origin" ], self.v[ "forward" ], self.v[ "up" ] );
|
|
triggerFx( self.looper );
|
|
exploder_playSound();
|
|
}
|
|
|
|
function fire_effect()
|
|
{
|
|
forward = self.v[ "forward" ];
|
|
up = self.v[ "up" ];
|
|
|
|
// org = undefined;
|
|
|
|
firefxSound = self.v[ "firefxsound" ];
|
|
origin = self.v[ "origin" ];
|
|
firefx = self.v[ "firefx" ];
|
|
ender = self.v[ "ender" ];
|
|
if( !isdefined( ender ) )
|
|
{
|
|
ender = "createfx_effectStopper";
|
|
}
|
|
|
|
fireFxDelay = 0.5;
|
|
if( isdefined( self.v[ "firefxdelay" ] ) )
|
|
{
|
|
fireFxDelay = self.v[ "firefxdelay" ];
|
|
}
|
|
|
|
self exploder_delay();
|
|
|
|
if( isdefined( firefxSound ) )
|
|
{
|
|
level thread sound::loop_fx_sound( firefxSound, origin, ender );
|
|
}
|
|
|
|
playfx( level._effect[ firefx ], self.v[ "origin" ], forward, up );
|
|
}
|
|
|
|
function sound_effect()
|
|
{
|
|
self effect_soundalias();
|
|
}
|
|
|
|
function effect_soundalias()
|
|
{
|
|
// save off this info in case we delete the effect
|
|
origin = self.v[ "origin" ];
|
|
alias = self.v[ "soundalias" ];
|
|
self exploder_delay();
|
|
sound::play_in_space( alias, origin );
|
|
}
|
|
|
|
function trail_effect()
|
|
{
|
|
self exploder_delay();
|
|
|
|
// self.trailfx_looper = _utility::PlayLoopedFX( level._effect[self.v["trailfx"]], self.v["trailfxdelay"], self.v["origin"], 0, self.v["forward"], self.v["up"]);
|
|
|
|
if( !isdefined( self.v["trailfxtag"] ) )
|
|
{
|
|
self.v["trailfxtag"] = "tag_origin";
|
|
}
|
|
|
|
temp_ent = undefined;
|
|
|
|
|
|
if(self.v["trailfxtag"] == "tag_origin")
|
|
{
|
|
PlayFxOnTag( level._effect[self.v["trailfx"]], self.model, self.v["trailfxtag"] );
|
|
}
|
|
else
|
|
{
|
|
temp_ent = Spawn( "script_model", self.model.origin );
|
|
temp_ent SetModel( "tag_origin" );
|
|
temp_ent LinkTo( self.model, self.v[ "trailfxtag" ] ); // TravisJ 2/16/2011 - temporary solution to playing FX off of tags; previously wouldn't work unless using tag_origin
|
|
PlayFxOnTag( level._effect[self.v["trailfx"]], temp_ent, "tag_origin" );
|
|
}
|
|
// self.trailfx_looper LinkTo( self, self.v["trailfxtag"] );
|
|
|
|
if( isdefined( self.v["trailfxsound"] ) )
|
|
{
|
|
// self.trailfx_looper PlayLoopSound( self.v["trailfxsound"] );
|
|
// self PlayLoopSound( self.v["trailfxsound"] );
|
|
if(!isdefined(temp_ent))
|
|
{
|
|
self.model PlayLoopSound( self.v["trailfxsound"] );
|
|
}
|
|
else
|
|
{
|
|
temp_ent PlayLoopSound( self.v["trailfxsound"] );
|
|
}
|
|
}
|
|
|
|
// TravisJ 2/16/2011 - allow deletion of temp fx ent for endon condition
|
|
if( isdefined( self.v[ "ender" ] ) && isdefined( temp_ent ) )
|
|
{
|
|
level thread trail_effect_ender( temp_ent, self.v[ "ender" ] );
|
|
}
|
|
|
|
if( !isdefined( self.v["trailfxtimeout"] ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
wait( self.v["trailfxtimeout"] );
|
|
// self.trailfx_looper Delete();
|
|
|
|
if(isdefined(temp_ent))
|
|
{
|
|
temp_ent Delete();
|
|
}
|
|
}
|
|
|
|
function trail_effect_ender( ent, ender )
|
|
{
|
|
ent endon( "death" );
|
|
self waittill( ender );
|
|
ent Delete();
|
|
}
|
|
|
|
function exploder_delay()
|
|
{
|
|
if( !isdefined( self.v[ "delay" ] ) )
|
|
{
|
|
self.v[ "delay" ] = 0;
|
|
}
|
|
|
|
min_delay = self.v[ "delay" ];
|
|
max_delay = self.v[ "delay" ] + 0.001;// cant randomfloatrange on the same #
|
|
if( isdefined( self.v[ "delay_min" ] ) )
|
|
{
|
|
min_delay = self.v[ "delay_min" ];
|
|
}
|
|
|
|
if( isdefined( self.v[ "delay_max" ] ) )
|
|
{
|
|
max_delay = self.v[ "delay_max" ];
|
|
}
|
|
|
|
if( min_delay > 0 )
|
|
{
|
|
wait( randomfloatrange( min_delay, max_delay ) );
|
|
}
|
|
}
|
|
|
|
function exploder_playSound()
|
|
{
|
|
if( !isdefined( self.v[ "soundalias" ] ) || self.v[ "soundalias" ] == "nil" )
|
|
{
|
|
return;
|
|
}
|
|
|
|
sound::play_in_space( self.v[ "soundalias" ], self.v[ "origin" ] );
|
|
}
|
|
|
|
function brush_delete()
|
|
{
|
|
num = self.v[ "exploder" ];
|
|
|
|
if( isdefined( self.v[ "delay" ] ) )
|
|
{
|
|
wait( self.v[ "delay" ] );
|
|
}
|
|
else
|
|
{
|
|
wait( .05 );// so it disappears after the replacement appears
|
|
}
|
|
|
|
if( !isdefined( self.model ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
assert( isdefined( self.model ) );
|
|
|
|
if( !isdefined( self.v[ "fxid" ] ) || self.v[ "fxid" ] == "No FX" )
|
|
{
|
|
self.v[ "exploder" ] = undefined;
|
|
}
|
|
|
|
waittillframeend;// so it hides stuff after it shows the new stuff
|
|
self.model delete();
|
|
}
|
|
|
|
function brush_show()
|
|
{
|
|
if( isdefined( self.v[ "delay" ] ) )
|
|
{
|
|
wait( self.v[ "delay" ] );
|
|
}
|
|
|
|
assert( isdefined( self.model ) );
|
|
|
|
self.model show();
|
|
self.model solid();
|
|
}
|
|
|
|
function 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 ) )
|
|
{
|
|
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 ];
|
|
|
|
self.model rotateVelocity( ( x, y, z ), 12 );
|
|
|
|
self.model moveGravity( ( x, y, z ), 12 );
|
|
|
|
self.v[ "exploder" ] = undefined;
|
|
wait( 6 );
|
|
self.model delete();
|
|
}
|
|
|
|
function exploder_trigger( trigger, script_value )
|
|
{
|
|
trigger endon( "death" );
|
|
|
|
level endon( "killexplodertridgers" + script_value );
|
|
|
|
trigger trigger::wait_till();
|
|
|
|
if( isdefined( trigger.script_chance ) && RandomFloat( 1 ) > trigger.script_chance )
|
|
{
|
|
if ( isdefined( trigger.script_delay ) )
|
|
{
|
|
wait( trigger.script_delay );
|
|
}
|
|
else
|
|
{
|
|
wait 4;
|
|
}
|
|
level thread exploder_trigger( trigger, script_value );
|
|
return;
|
|
}
|
|
|
|
exploder( script_value );
|
|
level notify( "killexplodertridgers" + script_value );
|
|
}
|
|
|
|
function 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]]);
|
|
}
|
|
#/
|
|
}
|
|
|
|
function 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"]];
|
|
}
|
|
|
|
function createExploder( fxid )
|
|
{
|
|
ent = fx::create_effect( "exploder", fxid );
|
|
ent.v[ "delay" ] = 0;
|
|
ent.v[ "exploder" ] = 1;
|
|
ent.v[ "exploder_type" ] = "normal";
|
|
|
|
return ent;
|
|
}
|
|
|
|
function activate_exploder( num )
|
|
{
|
|
num = int( num );
|
|
level notify( "exploder" + num );
|
|
|
|
client_send = true;
|
|
|
|
if(IsDefined(level.createFXexploders[num]))
|
|
{
|
|
for(i = 0; i < level.createFXexploders[num].size; i ++)
|
|
{
|
|
if(client_send && IsDefined(level.createFXexploders[num][i].v["exploder_server"]))
|
|
{
|
|
client_send = false;
|
|
}
|
|
|
|
level.createFXexploders[num][i] activate_individual_exploder( num );
|
|
}
|
|
}
|
|
|
|
if(level.clientScripts)
|
|
{
|
|
if(client_send == true)
|
|
{
|
|
activate_exploder_on_clients(num);
|
|
}
|
|
}
|
|
}
|
|
|
|
//TODO T7 - update this if other functionality comes online for the new system
|
|
function activate_radiant_exploder( string )
|
|
{
|
|
level notify( "exploder" + string );
|
|
|
|
ActivateClientRadiantExploder( string );
|
|
}
|
|
|
|
/@
|
|
"Name: activate_individual_exploder( num )"
|
|
"Summary: Activates an individual exploder, rather than all the exploders of a given number"
|
|
"Module: Utility"
|
|
"CallOn: An exploder"
|
|
"Example: exploder activate_individual_exploder( num );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
|
|
function activate_individual_exploder( num )
|
|
{
|
|
level notify("exploder" + self.v["exploder"]);
|
|
|
|
// CODER_MOD : DSL - Contents of if statement created on client.
|
|
// GLocke (12/8/2008) - checking for self.v["exploder_server"] instead of self.exploder_server
|
|
if(!level.clientScripts || !isdefined(level._exploder_ids[int(self.v["exploder"])] ) || isdefined(self.v["exploder_server"]))
|
|
{
|
|
/#
|
|
println("Exploder " + self.v["exploder"] + " created on 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();
|
|
}
|
|
}
|
|
|
|
// CODER_MOD : DSL - Stuff below here happens on the server.
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
function 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]);
|
|
}
|
|
|
|
function stop_exploder( num )
|
|
{
|
|
if(level.clientScripts)
|
|
{
|
|
delete_exploder_on_clients(num);
|
|
}
|
|
|
|
if(isdefined(level.createFXexploders[num]))
|
|
{
|
|
for(i = 0; i < level.createFXexploders[num].size; i ++)
|
|
{
|
|
|
|
if ( !isdefined( level.createFXexploders[num][i].looper ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
level.createFXexploders[num][i].looper delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
function delete_exploder_on_clients( exploder_id )
|
|
{
|
|
//Check if this is a radiant exploder first
|
|
if( IsString( exploder_id ) )
|
|
{
|
|
DeactivateClientRadiantExploder( exploder_id );
|
|
return;
|
|
}
|
|
|
|
if(!isdefined(level._exploder_ids[exploder_id]))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!isdefined(level._client_exploders[exploder_id]))
|
|
{
|
|
return;
|
|
}
|
|
|
|
level._client_exploders[exploder_id] = undefined;
|
|
|
|
level._client_exploder_ids[exploder_id] = undefined;
|
|
|
|
DeactivateClientExploder(level._exploder_ids[exploder_id]);
|
|
}
|
|
|
|
function kill_exploder( exploder_string )
|
|
{
|
|
if( IsString( exploder_string ) )
|
|
{
|
|
KillClientRadiantExploder( exploder_string );
|
|
return;
|
|
}
|
|
|
|
assertmsg( "unhandled exploder type, only radiant exploders are handled" );
|
|
}
|
|
|
|
function 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 );
|
|
// Range, max damage, min damage
|
|
self.model RadiusDamage( origin, radius, damage, damage / 3 );
|
|
}
|
|
|
|
function earthquake()
|
|
{
|
|
earthquake_name = self.v[ "earthquake" ];
|
|
|
|
assert(isdefined(level.earthquake) && isdefined(level.earthquake[earthquake_name]),
|
|
"No earthquake '" + earthquake_name + "' defined for exploder - call add_earthquake() in your level script.");
|
|
|
|
self exploder::exploder_delay();
|
|
eq = level.earthquake[earthquake_name];
|
|
earthquake( eq[ "magnitude" ], eq[ "duration" ], self.v[ "origin" ], eq[ "radius" ] );
|
|
}
|
|
|
|
function rumble()
|
|
{
|
|
self exploder_delay();
|
|
|
|
// TravisJ (2/14/2011) - replaced level.player reference with get_players loop, and added distance check
|
|
a_players = GetPlayers();
|
|
|
|
if( isdefined( self.v[ "damage_radius" ] ) )
|
|
{
|
|
n_rumble_threshold_squared = self.v[ "damage_radius" ] * self.v[ "damage_radius" ];
|
|
}
|
|
else
|
|
{
|
|
/#println( "exploder #" + self.v[ "exploder" ] + " missing script_radius KVP, using default." );#/
|
|
n_rumble_threshold_squared = 128 * 128; // default distance of exploder_damage is 128
|
|
}
|
|
|
|
for( i = 0; i < a_players.size; i++ )
|
|
{
|
|
n_player_dist_squared = distancesquared( a_players[ i ].origin, self.v[ "origin" ] );
|
|
|
|
if( n_player_dist_squared < n_rumble_threshold_squared )
|
|
{
|
|
a_players[ i ] PlayRumbleonentity( self.v[ "rumble" ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
function stop_after_duration( name, duration )
|
|
{
|
|
wait( duration );
|
|
stop_exploder( name );
|
|
}
|
|
|
|
|
|
function exploder_duration( name, duration )
|
|
{
|
|
if ( !( isdefined( duration ) && duration ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
exploder( name );
|
|
|
|
level thread stop_after_duration( name, duration );
|
|
}
|
|
|