mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-12 08:11:10 +02:00
Justin Marshall
1134 lines
27 KiB
Plaintext
1134 lines
27 KiB
Plaintext
namespace map_delta2a {
|
|
#define NEG_ROT '0 -120 0'
|
|
#define POS_ROT '0 120 0'
|
|
#define HEAD_TIME 3
|
|
#define LIFT_TIME 3
|
|
#define JET_VENT_TIME 1.5 // How long do we want the lock vents to fire ?
|
|
|
|
float rotmult; // Matt's lift
|
|
float lift_state_updown;
|
|
float crate_number; // Stored from identify_crate(slot);
|
|
float deconPosition = 0;
|
|
//***
|
|
// Given the cranes position in front of a cage slot, find out which crate is in that space
|
|
// Returns the cage number. bind "cage_" + value to the hand
|
|
//***
|
|
|
|
void set_crate_in_slot( float slot, float crate ) {
|
|
$world.setKey( "slot_" + slot, crate );
|
|
}
|
|
|
|
float identify_crate (float slot) {
|
|
float value;
|
|
|
|
value = $world.getFloatKey( "slot_" + slot );
|
|
//sys.print ("IDENTIFY_CRATE:: Found crate #" + value + " @ slot # " + slot + "\n");
|
|
|
|
return value;
|
|
}
|
|
|
|
void setup_objects()
|
|
{
|
|
sys.trigger ($speaker_131); // Turn this speaker in the tube off
|
|
// Was screwing up the fadeout for teleport_end
|
|
|
|
$mister1.bind ($mister1_anchor);
|
|
$mister2.bind ($mister2_anchor);
|
|
|
|
$tp_leftarm.bind ($tp_shoulder);
|
|
$tp_rightarm.bind ($tp_shoulder);
|
|
|
|
// name of array, index number, data
|
|
set_crate_in_slot( 1, 1 ); // Cage 1 is occupied
|
|
set_crate_in_slot( 2, 2 );
|
|
set_crate_in_slot( 3, 3 );
|
|
set_crate_in_slot( 4, 4 );
|
|
set_crate_in_slot( 5, 5 );
|
|
set_crate_in_slot( 6, 0 ); // Cage 6 is empty
|
|
set_crate_in_slot( 7, 7 );
|
|
set_crate_in_slot( 8, 0 ); // Cage 8 is empty
|
|
set_crate_in_slot( 9, 9 );
|
|
|
|
$crane_control.setGuiParm ("gui_parm11", 1 );
|
|
$crane_control.setGuiParm ("gui_parm12", 1 );
|
|
$crane_control.setGuiParm ("gui_parm13", 1 );
|
|
$crane_control.setGuiParm ("gui_parm14", 1 );
|
|
$crane_control.setGuiParm ("gui_parm15", 1 );
|
|
$crane_control.setGuiParm ("gui_parm16", 0 );
|
|
$crane_control.setGuiParm ("gui_parm17", 1 );
|
|
$crane_control.setGuiParm ("gui_parm18", 0 );
|
|
$crane_control.setGuiParm ("gui_parm19", 1 );
|
|
|
|
$cagecrane_base.time (1);
|
|
$crane_base.time (1);
|
|
$teeth_anchor.time (1);
|
|
$cagecrane_rod.time (1);
|
|
$cagecrane_teeth_teeth.time (0.5);
|
|
|
|
$teeth_anchor.rotateOnce ('0 0 -90');
|
|
$cagecrane_teeth_teeth.move (LEFT, 64);
|
|
|
|
$cagecrane_armsupport.time (1);
|
|
}
|
|
|
|
void open_fingers() {
|
|
sys.trigger ($finger_speaker_1);
|
|
$finger_1b_anchor.rotateOnce (POS_ROT);
|
|
$finger_1a_anchor.rotateOnce (NEG_ROT);
|
|
sys.wait (0.75);
|
|
//sys.waitFor ($finger_1a_anchor);
|
|
|
|
sys.trigger ($finger_speaker_2);
|
|
$finger_2a_anchor.rotateOnce (POS_ROT);
|
|
$finger_2b_anchor.rotateOnce (NEG_ROT);
|
|
sys.waitFor ($finger_2b_anchor);
|
|
}
|
|
|
|
void close_fingers() {
|
|
sys.trigger ($finger_speaker_2);
|
|
$finger_2a_anchor.rotateOnce (NEG_ROT);
|
|
$finger_2b_anchor.rotateOnce (POS_ROT);
|
|
sys.wait (0.75);
|
|
//sys.waitFor ($finger_2b_anchor);
|
|
|
|
sys.trigger ($finger_speaker_1);
|
|
$finger_1b_anchor.rotateOnce (NEG_ROT);
|
|
$finger_1a_anchor.rotateOnce (POS_ROT);
|
|
sys.waitFor ($finger_1a_anchor);
|
|
}
|
|
|
|
void unlock_cage (float cage) {
|
|
entity ent;
|
|
ent = sys.getEntity ("cagelock_" + cage);
|
|
ent.time (0.5);
|
|
ent.move (RIGHT, 16);
|
|
sys.waitFor (ent);
|
|
}
|
|
|
|
void lock_cage (float cage) {
|
|
entity ent;
|
|
ent = sys.getEntity ("cagelock_" + cage);
|
|
ent.time (0.5);
|
|
ent.move (LEFT, 16);
|
|
sys.waitFor (ent);
|
|
}
|
|
|
|
void disable_crane_control() {
|
|
$crane_control.setGuiParm ("gui_parm10", 1);
|
|
}
|
|
|
|
void enable_crane_control() {
|
|
$crane_control.setGuiParm ("gui_parm10", 0);
|
|
}
|
|
|
|
void crane_alarm_on() {
|
|
sys.trigger ($clight_1);
|
|
sys.trigger ($clight_2);
|
|
$crane_alarm_anchor.rotate ('0 270 0');
|
|
}
|
|
|
|
void crane_alarm_off() {
|
|
sys.trigger ($clight_1);
|
|
sys.trigger ($clight_2);
|
|
$crane_alarm_anchor.stopRotating();
|
|
}
|
|
|
|
|
|
void init_claw() {
|
|
|
|
disable_crane_control();
|
|
|
|
$body.time (3);
|
|
$shoulder_anchor.time (1);
|
|
// Compress fingers
|
|
|
|
$finger_1a_anchor.time (1.5);
|
|
$finger_1b_anchor.time (1.5);
|
|
$finger_2a_anchor.time (1.5);
|
|
$finger_2b_anchor.time (1.5);
|
|
|
|
|
|
$finger_1b_anchor.rotateOnce ('0 -180 0');
|
|
$finger_2b_anchor.rotateOnce ('0 180 0');
|
|
|
|
$finger_1a_anchor.rotateOnce ('0 180 0');
|
|
$finger_2a_anchor.rotateOnce ('0 -180 0');
|
|
|
|
// rotate hand up
|
|
$hand_anchor.time (1);
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('-80 0 0');
|
|
|
|
// rotate arm in
|
|
$arm_anchor.time (1);
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('30 0 0');
|
|
|
|
// Face the proper direction
|
|
|
|
$body.rotateOnce ('0 -90 0');
|
|
sys.waitFor ($body);
|
|
$head.time (HEAD_TIME);
|
|
$head.accelTime (0.5);
|
|
$head.decelTime (0.5);
|
|
|
|
$body.rotateOnce ('0 180 0');
|
|
sys.trigger ($head_speaker);
|
|
$head.move (LEFT, 100);
|
|
|
|
crate_number = 0;
|
|
|
|
enable_crane_control();
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
M a t t ' s L i f t f r o m C o m m O u t s i d e
|
|
|
|
*/
|
|
|
|
////////////////////////////////////////////////////
|
|
//
|
|
// move lift down
|
|
//
|
|
////////////////////////////////////////////////////
|
|
void lift_down ()
|
|
{
|
|
vector rot11, rot12;
|
|
vector rot21, rot22;
|
|
|
|
rot11_x = 0;
|
|
rot11_y = 0;
|
|
rot11_z = rotmult;
|
|
|
|
rot12_x = 0;
|
|
rot12_y = 0;
|
|
rot12_z = (-1 * rotmult);
|
|
|
|
rot21_x = 0;
|
|
rot21_y = 0;
|
|
rot21_z = (2 * rotmult);
|
|
|
|
rot22_x = 0;
|
|
rot22_y = 0;
|
|
rot22_z = (-2 * rotmult);
|
|
|
|
if ( lift_state_updown == 0 ){
|
|
sys.trigger ($lift_speaker_down);
|
|
$lift_leg_11.rotateOnce ( rot11 );
|
|
$lift_leg_12.rotateOnce ( rot22 );
|
|
$lift_leg_13.rotateOnce ( rot21 );
|
|
$lift_connection_top_move.rotateOnce ( rot12 );
|
|
|
|
$lift_leg_21.rotateOnce ( rot22 );
|
|
$lift_connection_bottom_move.rotateOnce ( rot11 );
|
|
$lift_leg_22.rotateOnce ( rot21 );
|
|
$lift_leg_23.rotateOnce ( rot22 );
|
|
$lift_connection_top_static.rotateOnce ( rot11 );
|
|
|
|
sys.waitFor ($lift_leg_23);
|
|
lift_state_updown = 1;
|
|
}
|
|
// else sys.print ( "lift is already up\n" );
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////
|
|
//
|
|
// move lift up
|
|
//
|
|
////////////////////////////////////////////////////
|
|
void lift_up ()
|
|
{
|
|
vector rot11, rot12;
|
|
vector rot21, rot22;
|
|
|
|
rot11_x = 0;
|
|
rot11_y = 0;
|
|
rot11_z = rotmult;
|
|
|
|
rot12_x = 0;
|
|
rot12_y = 0;
|
|
rot12_z = (-1 * rotmult);
|
|
|
|
rot21_x = 0;
|
|
rot21_y = 0;
|
|
rot21_z = (2 * rotmult);
|
|
|
|
rot22_x = 0;
|
|
rot22_y = 0;
|
|
rot22_z = (-2 * rotmult);
|
|
|
|
if ( lift_state_updown == 1 ){
|
|
sys.trigger ($lift_speaker_up);
|
|
$lift_leg_11.rotateOnce ( rot12 );
|
|
$lift_leg_12.rotateOnce ( rot21 );
|
|
$lift_leg_13.rotateOnce ( rot22 );
|
|
$lift_connection_top_move.rotateOnce ( rot11 );
|
|
|
|
$lift_leg_21.rotateOnce ( rot21 );
|
|
$lift_connection_bottom_move.rotateOnce ( rot12 );
|
|
$lift_leg_22.rotateOnce ( rot22 );
|
|
$lift_leg_23.rotateOnce ( rot21 );
|
|
$lift_connection_top_static.rotateOnce ( rot12 );
|
|
|
|
sys.waitFor ($lift_leg_23);
|
|
lift_state_updown = 0;
|
|
}
|
|
//else sys.print ( "lift is already down\n" );
|
|
}
|
|
|
|
void init_lift() {
|
|
lift_state_updown = 0;
|
|
rotmult = 40;
|
|
|
|
//Lift binds, times, and speeds
|
|
//$lift_leg_11.bind ($lift_bottom);
|
|
//$lift_light1.bind ($lift_bottom);
|
|
|
|
$lift_axle1.bind ($lift_leg_11);
|
|
$lift_axle2.bind ($lift_leg_11);
|
|
$lift_leg_12.bind ($lift_axle2);
|
|
$lift_axle4.bind ($lift_leg_12);
|
|
$lift_axle6.bind ($lift_leg_12);
|
|
$lift_leg_13.bind ($lift_axle6);
|
|
$lift_axle7.bind ($lift_leg_13);
|
|
|
|
$lift_leg_23.bind ($lift_axle7);
|
|
$lift_axle5.bind ($lift_leg_23);
|
|
$lift_leg_22.bind ($lift_axle5);
|
|
$lift_axle3.bind ($lift_leg_22);
|
|
$lift_leg_21.bind ($lift_axle3);
|
|
|
|
$lift_connection_top_move.bind ($lift_leg_13);
|
|
$lift_connection_top_static.bind ($lift_leg_23);
|
|
$lift_connection_bottom_move.bind ($lift_leg_21);
|
|
|
|
$lift_cage.bind ($lift_connection_top_static);
|
|
|
|
$lift_bottom.accelTime ( .5 );
|
|
$lift_bottom.decelTime ( .5 );
|
|
|
|
$lift_leg_11.time ( LIFT_TIME );
|
|
$lift_leg_12.time ( LIFT_TIME );
|
|
$lift_leg_13.time ( LIFT_TIME );
|
|
$lift_connection_top_move.time ( LIFT_TIME );
|
|
$lift_leg_21.time ( LIFT_TIME );
|
|
$lift_connection_bottom_move.time ( LIFT_TIME );
|
|
$lift_leg_22.time ( LIFT_TIME );
|
|
$lift_leg_23.time ( LIFT_TIME );
|
|
$lift_connection_top_static.time ( LIFT_TIME );
|
|
|
|
$lift_leg_11.accelTime ( .25 );
|
|
$lift_leg_12.accelTime ( .25 );
|
|
$lift_leg_13.accelTime ( .25 );
|
|
$lift_connection_top_move.accelTime ( .25 );
|
|
$lift_leg_21.accelTime ( .25 );
|
|
$lift_connection_bottom_move.accelTime ( .25);
|
|
$lift_leg_22.accelTime ( .25 );
|
|
$lift_leg_23.accelTime ( .25 );
|
|
$lift_connection_top_static.accelTime ( .25 );
|
|
|
|
$lift_leg_11.decelTime ( .25 );
|
|
$lift_leg_12.decelTime ( .25 );
|
|
$lift_leg_13.decelTime ( .25 );
|
|
$lift_connection_top_move.decelTime ( .25 );
|
|
$lift_leg_21.decelTime ( .25 );
|
|
$lift_connection_bottom_move.decelTime ( .25 );
|
|
$lift_leg_22.decelTime ( .25 );
|
|
$lift_leg_23.decelTime ( .25 );
|
|
$lift_connection_top_static.decelTime ( .25 );
|
|
}
|
|
|
|
/*
|
|
|
|
End CommOutside code.
|
|
|
|
*/
|
|
|
|
//***
|
|
// Kinda ugly, need to find the proper jet pair for the accompanying slot
|
|
// I'd give my left nut for switch(value) functionality...
|
|
//***
|
|
|
|
float trigger_steamjets(float slot) {
|
|
entity ent1, ent2;
|
|
entity speaker1, speaker2;
|
|
float jet1, jet2;
|
|
|
|
if ( slot == 1) {
|
|
jet1 = 1;
|
|
jet2 = 2;
|
|
}
|
|
if ( slot == 2) {
|
|
jet1 = 2;
|
|
jet2 = 3;
|
|
}
|
|
if ( slot == 3) {
|
|
jet1 = 3;
|
|
jet2 = 4;
|
|
}
|
|
if ( slot == 4) {
|
|
jet1 = 5;
|
|
jet2 = 6;
|
|
}
|
|
if ( slot == 5) {
|
|
jet1 = 6;
|
|
jet2 = 7;
|
|
}
|
|
if ( slot == 6) {
|
|
jet1 = 7;
|
|
jet2 = 8;
|
|
}
|
|
if ( slot == 7) {
|
|
jet1 = 9;
|
|
jet2 = 10;
|
|
}
|
|
if ( slot == 8) {
|
|
jet1 = 10;
|
|
jet2 = 11;
|
|
}
|
|
if ( slot == 9) {
|
|
jet1 = 11;
|
|
jet2 = 12;
|
|
}
|
|
ent1 = sys.getEntity ("steamjet_" + jet1);
|
|
ent2 = sys.getEntity ("steamjet_" + jet2);
|
|
speaker1 = sys.getEntity ("steamspeaker_" + jet1);
|
|
speaker2 = sys.getEntity ("steamspeaker_" + jet2);
|
|
|
|
// Turn 'em on
|
|
sys.trigger (ent1);
|
|
sys.trigger (ent2);
|
|
|
|
sys.trigger (speaker1);
|
|
sys.trigger (speaker2);
|
|
|
|
sys.wait (JET_VENT_TIME);
|
|
|
|
// Turn 'em off
|
|
sys.trigger (ent1);
|
|
sys.trigger (ent2);
|
|
}
|
|
|
|
void update_control_gui (float slot, float status) {
|
|
//sys.print ("Enterint update_control_gui :: Setting slot " + slot + " to " + status + "\n");
|
|
|
|
if ( slot == 1 )
|
|
$crane_control.setGuiParm ( "gui_parm11", status );
|
|
if ( slot == 2 )
|
|
$crane_control.setGuiParm ( "gui_parm12", status );
|
|
if ( slot == 3 )
|
|
$crane_control.setGuiParm ( "gui_parm13", status );
|
|
if ( slot == 4 )
|
|
$crane_control.setGuiParm ( "gui_parm14", status );
|
|
if ( slot == 5 )
|
|
$crane_control.setGuiParm ( "gui_parm15", status );
|
|
if ( slot == 6 )
|
|
$crane_control.setGuiParm ( "gui_parm16", status );
|
|
if ( slot == 7 )
|
|
$crane_control.setGuiParm ( "gui_parm17", status );
|
|
if ( slot == 8 )
|
|
$crane_control.setGuiParm ( "gui_parm18", status );
|
|
if ( slot == 9 )
|
|
$crane_control.setGuiParm ( "gui_parm19", status );
|
|
|
|
|
|
}
|
|
|
|
|
|
//***
|
|
// Find the target vertical rung given a slot position.
|
|
// Need for moving the crane vertically
|
|
//***
|
|
|
|
float find_rung (float slot) {
|
|
if ( slot <= 3 )
|
|
return 1;
|
|
if ( slot <= 6 )
|
|
return 2;
|
|
if ( slot <= 9 )
|
|
return 3;
|
|
}
|
|
|
|
//***
|
|
// Workhorse #2
|
|
// Pick up the crate off the platform and move it back into a slot
|
|
//***
|
|
|
|
void insert_crate (float slot) {
|
|
entity ent;
|
|
entity crate;
|
|
float thread1, thread2;
|
|
vector vec, vec2, diff;
|
|
float target_rung;
|
|
// sys.print ("*** ENTERING insert_crate (" + slot + ")\n");
|
|
|
|
crane_alarm_on();
|
|
|
|
sys.trigger ($movement_alarm);
|
|
sys.wait (2);
|
|
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (DOWN, 64);
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('110 0 0');
|
|
sys.waitFor ($hand_anchor);
|
|
|
|
// Gameplay stuff here... delays so that the player can jump onto the crate
|
|
// in time...
|
|
|
|
sys.wait (0.5);
|
|
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('-60 0 0');
|
|
sys.waitFor ($arm_anchor);
|
|
|
|
sys.wait (0.5);
|
|
|
|
lift_up();
|
|
|
|
open_fingers();
|
|
|
|
// ****
|
|
// Get the cage on the platform
|
|
// Remember, that crate_number is stored as a global still from the removal function...
|
|
// ****
|
|
|
|
// sys.print ("Trying to bind cage_" + crate_number + " to $hand\n");
|
|
ent = sys.getEntity ( "cage_" + crate_number );
|
|
crate = ent;
|
|
ent.bind ($hand); // Bind crate to hand
|
|
|
|
thread map_delta2a::lift_down();
|
|
sys.waitFor ($shoulder_anchor);
|
|
|
|
// Break here and sync up original rotation values.
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('-50 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('50 0 0');
|
|
|
|
sys.waitFor ($arm_anchor);
|
|
|
|
|
|
sys.trigger ($head_speaker);
|
|
$head.move (RIGHT, 100);
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (UP, 64);
|
|
$body.time (5);
|
|
sys.trigger ($body_speaker_5);
|
|
$body.rotateOnce ('0 180 0');
|
|
sys.waitFor ($body);
|
|
$body.time (3);
|
|
|
|
// Need to find vertical here...
|
|
|
|
target_rung = find_rung (slot);
|
|
if ( target_rung == 3 ) {
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (DOWN, 64);
|
|
sys.trigger ($body_vert_speaker);
|
|
$body.move (DOWN, 128);
|
|
sys.waitFor ($body);
|
|
}
|
|
if ( target_rung == 2) {
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (DOWN, 64);
|
|
sys.trigger ($body_vert_speaker);
|
|
$body.move (DOWN, 32);
|
|
sys.waitFor ($body);
|
|
}
|
|
|
|
// Need lateral movement here.
|
|
|
|
ent = sys.getEntity ("pos" + slot);
|
|
vec = ent.getWorldOrigin ();
|
|
|
|
vec2 = $crane_guide.getWorldOrigin ();
|
|
|
|
// ---
|
|
// Calculate movement vectors and move accordingly
|
|
// ---
|
|
|
|
diff_x = ( vec2_x - vec_x );
|
|
if ( diff_x < 0 ) {
|
|
diff_x = abs ( diff_x );
|
|
sys.trigger ($head_speaker);
|
|
$head.move (FORWARD, diff_x);
|
|
}
|
|
else {
|
|
sys.trigger ($head_speaker);
|
|
$head.move (BACK, diff_x);
|
|
}
|
|
|
|
sys.waitFor ($head);
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('60 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('-60 0 0');
|
|
|
|
trigger_steamjets(slot);
|
|
thread1 = thread map_delta2a::unlock_cage(slot);
|
|
sys.waitFor ($arm_anchor);
|
|
|
|
trigger_steamjets(slot);
|
|
|
|
sys.waitForThread (thread1);
|
|
|
|
//thread map_delta2a::lock_cage(slot);
|
|
|
|
lock_cage(slot);
|
|
|
|
crate.unbind(); // Unbind the crate
|
|
|
|
// ***
|
|
// Paranoia case to ensure that the crate gets bound to it's absolute starting position
|
|
// after it has been manipulated
|
|
// ***
|
|
|
|
crate.setOrigin (ent.getWorldOrigin () );
|
|
// sys.print ("fixed the crate\n");
|
|
|
|
close_fingers();
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('-60 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('60 0 0');
|
|
sys.waitFor ($hand_anchor);
|
|
|
|
// ***
|
|
// Lateral movement to center
|
|
// ***
|
|
|
|
ent = sys.getEntity ("pos5");
|
|
vec = ent.getWorldOrigin ();
|
|
vec2 = $crane_guide.getWorldOrigin ();
|
|
diff_x = ( vec2_x - vec_x );
|
|
if ( diff_x < 0 ) {
|
|
diff_x = abs ( diff_x );
|
|
sys.trigger ($head_speaker);
|
|
$head.move (FORWARD, diff_x);
|
|
}
|
|
else {
|
|
sys.trigger ($head_speaker);
|
|
$head.move (BACK, diff_x);
|
|
}
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('50 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('-50 0 0');
|
|
sys.waitFor ($arm_anchor);
|
|
|
|
sys.waitFor ($head);
|
|
|
|
// Reset rungs
|
|
|
|
if ( target_rung == 3 ) {
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (UP, 64);
|
|
sys.trigger ($body_vert_speaker);
|
|
$body.move (UP, 128);
|
|
sys.waitFor ($body);
|
|
}
|
|
if ( target_rung == 2) {
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (UP, 64);
|
|
sys.trigger ($body_vert_speaker);
|
|
$body.move (UP, 32);
|
|
sys.waitFor ($body);
|
|
}
|
|
|
|
// Rotate around
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('-110 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('60 0 0');
|
|
sys.trigger ($head_speaker);
|
|
$head.move (LEFT, 100);
|
|
sys.trigger ($body_speaker_3);
|
|
$body.rotateOnce ('0 180 0');
|
|
sys.waitFor ($arm_anchor);
|
|
sys.waitFor ($head);
|
|
|
|
crane_alarm_off();
|
|
|
|
// Ok, find my way back to the reset point...
|
|
|
|
set_crate_in_slot( slot, crate_number );
|
|
crate_number = 0; // All crates accounted for
|
|
// sys.print ("*** EXITING insert_crate (" + slot + ")\n");
|
|
update_control_gui (slot, 1);
|
|
}
|
|
|
|
//***
|
|
// (In his best Ian Astbury voice... Xian bellows...)
|
|
// "Talking 'bout crates ! CRATE REMOVAL MACHINE !!!"
|
|
//
|
|
// Workhorse #1
|
|
// Grabs a crate from the desired slot, and moves it onto the platform.
|
|
//***
|
|
|
|
void remove_crate (float slot) {
|
|
entity ent;
|
|
entity crate;
|
|
float thread1, thread2;
|
|
vector vec, vec2, diff;
|
|
float target_rung;
|
|
// sys.print ("*** ENTERING insert_crate (" + slot + ")\n");
|
|
|
|
crane_alarm_on();
|
|
|
|
sys.trigger ($movement_alarm);
|
|
sys.wait (2);
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('110 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('-60 0 0');
|
|
|
|
sys.trigger ($head_speaker);
|
|
$head.move (RIGHT, 100);
|
|
sys.trigger ($body_speaker_3);
|
|
$body.rotateOnce ('0 180 0');
|
|
sys.waitFor ($head);
|
|
sys.waitFor ($body);
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('-50 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('50 0 0');
|
|
|
|
sys.waitFor ($hand_anchor);
|
|
|
|
// Need to find vertical here...
|
|
|
|
target_rung = find_rung (slot);
|
|
if ( target_rung == 3 ) {
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (DOWN, 64);
|
|
sys.trigger ($body_vert_speaker);
|
|
$body.move (DOWN, 128);
|
|
sys.waitFor ($body);
|
|
}
|
|
if ( target_rung == 2) {
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (DOWN, 64);
|
|
sys.trigger ($body_vert_speaker);
|
|
$body.move (DOWN, 32);
|
|
sys.waitFor ($body);
|
|
}
|
|
|
|
// Need lateral movement here.
|
|
|
|
ent = sys.getEntity ("pos" + slot);
|
|
vec = ent.getWorldOrigin ();
|
|
|
|
vec2 = $crane_guide.getWorldOrigin ();
|
|
|
|
// ---
|
|
// Calculate movement vectors and move accordingly
|
|
// ---
|
|
|
|
diff_x = ( vec2_x - vec_x );
|
|
if ( diff_x < 0 ) {
|
|
diff_x = abs ( diff_x );
|
|
sys.trigger ($head_speaker);
|
|
$head.move (FORWARD, diff_x);
|
|
}
|
|
else {
|
|
sys.trigger ($head_speaker);
|
|
$head.move (BACK, diff_x);
|
|
}
|
|
|
|
sys.waitFor ($head);
|
|
|
|
// This should put us in front of the crate we want to snag
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('60 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('-60 0 0');
|
|
sys.waitFor ($arm_anchor);
|
|
open_fingers();
|
|
|
|
thread1 = thread map_delta2a::unlock_cage (slot);
|
|
trigger_steamjets(slot);
|
|
|
|
// Get the cage on the platform
|
|
|
|
crate_number = identify_crate(slot);
|
|
|
|
// sys.print ("Trying to bind cage_" + crate_number + " to $hand\n");
|
|
crate = sys.getEntity ( "cage_" + crate_number );
|
|
crate.bind ($hand); // Bind crate to hand
|
|
|
|
sys.waitForThread (thread1);
|
|
thread map_delta2a::lock_cage(slot);
|
|
|
|
// Ok, the crate is now bound to the crane
|
|
|
|
sys.wait (0.5);
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('-60 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('60 0 0');
|
|
|
|
sys.waitFor ($arm_anchor);
|
|
|
|
// ***
|
|
// Lateral movement to center
|
|
// ***
|
|
|
|
ent = sys.getEntity ("pos5");
|
|
vec = ent.getWorldOrigin ();
|
|
vec2 = $crane_guide.getWorldOrigin ();
|
|
diff_x = ( vec2_x - vec_x );
|
|
if ( diff_x < 0 ) {
|
|
diff_x = abs ( diff_x );
|
|
sys.trigger ($head_speaker);
|
|
$head.move (FORWARD, diff_x);
|
|
}
|
|
else {
|
|
sys.trigger ($head_speaker);
|
|
$head.move (BACK, diff_x);
|
|
}
|
|
|
|
sys.waitFor ($head);
|
|
|
|
// Crane should be centered and ready to move toward the platform.
|
|
|
|
if ( target_rung == 3 ) {
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (UP, 64);
|
|
sys.trigger ($body_vert_speaker);
|
|
$body.move (UP, 128);
|
|
}
|
|
if ( target_rung == 2) {
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (UP, 64);
|
|
sys.trigger ($body_vert_speaker);
|
|
$body.move (UP, 32);
|
|
}
|
|
sys.waitFor ($body);
|
|
|
|
// Ok, now it's centered and on the top rung...
|
|
// Move toward the platform... for real this time...
|
|
|
|
thread lift_up();
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('50 0 0');
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (DOWN, 64);
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('-50 0 0');
|
|
sys.trigger ($head_speaker);
|
|
$head.move (LEFT, 100);
|
|
sys.trigger ($body_speaker_3);
|
|
$body.rotateOnce ('0 180 0');
|
|
sys.waitFor ($head);
|
|
|
|
// woop ! It's on the platform now...
|
|
|
|
thread map_delta2a::close_fingers();
|
|
|
|
crate.unbind();
|
|
crate.bind ($lift_cage);
|
|
sys.wait (0.5);
|
|
|
|
thread map_delta2a::lift_down();
|
|
|
|
sys.trigger ($hand_speaker);
|
|
$hand_anchor.rotateOnce ('-110 0 0');
|
|
sys.trigger ($arm_speaker);
|
|
$arm_anchor.rotateOnce ('60 0 0');
|
|
sys.trigger ($shoulder_speaker);
|
|
$shoulder_anchor.move (UP, 64);
|
|
sys.waitFor ($shoulder_anchor);
|
|
|
|
crane_alarm_off();
|
|
//
|
|
set_crate_in_slot( slot, 0 ); // Set the cage as empty
|
|
update_control_gui (slot, 0);
|
|
}
|
|
|
|
void process_cage (float slot) {
|
|
float value;
|
|
entity ent, ent2;
|
|
vector deb;
|
|
vector vec, vec2, diff;
|
|
float rod_rotation;
|
|
float shoulder_diff;
|
|
float body_diff;
|
|
float desired_rung;
|
|
float rung_thread;
|
|
|
|
rotmult = 41;
|
|
|
|
disable_crane_control();
|
|
|
|
deb = $hand_anchor.getWorldOrigin ();
|
|
// sys.print ("ENTER: process_cage: $hand_anchor @ (" + deb_x + ", " + deb_y + ", "+ deb_z + ")\n");
|
|
|
|
// Load the state of the slot into value
|
|
value = identify_crate(slot);
|
|
|
|
// sys.print ("Target Slot Value :: " + value + "\n");
|
|
|
|
// ---
|
|
// First, check to see if there is anything on the platform. If there is,
|
|
// we are going to move it to a slot instead of extracting a slot
|
|
// ---
|
|
|
|
if ( ( crate_number != 0) ) { // No crate on the platform ?
|
|
// sys.print ("Crate #" + crate_number + " is currently on the platform\n");
|
|
if ( value == 0 ) {
|
|
// sys.print ("It wants to go to position " + slot + ", which is free\n");
|
|
insert_crate (slot);
|
|
}
|
|
// else {
|
|
// sys.print ("It wants to go to position " + slot + ", which is *NOT* free\n");
|
|
// }
|
|
}
|
|
// Nope, nothing on the platform, lets go get it...
|
|
else {
|
|
// sys.print ("Nothing on the platform. lets proceed with possible movement...\n");
|
|
// Is there anything at the slot we are interested in ?
|
|
if ( value > 0 ) {
|
|
remove_crate (slot);
|
|
}
|
|
// else if ( value == -1 ) {
|
|
// sys.print ("That slot is broken\n");
|
|
// }
|
|
// else
|
|
// sys.print ("There is nothing at that location to move...\n");
|
|
}
|
|
|
|
deb = $hand_anchor.getWorldOrigin ();
|
|
// sys.print ("BEFORE: $hand_anchor @ (" + deb_x + ", " + deb_y + ", "+ deb_z + ")\n");
|
|
enable_crane_control();
|
|
// sys.print ("Leaving process_cage()\n");
|
|
|
|
}
|
|
|
|
// ---
|
|
// Bumper functions for map gui calls
|
|
// ---
|
|
|
|
void proc_cage1() {
|
|
process_cage (1);
|
|
}
|
|
|
|
void proc_cage2() {
|
|
process_cage (2);
|
|
}
|
|
|
|
void proc_cage3() {
|
|
process_cage (3);
|
|
}
|
|
|
|
void proc_cage4() {
|
|
process_cage (4);
|
|
}
|
|
|
|
void proc_cage5() {
|
|
process_cage (5);
|
|
}
|
|
|
|
void proc_cage6() {
|
|
process_cage (6);
|
|
}
|
|
|
|
void proc_cage7() {
|
|
process_cage (7);
|
|
}
|
|
|
|
void proc_cage8() {
|
|
process_cage (8);
|
|
}
|
|
|
|
void proc_cage9() {
|
|
process_cage (9);
|
|
}
|
|
|
|
// ---
|
|
// **** End bumper functions
|
|
// ---
|
|
|
|
//************************
|
|
// Decon Chamber
|
|
//************************
|
|
|
|
void decon_cycle1()
|
|
{
|
|
$decon_trigger1.enable ();
|
|
deconPosition = 1;
|
|
}
|
|
|
|
void decon_cycle2()
|
|
{
|
|
$decon_trigger1.enable ();
|
|
deconPosition = 0;
|
|
}
|
|
|
|
void mister_move ()
|
|
{
|
|
$decondoor1.lock (1);
|
|
$decondoor2.lock (1);
|
|
|
|
//start decon1 computer voice
|
|
sys.trigger ($decon1_start_speaker);
|
|
sys.wait (1.5);
|
|
|
|
thread crossFadeEnt ($misterlight_white, '1 1 1', '1 0 0', 1.0);
|
|
thread crossFadeEnt ($decontop_fade, '1 1 1', '1 0 0', 1.0);
|
|
thread crossFadeEnt ($decon_toplight_red, '0 0 0', '1 0 0', 1.0);
|
|
thread crossFadeEnt ($decondoorframe1, '1 1 1', '1 0 0', 1.0);
|
|
thread crossFadeEnt ($decondoorframe1_light, '1 1 1', '1 0 0', 1.0);
|
|
thread crossFadeEnt ($decondoorframe2, '1 1 1', '1 0 0', 1.0);
|
|
thread crossFadeEnt ($decondoorframe2_light, '1 1 1', '1 0 0', 1.0);
|
|
|
|
|
|
sys.trigger ($decon1_mister1start_spkr);
|
|
sys.trigger ($decon1_mister2start_spkr);
|
|
sys.wait (.15);
|
|
sys.trigger ($decon1_mister1loop_spkr);
|
|
sys.trigger ($decon1_mister2loop_spkr);
|
|
|
|
$mister1_anchor.moveTo ($mister1_spot2);
|
|
$mister2_anchor.moveTo ($mister2_spot2);
|
|
sys.waitFor ($mister1_anchor);
|
|
|
|
$mister1_anchor.rotateOnce ('60 0 0');
|
|
$mister2_anchor.rotateOnce ('-60 0 0');
|
|
sys.waitFor ($mister1_anchor);
|
|
|
|
$mister1_anchor.rotateOnce ('-60 0 0');
|
|
$mister2_anchor.rotateOnce ('60 0 0');
|
|
sys.waitFor ($mister1_anchor);
|
|
|
|
$mister1_anchor.moveTo ($mister1_spot1);
|
|
$mister2_anchor.moveTo ($mister2_spot1);
|
|
sys.waitFor ($mister1_anchor);
|
|
|
|
sys.trigger ($decon1_mister1stop_spkr);
|
|
sys.trigger ($decon1_mister2stop_spkr);
|
|
//trigger looping speaker again to turn off
|
|
sys.trigger ($decon1_mister1loop_spkr);
|
|
sys.trigger ($decon1_mister2loop_spkr);
|
|
|
|
//turn off emitter
|
|
sys.trigger($mister1_emitter);
|
|
sys.trigger($mister2_emitter);
|
|
|
|
sys.wait (.5);
|
|
thread crossFadeEnt ($misterlight_white, '1 0 0', '1 1 1', 1.0);
|
|
thread crossFadeEnt ($decontop_fade, '1 0 0', '1 1 1', 1.0);
|
|
thread crossFadeEnt ($decon_toplight_red, '1 0 0', '0 0 0', 1.0);
|
|
thread crossFadeEnt ($decondoorframe1, '1 0 0', '1 1 1', 1.0);
|
|
thread crossFadeEnt ($decondoorframe1_light, '1 0 0', '1 1 1', 1.0);
|
|
thread crossFadeEnt ($decondoorframe2, '1 0 0', '1 1 1', 1.0);
|
|
thread crossFadeEnt ($decondoorframe2_light, '1 0 0', '1 1 1', 1.0);
|
|
}
|
|
|
|
void mister1()
|
|
{
|
|
$decondoor1.close ();
|
|
$decondoor2.close ();
|
|
$decon_trigger1.disable ();
|
|
|
|
$decondoorframe1.setShaderParm (7, 0);
|
|
$decondoorframe2.setShaderParm (7, 0);
|
|
|
|
//turn on emitter
|
|
sys.trigger($mister1_emitter);
|
|
sys.trigger($mister2_emitter);
|
|
|
|
float i;
|
|
i = thread mister_move();
|
|
sys.waitForThread (i);
|
|
|
|
//complete decon1 computer voice
|
|
sys.trigger ($decon1_complete_speaker);
|
|
|
|
sys.wait (.25);
|
|
if (deconPosition == 0)
|
|
{
|
|
$decondoorframe1.setShaderParm (7, 1);
|
|
$decondoor1.lock (0);
|
|
}
|
|
if (deconPosition == 1)
|
|
{
|
|
$decondoorframe2.setShaderParm (7, 1);
|
|
$decondoor2.lock (0);
|
|
}
|
|
}
|
|
|
|
|
|
void tp_1 ()
|
|
{
|
|
$tp_guard.time (2);
|
|
$tp_guard.decelTime (1);
|
|
$tp_guard.rotateOnce ('0 0 -67');
|
|
sys.waitFor ($tp_guard);
|
|
|
|
$tp_shoulder.time (1.5);
|
|
$tp_shoulder.rotateOnce ('0 0 -30');
|
|
sys.waitFor ($tp_shoulder);
|
|
|
|
$tp_leftarm.rotateOnce ('0 35 0');
|
|
$tp_rightarm.rotateOnce ('0 -35 0');
|
|
sys.wait(5);
|
|
|
|
$tp_shoulder.rotateOnce ('0 0 30');
|
|
$tp_leftarm.rotateOnce ('0 -35 0');
|
|
$tp_rightarm.rotateOnce ('0 35 0');
|
|
sys.waitFor ($tp_shoulder);
|
|
|
|
$tp_guard.rotateOnce ('0 0 67');
|
|
}
|
|
|
|
void show_chair ()
|
|
{
|
|
$delta2a_chair_2.show();
|
|
$char_scientist_old_sitting_1.setBoneMod( false );
|
|
}
|
|
|
|
void set_scientist_skin ()
|
|
{
|
|
$char_scientist_old_sitting_1.setSkin( "skins/models/chars/labcoat/labcoat3nochair.skin");
|
|
}
|
|
|
|
void drag_corpse ()
|
|
{
|
|
$corpse_mover.time (6);
|
|
$corpse_mover.move (WEST,352);
|
|
sys.waitFor ($corpse_mover);
|
|
$env_ragdoll_lab1_1.remove ();
|
|
}
|
|
|
|
void tproom_fadeout() {
|
|
$speaker_79.fadeSound ( SND_CHANNEL_ANY, -60, 5 );
|
|
$speaker_130.fadeSound ( SND_CHANNEL_ANY, -60, 5 );
|
|
$speaker_77.fadeSound ( SND_CHANNEL_ANY, -60, 5 );
|
|
$speaker_116.fadeSound ( SND_CHANNEL_ANY, -60, 5 );
|
|
$speaker_115.fadeSound ( SND_CHANNEL_ANY, -60, 5 );
|
|
$speaker_1.fadeSound ( SND_CHANNEL_ANY, -60, 5 );
|
|
}
|
|
|
|
void main ()
|
|
{
|
|
setup_objects ();
|
|
thread map_delta2a::init_claw();
|
|
init_lift();
|
|
lift_down();
|
|
$delta2a_chair_2.hide();
|
|
}
|
|
}
|