07-19-2011, 15:58
Hello
This is something I previewed sometime ago and forgot to release,
. This contains a mad vending machine, a mad metal detector, mad fans and lights.
Save this in your mod: in your mod folder, create a new folder called common_scripts and inside paste this file with the name of _dynamic_world.gsc
This is something I previewed sometime ago and forgot to release,
. This contains a mad vending machine, a mad metal detector, mad fans and lights.Save this in your mod: in your mod folder, create a new folder called common_scripts and inside paste this file with the name of _dynamic_world.gsc
Code:
#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 = 200; // number of soda per machine
CONST_soda_launch_force = 5000; // soda shoot out force
CONST_soda_random_factor = 0.15; // in percentage 0.2 = 20%
CONST_soda_splash_dmg_scaler = 30; // splash damage multiplier
// Metal Detector
CONST_alarm_tolerance = 10; // number of alarm sounds before silenced, 0 disables silencing
CONST_alarm_interval = 20; // alarm interval time in seconds
CONST_alarm_interval_sp = 20; // 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 );
playfx( light, light_pos1 );
wait 0.6;
self playsound( sound );
playfx( light, light_pos1 );
wait 0.6;
self playsound( sound );
playfx( light, light_pos1 );
wait 0.6;
self playsound( sound );
playfx( light, light_pos1 );
wait 0.6;
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( 150*speed_multiplier, 360*speed_multiplier );
else if ( type == "fast" )
speed = randomfloatrange( 780*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 ] ) );
}
. I simply change parametres and stuff like that. This is something simple.
