basic door

 

 

Scripts name basic door  
Purpose A basic (rotating) door  
script lanugages used lsl  
important settings for region ./.  
test on standalone - trunk  6.3 SVN8786, XEngine  
source Michelle Argus @ osgrid  

 

// Particle Script 0.3
// Created by Ama Omega
// 10-10-2003
// Modified by Jeri Zuma 4/05 for bling on and off commands

// Mask Flags - set to TRUE to enable
integer glow = TRUE; // Make the particles glow
integer bounce = FALSE; // Make particles bounce on Z plan of object
integer interpColor = TRUE; // Go from start to end color
integer interpSize = TRUE; // Go from start to end size
integer wind = FALSE; // Particles effected by wind
integer followSource = TRUE; // Particles follow the source
integer followVel = TRUE; // Particles turn to velocity direction

// Choose a pattern from the following:
// PSYS_SRC_PATTERN_EXPLODE
// PSYS_SRC_PATTERN_DROP
// PSYS_SRC_PATTERN_ANGLE_CONE_EMPTY
// PSYS_SRC_PATTERN_ANGLE_CONE
// PSYS_SRC_PATTERN_ANGLE
integer pattern = PSYS_SRC_PATTERN_EXPLODE;

// Select a target for particles to go towards
// "" for no target, "owner" will follow object owner
// and "self" will target this object
// or put the key of an object for particles to go to
key target = "self";

// Particle paramaters
float age = 0.2; // Life of each particle
float maxSpeed = .9; // Max speed each particle is spit out at
float minSpeed = .05; // Min speed each particle is spit out at
string texture; // Texture used for particles, default used if blank
float startAlpha = .85; // Start alpha (transparency) value
float endAlpha = 0; // End alpha (transparency) value
vector startColor = <1,1,1>; // Start color of particles <R,G,B>
vector endColor = <1,1,1>; // End color of particles <R,G,B> (if interpColor == TRUE)
vector startSize = <.05,0.4,.05>; // Start size of particles
vector endSize = <.03,1.2,.03>; // End size of particles (if interpSize == TRUE)
vector push = <0,0,0>; // Force pushed on particles

// System paramaters
// ==========================================================================
// Basic Door Script
// Original Script By Unknown
// Modifications made by Zanlew Wu 01-Apr-2003
//
//============================================
// Declare global constants.
//
integer SW_OPEN = FALSE; // used to signify door swinging open
integer SW_CLOSE = TRUE; // used to signify door swinging closed
integer SW_NORMAL = FALSE; // used to signify a normal swing
integer SW_REVERSE = TRUE; // used to signify a reverse swing
//
// Note that it is hard to call a given swing outward or inward as that has
// a lot to do witht he rotation and/or orientation of the door, which
// swing direction is correct/desired, and whether you are referring to the
// swing from the "out" side of the door or the "in" side of the door. It
// was easier by convention to call the swings normal and reverse.

//============================================
// Declare global fields.
//
key gfOwnerKey; // Owner of the elevator object
integer gfDoorClosed; // Current state of the door (Open, Closed)
integer gfDoorSwing; // Deteremines which way the door swings (In, Out)

//============================================
// gmInitFields
//
gmInitFields()
{
//
// Get the owner of the door.
//
gfOwnerKey = llGetOwner();

//
// Close doors by default.
//
gfDoorClosed = TRUE;

//
// Set the door swing.
//
gfDoorSwing = SW_NORMAL;

return;
}
//
// End of gmInitVars
//============================================

//============================================
// gmSwingDoor
//
gmSwingDoor(integer direction)
{
//-----------------------
// Local variable defines
//
rotation rot;
rotation delta;
float piVal;

//
// First thing we need to do is decide whether we are applying a
// negative or positive PI value to the door swing algorythm. The
// positive or negative makes the difference on which direction the door
// swings. Additionally, since we allow the doors to modify their swing
// direction (so the same door can be placed for inward or outward
// swing, we have to take that into account as well. Best to determine
// that value first. The rest of the formula does not change regardless
// of door swing direction.
//
// So we have two variables to pay attention to: open/close and swing
// in/out. First we start with open/close. We will presume the
// following:
// SW_OPEN: +PI
// SW_CLOSE: -PI
// This also presumes that the door has a standard swing value of
// SW_NORMAL.
//
// A door that has had it's swing changed would have those values
// reversed:
// SW_OPEN: -PI
// SW_CLOSE: +PI
//
// The variable passed into this method determines if the intent were
// to open the door or close it.
//
// The global field gfDoorSwing will be used to modify the PI based on
// whether the door normally swings in or out.
//
if (direction == SW_OPEN)
{
//
// Ok, we know the door is opening. Assign a +PI value to piVal.
//
piVal = PI/4;
//
// Now check to see if the door has it's swing reversed.
//
if (gfDoorSwing == SW_REVERSE)
{
//
// Yep, it's reversed and we are opening the door, so replace
// piVal with a -PI value.
//
piVal = -PI/4;
}
} else
{
//
// So we know we are closing the door this time. Assign a -PI value
// to piVal.
//
piVal = -PI/4;
//
// Now check to see if the door has it's swing reversed.
//
if (gfDoorSwing == SW_REVERSE)
{
//
// Yep, it's reversed and we are closing the door, so we need to
// assing a +PI value to piVal.
//
piVal = PI/4;
}
}

//
// This formula was part of the original script and is what makes
// the door swing open and closed. This formula use a Pi/-Pi to
// move the door one quarter-circle in total distance.
//
// The only change I've made to this function is to replace the hard-
// coded PI/-PI values with a variable that is adjusted
// programmatically to suit the operation at hand.
//
rot = llGetRot();
delta = llEuler2Rot(<0,0,piVal> );
rot = delta * rot;
llSetRot(rot);
llSleep(0.25);
rot = delta * rot;
llSetRot(rot);

return;
}
//
// End of gmSwingDoor
//============================================

//============================================
// gmCloseDoor
//
// The close command is used to close doors. If the doors are
// locked, the doors cannot be closed. (Note: presumably, this
// script does not allow doors to be opened AND locked at the same
// time). If the doors are already closed, they cannot be
// re-closed. These checks will be made before performing a door
// close operation. Once the door is successfully closed, the
// door's state will be updated.
//
gmCloseDoor()
{
//
// First let's check to see if the door is already closed. If it
// is, let the user know.
//
if (gfDoorClosed == TRUE)
{
//
// Yep, it was already closed.
//
llSay (0, "This door is already closed.");
return;
}

//
// Now we generate the proper sound for the door closing.
//
llTriggerSound("Door close", 0.2);

//
// Now we call the method gmSwingDoor with the SW_CLOSE argument (since
// we are closing the door.
//
gmSwingDoor(SW_CLOSE);

//
// Now that the door is closed, set the door's state.
//
gfDoorClosed = TRUE;

return;
}
//
// End of gmCloseDoor
//============================================

//============================================
// gmOpenDoor
//
// The open command is used to open the doors. If the doors are
// locked, the doors cannot be opened. If the doors are already
// opened, they cannot be re-opened. These checks will be made
// before performing a door open operation. Once the door is
// successfully opened, the door's state will be updated.
//
gmOpenDoor()
{
//
// First let's check to see if the door is open already. If it is,
// let the user know.
//
if (gfDoorClosed == FALSE)
{
//
// Yep, it was already open.
//
llSay (0, "This door is already open.");
return;
}

//
// Now we generate the proper sound for the door closing.
//
llTriggerSound("Door open", 0.2);

//
// Now we call the method gmSwingDoor with the SW_OPEN argument (since
// we are opening the door.
//
gmSwingDoor(SW_OPEN);

//
// Now that the door is opened, set the door's state.
//
gfDoorClosed = FALSE;
return;
}
//
// End of gmOpenDoor
//============================================


//============================================
// Default State
//
// This is the state that is automatically bootstrapped when the object
// is first created/rez'd, or the world or environment resets.
//
default
{
//
// state_entry() is the first method executed when the state it resides
// in is run. So State A, B, and C all can have state_entry methods,
// and if they do, they are run when their respective states are called
// and or executed.
//
state_entry()
{
//
// Perform global field initialization
//
gmInitFields();

//
// We are listening for two different commands. This script is set
// up to accept spoken commands only from the object owner.
//
llListen(0, "", "", "open");
llListen(0, "", "", "close");
}

listen(integer channel, string name, key id, string msg)
{
//-----------------------
// Local variable defines
//
string operName;
string ownerName;

//
// Ideally, we want the door only to work on spoken commands
// from the owner. To accomplish this task, we need to check the
// id of the owner and the person issuing the command to see if
// they match.
//
// Alternately, commands can be issued from the control panel,
// which can be used by anyone. Later on, it will be presumed that
// access to the control panel will be controlled.
//

//
// First get the string names of the owner and the operator so they
// can be compared.
//
operName = llKey2Name(id);
ownerName = llKey2Name(gfOwnerKey);

//
// First we check the owner.
//
if (ownerName != operName)
{
//
// Nope, not a match.
//
llTriggerSound("Door knock", 0.2);
llSay(0, "Voice command access is for owner only.");
return;
}

//----------------------------------------
// OPEN DOOR
//
if(msg == "open")
{
gmOpenDoor();
}

//----------------------------------------
// CLOSE DOOR
//
if (msg == "close")
{
gmCloseDoor();
}
}

touch_start(integer i)
{
//
// This is the same code as the UNLOCK, OPEN and CLOSE DOOR
// code. For reasons of brevity, I have removed the comments
// from this copy of the code.
//
if (gfDoorClosed == FALSE)
{
llTriggerSound("Door close", 0.2);
gmSwingDoor(SW_CLOSE);
gfDoorClosed = TRUE;
return;
} else
{
llTriggerSound("Door open", 0.2);
gmSwingDoor(SW_OPEN);
gfDoorClosed = FALSE;
return;
}
}
}