1527 lines
39 KiB
Plaintext
1527 lines
39 KiB
Plaintext
#include common_scripts\utility;
|
|
|
|
/*QUAKED trigger_multiple_dyn_metal_detector (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
|
|
defaulttexture="flag"
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_multiple_dyn_creaky_board (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
|
|
defaulttexture="flag"
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_multiple_dyn_photo_copier (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
|
|
defaulttexture="flag"
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_multiple_dyn_copier_no_light (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
|
|
defaulttexture="flag"
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_radius_dyn_motion_light (0.12 0.23 1.0) (-16 -16 -16) (16 16 16)
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_radius_dyn_motion_dlight (0.12 0.23 1.0) (-16 -16 -16) (16 16 16)
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_multiple_dog_bark (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_radius_bird_startle (0.12 0.23 1.0) (-16 -16 -16) (16 16 16)
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_multiple_dyn_motion_light (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
|
|
defaulttexture="flag"
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_multiple_dyn_door (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
|
|
defaulttexture="flag"
|
|
Comments to be added.*/
|
|
|
|
/*QUAKED trigger_multiple_freefall (0.12 0.23 1.0) ? AI_AXIS AI_ALLIES AI_NEUTRAL NOTPLAYER VEHICLE TRIGGER_SPAWN TOUCH_ONCE
|
|
defaulttexture="flag"
|
|
Player free falling with animation and screaming of doom.*/
|
|
|
|
// Crouch Speed 5.7-6.0
|
|
// Run Speed 8.7-9.2
|
|
// Sprint Speed 13.0-14.0
|
|
|
|
|
|
// ========================= Constants ==========================
|
|
|
|
// Vending Machine
|
|
CONST_vending_machine_health = 400;
|
|
CONST_soda_pop_time = 0.1; // seconds
|
|
CONST_soda_count = 12; // number of soda per machine
|
|
CONST_soda_launch_force = 1000; // soda shoot out force
|
|
CONST_soda_random_factor = 0.15; // in percentage 0.2 = 20%
|
|
CONST_soda_splash_dmg_scaler = 3; // splash damage multiplier
|
|
|
|
// Metal Detector
|
|
CONST_alarm_tolerance = 0; // number of alarm sounds before silenced, 0 disables silencing
|
|
CONST_alarm_interval = 7; // alarm interval time in seconds
|
|
CONST_alarm_interval_sp = 2; // alarm interval time in seconds for single player
|
|
|
|
// Civilian Jet
|
|
CONST_jet_speed = 2000; // jet while landing is 130 - 160mph( 2292inch / sec - 2820inch / sec ), emergency landing is 110mph
|
|
CONST_jet_extend = 20000; // units, each jet and flyto origin will extend from each other by
|
|
|
|
init()
|
|
{
|
|
|
|
//rotate fan blades in mp_highrise
|
|
array_thread( getEntArray( "com_wall_fan_blade_rotate", "targetname" ), ::fan_blade_rotate, "slow" );
|
|
array_thread( getEntArray( "com_wall_fan_blade_rotate_fast", "targetname" ), ::fan_blade_rotate, "fast" );
|
|
|
|
trigger_classes = [];
|
|
trigger_classes[ "trigger_multiple_dyn_metal_detector" ] = ::metal_detector;
|
|
trigger_classes[ "trigger_multiple_dyn_creaky_board" ] = ::creaky_board;
|
|
trigger_classes[ "trigger_multiple_dyn_photo_copier" ] = ::photo_copier;
|
|
trigger_classes[ "trigger_multiple_dyn_copier_no_light" ] = ::photo_copier_no_light;
|
|
trigger_classes[ "trigger_radius_motion_light" ] = ::motion_light;
|
|
trigger_classes[ "trigger_radius_dyn_motion_dlight" ] = ::outdoor_motion_dlight;
|
|
trigger_classes[ "trigger_multiple_dog_bark" ] = ::dog_bark;
|
|
trigger_classes[ "trigger_radius_bird_startle" ] = ::bird_startle;
|
|
trigger_classes[ "trigger_multiple_dyn_motion_light" ] = ::motion_light;
|
|
trigger_classes[ "trigger_multiple_dyn_door" ] = ::trigger_door;
|
|
//trigger_classes[ "trigger_multiple_freefall" ] = ::freefall;
|
|
|
|
player_init();
|
|
|
|
foreach ( classname, function in trigger_classes )
|
|
{
|
|
triggers = getEntArray( classname, "classname" );
|
|
array_thread( triggers, ::triggerTouchThink );
|
|
array_thread( triggers, function );
|
|
}
|
|
|
|
array_thread( getEntArray( "vending_machine", "targetname" ), ::vending_machine );
|
|
array_thread( getEntArray( "toggle", "targetname" ), ::use_toggle );
|
|
|
|
level thread onPlayerConnect();
|
|
|
|
civilian_jet = getEnt( "civilian_jet_origin", "targetname" );
|
|
if ( isDefined( civilian_jet ) )
|
|
civilian_jet thread civilian_jet_flyby();
|
|
}
|
|
|
|
onPlayerConnect()
|
|
{
|
|
for ( ;; )
|
|
{
|
|
level waittill( "connecting", player );
|
|
player thread movementTracker();
|
|
}
|
|
}
|
|
|
|
player_init()
|
|
{
|
|
if ( isSP() )
|
|
{
|
|
foreach ( player in level.players )
|
|
{
|
|
player.touchTriggers = [];
|
|
player thread movementTracker();
|
|
}
|
|
}
|
|
}
|
|
|
|
ai_init()
|
|
{
|
|
/*if ( !isdefined( level.registeredAI ) )
|
|
level.registeredAI = [];
|
|
|
|
level.registeredAI[ level.registeredAI.size ] = self;
|
|
*/
|
|
|
|
// self is AI
|
|
self.touchTriggers = [];
|
|
self thread movementTracker();
|
|
}
|
|
|
|
|
|
// ================================================================================ //
|
|
// Civilian Jet //
|
|
// ================================================================================ //
|
|
|
|
civilian_jet_flyby()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
self jet_init();
|
|
|
|
level waittill( "prematch_over" );
|
|
|
|
while ( 1 )
|
|
{
|
|
self thread jet_timer();
|
|
self waittill( "start_flyby" );
|
|
|
|
self thread jet_flyby();
|
|
self waittill( "flyby_done" );
|
|
|
|
self jet_reset();
|
|
}
|
|
}
|
|
|
|
|
|
jet_init()
|
|
{
|
|
// move jet plane and flyto origin out of the map and hide on level load
|
|
self.jet_parts = getentarray( self.target, "targetname" );
|
|
self.jet_flyto = getent( "civilian_jet_flyto", "targetname" );
|
|
self.engine_fxs = getentarray( "engine_fx", "targetname" );
|
|
self.flash_fxs = getentarray( "flash_fx", "targetname" );
|
|
|
|
self.jet_engine_fx = loadfx( "fire/jet_afterburner" );
|
|
self.jet_flash_fx_red = loadfx( "misc/aircraft_light_wingtip_red" );
|
|
self.jet_flash_fx_green = loadfx( "misc/aircraft_light_wingtip_green" );
|
|
self.jet_flash_fx_blink = loadfx( "misc/aircraft_light_red_blink" );
|
|
|
|
level.civilianJetFlyBy = undefined; // priority with air supremacies
|
|
|
|
assertex( isdefined( self.jet_parts ), "Missing cilivian jet model" );
|
|
assertex( isdefined( self.jet_flyto ), "Missing cilivian jet flyto script_origin: civilian_jet_flyto" );
|
|
assertex( isdefined( self.engine_fxs ), "Missing cilivian jet engine fxs script_origins: engine_fx" );
|
|
assertex( isdefined( self.flash_fxs ), "Missing cilivian jet signal light script_origins: flash_fxs" );
|
|
|
|
// extending vector to place jet and flyto origin outside sky box
|
|
negative_vec = Vector_multiply( VectorNormalize( self.origin - self.jet_flyto.origin ), CONST_jet_extend );
|
|
|
|
// extend flyto origin
|
|
self.jet_flyto.origin -= negative_vec;
|
|
|
|
// extend jet
|
|
self.origin += negative_vec;
|
|
foreach ( part in self.jet_parts )
|
|
{
|
|
part.origin += negative_vec;
|
|
part.old_origin = part.origin;
|
|
part hide();
|
|
}
|
|
|
|
// extend jet's engine fx origins
|
|
foreach ( engine_fx in self.engine_fxs )
|
|
engine_fx.origin += negative_vec;
|
|
|
|
foreach ( flash_fx in self.flash_fxs )
|
|
flash_fx.origin += negative_vec;
|
|
|
|
// -------------- flight time and vector calculation -------------
|
|
jet_origin = self.origin;// origin is the nose of the jet
|
|
jet_flyto_pos = self.jet_flyto.origin;
|
|
self.jet_fly_vec = jet_flyto_pos - jet_origin;
|
|
|
|
jet_speed = CONST_jet_speed;
|
|
jet_flight_dist = abs( distance( jet_origin, jet_flyto_pos ) );
|
|
self.jet_flight_time = jet_flight_dist / jet_speed;
|
|
}
|
|
|
|
|
|
jet_reset()
|
|
{
|
|
foreach ( part in self.jet_parts )
|
|
{
|
|
part.origin = part.old_origin;
|
|
part hide();
|
|
}
|
|
}
|
|
|
|
|
|
jet_timer()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
match_timelimit = getTimeInterval();
|
|
assert( isdefined( match_timelimit ) );
|
|
timelimit = max( 10, match_timelimit );
|
|
timelimit = min( timelimit, 100 );
|
|
|
|
if ( getdvar( "jet_flyby_timer" ) != "" )
|
|
level.civilianJetFlyBy_timer = 5 + getdvarint( "jet_flyby_timer" );
|
|
else
|
|
level.civilianJetFlyBy_timer = ( 0.25 + randomFloatRange( 0.3, 0.7 ) ) * 60 * timeLimit; // seconds into the match when jet flys by
|
|
|
|
wait level.civilianJetFlyBy_timer;
|
|
|
|
// wait till all the airborne kill streaks are done
|
|
while ( isDefined( level.airstrikeInProgress ) || isDefined( level.ac130player ) || isDefined( level.chopper ) || isDefined( level.remoteMissileInProgress ) )
|
|
wait 0.05;
|
|
|
|
// start flyby
|
|
self notify( "start_flyby" );
|
|
|
|
// blocks out all airborne kill streaks
|
|
level.civilianJetFlyBy = true;
|
|
self waittill( "flyby_done" );
|
|
level.civilianJetFlyBy = undefined;
|
|
}
|
|
|
|
getTimeInterval()
|
|
{
|
|
if ( isSP() )
|
|
return 10.0;
|
|
|
|
if ( isDefined( game[ "status" ] ) && game[ "status" ] == "overtime" )
|
|
return 1.0;
|
|
else
|
|
return getWatchedDvar( "timelimit" );
|
|
}
|
|
|
|
getWatchedDvar( dvarString )
|
|
{
|
|
dvarString = "scr_" + level.gameType + "_" + dvarString;
|
|
return( level.watchDvars[ dvarString ].value );
|
|
}
|
|
|
|
|
|
jet_flyby()
|
|
{
|
|
// show plane
|
|
foreach ( part in self.jet_parts )
|
|
part show();
|
|
|
|
engine_fx_array = [];
|
|
flash_fx_array = [];
|
|
|
|
foreach ( engine_fx in self.engine_fxs )
|
|
{
|
|
engine_fx_ent = spawn( "script_model", engine_fx.origin );
|
|
engine_fx_ent setModel( "tag_origin" );
|
|
engine_fx_ent.angles = engine_fx.angles;
|
|
engine_fx_array [ engine_fx_array.size ] = engine_fx_ent;
|
|
}
|
|
|
|
foreach ( flash_fx in self.flash_fxs )
|
|
{
|
|
flash_fx_ent = spawn( "script_model", flash_fx.origin );
|
|
flash_fx_ent setModel( "tag_origin" );
|
|
flash_fx_ent.color = flash_fx.script_noteworthy;
|
|
flash_fx_ent.angles = flash_fx.angles;
|
|
flash_fx_array [ flash_fx_array.size ] = flash_fx_ent;
|
|
}
|
|
|
|
assertex( isdefined( level.mapcenter ), "Calling for civilian jet flyby when level.mapcenter is not yet defined." );
|
|
self thread jet_planeSound( self.jet_parts[ 0 ], level.mapcenter );
|
|
|
|
wait 0.05;
|
|
|
|
// play engine fx on fx ents
|
|
foreach ( engine_fx_ent in engine_fx_array )
|
|
playfxontag( self.jet_engine_fx, engine_fx_ent, "tag_origin" );
|
|
|
|
// play flash fx on fx ents
|
|
foreach ( flash_fx_ent in flash_fx_array )
|
|
{
|
|
if ( isdefined( flash_fx_ent.color ) && flash_fx_ent.color == "blink" )
|
|
playfxontag( self.jet_flash_fx_blink, flash_fx_ent, "tag_origin" );
|
|
else if ( isdefined( flash_fx_ent.color ) && flash_fx_ent.color == "red" )
|
|
playfxontag( self.jet_flash_fx_red, flash_fx_ent, "tag_origin" );
|
|
else
|
|
playfxontag( self.jet_flash_fx_green, flash_fx_ent, "tag_origin" );
|
|
}
|
|
|
|
// move plane
|
|
foreach ( part in self.jet_parts )
|
|
part moveTo( part.origin + self.jet_fly_vec, self.jet_flight_time );
|
|
|
|
// move fx ents
|
|
foreach ( engine_fx_ent in engine_fx_array )
|
|
engine_fx_ent moveTo( engine_fx_ent.origin + self.jet_fly_vec, self.jet_flight_time );
|
|
foreach ( flash_fx_ent in flash_fx_array )
|
|
flash_fx_ent moveTo( flash_fx_ent.origin + self.jet_fly_vec, self.jet_flight_time );
|
|
|
|
wait( self.jet_flight_time + 1 );
|
|
|
|
// delete fxs
|
|
foreach ( engine_fx_ent in engine_fx_array )
|
|
engine_fx_ent delete();
|
|
foreach ( flash_fx_ent in flash_fx_array )
|
|
flash_fx_ent delete();
|
|
|
|
self notify( "flyby_done" );
|
|
}
|
|
|
|
|
|
jet_planeSound( plane, bombsite )
|
|
{
|
|
plane thread playsound_loop_on_ent( "veh_mig29_dist_loop" );
|
|
while ( !targetisclose( plane, bombsite ) )
|
|
wait .05;
|
|
|
|
plane thread playsound_loop_on_ent( "veh_mig29_close_loop" );
|
|
while ( targetisinfront( plane, bombsite ) )
|
|
wait .05;
|
|
wait .5;
|
|
|
|
plane thread playsound_float( "veh_mig29_sonic_boom" );
|
|
while ( targetisclose( plane, bombsite ) )
|
|
wait .05;
|
|
|
|
plane notify( "stop sound" + "veh_mig29_close_loop" );
|
|
self waittill( "flyby_done" );
|
|
|
|
plane notify( "stop sound" + "veh_mig29_dist_loop" );
|
|
}
|
|
|
|
|
|
playsound_float( alias, origin, master )
|
|
{
|
|
org = spawn( "script_origin", ( 0, 0, 1 ) );
|
|
org hide();
|
|
if ( !isdefined( origin ) )
|
|
origin = self.origin;
|
|
org.origin = origin;
|
|
if ( isdefined( master ) && master )
|
|
org playsoundasmaster( alias );
|
|
else
|
|
org playsound( alias );
|
|
wait( 10.0 );
|
|
org delete();
|
|
}
|
|
|
|
|
|
playsound_loop_on_ent( alias, offset )
|
|
{
|
|
org = spawn( "script_origin", ( 0, 0, 0 ) );
|
|
org hide();
|
|
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 endon ("death");
|
|
org playloopsound( alias );
|
|
// println ("playing loop sound ", alias," on entity at origin ", self.origin, " at ORIGIN ", org.origin);
|
|
self waittill( "stop sound" + alias );
|
|
org stoploopsound( alias );
|
|
org delete();
|
|
}
|
|
|
|
targetisinfront( other, target )
|
|
{
|
|
forwardvec = anglestoforward( flat_angle( other.angles ) );
|
|
normalvec = vectorNormalize( flat_origin( target ) - other.origin );
|
|
dot = vectordot( forwardvec, normalvec );
|
|
|
|
if ( dot > 0 )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
targetisclose( other, target )
|
|
{
|
|
infront = targetisinfront( other, target );
|
|
|
|
if ( infront )
|
|
dir = 1;
|
|
else
|
|
dir = -1;
|
|
|
|
a = flat_origin( other.origin );
|
|
b = a + Vector_Multiply( anglestoforward( flat_angle( other.angles ) ), ( dir * 100000 ) );
|
|
point = pointOnSegmentNearestToPoint( a, b, target );
|
|
dist = distance( a, point );
|
|
|
|
if ( dist < 3000 )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
// ================================================================================ //
|
|
// Vending Machine //
|
|
// ================================================================================ //
|
|
|
|
vending_machine()
|
|
{
|
|
level endon( "game_ended" );
|
|
self endon( "death" );
|
|
|
|
// self is use trigger
|
|
self SetCursorHint( "HINT_ACTIVATE" );
|
|
|
|
self.vm_normal = getent( self.target, "targetname" );
|
|
assertex( isdefined( self.vm_normal ), "Vending machine use trigger is missing target to the normal vending machine script_model" );
|
|
vm_soda_start = getent( self.vm_normal.target, "targetname" );
|
|
assertex( isdefined( vm_soda_start ), "Vending machine normal script_model is missing target to the start-soda can script_model" );
|
|
vm_soda_stop = getent( vm_soda_start.target, "targetname" );
|
|
assertex( isdefined( vm_soda_start ), "Start-soda can script_model is missing target to the end-soda can script_model" );
|
|
self.vm_launch_from = getent( vm_soda_stop.target, "targetname" );
|
|
assertex( isdefined( self.vm_launch_from ), "End-soda can script_model is missing target to the physics launch-from script_origin" );
|
|
self.vm_launch_to = getent( self.vm_launch_from.target, "targetname" );
|
|
assertex( isdefined( self.vm_launch_to ), "launch-from can script_origin is missing target to the physics launch-to script_origin" );
|
|
|
|
if ( isdefined( self.vm_launch_to.target ) )
|
|
self.vm_fx_loc = getent( self.vm_launch_to.target, "targetname" );
|
|
|
|
//assertex( isdefined( self.vm_launch_to ), "launch-to can script_origin is missing target to the fx location script_origin" );
|
|
|
|
self.vm_normal setCanDamage( true );
|
|
|
|
self.vm_normal_model = self.vm_normal.model;
|
|
self.vm_damaged_model = self.vm_normal.script_noteworthy;
|
|
self.vm_soda_model = vm_soda_start.model;
|
|
|
|
self.vm_soda_start_pos = vm_soda_start.origin;
|
|
self.vm_soda_start_angle = vm_soda_start.angles;
|
|
self.vm_soda_stop_pos = vm_soda_stop.origin;
|
|
self.vm_soda_stop_angle = vm_soda_stop.angles;
|
|
|
|
// precache damage model
|
|
precacheModel( self.vm_damaged_model );
|
|
|
|
// ride the no longer needed models
|
|
vm_soda_start delete();
|
|
vm_soda_stop delete();
|
|
|
|
self.soda_array = [];
|
|
self.soda_count = CONST_soda_count;
|
|
self.soda_slot = undefined;// the soda can thats resting in the slot
|
|
self.hp = CONST_vending_machine_health;
|
|
|
|
self thread vending_machine_damage_monitor( self.vm_normal );
|
|
self playloopsound( "vending_machine_hum" );
|
|
|
|
while ( 1 )
|
|
{
|
|
self waittill( "trigger", player );
|
|
//level.players[0] iprintln( "used" );
|
|
|
|
self playsound( "vending_machine_button_press" );
|
|
if ( !self.soda_count )
|
|
continue;
|
|
|
|
// drop a can, and shoot out the previous one if in slot
|
|
if ( isdefined( self.soda_slot ) )
|
|
self soda_can_eject();
|
|
soda_can_drop( spawn_soda() );
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
vending_machine_damage_monitor( vending_machine )
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
exp_dmg = "mod_grenade mod_projectile mod_explosive mod_grenade_splash mod_projectile_splash splash";
|
|
sparks_fx = loadfx( "explosions/tv_explosion" );
|
|
|
|
while ( 1 )
|
|
{
|
|
vending_machine waittill( "damage", damage, other, direction_vec, P, type );
|
|
|
|
if ( isdefined( type ) )
|
|
{
|
|
if ( isSubStr( exp_dmg, ToLower( type ) ) )
|
|
damage *= CONST_soda_splash_dmg_scaler; // multiply explosive dmg
|
|
|
|
self.hp -= damage;
|
|
if ( self.hp > 0 )
|
|
continue;
|
|
|
|
// vending machine is now dead, button usage is disabled
|
|
self notify( "death" );
|
|
|
|
// disable use trigger
|
|
self.origin += ( 0, 0, 10000 );
|
|
|
|
if( !isdefined( self.vm_fx_loc ) )
|
|
playfx_loc = self.vm_normal.origin + ( ( 17, -13, 52 ) - ( -20, 18, 0 ) );
|
|
else
|
|
playfx_loc = self.vm_fx_loc.origin;
|
|
|
|
playfx( sparks_fx, playfx_loc );
|
|
|
|
// when vending machine is explosively damaged, shoots out soda cans
|
|
self.vm_normal setmodel( self.vm_damaged_model );
|
|
|
|
while ( self.soda_count > 0 )
|
|
{
|
|
// drop a can, and shoot out the previous one if in slot
|
|
if ( isdefined( self.soda_slot ) )
|
|
self soda_can_eject();
|
|
soda_can_drop( spawn_soda() );
|
|
wait 0.05;
|
|
}
|
|
|
|
self stoploopsound( "vending_machine_hum" );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
spawn_soda()
|
|
{
|
|
soda = spawn( "script_model", self.vm_soda_start_pos );
|
|
soda setmodel( self.vm_soda_model );
|
|
soda.origin = self.vm_soda_start_pos;
|
|
soda.angles = self.vm_soda_start_angle;
|
|
return soda;
|
|
}
|
|
|
|
soda_can_drop( soda )
|
|
{
|
|
soda MoveTo( self.vm_soda_stop_pos, CONST_soda_pop_time );
|
|
soda playsound( "vending_machine_soda_drop" ); // soda can drop sound
|
|
wait CONST_soda_pop_time;
|
|
|
|
self.soda_slot = soda;
|
|
self.soda_count -- ;
|
|
}
|
|
|
|
soda_can_eject()
|
|
{
|
|
self endon( "death" );
|
|
|
|
if( isdefined( self.soda_slot.ejected ) && self.soda_slot.ejected == true )
|
|
return;
|
|
|
|
// physics launch
|
|
force_max = CONST_soda_launch_force * ( 1 + CONST_soda_random_factor );
|
|
force_min = force_max * 0.75 * ( 1 + CONST_soda_random_factor );
|
|
|
|
launch_vec = vectorNormalize( self.vm_launch_to.origin - self.vm_launch_from.origin );
|
|
force_vec = vector_multiply( launch_vec, randomfloatrange( force_min, force_max ) );
|
|
launch_force_vec = ( force_vec[ 0 ] * randomfloatrange( 1, 1 + CONST_soda_random_factor ), force_vec[ 1 ] * randomfloatrange( 1, 1 + CONST_soda_random_factor ), force_vec[ 2 ] * randomfloatrange( 1, 1 + CONST_soda_random_factor ) );
|
|
|
|
self.soda_slot PhysicsLaunchClient( self.vm_launch_from.origin, launch_force_vec );
|
|
self.soda_slot.ejected = true;
|
|
}
|
|
|
|
// ================================================================================ //
|
|
// Free Fall //
|
|
// ================================================================================ //
|
|
|
|
freefall()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
freefall_weapon = "briefcase_bomb_mp";
|
|
precacheItem( freefall_weapon );
|
|
|
|
while ( 1 )
|
|
{
|
|
self waittill( "trigger_enter", player );
|
|
|
|
if ( !( player hasWeapon( freefall_weapon ) ) )
|
|
{
|
|
player playsound( "freefall_death" );
|
|
|
|
player giveweapon( freefall_weapon );
|
|
player setWeaponAmmoStock( freefall_weapon, 0 );
|
|
player setWeaponAmmoClip( freefall_weapon, 0 );
|
|
player switchToWeapon( freefall_weapon );
|
|
}
|
|
}
|
|
}
|
|
|
|
// ================================================================================ //
|
|
// Metal Detector //
|
|
// ================================================================================ //
|
|
|
|
metal_detector()
|
|
{
|
|
// self is trigger: trigger_multiple_dyn_metal_detector
|
|
|
|
level endon( "game_ended" );
|
|
assertex( isdefined( self.target ), "trigger_multiple_dyn_metal_detector is missing target damage trigger used for detecting entities other than players" );
|
|
|
|
damage_trig = getent( self.target, "targetname" );
|
|
damage_trig EnableGrenadeTouchDamage();
|
|
|
|
bound_org_1 = getent( damage_trig.target, "targetname" );
|
|
bound_org_2 = getent( bound_org_1.target, "targetname" );
|
|
|
|
assertex( isdefined( bound_org_1 ) && isdefined( bound_org_2 ), "Metal detector missing bound origins for claymore test" );
|
|
|
|
detector_1 = getent( bound_org_2.target, "targetname" );
|
|
detector_2 = getent( detector_1.target, "targetname" );
|
|
|
|
assertex( isdefined( detector_1 ) && isdefined( detector_2 ), "Recompile the bsp to fix this, metal detector prefab changed." );
|
|
|
|
bounds = [];
|
|
bound_x_min = min( bound_org_1.origin[ 0 ], bound_org_2.origin[ 0 ] ); bounds[ 0 ] = bound_x_min;
|
|
bound_x_max = max( bound_org_1.origin[ 0 ], bound_org_2.origin[ 0 ] ); bounds[ 1 ] = bound_x_max;
|
|
bound_y_min = min( bound_org_1.origin[ 1 ], bound_org_2.origin[ 1 ] ); bounds[ 2 ] = bound_y_min;
|
|
bound_y_max = max( bound_org_1.origin[ 1 ], bound_org_2.origin[ 1 ] ); bounds[ 3 ] = bound_y_max;
|
|
bound_z_min = min( bound_org_1.origin[ 2 ], bound_org_2.origin[ 2 ] ); bounds[ 4 ] = bound_z_min;
|
|
bound_z_max = max( bound_org_1.origin[ 2 ], bound_org_2.origin[ 2 ] ); bounds[ 5 ] = bound_z_max;
|
|
|
|
bound_org_1 delete();
|
|
bound_org_2 delete();
|
|
|
|
if ( !isSP() )
|
|
self.alarm_interval = CONST_alarm_interval;
|
|
else
|
|
self.alarm_interval = CONST_alarm_interval_sp;
|
|
|
|
self.alarm_playing = 0;
|
|
self.alarm_annoyance = 0;
|
|
self.tolerance = CONST_alarm_tolerance;
|
|
|
|
self thread metal_detector_dmg_monitor( damage_trig );
|
|
self thread metal_detector_touch_monitor();
|
|
self thread metal_detector_weapons( bounds, "weapon_claymore", "weapon_c4" );
|
|
|
|
light_pos1 = ( detector_1.origin[ 0 ], detector_1.origin[ 1 ], bound_z_max );
|
|
light_pos2 = ( detector_2.origin[ 0 ], detector_2.origin[ 1 ], bound_z_max );
|
|
|
|
//light_pos1 = ( bound_x_min, bound_y_min, bound_z_max );
|
|
//light_pos2 = ( bound_x_max, bound_y_max, bound_z_max );
|
|
md_light = loadfx( "props/metal_detector_light" );
|
|
|
|
while ( 1 )
|
|
{
|
|
self waittill_any( "dmg_triggered", "touch_triggered", "weapon_triggered" );
|
|
self thread playsound_and_light( "alarm_metal_detector", md_light, light_pos1, light_pos2 );
|
|
}
|
|
}
|
|
|
|
playsound_and_light( sound, light, light_pos1, light_pos2 )
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
if ( !self.alarm_playing )
|
|
{
|
|
self.alarm_playing = 1;
|
|
self thread annoyance_tracker();
|
|
|
|
if ( !self.alarm_annoyance )
|
|
self playsound( sound );
|
|
|
|
// 1000ms red light fx
|
|
playfx( light, light_pos1 );
|
|
playfx( light, light_pos2 );
|
|
|
|
wait self.alarm_interval;
|
|
self.alarm_playing = 0;
|
|
}
|
|
}
|
|
|
|
annoyance_tracker()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
if ( !self.tolerance )
|
|
return;
|
|
|
|
interval = self.alarm_interval + 0.15;
|
|
if ( self.tolerance )
|
|
self.tolerance -- ;
|
|
else
|
|
self.alarm_annoyance = 1;
|
|
|
|
current_time = gettime();// ms
|
|
|
|
alarm_timeout = CONST_alarm_interval;
|
|
if ( isSP() )
|
|
alarm_timeout = CONST_alarm_interval_sp;
|
|
|
|
self waittill_any_or_timeout( "dmg_triggered", "touch_triggered", "weapon_triggered", ( alarm_timeout + 2 ) );
|
|
|
|
time_delta = ( gettime() - current_time );
|
|
if ( time_delta > ( ( alarm_timeout * 1000 ) + 1150 ) )
|
|
{
|
|
self.alarm_annoyance = 0;
|
|
self.tolerance = CONST_alarm_tolerance;
|
|
}
|
|
}
|
|
|
|
waittill_any_or_timeout( msg1, msg2, msg3, timer )
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
self endon( msg1 );
|
|
self endon( msg2 );
|
|
self endon( msg3 );
|
|
wait timer;
|
|
}
|
|
|
|
metal_detector_weapons( bounds, weapon_1, weapon_2 )
|
|
{
|
|
level endon( "game_ended" );
|
|
while ( 1 )
|
|
{
|
|
self waittill_weapon_placed();
|
|
|
|
all_grenades = getentarray( "grenade", "classname" );
|
|
foreach ( grenade in all_grenades )
|
|
{
|
|
if ( isdefined( grenade.model ) && ( grenade.model == weapon_1 || grenade.model == weapon_2 ) )
|
|
{
|
|
if ( isInBound( grenade, bounds ) )
|
|
self thread weapon_notify_loop( grenade, bounds );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
waittill_weapon_placed()
|
|
{
|
|
level endon( "game_ended" );
|
|
self endon( "dmg_triggered" );
|
|
self waittill( "touch_triggered" );
|
|
}
|
|
|
|
weapon_notify_loop( grenade, bounds )
|
|
{
|
|
grenade endon( "death" );
|
|
|
|
while ( isInBound( grenade, bounds ) )
|
|
{
|
|
self notify( "weapon_triggered" );
|
|
wait self.alarm_interval;
|
|
}
|
|
}
|
|
|
|
isInBound( ent, bounds )
|
|
{
|
|
bound_x_min = bounds[ 0 ]; bound_x_max = bounds[ 1 ];
|
|
bound_y_min = bounds[ 2 ]; bound_y_max = bounds[ 3 ];
|
|
bound_z_min = bounds[ 4 ]; bound_z_max = bounds[ 5 ];
|
|
|
|
ent_x = ent.origin[ 0 ];
|
|
ent_y = ent.origin[ 1 ];
|
|
ent_z = ent.origin[ 2 ];
|
|
|
|
if ( isInBound_single( ent_x, bound_x_min, bound_x_max ) )
|
|
{
|
|
if ( isInBound_single( ent_y, bound_y_min, bound_y_max ) )
|
|
{
|
|
if ( isInBound_single( ent_z, bound_z_min, bound_z_max ) )
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
isInBound_single( var, v_min, v_max )
|
|
{
|
|
if ( var > v_min && var < v_max )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
metal_detector_dmg_monitor( damage_trig )
|
|
{
|
|
level endon( "game_ended" );
|
|
while ( 1 )
|
|
{
|
|
damage_trig waittill( "damage", damage, other, direction_vec, P, type );
|
|
if ( isdefined( type ) && alarm_validate_damage( type ) )
|
|
self notify( "dmg_triggered" );
|
|
}
|
|
}
|
|
|
|
metal_detector_touch_monitor()
|
|
{
|
|
level endon( "game_ended" );
|
|
while ( 1 )
|
|
{
|
|
self waittill( "trigger_enter" );
|
|
while ( anythingTouchingTrigger( self ) )
|
|
{
|
|
self notify( "touch_triggered" );
|
|
wait self.alarm_interval;
|
|
}
|
|
}
|
|
}
|
|
|
|
alarm_validate_damage( damageType )
|
|
{
|
|
//disallowed_dmg = "mod_pistol_bullet mod_rifle_bullet bullet mod_crush mod_grenade_splash mod_projectile_splash splash unknown";
|
|
//disallowed_dmg_array = strtok( disallowed_damage, " " );
|
|
|
|
allowed_dmg = "mod_melee melee mod_grenade mod_projectile mod_explosive mod_impact";
|
|
allowed_dmg_array = strtok( allowed_dmg, " " );
|
|
|
|
foreach ( dmg in allowed_dmg_array )
|
|
{
|
|
if ( ToLower( dmg ) == ToLower( damageType ) )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
// ================================================================================ //
|
|
|
|
|
|
creaky_board()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger_enter", player );
|
|
player thread do_creak( self );
|
|
}
|
|
}
|
|
|
|
|
|
do_creak( trigger )
|
|
{
|
|
self endon( "disconnect" );
|
|
self endon( "death" );
|
|
|
|
self playSound( "step_walk_plr_woodcreak_on" );
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger_leave", leftTrigger );
|
|
if ( trigger != leftTrigger )
|
|
continue;
|
|
|
|
self playSound( "step_walk_plr_woodcreak_off" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
motion_light()
|
|
{
|
|
level endon( "game_ended" );
|
|
self.moveTracker = true;
|
|
|
|
self.lightsOn = false;
|
|
lights = getEntArray( self.target, "targetname" );
|
|
assertEx( lights.size, "ERROR: trigger_ * _motion_light with no targets at " + self.origin );
|
|
|
|
precacheModel( "com_two_light_fixture_off" );
|
|
precacheModel( "com_two_light_fixture_on" );
|
|
|
|
foreach ( light in lights )
|
|
{
|
|
light.lightRigs = [];
|
|
infoNull = getEnt( light.target, "targetname" );
|
|
if ( !isDefined( infoNull.target ) )
|
|
continue;
|
|
|
|
light.lightRigs = getEntArray( infoNull.target, "targetname" );
|
|
}
|
|
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger_enter" );
|
|
|
|
while ( anythingTouchingTrigger( self ) )
|
|
{
|
|
objectMoved = false;
|
|
foreach ( object in self.touchList )
|
|
{
|
|
if ( isDefined( object.distMoved ) && object.distMoved > 5.0 )
|
|
objectMoved = true;
|
|
}
|
|
|
|
if ( objectMoved )
|
|
{
|
|
if ( !self.lightsOn )
|
|
{
|
|
self.lightsOn = true;
|
|
lights[ 0 ] playSound( "switch_auto_lights_on" );
|
|
|
|
foreach ( light in lights )
|
|
{
|
|
light setLightIntensity( 1.0 );
|
|
|
|
if ( isdefined( light.lightRigs ) )
|
|
{
|
|
foreach ( rig in light.lightRigs )
|
|
rig setModel( "com_two_light_fixture_on" );
|
|
}
|
|
}
|
|
}
|
|
self thread motion_light_timeout( lights, 10.0 );
|
|
}
|
|
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
motion_light_timeout( lights, timeOut )
|
|
{
|
|
self notify( "motion_light_timeout" );
|
|
self endon( "motion_light_timeout" );
|
|
|
|
wait( timeOut );
|
|
|
|
foreach ( light in lights )
|
|
{
|
|
light setLightIntensity( 0 );
|
|
if ( isdefined( light.lightRigs ) )
|
|
{
|
|
foreach ( rig in light.lightRigs )
|
|
rig setModel( "com_two_light_fixture_off" );
|
|
}
|
|
}
|
|
|
|
lights[ 0 ] playSound( "switch_auto_lights_off" );
|
|
|
|
self.lightsOn = false;
|
|
}
|
|
|
|
|
|
outdoor_motion_dlight()
|
|
{
|
|
|
|
if( !isdefined( level.outdoor_motion_light ) )
|
|
{
|
|
level.outdoor_motion_light = loadFx( "misc/outdoor_motion_light" );
|
|
}
|
|
|
|
level endon( "game_ended" );
|
|
self.moveTracker = true;
|
|
|
|
self.lightsOn = false;
|
|
lightRig = getEnt( self.target, "targetname" );
|
|
assertEx( lightRig.size, "ERROR: trigger_ * _motion_light with no targets at " + self.origin );
|
|
lights = getEntArray( lightRig.target, "targetname" );
|
|
assertEx( lights.size, "ERROR: trigger_ * _motion_light model target with no light targets at " + lightRig.origin );
|
|
|
|
precacheModel( "com_two_light_fixture_off" );
|
|
precacheModel( "com_two_light_fixture_on" );
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger_enter" );
|
|
|
|
while ( anythingTouchingTrigger( self ) )
|
|
{
|
|
objectMoved = false;
|
|
foreach ( object in self.touchList )
|
|
{
|
|
if ( isDefined( object.distMoved ) && object.distMoved > 5.0 )
|
|
objectMoved = true;
|
|
}
|
|
|
|
if ( objectMoved )
|
|
{
|
|
if ( !self.lightsOn )
|
|
{
|
|
self.lightsOn = true;
|
|
lightRig playSound( "switch_auto_lights_on" );
|
|
lightRig setModel( "com_two_light_fixture_on" );
|
|
|
|
foreach ( light in lights )
|
|
{
|
|
assert( !isDefined( light.lightEnt ) );
|
|
light.lightEnt = spawn( "script_model", light.origin );
|
|
light.lightEnt setModel( "tag_origin" );
|
|
playFxOnTag( level.outdoor_motion_light, light.lightEnt, "tag_origin" );
|
|
}
|
|
}
|
|
self thread outdoor_motion_dlight_timeout( lightRig, lights, 10.0 );
|
|
}
|
|
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
outdoor_motion_dlight_timeout( lightRig, lights, timeOut )
|
|
{
|
|
self notify( "motion_light_timeout" );
|
|
self endon( "motion_light_timeout" );
|
|
|
|
wait( timeOut );
|
|
|
|
foreach ( light in lights )
|
|
{
|
|
assert( isDefined( light.lightEnt ) );
|
|
light.lightEnt delete();
|
|
}
|
|
|
|
lightRig playSound( "switch_auto_lights_off" );
|
|
lightRig setModel( "com_two_light_fixture_off" );
|
|
|
|
self.lightsOn = false;
|
|
}
|
|
|
|
dog_bark()
|
|
{
|
|
level endon( "game_ended" );
|
|
self.moveTracker = true;
|
|
|
|
dogOrigin = getEnt( self.target, "targetname" );
|
|
assertEx( isDefined( dogOrigin ), "ERROR: trigger_multiple_dog_bark with no target at " + self.origin );
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger_enter", player );
|
|
|
|
while ( anythingTouchingTrigger( self ) )
|
|
{
|
|
maxDistMoved = 0;
|
|
foreach ( object in self.touchList )
|
|
{
|
|
if ( isDefined( object.distMoved ) && object.distMoved > maxDistMoved )
|
|
maxDistMoved = object.distMoved;
|
|
}
|
|
|
|
if ( maxDistMoved > 6.0 )
|
|
{
|
|
dogOrigin playSound( "dyn_anml_dog_bark" );
|
|
wait( randomFloatRange( 16 / maxDistMoved, 16 / maxDistMoved + randomFloat( 1.0 ) ) );
|
|
}
|
|
else
|
|
{
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
trigger_door()
|
|
{
|
|
doorEnt = getEnt( self.target, "targetname" );
|
|
assertEx( isDefined( doorEnt ), "ERROR: trigger_multiple_dyn_door with no door brush at " + self.origin );
|
|
|
|
self.doorEnt = doorEnt;
|
|
self.doorAngle = getVectorRightAngle( vectorNormalize( self getOrigin() - doorEnt getOrigin() ) );
|
|
doorEnt.baseYaw = doorEnt.angles[ 1 ];
|
|
openTime = 1.0;
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger_enter", player );
|
|
|
|
doorEnt thread doorOpen( openTime, self getDoorSide( player ) );
|
|
|
|
if ( anythingTouchingTrigger( self ) )
|
|
self waittill( "trigger_empty" );
|
|
|
|
wait( 3.0 );
|
|
|
|
if ( anythingTouchingTrigger( self ) )
|
|
self waittill( "trigger_empty" );
|
|
|
|
doorEnt thread doorClose( openTime );
|
|
}
|
|
}
|
|
|
|
|
|
doorOpen( openTime, doorSide )
|
|
{
|
|
if ( doorSide )
|
|
self rotateTo( ( 0, self.baseYaw + 90, 1 ), openTime, 0.1, 0.75 );
|
|
else
|
|
self rotateTo( ( 0, self.baseYaw - 90, 1 ), openTime, 0.1, 0.75 );
|
|
|
|
self playSound( "door_generic_house_open" );
|
|
|
|
wait( openTime + 0.05 );
|
|
}
|
|
|
|
|
|
doorClose( openTime )
|
|
{
|
|
self rotateTo( ( 0, self.baseYaw, 1 ), openTime );
|
|
self playSound( "door_generic_house_close" );
|
|
|
|
wait( openTime + 0.05 );
|
|
}
|
|
|
|
getDoorSide( player )
|
|
{
|
|
return( vectorDot( self.doorAngle, vectornormalize( player.origin - self.doorEnt getOrigin() ) ) > 0 );
|
|
}
|
|
|
|
|
|
getVectorRightAngle( vDir )
|
|
{
|
|
return( vDir[ 1 ], 0 - vDir[ 0 ], vDir[ 2 ] );
|
|
}
|
|
|
|
use_toggle()
|
|
{
|
|
if ( self.classname != "trigger_use_touch" )
|
|
return;
|
|
|
|
lights = getEntArray( self.target, "targetname" );
|
|
assert( lights.size );
|
|
|
|
self.lightsOn = 1;
|
|
foreach ( light in lights )
|
|
light setLightIntensity( 1.5 * self.lightsOn );
|
|
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger" );
|
|
|
|
self.lightsOn = !self.lightsOn;
|
|
if ( self.lightsOn )
|
|
{
|
|
foreach ( light in lights )
|
|
light setLightIntensity( 1.5 );
|
|
|
|
self playSound( "switch_auto_lights_on" );
|
|
}
|
|
else
|
|
{
|
|
foreach ( light in lights )
|
|
light setLightIntensity( 0 );
|
|
|
|
self playSound( "switch_auto_lights_off" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bird_startle()
|
|
{
|
|
}
|
|
|
|
|
|
photo_copier_init( trigger )
|
|
{
|
|
// self is trigger
|
|
|
|
self.copier = get_photo_copier( trigger );
|
|
assertex( self.copier.classname == "script_model", "Photocopier at " + trigger.origin + " doesn't target a photo copier" );
|
|
|
|
copy_bar = getent( self.copier.target, "targetname" );
|
|
assertex( copy_bar.classname == "script_brushmodel", "Photocopier at " + trigger.origin + " doesn't target a photo copier" );
|
|
|
|
light = getent( copy_bar.target, "targetname" );
|
|
assertex( light.classname == "light_spot" || light.classname == "light", "Photocopier at " + trigger.origin + " doesn't have a light" );
|
|
|
|
light.intensity = light getlightintensity();
|
|
light setlightintensity( 0 );
|
|
trigger.copy_bar = copy_bar;
|
|
trigger.start_pos = copy_bar.origin;
|
|
trigger.light = light;
|
|
|
|
angles = self.copier.angles + ( 0, 90, 0 );
|
|
forward = anglestoforward( angles );
|
|
trigger.end_pos = trigger.start_pos + vector_multiply( forward, 30 );
|
|
}
|
|
|
|
get_photo_copier( trigger )
|
|
{
|
|
if ( !isdefined( trigger.target ) )
|
|
{
|
|
//cant target directly to a destructible toy, so we are grabing the nearest one, since primary light requires them to be far anyway
|
|
toys = getentarray( "destructible_toy", "targetname" );
|
|
copier = toys[ 0 ];
|
|
foreach ( toy in toys )
|
|
{
|
|
if ( isdefined( toy.destructible_type ) && toy.destructible_type == "toy_copier" )
|
|
{
|
|
if ( distance( trigger.origin, copier.origin ) > distance( trigger.origin, toy.origin ) )
|
|
copier = toy;
|
|
}
|
|
}
|
|
assertex( distance( trigger.origin, copier.origin ) < 128, "Photocopier at " + trigger.origin + " doesn't contain a photo copier" );
|
|
}
|
|
else
|
|
{
|
|
copier = getent( trigger.target, "targetname" );
|
|
assertex( isdefined( copier ), "Photocopier at " + trigger.origin + " doesn't target a photo copier" );
|
|
copier setcandamage( true );
|
|
}
|
|
|
|
return copier;
|
|
}
|
|
|
|
waittill_copier_copies()
|
|
{
|
|
self.copier endon( "FX_State_Change0" );
|
|
self.copier endon( "death" );
|
|
|
|
self waittill( "trigger_enter" );
|
|
}
|
|
|
|
photo_copier()
|
|
{
|
|
level endon( "game_ended" );
|
|
photo_copier_init( self );
|
|
|
|
self.copier endon( "FX_State_Change0" ); // this is when copier breaks
|
|
self thread photo_copier_stop(); // monitor copier for quick stop
|
|
|
|
for ( ;; )
|
|
{
|
|
waittill_copier_copies();
|
|
|
|
self playSound( "mach_copier_run" );
|
|
|
|
if ( isdefined( self.copy_bar ) )
|
|
{
|
|
reset_copier( self );
|
|
thread photo_copier_copy_bar_goes();
|
|
thread photo_copier_light_on();
|
|
}
|
|
wait( 3 );
|
|
}
|
|
}
|
|
|
|
photo_copier_no_light()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
self.copier = get_photo_copier( self );
|
|
assertex( self.copier.classname == "script_model", "Photocopier at " + self.origin + " doesn't target or contain a photo copier" );
|
|
self.copier endon( "FX_State_Change0" ); // this is when copier breaks
|
|
|
|
for ( ;; )
|
|
{
|
|
waittill_copier_copies();
|
|
self playSound( "mach_copier_run" );
|
|
wait( 3 );
|
|
}
|
|
}
|
|
|
|
// reset light and copy bar position, interruptes previous copy in progress
|
|
reset_copier( trigger )
|
|
{
|
|
trigger.copy_bar moveto( trigger.start_pos, 0.2 ); // reset position
|
|
trigger.light setlightintensity( 0 );
|
|
}
|
|
|
|
photo_copier_copy_bar_goes()
|
|
{
|
|
self.copier notify( "bar_goes" );
|
|
self.copier endon( "bar_goes" );
|
|
self.copier endon( "FX_State_Change0" );
|
|
self.copier endon( "death" );
|
|
|
|
copy_bar = self.copy_bar;
|
|
wait( 2.0 );
|
|
copy_bar moveto( self.end_pos, 1.6 );
|
|
wait( 1.8 );
|
|
copy_bar moveto( self.start_pos, 1.6 );
|
|
wait( 1.6 ); // wait( 13.35 );
|
|
|
|
light = self.light;
|
|
timer = 0.2;
|
|
steps = timer / 0.05;
|
|
|
|
for ( i = 0; i < steps; i++ )
|
|
{
|
|
intensity = i * 0.05;
|
|
intensity /= timer;
|
|
intensity = 1 - ( intensity * light.intensity );
|
|
if ( intensity > 0 )
|
|
light setlightintensity( intensity );
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
|
|
photo_copier_light_on()
|
|
{
|
|
self.copier notify( "light_on" );
|
|
self.copier endon( "light_on" );
|
|
self.copier endon( "FX_State_Change0" );
|
|
self.copier endon( "death" );
|
|
|
|
light = self.light;
|
|
timer = 0.2;
|
|
steps = timer / 0.05;
|
|
|
|
for ( i = 0; i < steps; i++ )
|
|
{
|
|
intensity = i * 0.05;
|
|
intensity /= timer;
|
|
light setlightintensity( intensity * light.intensity );
|
|
wait( 0.05 );
|
|
}
|
|
|
|
photo_light_flicker( light );
|
|
}
|
|
|
|
// stopping light and bar move on death
|
|
photo_copier_stop()
|
|
{
|
|
self.copier waittill( "FX_State_Change0" );
|
|
self.copier endon( "death" );
|
|
|
|
reset_copier( self );
|
|
}
|
|
|
|
photo_light_flicker( light )
|
|
{
|
|
// flicker
|
|
light setlightintensity( 1 );
|
|
wait( 0.05 );
|
|
light setlightintensity( 0 );
|
|
wait( 0.10 );
|
|
light setlightintensity( 1 );
|
|
wait( 0.05 );
|
|
light setlightintensity( 0 );
|
|
wait( 0.10 );
|
|
light setlightintensity( 1 );
|
|
}
|
|
|
|
|
|
fan_blade_rotate( type )
|
|
{
|
|
assert( isdefined( type ) );
|
|
|
|
speed = 0;
|
|
time = 20000;
|
|
|
|
speed_multiplier = 1.0;
|
|
if( isdefined( self.speed ) )
|
|
{
|
|
speed_multiplier = self.speed;
|
|
}
|
|
|
|
if ( type == "slow" )
|
|
speed = randomfloatrange( 100*speed_multiplier, 360*speed_multiplier );
|
|
else if ( type == "fast" )
|
|
speed = randomfloatrange( 720*speed_multiplier, 1000*speed_multiplier );
|
|
else
|
|
assertmsg( "Type must be fast or slow" );
|
|
|
|
wait randomfloatrange( 0, 1 );
|
|
|
|
fan_angles = self.angles;
|
|
fan_vec = Vector_multiply( AnglesToRight( self.angles ), 100 ); // assures normalized vector is length of "1"
|
|
fan_vec = VectorNormalize( fan_vec );
|
|
|
|
while ( true )
|
|
{
|
|
dot_x = abs( vectorDot( fan_vec, ( 1, 0, 0 ) ) );
|
|
dot_y = abs( vectorDot( fan_vec, ( 0, 1, 0 ) ) );
|
|
dot_z = abs( vectorDot( fan_vec, ( 0, 0, 1 ) ) );
|
|
|
|
if ( dot_x > 0.9 )
|
|
self rotatevelocity( ( speed, 0, 0 ), time );
|
|
else if ( dot_y > 0.9 )
|
|
self rotatevelocity( ( speed, 0, 0 ), time );
|
|
else if ( dot_z > 0.9 )
|
|
self rotatevelocity( ( 0, speed, 0 ), time );
|
|
else
|
|
self rotatevelocity( ( 0, speed, 0 ), time );
|
|
|
|
wait time;
|
|
}
|
|
}
|
|
|
|
|
|
triggerTouchThink( enterFunc, exitFunc )
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
self.entNum = self getEntityNumber();
|
|
|
|
while ( true )
|
|
{
|
|
self waittill( "trigger", player );
|
|
|
|
if ( !isPlayer( player ) && !isDefined( player.finished_spawning ) )
|
|
continue;
|
|
|
|
if ( !isAlive( player ) )
|
|
continue;
|
|
|
|
if ( !isDefined( player.touchTriggers[ self.entNum ] ) )
|
|
player thread playerTouchTriggerThink( self, enterFunc, exitFunc );
|
|
}
|
|
}
|
|
|
|
|
|
playerTouchTriggerThink( trigger, enterFunc, exitFunc )
|
|
{
|
|
if ( !isPlayer( self ) )
|
|
self endon( "death" );
|
|
|
|
if ( !isSP() )
|
|
touchName = self.guid; // generate GUID
|
|
else
|
|
touchName = "player" + gettime(); // generate GUID
|
|
|
|
trigger.touchList[ touchName ] = self;
|
|
if ( isDefined( trigger.moveTracker ) )
|
|
self.moveTrackers++ ;
|
|
|
|
trigger notify( "trigger_enter", self );
|
|
self notify( "trigger_enter", trigger );
|
|
|
|
if ( isDefined( enterFunc ) )
|
|
self thread [[ enterFunc ]]( trigger );
|
|
|
|
self.touchTriggers[ trigger.entNum ] = trigger;
|
|
|
|
while ( isAlive( self ) && self isTouching( trigger ) && ( isSP() || !level.gameEnded ) )
|
|
wait( 0.05 );
|
|
|
|
// disconnected player will skip this code
|
|
if ( isDefined( self ) )
|
|
{
|
|
self.touchTriggers[ trigger.entNum ] = undefined;
|
|
if ( isDefined( trigger.moveTracker ) )
|
|
self.moveTrackers -- ;
|
|
|
|
self notify( "trigger_leave", trigger );
|
|
|
|
if ( isDefined( exitFunc ) )
|
|
self thread [[ exitFunc ]]( trigger );
|
|
}
|
|
|
|
if ( !isSP() && level.gameEnded )
|
|
return;
|
|
|
|
trigger.touchList[ touchName ] = undefined;
|
|
trigger notify( "trigger_leave", self );
|
|
|
|
if ( !anythingTouchingTrigger( trigger ) )
|
|
trigger notify( "trigger_empty" );
|
|
}
|
|
|
|
|
|
movementTracker()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
if ( !isPlayer( self ) )
|
|
self endon( "death" );
|
|
|
|
self.moveTrackers = 0;
|
|
self.distMoved = 0;
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger_enter" );
|
|
|
|
lastOrigin = self.origin;
|
|
while ( self.moveTrackers )
|
|
{
|
|
self.distMoved = distance( lastOrigin, self.origin );
|
|
lastOrigin = self.origin;
|
|
wait( 0.05 );
|
|
}
|
|
|
|
self.distMoved = 0;
|
|
}
|
|
}
|
|
|
|
|
|
anythingTouchingTrigger( trigger )
|
|
{
|
|
return( trigger.touchList.size );
|
|
}
|
|
|
|
|
|
playerTouchingTrigger( player, trigger )
|
|
{
|
|
assert( isDefined( trigger.entNum ) );
|
|
return( isDefined( player.touchTriggers[ trigger.entNum ] ) );
|
|
}
|