1255 lines
48 KiB
Plaintext
1255 lines
48 KiB
Plaintext
// ZHAO-II-core - Ziggy Puff, 07/07
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Main engine script - receives link messages from any interface script. Handles the core AO work
|
|
//
|
|
// Interface definition: The following link_message commands are handled by this script. All of
|
|
// these are sent in the string field. All other fields are ignored
|
|
//
|
|
// ZHAO_RESET Reset script
|
|
// ZHAO_LOAD|<notecardName> Load specified notecard
|
|
// ZHAO_NEXTSTAND Switch to next stand
|
|
// ZHAO_STANDTIME|<time> Time between stands. Specified in seconds, expects an integer.
|
|
// 0 turns it off
|
|
// ZHAO_AOON AO On
|
|
// ZHAO_AOOFF AO Off
|
|
// ZHAO_SITON Sit On
|
|
// ZHAO_SITOFF Sit Off
|
|
// ZHAO_RANDOMSTANDS Stands cycle randomly
|
|
// ZHAO_SEQUENTIALSTANDS Stands cycle sequentially
|
|
// ZHAO_SETTINGS Prints status
|
|
// ZHAO_SITS Select a sit
|
|
// ZHAO_GROUNDSITS Select a ground sit
|
|
// ZHAO_WALKS Select a walk
|
|
//
|
|
// ZHAO_SITANYWHERE_ON Sit Anywhere mod On
|
|
// ZHAO_SITANYWHERE_OFF Sit Anywhere mod Off
|
|
//
|
|
// ZHAO_TYPE_ON Typing AO On
|
|
// ZHAO_TYPE_OFF Typing AO Off
|
|
//
|
|
// ZHAO_TYPEKILL_ON Typing Killer On
|
|
// ZHAO_TYPEKILL_OFF Typing Killer Off
|
|
//
|
|
// ZHAO_STANDON Sit On
|
|
// ZHAO_STANDOFF Sit Off
|
|
//
|
|
// So, to send a command to the ZHAO-II engine, send a linked message:
|
|
//
|
|
// llMessageLinked(LINK_SET, 0, "ZHAO_AOON", NULL_KEY);
|
|
//
|
|
// This script uses a listener on channel -91234. If other scripts are added to the ZHAO, make sure
|
|
// they don't use the same channel
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// New notecard format
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Lines starting with a / are treated as comments and ignored. Blank lines are ignored. Valid lines
|
|
// look like this:
|
|
//
|
|
// [ Walking ]SexyWalk1|SexyWalk2|SexyWalk3
|
|
//
|
|
// The token (in this case, [ Walking ]) identifies the animation to be overridden. The rest is a
|
|
// list of animations, separated by the '|' (pipe) character. You can specify multiple animations
|
|
// for Stands, Walks, Sits, and GroundSits. Multiple animations on any other line will be ignored.
|
|
// You can have up to 12 animations each for Walks, Sits and GroundSits. There is no hard limit
|
|
// on the number of stands, but adding too many stands will make the script run out of memory and
|
|
// crash, so be careful. You can repeat tokens, so you can split the Stands up across multiple lines.
|
|
// Use the [ Standing ] token in each line, and the script will add the animation lists together.
|
|
//
|
|
// Advanced: Each 'animation name' can be a comma-separated list of animations, which will be played
|
|
// together. For example:
|
|
//
|
|
// [ Walking ]SexyWalk1UpperBody,SexyWalk1LowerBody|SexyWalk2|SexyWalk3
|
|
//
|
|
// Note the ',' between SexyWalk1UpperBody and SexyWalk1LowerBody - this tells ZHAO-II to treat these
|
|
// as a single 'animation' and play them together. The '|' between this 'animation' and SexyWalk2 tells
|
|
// ZHAO-II to treat SexyWalk2 and SexyWalk3 as separate walk animations. You can use this to layer
|
|
// animations on top of each other.
|
|
//
|
|
// Do not add any spaces around animation names!!!
|
|
//
|
|
// The token can be one of the following:
|
|
//
|
|
// [ Standing ]
|
|
// [ Walking ]
|
|
// [ Sitting ]
|
|
// [ Sitting On Ground ]
|
|
// [ Crouching ]
|
|
// [ Crouch Walking ]
|
|
// [ Landing ]
|
|
// [ Standing Up ]
|
|
// [ Falling ]
|
|
// [ Flying Down ]
|
|
// [ Flying Up ]
|
|
// [ Flying ]
|
|
// [ Flying Slow ]
|
|
// [ Hovering ]
|
|
// [ Jumping ]
|
|
// [ Pre Jumping ]
|
|
// [ Running ]
|
|
// [ Turning Right ]
|
|
// [ Turning Left ]
|
|
// [ Floating ]
|
|
// [ Swimming Forward ]
|
|
// [ Swimming Up ]
|
|
// [ Swimming Down ]
|
|
// [ Typing ]
|
|
//
|
|
// [ Settings ]
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Marcus Gray, 2010-01-03
|
|
// ADDED option to disable AO in Mouselook (interface, core)
|
|
// ADDED possibility to set certain settings in a config notecard (adding tag [ Settings ], editing loadcards only :P)
|
|
|
|
// Marcus Gray, 07/02/2009 (July 2nd)
|
|
// hardened script against animation names containing ":" (":"-character is used for unlooped anims timing)
|
|
// should now work with anything thas isn't ":" followed by only an integer (loadcards, minor core)
|
|
|
|
// interlude:
|
|
// added this and that 0o, fixed some bugs i think
|
|
// uhm
|
|
// ...yeah
|
|
// at least some kindergarden level math errors x)
|
|
|
|
|
|
// Marcus Gray / Johann Ehrler, 09/28/2008:
|
|
// Inserted some new parts for the stand-ON/OFF-toggle function.
|
|
// Also terminated some typos.
|
|
|
|
// Johann Ehrler, 09/16/2008:
|
|
// WARNING: This script was MONO-recompiled!
|
|
|
|
// Johann Ehrler, 04/19/2008:
|
|
// Added support for custom animation timing.
|
|
//
|
|
// Johann Ehrler, 04/06/2008:
|
|
// Some optimations are done...like cleaning up the code and merge it with newly
|
|
// developed functions from a trunk of the core script.
|
|
// Added the byte count to the free memory display for a much better geek factor. ;o)
|
|
// The channel for the listener depends now on the owner UUID...not really necessary but funny.
|
|
// Corrected some typos, redundant whitespaces and indentations.
|
|
// Set Marcus change date to the right year. ;P
|
|
|
|
// Marcus Gray, 03/26/2008:
|
|
// Included Seamless Sit mod by Moeka Kohime (core script).
|
|
// Freed some memory DELETING THE DEFAULT UNOVERRIDABLE ANIMS!!!!!!!! (core script)
|
|
// Added sit anywhere functionality to replace stands by groundsits (core script).
|
|
// Therefore changed functionality of Sit-ON/OFF button to work as Sit Anywhere button (interface).
|
|
|
|
// Ziggy, 07/16/07 - Warning instead of error on 'no animation in inventory', that way SL's built-in
|
|
// anims can be used
|
|
//
|
|
// Ziggy, 07/14/07 - 2 bug fixes. Listens aren't being reset on owner change, and a typo in the
|
|
// ground sit animation code
|
|
//
|
|
// Ziggy, 06/07:
|
|
// Reduce script count, since idle scripts take up scheduler time
|
|
// Tokenize notecard reader, to simplify notecard setup
|
|
// Remove scripted texture changes, to simplify customization by animation sellers
|
|
|
|
// Fennec Wind, January 18th, 2007:
|
|
// Changed Walk/Sit/Ground Sit dialogs to show animation name (or partial name if too long)
|
|
// and only show buttons for non-blank entries.
|
|
// Fixed minor bug in the state_entry, ground sits were not being initialized.
|
|
//
|
|
|
|
// Dzonatas Sol, 09/06: Fixed forward walk override (same as previous backward walk fix).
|
|
|
|
// Based on Francis Chung's Franimation Overrider v1.8
|
|
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
// CONSTANTS
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Default notecard we read on script_entry
|
|
string defaultNoteCard = "Default";
|
|
|
|
// List of all the animation states
|
|
list animState = [ "Sitting on Ground", "Sitting", "Striding", "Crouching", "CrouchWalking",
|
|
"Soft Landing", "Standing Up", "Falling", "Hovering Down", "Hovering Up",
|
|
"FlyingSlow", "Flying", "Hovering", "Jumping", "PreJumping", "Running",
|
|
"Turning Right", "Turning Left", "Walking", "Landing", "Standing", "Typing", "Dancing" ];
|
|
|
|
|
|
// Logic change - we now have a list of tokens. The 'overrides' list is the same length as this,
|
|
// i.e. it has one entry per token, *not* one entry per animation. Multiple options for a token
|
|
// are stored as | separated strings in a single list entry. This was done to save memory, and
|
|
// allow a larger number of stands etc. All the xxxIndex variables now refer to the token index,
|
|
// since that's how long 'overrides' is.
|
|
|
|
// List of internal tokens. This *must* be in the same sequence as the animState list. Note that
|
|
// we combine some tokens after the notecard is read (striding/walking, landing/soft landing), etc.
|
|
// The publicized tokens list only contains one entry for each pair, but we'll accept both, and
|
|
// combine them later
|
|
//list tokens = [
|
|
// "[ Sitting On Ground ]", // 0
|
|
// "[ Sitting ]", // 1
|
|
// "", // 2 - We don't allow Striding as a token
|
|
// "[ Crouching ]", // 3
|
|
// "[ Crouch Walking ]", // 4
|
|
// "", // 5 - We don't allow Soft Landing as a token
|
|
// "[ Standing Up ]", // 6
|
|
// "[ Falling ]", // 7
|
|
// "[ Flying Down ]", // 8
|
|
// "[ Flying Up ]", // 9
|
|
// "[ Flying Slow ]", // 10
|
|
// "[ Flying ]", // 11
|
|
// "[ Hovering ]", // 12
|
|
// "[ Jumping ]", // 13
|
|
// "[ Pre Jumping ]", // 14
|
|
// "[ Running ]", // 15
|
|
// "[ Turning Right ]", // 16
|
|
// "[ Turning Left ]", // 17
|
|
// "[ Walking ]", // 18
|
|
// "[ Landing ]", // 19
|
|
// "[ Standing ]", // 20
|
|
// "[ Swimming Down ]", // 21
|
|
// "[ Swimming Up ]", // 22
|
|
// "[ Swimming Forward ]", // 23
|
|
// "[ Floating ]", // 24
|
|
// "[ Typing ]", // 25
|
|
// "[ Dancing ]", // 27 For Dancing
|
|
//];
|
|
//
|
|
// | | |
|
|
// | | |
|
|
// V V V
|
|
//
|
|
integer numOverrides = 28; // number of overrides == tokens
|
|
|
|
// The tokens for which we allow multiple animations
|
|
//list multiAnimTokenIndexes = [
|
|
// 0, // "[ Sitting On Ground ]"
|
|
// 1, // "[ Sitting ]"
|
|
// 18, // "[ Walking ]"
|
|
// 20, // "[ Standing ]"
|
|
// 27 // "[ Dancing ]"
|
|
//];
|
|
|
|
// Index of interesting animations
|
|
integer noAnimIndex = -1;
|
|
integer sitgroundIndex = 0;
|
|
integer sittingIndex = 1;
|
|
integer stridingIndex = 2;
|
|
integer standingupIndex = 6;
|
|
integer fallingIndex = 7;
|
|
integer hoverdownIndex = 8;
|
|
integer hoverupIndex = 9;
|
|
integer flyingslowIndex = 10;
|
|
integer flyingIndex = 11;
|
|
integer hoverIndex = 12;
|
|
integer runningIndex = 15;
|
|
integer walkingIndex = 18;
|
|
integer standingIndex = 20;
|
|
integer swimdownIndex = 21;
|
|
integer dancingIndex = 22;
|
|
integer swimmingIndex = 23;
|
|
integer waterTreadIndex = 24;
|
|
integer typingIndex = 25;
|
|
integer swimupIndex = 27;
|
|
|
|
// list of animations that have a different value when underwater
|
|
list underwaterAnim = [ 12, 11, 10, 9, 8 ];
|
|
|
|
// corresponding list of animations that we override the overrider with when underwater
|
|
list underwaterOverride = [ 24, 23, 23, 27, 21];
|
|
|
|
// This is an ugly hack, because the standing up animation doesn't work quite right
|
|
// (SL is borked, this has been bug reported)
|
|
// If you play a pose overtop the standing up animation, your avatar tends to get
|
|
// stuck in place.
|
|
// This is a list of anims that we'll stop automatically
|
|
list autoStop = [ 5, 6, 19 ];
|
|
// Amount of time we'll wait before autostopping the animation (set to 0 to turn off autostopping)
|
|
float autoStopTime = 1.5;
|
|
|
|
// How long before flipping stand animations
|
|
integer standTimeDefault = 30;
|
|
|
|
// How fast we should poll for changed anims (as fast as possible)
|
|
// In practice, you will not poll more than 8 times a second.
|
|
float timerEventLength = 0.0;
|
|
|
|
// The minimum time between events.
|
|
// While timerEvents are scaled automatically by the server, control events are processed
|
|
// much more aggressively, and needs to be throttled by this script
|
|
float minEventDelay = 0.0;
|
|
|
|
// The key for the typing animation
|
|
// key typingAnim = "c541c47f-e0c0-058b-ad1a-d6ae3a4584d9";
|
|
// we dont need this right now ;)
|
|
|
|
// Listen channel for pop-up menu
|
|
//
|
|
// Mod: Channel will now be generated from owner UUID.
|
|
integer listenChannel = -1; //-91234;
|
|
integer LMControlChannel = -4200; // Channel for Listening to Wholearth Love Machines
|
|
|
|
// GLOBALS
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
integer typingStatus = FALSE; // status of avatar typing
|
|
|
|
integer numTyping; // Number of typing anims
|
|
integer numStands; // Number of stands - needed for auto cycle
|
|
integer numRuns; // Num of Run Animations - Needed for AutoCycle
|
|
integer numDances; // Num of Dance Animations - Needed for AutoCycle
|
|
integer randomStands = FALSE; // Whether stands cycle randomly
|
|
integer randomRuns = FALSE; // Whether runs cycle randomly
|
|
integer randomDance = FALSE; // Whether dances cycle randomly
|
|
integer curStandIndex; // Current stand - needed for cycling
|
|
integer curRunIndex; // Current Run Index - needed for Cycling
|
|
integer curDanceIndex; // Current Dance Index - needed for Cycling
|
|
string curStandAnim = ""; // Current Stand animation
|
|
string curSitAnim = ""; // Current sit animation
|
|
string curWalkAnim = ""; // Current walk animation
|
|
string curGsitAnim = ""; // Current ground sit animation
|
|
string curTypingAnim = ""; // Current typing animation
|
|
string curFallingAnim = ""; // Current falling animation
|
|
string curRunningAnim = ""; // Current Running Animation
|
|
string curDancingAnim = ""; // Current Dancing Animation
|
|
|
|
list overrides = []; // List of animations we override
|
|
|
|
string lastAnim = ""; // last Animation we ever played
|
|
string lastAnimSet = ""; // last set of animations we ever played
|
|
integer lastAnimIndex = 0; // index of the last animation we ever played
|
|
string lastAnimState = ""; // last thing llGetAnimation() returned
|
|
|
|
integer dialogStandTime = 30; // How long before flipping stand animations
|
|
integer standTime = 30; // How long before flipping stand animations
|
|
|
|
integer animOverrideOn = TRUE; // Is the animation override on?
|
|
integer gotPermission = TRUE; // Do we have animation permissions?
|
|
|
|
integer listenHandle; // Listen handlers - only used for pop-up menu, then turned off
|
|
|
|
integer haveWalkingAnim = FALSE; // Hack to get it so we face the right way when we walk backwards
|
|
|
|
integer sitOverride = TRUE; // Whether we're overriding sit or not
|
|
integer standOverride = TRUE; // Whether we're overriding sit or not
|
|
integer danceOverride = FALSE; // Whether we're dancing or not
|
|
integer typingOverrideOn = TRUE; // Whether we're overriding typing or not
|
|
integer typingKill = TRUE; // Whether we're killing the typing completely
|
|
integer mlAO = TRUE; // Whether AO is ON/OF in Mouselook
|
|
/// Sit Anywhere mod by Marcus Gray
|
|
/// just one var to overrider stands... let's see how this works out 0o
|
|
integer sitAnywhereOn = FALSE;
|
|
|
|
integer listenState = 0; // What pop-up menu we're handling now
|
|
|
|
integer loadInProgress = FALSE; // Are we currently loading a notecard
|
|
string notecardName = ""; // The notecard we're currently reading
|
|
string curAnimState = "";
|
|
key Owner = NULL_KEY;
|
|
|
|
// String constants to save a few bytes
|
|
string EMPTY = "";
|
|
//
|
|
string TIMINGSEPARATOR = "²Ø";
|
|
//
|
|
string SEPARATOR = "|";
|
|
string TRYAGAIN = "Please correct the notecard and try again.";
|
|
string S_SIT = "Sit override: ";
|
|
string S_SIT_AW = "Sit anywhere: ";
|
|
string S_TYPING = "Typing override: ";
|
|
string S_TKILL_ON = "Typing killer: On - This also removes custom typing animations!";
|
|
string S_TKILL_OFF = "Typing killer: Off";
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Seamless Sit mod by Moeka Kohime
|
|
///
|
|
integer em;
|
|
list temp;
|
|
key sit = "1a5fe8ac-a804-8a5d-7cbd-56bd83184568";
|
|
|
|
// CODE
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Seamless Sit mod by Moeka Kohime
|
|
integer CheckSit()
|
|
{
|
|
if(!sitOverride)
|
|
return FALSE;
|
|
temp = llGetAnimationList(llGetOwner());
|
|
if (temp==[])
|
|
return FALSE;
|
|
if (llListFindList(temp,[sit])!=-1)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
startAnimationList( string _csvAnims ) {
|
|
list anims = llCSV2List( _csvAnims );
|
|
integer i;
|
|
for( i=0; i<llGetListLength(anims); i++ )
|
|
{
|
|
//
|
|
// Mod: Get the special timing parameter
|
|
list newAnim = llParseStringKeepNulls( llList2String(anims,i), [TIMINGSEPARATOR], []);
|
|
string newAnimName = llList2String(newAnim, 0);
|
|
|
|
|
|
if( llGetListLength(newAnim) == 2 )
|
|
{
|
|
integer newStandTime = (integer)llList2String(newAnim, 1);
|
|
if( newStandTime > 0)
|
|
standTime = (integer)llList2String(newAnim, 1);
|
|
else
|
|
llOwnerSay("Found improper custom timing parameter for animation \""+ newAnimName + "\" - The value must be greater 0, please correct this!");
|
|
}
|
|
else
|
|
standTime = dialogStandTime;
|
|
//
|
|
//
|
|
// llStartAnimation( llList2String(anims,i) );
|
|
llStartAnimation( newAnimName );
|
|
}
|
|
}
|
|
|
|
stopAnimationList( string _csvAnims ) {
|
|
list anims = llCSV2List( _csvAnims );
|
|
integer i;
|
|
for( i=0; i<llGetListLength(anims); i++ )
|
|
{
|
|
//
|
|
// Mod: Get the special timing parameter
|
|
list newAnim = llParseStringKeepNulls( llList2String(anims,i) ,
|
|
[TIMINGSEPARATOR], [""]);
|
|
string newAnimName = llList2String(newAnim, 0);
|
|
//
|
|
//
|
|
// llStopAnimation( llList2String(anims,i) );
|
|
llStopAnimation( newAnimName );
|
|
}
|
|
}
|
|
|
|
startNewAnimation( string _anim, integer _animIndex, string _state ) {
|
|
if ( _anim != lastAnimSet ) {
|
|
string newAnim;
|
|
if ( lastAnim != EMPTY )
|
|
stopAnimationList( lastAnim );
|
|
if ( _anim != EMPTY ) { // Time to play a new animation
|
|
list newAnimSet = llParseStringKeepNulls( _anim, [SEPARATOR], [] );
|
|
newAnim = llList2String( newAnimSet, (integer)llFloor(llFrand(llGetListLength(newAnimSet))) );
|
|
|
|
startAnimationList( newAnim );
|
|
|
|
if ( llListFindList( autoStop, [_animIndex] ) != -1 ) {
|
|
// This is an ugly hack, because the standing up animation doesn't work quite right
|
|
// (SL is borked, this has been bug reported)
|
|
// If you play a pose overtop the standing up animation, your avatar tends to get
|
|
// stuck in place.
|
|
if ( lastAnim != EMPTY ) {
|
|
stopAnimationList( lastAnim );
|
|
lastAnim = EMPTY;
|
|
}
|
|
llSleep( autoStopTime );
|
|
stopAnimationList( _anim );
|
|
}
|
|
}
|
|
lastAnim = newAnim;
|
|
lastAnimSet = _anim;
|
|
}
|
|
lastAnimIndex = _animIndex;
|
|
lastAnimState = _state;
|
|
}
|
|
|
|
// Figure out what animation we should be playing right now
|
|
animOverride() {
|
|
string tempState = llGetAnimation( Owner );
|
|
if(danceOverride==TRUE && standOverride == FALSE && tempState == "Standing"){ // We Finished Walking and should be dancing
|
|
curAnimState = "Dancing"; // Set to Dancing since it is not a default state
|
|
}else{ // All Other Normal Operation
|
|
curAnimState = llGetAnimation( Owner ); // Get Name of Animation Type that we just switched to.
|
|
}
|
|
integer curAnimIndex;
|
|
integer underwaterAnimIndex;
|
|
|
|
// Convert the ones we don't handle
|
|
if ( curAnimState == "Striding" ) {
|
|
curAnimState = "Walking";
|
|
} else if ( curAnimState == "Soft Landing" ) {
|
|
curAnimState = "Landing";
|
|
}
|
|
|
|
if ( curAnimState == lastAnimState && curAnimState != "Walking" ) {
|
|
// This conditional not absolutely necessary (In fact it's better if it's not here)
|
|
// But it's good for increasing performance.
|
|
// One of the drawbacks of this performance hack is the underwater animations
|
|
// If you fly up, it will keep playing the "swim up" animation even after you've
|
|
// left the water.
|
|
if(CheckSit()!=TRUE) {// Seamless Sit
|
|
em=0;
|
|
return;
|
|
}else{
|
|
if(em==0){startNewAnimation( EMPTY, noAnimIndex, curAnimState );em=1;}
|
|
}
|
|
}
|
|
curAnimIndex = llListFindList( animState, [curAnimState] ); // Use curAnimState Name to find its Index inside animState and set curAnimIndex to integer to be compared with (action)Index
|
|
//llOwnerSay((string)curAnimIndex); // <-- REMOVE
|
|
underwaterAnimIndex = llListFindList( underwaterAnim, [curAnimIndex] );
|
|
|
|
// For all the multi-anims, we know the animation name to play. Send
|
|
// in the actual overrides index, since that's what this function
|
|
// expects, not the index into the multi-anim list
|
|
if ( curAnimIndex == standingIndex ) {
|
|
// Sit Anywhere
|
|
if(sitAnywhereOn) {
|
|
startNewAnimation( curGsitAnim, sitgroundIndex, curAnimState );
|
|
}
|
|
else
|
|
{
|
|
if( standOverride ){ // Sit Anywhere is OFF AND Stand AO is on ;)
|
|
startNewAnimation( curStandAnim, standingIndex, curAnimState );
|
|
}
|
|
else {
|
|
startNewAnimation( EMPTY, noAnimIndex, curAnimState);
|
|
}
|
|
}
|
|
|
|
}else if ( curAnimIndex == fallingIndex ) { // If we are falling
|
|
startNewAnimation(curFallingAnim, fallingIndex, curAnimState);
|
|
}
|
|
else if ( curAnimIndex == sittingIndex ) {
|
|
// Check if sit override is turned off
|
|
if (( sitOverride == FALSE ) && ( curAnimState == "Sitting" ) && (CheckSit() != TRUE)) {// Seamless Sit
|
|
startNewAnimation( EMPTY, noAnimIndex, curAnimState );
|
|
}
|
|
else {
|
|
if(CheckSit()==TRUE){// Seamless Sit
|
|
startNewAnimation( curSitAnim, sittingIndex, curAnimState );
|
|
} else {
|
|
startNewAnimation( EMPTY, noAnimIndex, curAnimState );
|
|
}
|
|
}
|
|
}
|
|
else if ( curAnimIndex == walkingIndex ) {
|
|
startNewAnimation( curWalkAnim, walkingIndex, curAnimState );
|
|
}
|
|
else if ( curAnimIndex == sitgroundIndex ) {
|
|
startNewAnimation( curGsitAnim, sitgroundIndex, curAnimState );
|
|
}
|
|
else if ( curAnimIndex == runningIndex ) {
|
|
if(randomRuns){
|
|
curRunIndex = llFloor( llFrand(numRuns) );
|
|
curRunningAnim = findMultiAnim( runningIndex, curRunIndex );
|
|
}
|
|
startNewAnimation( curRunningAnim, runningIndex, curAnimState);
|
|
}
|
|
else if ( curAnimIndex == dancingIndex ) {
|
|
if(randomDance){
|
|
curDanceIndex = llFloor( llFrand(numDances) );
|
|
curDancingAnim = findMultiAnim( dancingIndex, curDanceIndex );
|
|
}
|
|
llOwnerSay((string)curDancingAnim);
|
|
startNewAnimation( curDancingAnim, dancingIndex, curAnimState);
|
|
}
|
|
else {
|
|
if ( underwaterAnimIndex != -1 ) {
|
|
// Only call llGetPos if we care about underwater anims
|
|
vector curPos = llGetPos();
|
|
if ( llWater(ZERO_VECTOR) > curPos.z ) {
|
|
curAnimIndex = llList2Integer( underwaterOverride, underwaterAnimIndex );
|
|
}
|
|
}
|
|
startNewAnimation( llList2String(overrides, curAnimIndex), curAnimIndex, curAnimState );
|
|
}
|
|
}
|
|
|
|
// Switch to the next stand anim
|
|
doNextStand(integer fromUI) {
|
|
if ( numStands > 0) {
|
|
if(!sitAnywhereOn && standOverride) { //no need to change stands if we're sitting anyways ;)
|
|
if ( randomStands ) {
|
|
curStandIndex = llFloor( llFrand(numStands) );
|
|
} else {
|
|
curStandIndex = (curStandIndex + 1) % numStands;
|
|
}
|
|
|
|
curStandAnim = findMultiAnim( standingIndex, curStandIndex );
|
|
if ( lastAnimState == "Standing" )
|
|
startNewAnimation( curStandAnim, standingIndex, lastAnimState );
|
|
|
|
if ( fromUI == TRUE ) {
|
|
string newAnimName = llList2String(
|
|
llParseStringKeepNulls(curStandAnim, [TIMINGSEPARATOR], []), 0);
|
|
llOwnerSay( "Switching to stand '" + newAnimName + "'." );
|
|
}
|
|
}
|
|
} else {
|
|
if ( fromUI == TRUE ) {
|
|
llOwnerSay( "No stand animations configured." );
|
|
}
|
|
}
|
|
|
|
//llResetTime();
|
|
}
|
|
|
|
// Switch to the next stand anim
|
|
doNextDance(integer fromUI) {
|
|
if ( numDances > 0) {
|
|
if(danceOverride==TRUE && standOverride == FALSE && lastAnimState == "Dancing") { // We are Dancing
|
|
if ( randomDance ) {
|
|
curDanceIndex = llFloor( llFrand(numDances) );
|
|
} else {
|
|
curDanceIndex = curDanceIndex + 1;
|
|
if(curDanceIndex > (numDances + 1)){
|
|
curDanceIndex = 0;
|
|
}
|
|
}
|
|
|
|
curDancingAnim = findMultiAnim( dancingIndex, curDanceIndex );
|
|
if ( lastAnimState == "Dancing" ){
|
|
startNewAnimation( curDancingAnim, curDanceIndex, lastAnimState );
|
|
}
|
|
if ( fromUI == TRUE ) {
|
|
string newAnimName = llList2String(
|
|
llParseStringKeepNulls(curDancingAnim, [TIMINGSEPARATOR], []), 0);
|
|
llOwnerSay( "Switching to dance '" + newAnimName + "'." );
|
|
}
|
|
}
|
|
} else {
|
|
if ( fromUI == TRUE ) {
|
|
llOwnerSay( "No stand animations configured." );
|
|
}
|
|
}
|
|
|
|
llResetTime();
|
|
}
|
|
|
|
// Start or stop typing animation
|
|
typingOverride(integer isTyping) {
|
|
if(isTyping) {
|
|
if( typingKill ) { // if we totally kill typing anims
|
|
llStopAnimation("type");
|
|
// typingStatus = FALSE;
|
|
}
|
|
else
|
|
{
|
|
integer curTypingIndex = 0;
|
|
if(numTyping > 1) {
|
|
curTypingIndex = llFloor( llFrand(numTyping) );
|
|
}
|
|
curTypingAnim = findMultiAnim( typingIndex, curTypingIndex );
|
|
startAnimationList(curTypingAnim);
|
|
}
|
|
}
|
|
else if( !typingKill )
|
|
{
|
|
stopAnimationList(curTypingAnim);
|
|
}
|
|
}
|
|
|
|
// Displays menu of animation choices
|
|
doMultiAnimMenu( integer _animIndex, string _animType, string _currentAnim )
|
|
{
|
|
// Dialog enhancement - Fennec Wind
|
|
// Fix - a no-mod anim with a long name will break this
|
|
|
|
list anims = llParseString2List( llList2String(overrides, _animIndex), [SEPARATOR], [] );
|
|
integer numAnims = llGetListLength( anims );
|
|
if ( numAnims > 12 ) {
|
|
llOwnerSay( "Too many animations, only the first 12 will be displayed.");
|
|
numAnims = 12;
|
|
return;
|
|
}
|
|
|
|
list buttons = [];
|
|
integer i;
|
|
string animNames = EMPTY;
|
|
for ( i=0; i<numAnims; i++ ) {
|
|
animNames += "\n" + (string)(i+1) + ". " + llList2String( anims, i );
|
|
buttons += [(string)(i+1)];
|
|
}
|
|
// If no animations were configured, say so and just display an "OK" button
|
|
if ( animNames == EMPTY ) {
|
|
animNames = "\n\nNo overrides have been configured.";
|
|
}
|
|
llListenControl(listenHandle, TRUE);
|
|
llDialog( Owner, "Select the " + _animType + " animation to use:\n\nCurrently: " + _currentAnim + animNames,
|
|
buttons, listenChannel );
|
|
}
|
|
|
|
// Returns an animation from the multiAnims
|
|
string findMultiAnim( integer _animIndex, integer _multiAnimIndex )
|
|
{
|
|
list animsList = llParseString2List( llList2String(overrides, _animIndex), [SEPARATOR], [] );
|
|
return llList2String( animsList, _multiAnimIndex );
|
|
}
|
|
|
|
// Print free memory. Separate function to save a few bytes
|
|
printFreeMemory()
|
|
{
|
|
integer freemem = llGetFreeMemory();
|
|
integer memory = (integer)((float)freemem * 100.0 / 65536.0);
|
|
llOwnerSay( (string)memory + "% memory free ("+(string)freemem+" Byte)." );
|
|
}
|
|
|
|
// Returns true if we should override the current animation
|
|
integer checkAndOverride() {
|
|
if ( animOverrideOn && gotPermission ) {
|
|
animOverride();
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// Load all the animation names from a notecard
|
|
loadNoteCard() {
|
|
|
|
if ( llGetInventoryKey(notecardName) == NULL_KEY ) {
|
|
llOwnerSay( "Notecard '" + notecardName + "' does not exist, or does not have full permissions." );
|
|
notecardName = EMPTY;
|
|
loadInProgress = FALSE;
|
|
return;
|
|
}
|
|
else {
|
|
|
|
loadInProgress = TRUE;
|
|
|
|
// Faster events while processing our notecard
|
|
llMinEventDelay( 0 );
|
|
|
|
// Clear out saved override information, since we now allow sparse notecards
|
|
overrides = [];
|
|
integer i;
|
|
for ( i=0; i<numOverrides; i++ )
|
|
overrides += [EMPTY];
|
|
|
|
// Clear out multi-anim info as well, since we may end up with fewer options
|
|
// that the last time
|
|
curStandIndex = 0;
|
|
curStandAnim = EMPTY;
|
|
curSitAnim = EMPTY;
|
|
curWalkAnim = EMPTY;
|
|
curGsitAnim = EMPTY;
|
|
curFallingAnim = EMPTY;
|
|
|
|
// Start reading the data
|
|
llMessageLinked(LINK_SET, 0, "LOAD_NC|" + notecardName, NULL_KEY);
|
|
}
|
|
}
|
|
|
|
// Stop loading notecard
|
|
endNotecardLoad()
|
|
{
|
|
loadInProgress = FALSE;
|
|
notecardName = EMPTY;
|
|
|
|
// Restore the minimum event delay
|
|
llMinEventDelay( minEventDelay );
|
|
}
|
|
|
|
// Initialize listeners, and reset some status variables
|
|
initialize() {
|
|
Owner = llGetOwner();
|
|
|
|
llSetTimerEvent( 0.0 );
|
|
|
|
if ( animOverrideOn )
|
|
llSetTimerEvent( timerEventLength );
|
|
|
|
lastAnim = EMPTY;
|
|
lastAnimSet = EMPTY;
|
|
lastAnimIndex = noAnimIndex;
|
|
lastAnimState = EMPTY;
|
|
gotPermission = FALSE;
|
|
|
|
// Create new listener, and turn it off
|
|
if ( listenHandle )
|
|
llListenRemove( listenHandle );
|
|
listenHandle = llListen( listenChannel, EMPTY, Owner, EMPTY );
|
|
llListenControl( listenHandle, FALSE );
|
|
|
|
printFreeMemory();
|
|
}
|
|
|
|
// STATE
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
default {
|
|
state_entry() {
|
|
integer i;
|
|
|
|
Owner = llGetOwner();
|
|
|
|
// Just a precaution, this shouldn't be on after a reset
|
|
if ( listenHandle )
|
|
llListenRemove( listenHandle );
|
|
|
|
// Generate the channel from the owner UUID.
|
|
listenChannel = ( 1 + (integer)( "0xF" + llGetSubString( llGetOwner(), 0, 6) ) );
|
|
llListen(LMControlChannel, EMPTY, EMPTY, EMPTY);
|
|
listenHandle = llListen( listenChannel, EMPTY, Owner, EMPTY );
|
|
if ( llGetAttached() ){
|
|
llRequestPermissions( llGetOwner(), PERMISSION_TRIGGER_ANIMATION|PERMISSION_TAKE_CONTROLS );
|
|
}
|
|
// populate override list with blanks
|
|
overrides = [];
|
|
for ( i=0; i<numOverrides; i++ ) {
|
|
overrides += [ EMPTY ];
|
|
}
|
|
randomStands = FALSE;
|
|
initialize();
|
|
notecardName = defaultNoteCard;
|
|
loadInProgress = TRUE;
|
|
loadNoteCard();
|
|
|
|
// turn off the auto-stop anim hack
|
|
if ( autoStopTime == 0 )
|
|
autoStop = [];
|
|
|
|
llResetTime();
|
|
}
|
|
|
|
on_rez( integer _code ) {
|
|
initialize();
|
|
gotPermission = TRUE;
|
|
}
|
|
|
|
attach( key _k ) {
|
|
if ( _k != NULL_KEY ){
|
|
llRequestPermissions( llGetOwner(), PERMISSION_TRIGGER_ANIMATION|PERMISSION_TAKE_CONTROLS );
|
|
}
|
|
}
|
|
|
|
run_time_permissions( integer _perm ) {
|
|
if ( _perm != (PERMISSION_TRIGGER_ANIMATION|PERMISSION_TAKE_CONTROLS) ){
|
|
gotPermission = FALSE;
|
|
}else{
|
|
llTakeControls( CONTROL_BACK|CONTROL_FWD, TRUE, TRUE );
|
|
gotPermission = TRUE;
|
|
}
|
|
}
|
|
|
|
link_message( integer _sender, integer _num, string _message, key _id) {
|
|
// Coming from an interface script
|
|
if ( _message == "ZHAO_RESET" ) {
|
|
llOwnerSay( "Resetting..." );
|
|
llResetScript();
|
|
} else if ( _message == "ZHAO_AOON" ) {
|
|
// AO On
|
|
llSetTimerEvent( timerEventLength );
|
|
animOverrideOn = TRUE;
|
|
checkAndOverride();
|
|
|
|
} else if ( _message == "ZHAO_AOOFF" ) {
|
|
//AO OFF
|
|
llSetTimerEvent(0);
|
|
animOverrideOn = FALSE;
|
|
startNewAnimation( EMPTY, noAnimIndex, lastAnimState );
|
|
lastAnim = EMPTY;
|
|
lastAnimSet = EMPTY;
|
|
lastAnimIndex = noAnimIndex;
|
|
lastAnimState = EMPTY;
|
|
checkAndOverride();
|
|
|
|
} else if ( _message == "ZHAO_STANDON" ) {
|
|
// Turning on sit override
|
|
standOverride = TRUE;
|
|
llOwnerSay( "Stand AO On" );
|
|
if ( lastAnimState == "Standing" )
|
|
startNewAnimation( curStandAnim, standingIndex, lastAnimState );
|
|
|
|
} else if ( _message == "ZHAO_STANDOFF" ) {
|
|
// Turning off sit override
|
|
standOverride = FALSE;
|
|
llOwnerSay( "Stand AO Off" );
|
|
if ( lastAnimState == "Standing" )
|
|
startNewAnimation( EMPTY, noAnimIndex, lastAnimState );
|
|
|
|
} else if ( _message == "ZHAO_SITON" ) {
|
|
// Turning on sit override
|
|
sitOverride = TRUE;
|
|
llOwnerSay( S_SIT + "On" );
|
|
if ( lastAnimState == "Sitting" )
|
|
startNewAnimation( curSitAnim, sittingIndex, lastAnimState );
|
|
|
|
} else if ( _message == "ZHAO_SITOFF" ) {
|
|
// Turning off sit override
|
|
sitOverride = FALSE;
|
|
llOwnerSay( S_SIT + "Off" );
|
|
if ( lastAnimState == "Sitting" )
|
|
startNewAnimation( EMPTY, noAnimIndex, lastAnimState );
|
|
|
|
} else if ( _message == "ZHAO_SITANYWHERE_ON" ) {
|
|
// Turning on sit anywhre mod
|
|
sitAnywhereOn = TRUE;
|
|
llOwnerSay( S_SIT_AW + "On" );
|
|
if ( lastAnimState == "Standing" ){
|
|
startNewAnimation( curGsitAnim, sitgroundIndex, lastAnimState );
|
|
}
|
|
|
|
} else if ( _message == "ZHAO_SITANYWHERE_OFF" ) {
|
|
// Turning off sit anywhere mod
|
|
sitAnywhereOn = FALSE;
|
|
llOwnerSay( S_SIT_AW + "Off" );
|
|
if ( lastAnimState == "Standing" )
|
|
startNewAnimation( curStandAnim, standingIndex, lastAnimState );
|
|
|
|
} else if ( _message == "ZHAO_TYPEAO_ON" ) {
|
|
// Turning on typing override
|
|
typingOverrideOn = TRUE;
|
|
llOwnerSay( S_TYPING + "On" );
|
|
typingStatus = FALSE;
|
|
|
|
} else if ( _message == "ZHAO_TYPEAO_OFF" ) {
|
|
// Turning off typing override
|
|
typingOverrideOn = FALSE;
|
|
llOwnerSay( S_TYPING + "Off" );
|
|
if ( typingStatus && !typingKill ) {
|
|
stopAnimationList(curTypingAnim);
|
|
typingStatus = FALSE;
|
|
}
|
|
} else if ( _message == "ZHAO_TYPEKILL_ON" ) {
|
|
// Turning on Typing killer
|
|
typingKill = TRUE;
|
|
llOwnerSay( S_TKILL_ON );
|
|
typingStatus = FALSE;
|
|
} else if ( _message == "ZHAO_TYPEKILL_OFF" ) {
|
|
// Turning off Typing killer
|
|
typingKill = FALSE;
|
|
llOwnerSay( S_TKILL_OFF );
|
|
typingStatus = FALSE;
|
|
} else if ( _message == "ZHAO_RANDOMSTANDS" ) {
|
|
// Cycling to next stand - sequential or random
|
|
randomStands = TRUE;
|
|
llOwnerSay( "Stand cycling: Random" );
|
|
|
|
} else if ( _message == "ZHAO_SEQUENTIALSTANDS" ) {
|
|
// Cycling to next stand - sequential or random
|
|
randomStands = FALSE;
|
|
llOwnerSay( "Stand cycling: Sequential" );
|
|
|
|
}
|
|
else if ( _message == "ZHAO_RANDOMDANCE" ) {
|
|
// Cycling to next stand - sequential or random
|
|
randomDance = TRUE;
|
|
llOwnerSay( "Dance cycling: Random" );
|
|
|
|
} else if ( _message == "ZHAO_SEQUENTIALDANCE" ) {
|
|
// Cycling to next stand - sequential or random
|
|
randomDance = FALSE;
|
|
llOwnerSay( "Dance cycling: Sequential" );
|
|
|
|
}
|
|
else if ( _message == "ZHAO_RANDOMRUN" ) {
|
|
// Cycling to next run - sequential or random
|
|
randomRuns = TRUE;
|
|
llOwnerSay( "Run cycling: Random" );
|
|
|
|
} else if ( _message == "ZHAO_SINGLERUN" ) {
|
|
// Cycling to next run - single or random
|
|
randomRuns = FALSE;
|
|
llOwnerSay( "Run cycling: Off" );
|
|
|
|
}
|
|
else if ( _message == "ZHAO_SETTINGS" ) {
|
|
// Print settings
|
|
if ( sitOverride ) {
|
|
llOwnerSay( S_SIT + "On" );
|
|
} else {
|
|
llOwnerSay( S_SIT + "Off" );
|
|
}
|
|
if ( sitAnywhereOn ) {
|
|
llOwnerSay( S_SIT_AW + "On" );
|
|
} else {
|
|
llOwnerSay( S_SIT_AW + "Off" );
|
|
}
|
|
//if ( typingOverrideOn ) {
|
|
// llOwnerSay( S_TYPING + "On" );
|
|
//} else {
|
|
// llOwnerSay( S_TYPING + "Off" );
|
|
//}
|
|
//if ( typingKill ) {
|
|
// llOwnerSay( S_TKILL_ON );
|
|
//} else {
|
|
// llOwnerSay( S_TKILL_OFF );
|
|
//}
|
|
if ( danceOverride ) {
|
|
llOwnerSay( "Dance Overrider: On" );
|
|
} else {
|
|
llOwnerSay( "Dance Overrider: Off" );
|
|
}
|
|
if ( randomDance ) {
|
|
llOwnerSay( "Dance cycling: Random" );
|
|
} else {
|
|
llOwnerSay( "Dance cycling: Sequential" );
|
|
}
|
|
if ( randomStands ) {
|
|
llOwnerSay( "Stand cycling: Random" );
|
|
} else {
|
|
llOwnerSay( "Stand cycling: Sequential" );
|
|
}
|
|
if ( randomRuns ) {
|
|
llOwnerSay( "Run cycling: Random" );
|
|
} else {
|
|
llOwnerSay( "Run cycling: Sequential" );
|
|
}
|
|
llOwnerSay( "Stand cycle time: " + (string)dialogStandTime + " seconds" );
|
|
|
|
} else if ( _message == "ZHAO_NEXTSTAND" ) {
|
|
// Cycling to next stand - sequential or random. This is from UI, so we
|
|
// want feedback
|
|
doNextStand( TRUE );
|
|
|
|
}else if ( _message == "ZHAO_NEXTDANCE" ) {
|
|
// Cycling to next dance - sequential or random. This is from UI, so we
|
|
// want feedback
|
|
doNextDance( TRUE );
|
|
|
|
} else if ( llGetSubString(_message, 0, 14) == "ZHAO_STANDTIME|" ) {
|
|
// Stand time change
|
|
dialogStandTime = (integer)llGetSubString(_message, 15, -1);
|
|
llOwnerSay( "Stand cycle time: " + (string)dialogStandTime + " seconds" );
|
|
llSetTimerEvent(dialogStandTime);
|
|
} else if ( llGetSubString(_message, 0, 9) == "ZHAO_LOAD|" ) {
|
|
// Can't load while we're in the middle of a load
|
|
if ( loadInProgress == TRUE ) {
|
|
llOwnerSay( "Cannot load new notecard, still reading notecard '" + notecardName + "'" );
|
|
return;
|
|
}
|
|
|
|
// Notecard menu
|
|
notecardName = llGetSubString(_message, 10, -1);
|
|
loadNoteCard();
|
|
|
|
} else if ( _message == "ZHAO_SITS" ) {
|
|
// Selecting new sit anim
|
|
|
|
// Move these to a common function
|
|
doMultiAnimMenu( sittingIndex, "Sitting", curSitAnim );
|
|
|
|
listenState = 1;
|
|
|
|
}
|
|
else if ( _message == "ZHAO_WALKS" ) {
|
|
// Same thing for the walk
|
|
|
|
// Move these to a common function
|
|
doMultiAnimMenu( walkingIndex, "Walking", curWalkAnim );
|
|
|
|
listenState = 2;
|
|
|
|
}
|
|
else if ( _message == "ZHAO_GROUNDSITS" ) {
|
|
// And the ground sit
|
|
|
|
// Move these to a common function
|
|
doMultiAnimMenu( sitgroundIndex, "Sitting On Ground", curGsitAnim );
|
|
|
|
listenState = 3;
|
|
}
|
|
else if ( _message == "ZHAO_RUNS" ) {
|
|
// Selecting new run anim
|
|
|
|
// Move these to a common function
|
|
doMultiAnimMenu( runningIndex, "Running", curSitAnim );
|
|
|
|
listenState = 4;
|
|
|
|
}
|
|
else if ( _message == "ZHAO_DANCES" ) {
|
|
// Selecting new run anim
|
|
|
|
// Move these to a common function
|
|
doMultiAnimMenu( dancingIndex, "Dancing", curDancingAnim );
|
|
|
|
listenState = 5;
|
|
|
|
}
|
|
else if ( _message == "ZHAO_DANCEON" ) {
|
|
// Turning off stand override
|
|
standOverride = FALSE;
|
|
llOwnerSay( "Stand AO Off" );
|
|
//Turn On Dance Override
|
|
danceOverride = TRUE;
|
|
llOwnerSay( "Dance AO On");
|
|
checkAndOverride();
|
|
}
|
|
else if ( _message == "ZHAO_DANCEOFF" ) {
|
|
//Turn On Dance Override
|
|
danceOverride = FALSE;
|
|
llOwnerSay( "Dance AO Off");
|
|
// Turning off dance override
|
|
standOverride = TRUE;
|
|
llOwnerSay( "Stand AO On" );
|
|
checkAndOverride();
|
|
}
|
|
|
|
//Notecard read, we get the string sent over and do some tests
|
|
else if ( llGetSubString(_message, 0, 11) == "END_NC_LOAD|" ) {
|
|
//if loading was a success...
|
|
if(_num) {
|
|
overrides = [];
|
|
//convert overrides back to a list
|
|
overrides = llCSV2List(llGetSubString(_message, 12, llStringLength(_message) - 1));
|
|
// Do we have a walking animation?
|
|
if ( llList2String(overrides, walkingIndex) != EMPTY ) {
|
|
haveWalkingAnim = TRUE;
|
|
}
|
|
// Reset stand, walk, sit and ground-sit anims to first entry
|
|
curStandIndex = 0;
|
|
numStands = llGetListLength( llParseString2List(llList2String(overrides, standingIndex),
|
|
[SEPARATOR], []) );
|
|
|
|
numTyping = llGetListLength( llParseString2List(llList2String(overrides, typingIndex),
|
|
[SEPARATOR], []) );
|
|
numRuns = llGetListLength( llParseString2List(llList2String(overrides, runningIndex),
|
|
[SEPARATOR], []) );
|
|
numDances = llGetListLength( llParseString2List(llList2String(overrides, runningIndex),
|
|
[SEPARATOR], []) );
|
|
curStandAnim = findMultiAnim( standingIndex, 0 );
|
|
curWalkAnim = findMultiAnim( walkingIndex, 0 );
|
|
curSitAnim = findMultiAnim( sittingIndex, 0 );
|
|
curGsitAnim = findMultiAnim( sitgroundIndex, 0 );
|
|
curFallingAnim = findMultiAnim ( fallingIndex, 0);
|
|
curRunningAnim = findMultiAnim ( runningIndex, 0);
|
|
curDancingAnim = findMultiAnim ( dancingIndex, 0);
|
|
llOwnerSay(curDancingAnim);
|
|
// Clear out the currently playing anim so we play the new one on the next cycle
|
|
startNewAnimation( EMPTY, noAnimIndex, lastAnimState );
|
|
lastAnim = EMPTY;
|
|
lastAnimSet = EMPTY;
|
|
lastAnimIndex = noAnimIndex;
|
|
lastAnimState = EMPTY;
|
|
|
|
llOwnerSay( "Finished reading notecard '" + notecardName + "'." );
|
|
printFreeMemory();
|
|
}
|
|
endNotecardLoad();
|
|
}
|
|
}
|
|
|
|
listen( integer _channel, string _name, key _id, string _message) {
|
|
// Turn listen off. We turn it on again if we need to present
|
|
// another menu
|
|
llListenControl(listenHandle, FALSE);
|
|
if (_channel==LMControlChannel & _message == "ZHAO_AOOFF"){ // Love Machine Engine has requested we shutdown AO, Doing So...
|
|
llOwnerSay("Sending OFF Signal...");
|
|
llMessageLinked(LINK_SET, 0, "ZHAO_AOOFF", NULL_KEY);
|
|
} else if (_channel==LMControlChannel & _message == "ZHAO_AOON"){ // Love Machine Engine has requested we turn the AO ON, Doing So...
|
|
llOwnerSay("Sending ON Signal...");
|
|
llMessageLinked(LINK_SET, 0, "ZHAO_AOON", NULL_KEY);
|
|
} else if ( listenState == 1 ) {
|
|
// Dialog enhancement - Fennec Wind
|
|
// Note that this is within one 'overrides' entry
|
|
curSitAnim = findMultiAnim( sittingIndex, (integer)_message - 1 );
|
|
if ( lastAnimState == "Sitting" ) {
|
|
startNewAnimation( curSitAnim, sittingIndex, lastAnimState );
|
|
}
|
|
llOwnerSay( "New sitting animation: " + curSitAnim );
|
|
|
|
} else if ( listenState == 2 ) {
|
|
// Dialog enhancement - Fennec Wind
|
|
// Note that this is within one 'overrides' entry
|
|
curWalkAnim = findMultiAnim( walkingIndex, (integer)_message - 1 );
|
|
if ( lastAnimState == "Walking" ) {
|
|
startNewAnimation( curWalkAnim, walkingIndex, lastAnimState );
|
|
}
|
|
llOwnerSay( "New walking animation: " + curWalkAnim );
|
|
|
|
} else if ( listenState == 3 ) {
|
|
// Dialog enhancement - Fennec Wind
|
|
// Note that this is within one 'overrides' entry
|
|
curGsitAnim = findMultiAnim( sitgroundIndex, (integer)_message - 1 );
|
|
// Lowercase 'on' - that's the anim name in SL
|
|
if ( lastAnimState == "Sitting on Ground" || ( lastAnimState == "Standing" && sitAnywhereOn ) ) {
|
|
startNewAnimation( curGsitAnim, sitgroundIndex, lastAnimState );
|
|
}
|
|
llOwnerSay( "New sitting on ground animation: " + curGsitAnim );
|
|
} else if ( listenState == 4 ) {
|
|
// Dialog enhancement - Fennec Wind
|
|
// Note that this is within one 'overrides' entry
|
|
randomRuns = FALSE;
|
|
llOwnerSay( "Run cycling: Off" );
|
|
curRunningAnim = findMultiAnim( runningIndex, (integer)_message - 1 );
|
|
// Lowercase 'on' - that's the anim name in SL
|
|
//if ( lastAnimState == "Sitting on Ground" || ( lastAnimState == "Standing" && sitAnywhereOn ) ) {
|
|
// startNewAnimation( curGsitAnim, sitgroundIndex, lastAnimState );
|
|
//}
|
|
llOwnerSay( "New running animation: " + curRunningAnim );
|
|
}
|
|
else if ( listenState == 5 ) {
|
|
// Dialog enhancement - Fennec Wind
|
|
// Note that this is within one 'overrides' entry
|
|
randomDance = FALSE;
|
|
llOwnerSay( "Dance cycling: Off" );
|
|
curDancingAnim = findMultiAnim( dancingIndex, (integer)_message - 1 );
|
|
// Lowercase 'on' - that's the anim name in SL
|
|
if (danceOverride==TRUE && standOverride == FALSE) {
|
|
startNewAnimation( curDancingAnim, dancingIndex, lastAnimState );
|
|
}
|
|
llOwnerSay( "New dancing animation: " + curDancingAnim );
|
|
}
|
|
}
|
|
|
|
changed(integer _change) {
|
|
//if(_change & CHANGED_TELEPORT) {
|
|
// lastAnimSet = EMPTY;
|
|
// lastAnimState = EMPTY;
|
|
// checkAndOverride();
|
|
//}
|
|
|
|
if (_change & CHANGED_REGION)
|
|
{
|
|
lastAnimSet = EMPTY;
|
|
lastAnimState = EMPTY;
|
|
checkAndOverride();
|
|
}
|
|
|
|
if (_change & CHANGED_ANIMATION){
|
|
checkAndOverride();
|
|
}
|
|
|
|
}
|
|
|
|
collision_start( integer _num ) {
|
|
checkAndOverride();
|
|
}
|
|
|
|
collision( integer _num ) {
|
|
// checkAndOverride();
|
|
}
|
|
|
|
collision_end( integer _num ) {
|
|
checkAndOverride();
|
|
}
|
|
|
|
control( key _id, integer _level, integer _edge ) {
|
|
if ( _edge ) {
|
|
checkAndOverride();
|
|
}else{
|
|
checkAndOverride();
|
|
}
|
|
}
|
|
|
|
timer(){
|
|
if(danceOverride==TRUE && standOverride == FALSE && lastAnimState == "Dancing") { // We are Dancing
|
|
doNextDance( FALSE );
|
|
}else{
|
|
doNextStand( FALSE );
|
|
}
|
|
}
|
|
}
|