mirror of
https://github.com/ineedbots/t5_bot_warfare.git
synced 2025-04-21 00:55:44 +00:00
853 lines
24 KiB
Plaintext
853 lines
24 KiB
Plaintext
#include maps\mp\_utility;
|
|
#include common_scripts\utility;
|
|
|
|
|
|
main()
|
|
{
|
|
precachemodel("tag_origin");
|
|
|
|
/#
|
|
level thread devgui_radiation();
|
|
execdevgui("devgui_mp_radiation");
|
|
#/
|
|
|
|
//needs to be first for create fx
|
|
maps\mp\mp_radiation_fx::main();
|
|
|
|
precachemodel("collision_geo_64x64x256");
|
|
precachemodel("collision_wall_128x128x10");
|
|
precachemodel("collision_geo_256x256x10");
|
|
|
|
|
|
maps\mp\_load::main();
|
|
|
|
maps\mp\mp_radiation_amb::main();
|
|
if ( GetDvarInt( #"xblive_wagermatch" ) == 1 )
|
|
{
|
|
maps\mp\_compass::setupMiniMap("compass_map_mp_radiation_wager");
|
|
}
|
|
else
|
|
{
|
|
maps\mp\_compass::setupMiniMap("compass_map_mp_radiation");
|
|
}
|
|
|
|
|
|
//Increase sample size so as to resolve lighting issue
|
|
SetDvar("sm_sunSampleSizeNear", ".5" );
|
|
|
|
// If the team nationalites change in this file,
|
|
// you must update the team nationality in the level's csc file as well!
|
|
maps\mp\gametypes\_teamset_urbanspecops::level_init();
|
|
|
|
// Set up the default range of the compass
|
|
setdvar("compassmaxrange","2100");
|
|
|
|
// COLLISION - to prevent players from placing turrets inside a large cylinder brush in the tank room
|
|
spawncollision("collision_geo_64x64x256","collider",(1221, 41, 236), (0, 0, 0));
|
|
|
|
// COLLISION - to prevent players from jumping onto a little ledge of collision
|
|
spawncollision("collision_wall_128x128x10","collider",(1042, -309, 309), (0, 0, 0));
|
|
spawncollision("collision_wall_128x128x10","collider",(1080, -309, 309), (0, 0, 0));
|
|
|
|
// COLLISION - to prevent players from dropping turrets in the large grey tanks by the warehouse
|
|
spawncollision("collision_geo_64x64x256","collider",(568, 219, 264), (0, 0, 0));
|
|
spawncollision("collision_geo_64x64x256","collider",(567, -105, 264), (0, 0, 0));
|
|
|
|
// COLLISION - to prevent players dropping off the catwalk onto ledge in warehouse
|
|
spawncollision("collision_wall_128x128x10","collider",(1157, -345, 186), (0, 270, 0));
|
|
spawncollision("collision_wall_128x128x10","collider",(1157, -345, 314), (0, 270, 0));
|
|
spawncollision("collision_wall_128x128x10","collider",(1157, -345, 442), (0, 270, 0));
|
|
|
|
//NOTURRET - spawns radius triggers to stop players from placing turrets in the large cylinders in the NE corner of the map
|
|
addNoTurretTrigger((1440, -1116, 145), 230, 256);
|
|
addNoTurretTrigger((1446, -1659, 145), 230, 256);
|
|
|
|
|
|
|
|
// enable new spawning system
|
|
maps\mp\gametypes\_spawning::level_use_unified_spawning(true);
|
|
|
|
flag_init_func();
|
|
|
|
level_objects_init();
|
|
|
|
}
|
|
|
|
flag_init_func()
|
|
{
|
|
flag_init("kill_stuck_players");
|
|
}
|
|
|
|
level_objects_init()
|
|
{
|
|
level._digger_fx = LoadFX( "maps/mp_maps/fx_mp_sand_digger_radiation" );
|
|
waittillframeend;
|
|
level._door_switch_trig1 = getent_and_assert("switch_trigger1");
|
|
level._door_switch_trig2 = getent_and_assert("switch_trigger2");
|
|
|
|
level._door1 = getent_and_assert("big_door1_clip");
|
|
level._door2 = getent_and_assert("big_door2_clip");
|
|
|
|
level.const_fx_exploder_switch_green_light = 2001;
|
|
level.const_fx_exploder_switch_red_light = 2002;
|
|
|
|
//Gets some diggers digging
|
|
level thread digger_dig_init();
|
|
|
|
//Gets diggers in the background moving
|
|
moving_diggers_init();
|
|
|
|
//Sets up the switchs players can flip to open the double doors
|
|
level thread door_switch_func();
|
|
|
|
if( !level.wagerMatch && !isPregame() )
|
|
{
|
|
//get my doors opening at the start of the match
|
|
level thread double_doors_open_at_start();
|
|
}
|
|
|
|
//Get conveyer belt working
|
|
level thread conveyer_belt_init();
|
|
}
|
|
|
|
turnSwitchPanelRed()
|
|
{
|
|
exploder_stop( level.const_fx_exploder_switch_green_light );
|
|
exploder( level.const_fx_exploder_switch_red_light );
|
|
}
|
|
|
|
turnSwitchPanelGreen()
|
|
{
|
|
exploder_stop( level.const_fx_exploder_switch_red_light );
|
|
exploder( level.const_fx_exploder_switch_green_light );
|
|
}
|
|
|
|
//Sets it up so a player can flip a switch and open large double doors
|
|
door_switch_func()
|
|
{
|
|
//Set up the use trigger switches that activate my double doors
|
|
level._door_switch_trig1 thread door_switch_setup();
|
|
level._door_switch_trig2 thread door_switch_setup();
|
|
|
|
//Cooldown switches inform the player that the door switch is on cooldown if they try to interact with it
|
|
cooldown_switches = GetEntArray("off_trigger","targetname");
|
|
AssertEx( cooldown_switches.size > 0, "Missing off_triggers");
|
|
|
|
for( i = 0; i < cooldown_switches.size; i++)
|
|
{
|
|
cooldown_switches[i] UseTriggerRequireLookAt();
|
|
cooldown_switches[i] SetCursorHint( "HINT_NOICON" );
|
|
cooldown_switches[i] SetHintString( &"MP_HOLD_DOOR_SWITCH_UNAVAILABLE");
|
|
cooldown_switches[i] trigger_off();
|
|
}
|
|
|
|
turnSwitchPanelRed();
|
|
|
|
kill_trig1 = getent_and_assert("edge_death_trig1");
|
|
kill_trig2 = getent_and_assert("edge_death_trig2");
|
|
center_death_trig = getent_and_assert("center_death_trig");
|
|
|
|
//Set up DVARS for tweaking door opening sequence
|
|
d1_new_angle = set_dvar_int_if_unset("scr_d1_new_angle", "123");
|
|
d2_new_angle = set_dvar_int_if_unset("scr_d2_new_angle", "-123");
|
|
|
|
door_model1 = getent_and_assert("big_door1");
|
|
door_model2 = getent_and_assert("big_door2");
|
|
|
|
door_model1 LinkTo(level._door1);
|
|
door_model2 LinkTo(level._door2);
|
|
|
|
door_monster_clip = GetEnt("door_monster_clip","targetname");
|
|
|
|
//door_monster_clip thread dog_kill();
|
|
|
|
//snd_door_status tracks if the door is open or closed
|
|
snd_door_status = 0;
|
|
|
|
light_structs = getstructarray("switch_struct","targetname");
|
|
AssertEx( light_structs.size > 0, "Missing light structs");
|
|
|
|
for( i = 0; i < light_structs.size; i++)
|
|
{
|
|
light_structs[i] thread switch_lights(i);
|
|
}
|
|
|
|
tunnel_structs = getstructarray("tunnel_light_spot","targetname");
|
|
AssertEx(tunnel_structs.size > 0, "Missing light structs");
|
|
|
|
for( i = 0; i < light_structs.size; i++)
|
|
{
|
|
tunnel_structs[i] thread tunnel_lights(i);
|
|
}
|
|
|
|
while(!level.wagermatch)
|
|
{
|
|
//This is a switch in the level on the catwalk
|
|
waittill_any_ents(level._door_switch_trig1,"trigger",level._door_switch_trig2,"trigger");
|
|
|
|
//Disables the switch temporarily
|
|
level._door_switch_trig1 trigger_off();
|
|
level._door_switch_trig2 trigger_off();
|
|
|
|
for( i = 0; i < cooldown_switches.size; i++)
|
|
{
|
|
cooldown_switches[i] trigger_on();
|
|
}
|
|
|
|
//Set up DVARS for tweaking door opening sequence. Acceleration and decelation variation added for realistic offset.
|
|
door_time = set_dvar_int_if_unset("scr_d1_time", "8");
|
|
|
|
//The doors have specific accelleration and deceleration values so as give an organic-looking timing offset.
|
|
//When the doors are opening, we want Door 2 to accelerate slightly faster so as to avoid clipping.
|
|
if(snd_door_status == 0)
|
|
{
|
|
d1_accel = door_time * .6;
|
|
d2_accel = door_time * .7;
|
|
|
|
d1_decel = door_time * .4;
|
|
d2_decel = door_time * .3;
|
|
|
|
//Monster clip is placed and path nodes are severed to keep dogs from running on the doors
|
|
door_monster_clip trigger_on();
|
|
door_monster_clip DisconnectPaths();
|
|
}
|
|
//When the doors are closing, we want Door 1 to accelerate slightly faster so as to avoid clipping.
|
|
else
|
|
{
|
|
d1_accel = door_time * .7;
|
|
d2_accel = door_time * .6;
|
|
|
|
d1_decel = door_time * .3;
|
|
d2_decel = door_time * .4;
|
|
}
|
|
|
|
door_cooldown = set_dvar_int_if_unset("scr_door_cooldown", "20");
|
|
|
|
level._door1 RotateRoll(d1_new_angle, door_time, d1_accel, d1_decel);
|
|
level._door2 RotateRoll(d2_new_angle, door_time, d2_accel, d2_decel);
|
|
|
|
thread dropEverythingOnDoorsToGround();
|
|
level thread destroyEquipment();
|
|
|
|
// Play door opening sound
|
|
level._door1 playloopsound ("evt_hydraulic_loop", .5);
|
|
level._door1 playsound ("evt_hydraulic_start");
|
|
level._door1 thread door_snd_alarm ( 5 );
|
|
|
|
//This sets it so my doors move in reverse next time they're activated
|
|
d1_new_angle = d1_new_angle * -1;
|
|
d2_new_angle = d1_new_angle * -1;
|
|
|
|
//Flag marks the period of time i'm checking for any player caught in moving collision
|
|
flag_set("kill_stuck_players");
|
|
|
|
//Give time for doors to move a moderate amount before starts kill trigger
|
|
wait 4;
|
|
|
|
//Only want to kill players if doors are closing
|
|
if(snd_door_status == 1)
|
|
{
|
|
//These are three seperate trigger brushes I want to check for stuck players
|
|
kill_trig1 thread kill_edge_players_func();
|
|
kill_trig2 thread kill_edge_players_func();
|
|
center_death_trig thread kill_edge_players_func();
|
|
}
|
|
level._door1 waittill("rotatedone");
|
|
|
|
//snd_door_status tracks if the door is currently open or closed for seprate open and close audio
|
|
if (snd_door_status == 0)
|
|
{
|
|
//stops the move loop, plays endind sound, and set current door status
|
|
level._door1 stoploopsound (1);
|
|
center_death_trig playsound ("evt_hydraulic_open");
|
|
snd_door_status = 1;
|
|
}
|
|
else
|
|
{
|
|
//stops the move loop, plays endind sound, and set current door status
|
|
level._door1 stoploopsound (1);
|
|
center_death_trig playsound ("evt_hydraulic_close");
|
|
|
|
//Clip is removed so dogs can path
|
|
door_monster_clip ConnectPaths();
|
|
door_monster_clip trigger_off();
|
|
snd_door_status = 0;
|
|
}
|
|
|
|
flag_clear("kill_stuck_players");
|
|
|
|
//Special notify to end my check for players caught on collision
|
|
level notify ("edge_check");
|
|
|
|
wait (door_cooldown);
|
|
level notify ("no_cooldown");
|
|
|
|
for( i = 0; i < cooldown_switches.size; i++)
|
|
{
|
|
cooldown_switches[i] trigger_off();
|
|
}
|
|
|
|
level._door_switch_trig1 trigger_on();
|
|
level._door_switch_trig2 trigger_on();
|
|
}
|
|
}
|
|
door_snd_alarm ( alarmTimes )
|
|
{
|
|
|
|
for (i=0; i < alarmTimes; i++)
|
|
{
|
|
wait (.5);
|
|
|
|
playsoundatposition("amb_alarm_buzz",(-664,110,436));
|
|
|
|
playsoundatposition("amb_alarm_buzz",(-664,-72,436));
|
|
|
|
playsoundatposition("amb_alarm_buzz",(-666,-602,436));
|
|
|
|
playsoundatposition("amb_alarm_buzz",(-666,660,444));
|
|
|
|
wait (1.5);
|
|
}
|
|
}
|
|
//Self is the use triggers that activate the double doors
|
|
door_switch_setup()
|
|
{
|
|
self usetriggerrequirelookat();
|
|
if ( level.wagerMatch )
|
|
{
|
|
self SetHintString(&"MP_HOLD_DOOR_SWITCH_UNAVAILABLE");
|
|
turnSwitchPanelRed();
|
|
}
|
|
else
|
|
{
|
|
self SetHintString(&"MP_HOLD_TO_OPERATE_DOORS");
|
|
turnSwitchPanelGreen();
|
|
}
|
|
|
|
while ( !level.wagerMatch )
|
|
{
|
|
// self is the switch. who is the player that triggered switch
|
|
self waittill("trigger", who);
|
|
|
|
//Added "if" check for when the doors are triggered without a player -Leif
|
|
if(IsDefined( who ))
|
|
{
|
|
who playsound ("evt_hydraulic_switch");
|
|
}
|
|
|
|
wait (1);
|
|
}
|
|
}
|
|
|
|
//Self is a trigger. The triggers are placed in places i'm afraid of players getting caught
|
|
kill_edge_players_func()
|
|
{
|
|
level endon ("edge_check");
|
|
|
|
//This only loops while the doors are moving
|
|
while(1)
|
|
{
|
|
self waittill("trigger", player);
|
|
|
|
if((player IsTouching(level._door1)) || (player IsTouching(level._door2)))
|
|
{
|
|
player DoDamage(player.health * 2, self.origin, player, player, 0, "MOD_SUICIDE" );
|
|
// TODO: add crushing audio. CDC
|
|
}
|
|
else
|
|
{
|
|
wait .05;
|
|
}
|
|
}
|
|
}
|
|
|
|
//TO DO: Review this function for multiplayer API improvements.
|
|
//'Self' is the struct within the panel that operates the double doors
|
|
switch_lights( element_number )
|
|
{
|
|
if ( level.PrematchPeriod > 0 && level.inPrematchPeriod == true )
|
|
{
|
|
level waittill("prematch_over");
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
effect_ent = Spawn("script_model", self.origin);
|
|
effect_ent SetModel("tag_origin");
|
|
|
|
//This wait is necesary to get the effect to work on the newly created script model.
|
|
wait .1;
|
|
|
|
//Green light signals the switch is not on cooldown
|
|
turnSwitchPanelGreen();
|
|
//PlayFXOnTag(level._effect["green_light"], effect_ent,"tag_origin" );
|
|
|
|
waittill_any_ents(level._door_switch_trig1,"trigger",level._door_switch_trig2,"trigger");
|
|
|
|
//This function is array threaded, so we must prevent FX from playing in the same frame using this loop
|
|
for (i = 0; i < element_number; i++)
|
|
{
|
|
wait .1;
|
|
}
|
|
|
|
effect_ent Delete();
|
|
|
|
blinky_effect_ent = Spawn("script_model", self.origin);
|
|
blinky_effect_ent SetModel("tag_origin");
|
|
|
|
//This wait is necesary to get the effect to work on the newly created script model.
|
|
wait .1;
|
|
|
|
//Blink red light signals the double doors are moving
|
|
turnSwitchPanelRed();
|
|
//PlayFXOnTag(level._effect["blink_light"], blinky_effect_ent,"tag_origin" );
|
|
|
|
//This notify signals that the doors have stopped moving
|
|
level waittill ("edge_check");
|
|
|
|
for (i = 0; i < element_number; i++)
|
|
{
|
|
wait .1;
|
|
}
|
|
|
|
blinky_effect_ent Delete();
|
|
|
|
final_effect_ent = Spawn("script_model", self.origin);
|
|
final_effect_ent SetModel("tag_origin");
|
|
|
|
//This wait is necesary to get the effect to work on the newly created script model.
|
|
wait .1;
|
|
|
|
//Red light signals the switch cannot be used
|
|
//PlayFXOnTag(level._effect["red_light"], final_effect_ent,"tag_origin" );
|
|
|
|
//This notify signals that the doors have stopped moving
|
|
level waittill ("no_cooldown");
|
|
|
|
for (i = 0; i < element_number; i++)
|
|
{
|
|
wait .1;
|
|
}
|
|
|
|
final_effect_ent Delete();
|
|
}
|
|
}
|
|
|
|
//'Self' is the struct within the light bulbs in the Radiation tunnel. This function manages FX in the tunnel
|
|
//'Element number' is equal to self's index number in the array that got array threaded.
|
|
tunnel_lights(element_number)
|
|
{
|
|
door_closed = true;
|
|
|
|
while(1)
|
|
{
|
|
//Must define may variable to avoid SRE
|
|
effect_ent = undefined;
|
|
|
|
//When door is closed, play "solid" tunnel light effect
|
|
if(door_closed)
|
|
{
|
|
effect_ent = Spawn("script_model", self.origin);
|
|
effect_ent SetModel("tag_origin");
|
|
|
|
//Must wait a moment for the script model to finish spawning
|
|
wait .1;
|
|
|
|
PlayFXOnTag(level._effect["green_light"], effect_ent,"tag_origin" );
|
|
}
|
|
|
|
//Wait until a tunnel double door switch is hit
|
|
waittill_any_ents(level._door_switch_trig1,"trigger",level._door_switch_trig2,"trigger");
|
|
|
|
//This loop makes sure effects do not happen in the same frame, as this function has been array threaded to multiple ents.
|
|
for (i = 0; i < element_number; i++)
|
|
{
|
|
wait .1;
|
|
}
|
|
|
|
//'New effect' is the blinking lights that occur while the double doors are moving
|
|
new_effect_ent = Spawn("script_model", self.origin);
|
|
new_effect_ent SetModel("tag_origin");
|
|
|
|
if(IsDefined(effect_ent))
|
|
{
|
|
effect_ent Delete();
|
|
}
|
|
|
|
//Must wait a moment for the script model to finish spawning
|
|
wait .1;
|
|
|
|
PlayFXOnTag(level._effect["blink_light"], new_effect_ent,"tag_origin" );
|
|
|
|
level waittill ("edge_check");
|
|
|
|
for (i = 0; i < element_number; i++)
|
|
{
|
|
wait .1;
|
|
}
|
|
|
|
new_effect_ent Delete();
|
|
|
|
if(!door_closed)
|
|
{
|
|
door_closed = true;
|
|
}
|
|
else
|
|
{
|
|
door_closed = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Open doors at start
|
|
double_doors_open_at_start()
|
|
{
|
|
//Set up the double doors to open at the start of the match
|
|
if ( level.PrematchPeriod > 0 && level.inPrematchPeriod == true )
|
|
{
|
|
level waittill("prematch_over");
|
|
}
|
|
|
|
|
|
//Slow down my door for other functions to hit waittil's
|
|
wait .3;
|
|
|
|
//Note I didn't use the "useby player[0]" convention due to a hesitance to grab specific players in MP.
|
|
level._door_switch_trig1 notify ("trigger");
|
|
}
|
|
|
|
//Set up the devgui to have the ability to operate the doors, adjust door cooldown, rotate times, digger behavior, etc.
|
|
devgui_radiation(cmd)
|
|
{
|
|
while(1)
|
|
{
|
|
wait(0.5);
|
|
|
|
devgui_string = GetDvar( #"devgui_notify");
|
|
|
|
switch(devgui_string)
|
|
{
|
|
case "":
|
|
break;
|
|
|
|
case "operate_doors":
|
|
level._door_switch_trig1 notify ("trigger");
|
|
break;
|
|
|
|
default:
|
|
level notify(devgui_string);
|
|
break;
|
|
}
|
|
|
|
SetDvar("devgui_notify", "");
|
|
}
|
|
}
|
|
|
|
//*****TO DO: MOVE DIGGER FUNCTIONALITY CLIENT SIDE.*********
|
|
|
|
//Sets it up so I can handle multiple diggers doing a digging action
|
|
digger_dig_init()
|
|
{
|
|
diggers = GetEntArray("digger_body","targetname");
|
|
AssertEx( diggers.size > 0, "Unable to find entity with targetname 'digger_body'" );
|
|
array_thread(diggers,::digger_dig_think);
|
|
}
|
|
|
|
//Self is the digger's body entity. Function creates a series of movements for the diggers to create a digging behavior
|
|
digger_dig_think()
|
|
{
|
|
body = self;
|
|
arm = GetEnt(self.target, "targetname");
|
|
AssertEx(IsDefined(arm), "Unable to find arm entity for a digger at " + self.origin );
|
|
blade_center = GetEnt(arm.target, "targetname");
|
|
AssertEx(IsDefined(blade_center), "Unable to find blade entity for a digger at " + self.origin );
|
|
|
|
blade_pieces = GetEntArray("digger_blade","targetname");
|
|
|
|
for( i = 0; i < blade_pieces.size; i++)
|
|
{
|
|
blade_pieces[i] LinkTo(blade_center);
|
|
}
|
|
|
|
blade_center LinkTo( arm );
|
|
arm LinkTo( body );
|
|
|
|
//play idle sound on body
|
|
body playloopsound ("evt_excavator_idle", .5);
|
|
|
|
if(IsDefined(self.script_float))
|
|
{
|
|
set_dvar_int_if_unset("scr_dig_delay", self.script_float );
|
|
}
|
|
else
|
|
{
|
|
//'20' is the default value for the cooldown on the digger's dig action
|
|
set_dvar_int_if_unset("scr_dig_delay", 20 );
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
arm_move_speed = set_dvar_int_if_unset("scr_arm_move_speed", 11);
|
|
blade_spin_speed = set_dvar_int_if_unset("scr_blade_spin_speed", 80);
|
|
blade_spin_up_time = set_dvar_int_if_unset("scr_blade_spin_up_time", 3);
|
|
|
|
body_turn = RandomIntRange(-15,15);
|
|
//Must grab the absolute value of the turn value to get proper time fraction, which is the "positive_value_func"
|
|
body_turn_speed = (positive_value_func(body_turn)) * .3;
|
|
|
|
body RotateYaw(body_turn, body_turn_speed, body_turn_speed/4, body_turn_speed/4 );
|
|
|
|
// play move loop on arm, and rev one shot on body
|
|
arm playloopsound ("evt_excavator_move", .5);
|
|
body playsound ("evt_excavator_rev");
|
|
|
|
body waittill ("rotatedone");
|
|
|
|
arm Unlink(body);
|
|
arm RotatePitch(-45, arm_move_speed, arm_move_speed/4, arm_move_speed/4);
|
|
arm waittill ("rotatedone");
|
|
|
|
blade_center UnLink(arm);
|
|
blade_center RotatePitch(1800, blade_spin_speed, blade_spin_up_time, blade_spin_up_time);
|
|
smokeAngles = ( 0, arm.angles[1]+180, arm.angles[2] );
|
|
|
|
forward = anglesToForward( smokeAngles );
|
|
|
|
//playfx ( level.chopper_fx["explode"]["death"], self.origin, forward );
|
|
PlayFX( level._digger_fx, ( blade_center.origin[0], blade_center.origin[1], blade_center.origin[2]-560), forward );
|
|
//stop loop on arm
|
|
//iprintlnbold ("this is the stop I suspect"); //had to comment this out for playtest. -Leif
|
|
arm stoploopsound (1);
|
|
|
|
// play digging loop on blade
|
|
blade_center playloopsound ("evt_excavator_blade", .5);
|
|
|
|
blade_center waittill ("rotatedone");
|
|
|
|
// stop diggin loop blade
|
|
blade_center stoploopsound (.5);
|
|
|
|
blade_center LinkTo(arm);
|
|
|
|
arm RotatePitch(45, arm_move_speed, arm_move_speed/4, arm_move_speed/4 );
|
|
|
|
// play move loop on arm, and rev one shot on body
|
|
arm playloopsound ("evt_excavator_move", .5);
|
|
body playsound ("evt_excavator_rev");
|
|
|
|
arm waittill ("rotatedone");
|
|
arm LinkTo( body );
|
|
|
|
body RotateYaw((body_turn * -1), body_turn_speed, body_turn_speed/4, body_turn_speed/4);
|
|
|
|
body waittill ("rotatedone");
|
|
arm stoploopsound (.5);
|
|
|
|
wait (GetDvarFloat( #"scr_dig_delay" ));
|
|
}
|
|
}
|
|
|
|
//Sets it up so the script can easily handle multiple moving diggers
|
|
moving_diggers_init()
|
|
{
|
|
diggers = GetEntArray("moving_digger","targetname");
|
|
//AssertEx( diggers.size > 0, "Unable to find entity with targetname 'moving_digger'" );
|
|
array_thread(diggers, ::moving_diggers_think);
|
|
}
|
|
|
|
//Sets up diggers that follow structs. Note the script_int K/V pair sets up the move time.
|
|
moving_diggers_think()
|
|
{
|
|
digger_struct = getstruct_and_assert(self.target);
|
|
|
|
while(1)
|
|
{
|
|
//Each struct has a script_int key value pair that determines the length of time it takes to complete the move
|
|
self MoveTo(digger_struct.origin, digger_struct.script_int);
|
|
AssertEx(IsDefined(digger_struct.script_int), "Unable to find digger struct's 'script_int' key value pair for moving digger" );
|
|
|
|
self waittill("movedone");
|
|
|
|
//Structs target other structs to determine the digger's path.
|
|
if(IsDefined(digger_struct.target))
|
|
{
|
|
digger_struct = GetStruct(digger_struct.target,"targetname");
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Function needed to get the absolute value of an integer and be sure its a positive number
|
|
positive_value_func(num)
|
|
{
|
|
return(max(1, abs(num)));
|
|
}
|
|
|
|
//Starts a thread to alter player's velocity as long as they're in the trigger
|
|
conveyer_belt_init()
|
|
{
|
|
//Need to set dvar to determine force of momentum in trigger
|
|
set_dvar_int_if_unset( "scr_coveyer_speed", 45 );
|
|
|
|
conveyer_trigger = getent_and_assert("coveyer_trig");
|
|
|
|
//The trigger targets a script struct. The struct contains angles to determine the force direction.
|
|
trigger_struct = getstruct_and_assert(conveyer_trigger.target);
|
|
|
|
//Find direction that my trigger is pointed toward
|
|
trigger_angles = AnglesToForward(trigger_struct.angles);
|
|
|
|
//Create intensity of conveyer force equal to my script DVar. Store it on my trigger for a seperate function to use.
|
|
conveyer_trigger._conveyer_vector = vector_scale(trigger_angles,GetDvarInt( #"scr_coveyer_speed"));
|
|
|
|
while(1)
|
|
{
|
|
conveyer_trigger waittill("trigger", player);
|
|
if(IsPlayer(player))
|
|
{
|
|
conveyer_trigger thread trigger_thread(player, ::player_on_conveyer);
|
|
}
|
|
|
|
wait .05;
|
|
}
|
|
}
|
|
|
|
//Self is trigger. Function is ran when player jumps into the trigger.
|
|
player_on_conveyer(player, endon_string)
|
|
{
|
|
player endon ("death");
|
|
player endon ("disconnect");
|
|
player endon(endon_string);
|
|
|
|
while(1)
|
|
{
|
|
player_velocity = player GetVelocity();
|
|
|
|
//Don't want jumping player to be pulled by conveyer
|
|
if (player IsOnGround())
|
|
{
|
|
//Gives player momentum in the direction of the conveyer equal to a dvar I created earlier along with their own momentum
|
|
player SetVelocity(player_velocity + self._conveyer_vector);
|
|
}
|
|
|
|
wait .05;
|
|
}
|
|
}
|
|
|
|
getent_and_assert(ent_name)
|
|
{
|
|
thing = GetEnt( ent_name, "targetname");
|
|
AssertEx(IsDefined(thing), "Unable to find targetname " + ent_name);
|
|
|
|
return thing;
|
|
}
|
|
|
|
getstruct_and_assert(struct_name)
|
|
{
|
|
thing = getstruct( struct_name, "targetname");
|
|
AssertEx(IsDefined(thing), "Unable to find struct at " +struct_name);
|
|
|
|
return thing;
|
|
}
|
|
|
|
dropEverythingOnDoorsToGround()
|
|
{
|
|
level endon("edge_check");
|
|
|
|
// keep dropping all to ground to keep the items in physics
|
|
// if you only do it once or twice they come back to rest to fast
|
|
// if there is a problem with this solution then we are going to need
|
|
// to do something for keeping the crates in physics while in contact
|
|
// with the doors.
|
|
while(1)
|
|
{
|
|
wait(0.1);
|
|
dropAllToGround( (0,0,128), 181, 100 );
|
|
}
|
|
}
|
|
|
|
destroyEquipment()
|
|
{
|
|
level endon ( "edge_check" );
|
|
|
|
for ( ;; )
|
|
{
|
|
wait( 2 );
|
|
|
|
grenades = GetEntArray( "grenade", "classname" );
|
|
|
|
for ( i = 0; i < grenades.size; i++ )
|
|
{
|
|
item = grenades[i];
|
|
|
|
if ( !IsDefined( item.name ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( !IsDefined( item.owner ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( !IsWeaponEquipment( item.name ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( !item IsTouching( level._door1 ) && !item IsTouching( level._door2 ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
watcher = item.owner getWatcherForWeapon( item.name );
|
|
|
|
if ( !IsDefined( watcher ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
watcher thread maps\mp\gametypes\_weaponobjects::waitAndDetonate( item, 0.0, undefined );
|
|
}
|
|
}
|
|
}
|
|
|
|
getWatcherForWeapon( weapname )
|
|
{
|
|
if ( !IsDefined( self ) )
|
|
{
|
|
return undefined;
|
|
}
|
|
|
|
if ( !IsPlayer( self ) )
|
|
{
|
|
return undefined;
|
|
}
|
|
|
|
for ( i = 0; i < self.weaponObjectWatcherArray.size; i++ )
|
|
{
|
|
if ( self.weaponObjectWatcherArray[i].weapon != weapname )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
return ( self.weaponObjectWatcherArray[i] );
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
//spawns triggers to stop players from placing turrets
|
|
addNoTurretTrigger( position, radius, height )
|
|
{
|
|
while( !IsDefined( level.noTurretPlacementTriggers ) )
|
|
wait( 0.1 );
|
|
|
|
trigger = Spawn( "trigger_radius", position, 0, radius, height );
|
|
|
|
level.noTurretPlacementTriggers[level.noTurretPlacementTriggers.size] = trigger;
|
|
}
|