--- /dev/null
+
+// huffware script: jaunting library, by fred huffhines, released under GPL-v3 license.
+//
+// this script is a library of useful teleportation and movement calls. it should be added
+// into an object along with other scripts that use the library. the jaunting library
+// responds to linked messages as commands.
+// parts of this script are based on warpPos from "Teleporter Script v 3.0 by Asira Sakai",
+// which was found at the LSL wiki.
+//
+// this script is licensed by the GPL v3 which is documented at: http://www.gnu.org/licenses/gpl.html
+// do not use it in objects without fully realizing you are implicitly accepting that license.
+//
+
+// global constants...
+
+float PROXIMITY_REQUIRED = 0.1;
+ // how close we must be to the target location to call the jaunt done.
+ // we make this fairly low accuracy since we don't want jumps in space to immediately
+ // be counted as failures.
+
+// the most jumps the script will try to take. the overall distance from the start
+// to the end can be 10 * MAXIMUM_JUMPS_PER_CALL meters.
+integer MAXIMUM_JUMPS_PER_CALL = 84;
+
+// global variables...
+
+vector last_posn; // used to calculate jump distances.
+
+// jaunting library link message API...
+//////////////
+// do not redefine these constants.
+integer JAUNT_HUFFWARE_ID = 10008;
+ // the unique id within the huffware system for the jaunt script to
+ // accept commands on. this is used in llMessageLinked as the num parameter.
+string HUFFWARE_PARM_SEPARATOR = "{~~~}";
+ // this pattern is an uncommon thing to see in text, so we use it to separate
+ // our commands in link messages.
+string HUFFWARE_ITEM_SEPARATOR = "{|||}";
+ // used to separate lists of items from each other when stored inside a parameter.
+ // this allows lists to be passed as single string parameters if needed.
+integer REPLY_DISTANCE = 100008; // offset added to service's huffware id in reply IDs.
+// commands available via the jaunting library:
+string JAUNT_COMMAND = "#jaunt#";
+ // command used to tell jaunt script to move object. pass a vector with the location.
+string FULL_STOP_COMMAND = "#fullstop#";
+ // command used to bring object to a halt.
+string REVERSE_VELOCITY_COMMAND = "#reverse#";
+ // makes the object reverse its velocity and travel back from whence it came.
+string SET_VELOCITY_COMMAND = "#setvelocity#";
+ // makes the velocity equal to the vector passed as the first parameter.
+string JAUNT_UP_COMMAND = "#jauntup#";
+string JAUNT_DOWN_COMMAND = "#jauntdown#";
+ // commands for height adjustment. pass a float for number of meters to move.
+string JAUNT_LIST_COMMAND = "#jauntlist#";
+ // like regular jaunt, but expects a list of vectors as the first parameter; this list
+ // should be in the jaunter notecard format (separated by pipe characters).
+ // the second parameter, if any, should be 1 for forwards traversal and 0 for backwards.
+//////////////
+
+// returns what we consider to be safe to do in one big jump.
+float distance_safe_to_jaunt() { return (float)(MAXIMUM_JUMPS_PER_CALL - 4) * 10.0; }
+
+// tests whether the destination is safe for an object to enter.
+integer safe_for_entry(vector where)
+{
+ if (outside_of_sim(where)) {
+ // that's an obvious wrong idea; it tends to break us.
+ return FALSE;
+ }
+ return TRUE;
+}
+
+// helper function for warp_across_list. this adds one jump vector to the
+// list of rules as long as the destination is interesting.
+list process_warp_item(vector next_jump)
+{
+//log_it("mem: " + (string)llGetFreeMemory());
+ // calculate the number of jumps needed.
+ integer jumps = (integer)(llVecDist(next_jump, last_posn) / 10.0) + 1;
+ last_posn = next_jump; // record for next check.
+ // set up our list which we'll replicate.
+ list rules = [ PRIM_POSITION, next_jump ];
+ // Try and avoid stack/heap collisions.
+ if (jumps > MAXIMUM_JUMPS_PER_CALL - 1) jumps = MAXIMUM_JUMPS_PER_CALL;
+ // add the rules repeatedly to get the effective overall jump done.
+ integer count = 1;
+ while ( (count = count << 1) < jumps)
+ rules += rules;
+ // magnify the rule list before really adding it. this gets us to the proper
+ // final number of jumps.
+ return rules + llList2List(rules, (count - jumps) << 1 - 2, count);
+}
+
+// originally based on warpPos from lsl wiki but drastically modified.
+// uses a set of transfer points instead of a single target.
+list warp_across_list(list full_journey, integer forwards)
+{
+ // make sure the list didn't run out.
+ if (llGetListLength(full_journey) == 0) return [];
+ if (forwards) {
+ // forwards traversal of the list.
+ vector next_jump = (vector)llList2String(full_journey, 0);
+ // shortcut the jumps if we're already there.
+ if (next_jump == llGetPos())
+ return warp_across_list(chop_list(full_journey, 1,
+ llGetListLength(full_journey) - 1), forwards);
+ // calculate our trajectory for the next jump and add in all subsequent jumps.
+ return process_warp_item(next_jump)
+ + warp_across_list(chop_list(full_journey, 1, llGetListLength(full_journey) - 1), forwards);
+ } else {
+ // reverse traversal of the list.
+ vector next_jump = (vector)llList2String(full_journey, llGetListLength(full_journey) - 1);
+ // shortcut the jumps if we're already there.
+ if (next_jump == llGetPos())
+ return warp_across_list(chop_list(full_journey, 0,
+ llGetListLength(full_journey) - 2), forwards);
+ // calculate our trajectory for the next jump and add in all subsequent jumps.
+ return process_warp_item(next_jump)
+ + warp_across_list(chop_list(full_journey, 0, llGetListLength(full_journey) - 2), forwards);
+ }
+}
+
+// the main function that performs the jaunting process.
+// now also supports adding a rotation into the mix to avoid paying the extra delay
+// cost of calling llSetRot.
+jaunt(list full_journey, integer forwards, string command_used,
+ integer use_rotation, rotation rot, integer reply_to_request)
+{
+//log_it("jaunt: fullj=" + (string)full_journey + " forew=" + (string)forwards);
+ // set up our global variables...
+ last_posn = llGetPos();
+ // calculate the trip and run it.
+ list rot_add;
+ if (use_rotation)
+ rot_add = [ PRIM_ROTATION, rot ];
+ llSetPrimitiveParams(warp_across_list(full_journey, forwards) + rot_add);
+ if (reply_to_request) {
+ // pick out the last target in the list based on the direction we're moving.
+ integer last_indy = 0;
+ if (forwards == TRUE) last_indy = llGetListLength(full_journey) - 1;
+ vector last_jump = (vector)llList2String(full_journey, last_indy);
+ // final judge of success here is how close we got to the target.
+ integer landed_there = (llVecDist(llGetPos(), last_jump) <= PROXIMITY_REQUIRED);
+ send_reply(LINK_THIS, [landed_there, llGetPos()], command_used);
+ }
+}
+
+//////////////
+
+// sets the object's speed to "new_velocity".
+// if "local_axis" is TRUE, then it will be relative to the object's
+// own local coordinates.
+set_velocity(vector new_velocity, integer local_axis)
+{
+ vector current_velocity = llGetVel();
+
+ if (local_axis) {
+ rotation rot = llGetRot();
+ current_velocity /= rot; // undo the rotation.
+ }
+
+ new_velocity -= current_velocity;
+ new_velocity *= llGetMass();
+
+ llApplyImpulse(new_velocity, local_axis);
+}
+
+// attempts to bring the object to a complete stop.
+full_stop()
+{
+ llSetForce(<0,0,0>, FALSE);
+ set_velocity(<0,0,0>, FALSE);
+}
+
+// sends an object back along its trajectory.
+reverse_velocity(integer local_axis)
+{
+ vector current_velocity = llGetVel();
+ if (local_axis) {
+ rotation rot = llGetRot();
+ current_velocity /= rot; // undo the rotation.
+ }
+ vector new_velocity = -2 * current_velocity;
+ new_velocity *= llGetMass();
+ llApplyImpulse(new_velocity, local_axis);
+}
+
+// teleports to the new "location", if possible. does not change object's phantom / physical
+// states. this will do the jaunt in multiple steps if the distance from here to "location"
+// is too large.
+apportioned_jaunt(vector location, string command_used, integer use_rotation, rotation rot,
+ integer should_send_reply)
+{
+ if (!safe_for_entry(location)) {
+ // that's not good. we should not allow the script to get broken.
+ if (should_send_reply)
+ send_reply(LINK_THIS, [FALSE, llGetPos()], command_used);
+ return;
+ }
+ // go to position specified, by leapfrogs if too long.
+ integer chunk_of_jump;
+ integer MAX_CHUNKS = 200; // multiplies the distance a single jaunt can cover.
+ for (chunk_of_jump = 0; chunk_of_jump < MAX_CHUNKS; chunk_of_jump++) {
+ vector interim_vec = location - llGetPos();
+ float jump_dist = llVecDist(llGetPos(), location);
+ integer reply_needed = TRUE;
+ if (jump_dist > distance_safe_to_jaunt()) {
+ // the entire distance cannot be jumped. do the part of it that fits.
+ float proportion_can_do = distance_safe_to_jaunt() / jump_dist;
+ interim_vec *= proportion_can_do;
+ reply_needed = FALSE; // don't reply when this is not full jump.
+ }
+ interim_vec += llGetPos(); // bias jump back to where we are.
+//log_it("jumping from " + (string)llGetPos() + " to " + (string)interim_vec);
+ jaunt([llGetPos(), interim_vec], TRUE, command_used, use_rotation, rot,
+ reply_needed && should_send_reply);
+ float dist_now = llVecDist(llGetPos(), interim_vec);
+ if (dist_now > PROXIMITY_REQUIRED) {
+//log_it("failed to make interim jump, dist left is " + (string)dist_now);
+ // bail out. we failed to get as far as we thought we should.
+ chunk_of_jump = MAX_CHUNKS + 10;
+ if (!reply_needed) {
+ // we need to send the reply we hadn't sent yet.
+ if (should_send_reply)
+ send_reply(LINK_THIS, [FALSE, llGetPos()], command_used);
+ }
+ } else if (llVecDist(llGetPos(), location) <= PROXIMITY_REQUIRED) {
+ // leave loop for a different reason; we got there.
+ chunk_of_jump = MAX_CHUNKS + 10;
+ if (!reply_needed) {
+ // we need to send the reply we hadn't sent yet.
+ if (should_send_reply)
+ send_reply(LINK_THIS, [TRUE, llGetPos()], command_used);
+ }
+ }
+ }
+}
+
+// the entire distance embodied in the list of targets. this is a little smart,
+// in that if there's only one target, we assume we're going from "here" to that
+// one target.
+float total_jaunt_distance(list targets)
+{
+ if (!llGetListLength(targets)) return 0.0;
+ // add in "this" location if they omitted it.
+ if (llGetListLength(targets) < 2)
+ targets = [ llGetPos() ] + targets;
+ integer disindy;
+ float total_dist = 0.0;
+ vector prev = (vector)llList2String(targets, 0);
+ for (disindy = 1; disindy < llGetListLength(targets); disindy++) {
+ vector next = (vector)llList2String(targets, disindy);
+ total_dist += llVecDist(prev, next);
+ prev = next;
+ }
+ return total_dist;
+}
+
+// jaunts to a target via a set of intermediate locations. can either go forwards
+// through the list or backwards.
+phantom_jaunt_to_list(list targets, integer forwards, string command_used,
+ integer use_rotation, rotation rot)
+{
+ vector final_loc;
+ if (forwards) final_loc = (vector)llList2String(targets, llGetListLength(targets) - 1);
+ else final_loc = (vector)llList2String(targets, 0);
+
+//hmmm: check each destination in list??
+ if (!safe_for_entry(final_loc)) {
+ // that's not good. we should not allow the script to get broken.
+ send_reply(LINK_THIS, [FALSE, llGetPos()], command_used);
+ return;
+ }
+
+ // this turns off the physics property for the object, so that jaunt and
+ // llSetPos will still work. this became necessary due to havok4.
+ integer original_phantomosity = llGetStatus(STATUS_PHANTOM);
+ integer original_physicality = llGetStatus(STATUS_PHYSICS);
+ if (original_physicality != FALSE) llSetStatus(STATUS_PHYSICS, FALSE);
+ if (original_phantomosity != TRUE) llSetStatus(STATUS_PHANTOM, TRUE);
+
+ integer send_reply_still = TRUE; // true if we should send a reply when done.
+
+ // iterate through our list of targets and either we will jaunt to the next
+ // place directly or we will have to wrap a few destinations due to sim crossing.
+ while (llGetListLength(targets) > 0) {
+ vector next_loc;
+ if (forwards) next_loc = (vector)llList2String(targets, 0);
+ else next_loc = (vector)llList2String(targets, llGetListLength(targets) - 1);
+ if (outside_of_sim(next_loc)) {
+ log_it("bad jaunt path: first target is out of sim.");
+ send_reply(LINK_THIS, [FALSE, llGetPos()], command_used);
+ return; // skip that badness.
+ }
+
+ // check how much total distance we have in the path that's left. if it's under our
+ // limit, then we'll just take it in one jump.
+ float total_dist = total_jaunt_distance(targets);
+
+ // if we're below the threshold, we'll just jump now.
+ integer already_jumped = FALSE;
+ if (total_dist < distance_safe_to_jaunt()) {
+ jaunt(targets, forwards, command_used, use_rotation, rot, TRUE);
+ targets = []; // reset the list now.
+ send_reply_still = FALSE; // we have already sent the reply in jaunt().
+ already_jumped = TRUE; // don't do anything else.
+ }
+ if (!already_jumped) {
+ vector next_plus_1 = ZERO_VECTOR; // default cannot fail our "is inside sim" check.
+ if (llGetListLength(targets) > 1) {
+ if (forwards) next_plus_1 = (vector)llList2String(targets, 1);
+ else next_plus_1 = (vector)llList2String(targets, llGetListLength(targets) - 2);
+ }
+ if (outside_of_sim(next_plus_1)) {
+//hmmm: eventually find all the negative ones in a row and do them in combo, rather than
+// just giving up here and doing a jaunt to the rest..
+ jaunt(targets, forwards, command_used, use_rotation, rot, TRUE);
+ targets = []; // reset the list now.
+ send_reply_still = FALSE; // we have already sent the reply in jaunt().
+ } else {
+ // we've passed the negativity test, so we can at least jump to the next place.
+
+ // zap the next location, since we're about to jump there.
+ integer zap_pos = 0;
+ if (!forwards) zap_pos = llGetListLength(targets) - 1;
+ targets = llDeleteSubList(targets, zap_pos, zap_pos);
+
+ // only bother jumping if we're not already there.
+ if (llVecDist(next_loc, llGetPos()) > PROXIMITY_REQUIRED) {
+ apportioned_jaunt(next_loc, command_used, use_rotation, rot, FALSE);
+ }
+ }
+ }
+ }
+
+ if (send_reply_still) {
+ integer yippee = TRUE; // assume we succeeded until we prove otherwise.
+ if (llVecDist(final_loc, llGetPos()) > PROXIMITY_REQUIRED)
+ yippee = FALSE;
+ send_reply(LINK_THIS, [yippee, llGetPos()], command_used);
+ }
+
+ // return to prior characteristics.
+ if (original_phantomosity != TRUE) llSetStatus(STATUS_PHANTOM, original_phantomosity);
+ if (original_physicality != FALSE) llSetStatus(STATUS_PHYSICS, original_physicality);
+}
+
+// implements our API for jumping around.
+handle_link_message(integer sender, integer huff_id, string msg, key id)
+{
+ // separate the list out
+ list parms = llParseString2List(id, [HUFFWARE_PARM_SEPARATOR], []);
+ if (msg == JAUNT_COMMAND) {
+ // use list to string to avoid non-conversions.
+ vector v = (vector)llList2String(parms, 0);
+ rotation rot = <0.0, 0.0, 0.0, 1.0>;
+ integer gave_rot = llGetListLength(parms) > 1;
+ if (gave_rot) rot = (rotation)llList2String(parms, 1); // ooh, they gave us a rotational value also.
+// log_it("gave rot? " + (string)gave_rot + " rot=" + (string)rot);
+ phantom_jaunt_to_list([llGetPos(), v], TRUE, msg, gave_rot, rot);
+ } else if (msg == FULL_STOP_COMMAND) {
+ full_stop();
+ } else if (msg == REVERSE_VELOCITY_COMMAND) {
+ reverse_velocity(FALSE);
+ } else if (msg == SET_VELOCITY_COMMAND) {
+ vector v = (vector)llList2String(parms, 0);
+//log_it("jaunting lib received set velocity request for " + (string)v);
+ set_velocity(v, FALSE);
+ } else if (msg == JAUNT_UP_COMMAND) {
+ phantom_jaunt_to_list([ llGetPos(), llGetPos() + <0.0, 0.0, llList2Float(parms, 0)> ],
+ TRUE, msg, FALSE, ZERO_ROTATION);
+ } else if (msg == JAUNT_DOWN_COMMAND) {
+ phantom_jaunt_to_list([ llGetPos(), llGetPos() + <0.0, 0.0, -llList2Float(parms, 0)> ],
+ TRUE, msg, FALSE, ZERO_ROTATION);
+ } else if (msg == JAUNT_LIST_COMMAND) {
+ string destination_list = llList2String(parms, 0);
+ list targets = llParseString2List(destination_list, [HUFFWARE_ITEM_SEPARATOR], []);
+ destination_list = "";
+ integer forwards = TRUE;
+ // snag the directionality for the list, if specified.
+ if (llGetListLength(parms) > 1) forwards = llList2Integer(parms, 1);
+ rotation rot = <0.0, 0.0, 0.0, 1.0>;
+ integer gave_rot = llGetListLength(parms) > 2;
+ if (gave_rot) rot = llList2Rot(parms, 2); // ooh, they gave us a rotational value also.
+ phantom_jaunt_to_list(targets, forwards, msg, gave_rot, rot);
+ targets = [];
+ }
+}
+
+//////////////
+// from hufflets...
+
+integer debug_num = 0;
+
+// a debugging output method. can be disabled entirely in one place.
+log_it(string to_say)
+{
+ debug_num++;
+ // tell this to the owner.
+ llOwnerSay(llGetScriptName() + "[" + (string)debug_num + "] " + to_say);
+ // say this on open chat, but use an unusual channel.
+// llSay(108, llGetScriptName() + "--" + (string)debug_num + ": " + to_say);
+}
+//////////////
+
+// a simple version of a reply for a command that has been executed. the parameters
+// might contain an outcome or result of the operation that was requested.
+send_reply(integer destination, list parms, string command)
+{
+ llMessageLinked(destination, JAUNT_HUFFWARE_ID + REPLY_DISTANCE, command,
+ llDumpList2String(parms, HUFFWARE_PARM_SEPARATOR));
+}
+
+// returns TRUE if the value in "to_check" specifies a legal x or y value in a sim.
+integer valid_sim_value(float to_check)
+{
+ if (to_check < 0.0) return FALSE;
+ if (to_check >= 257.0) return FALSE;
+ return TRUE;
+}
+
+integer outside_of_sim(vector to_check)
+{
+ return !valid_sim_value(to_check.x) || !valid_sim_value(to_check.y);
+}
+
+///////////////
+
+// returns the portion of the list between start and end, but only if they are
+// valid compared with the list length. an attempt to use negative start or
+// end values also returns a blank list.
+list chop_list(list to_chop, integer start, integer end)
+{
+ integer last_len = llGetListLength(to_chop) - 1;
+ if ( (start < 0) || (end < 0) || (start > last_len) || (end > last_len) ) return [];
+ return llList2List(to_chop, start, end);
+}
+
+//////////////
+
+//////////////
+// huffware script: auto-retire, by fred huffhines, version 2.5.
+// distributed under BSD-like license.
+// !! keep in mind that this code must be *copied* into another
+// !! script that you wish to add auto-retirement capability to.
+// when a script has auto_retire in it, it can be dropped into an
+// object and the most recent version of the script will destroy
+// all older versions.
+//
+// the version numbers are embedded into the script names themselves.
+// the notation for versions uses a letter 'v', followed by two numbers
+// in the form "major.minor".
+// major and minor versions are implicitly considered as a floating point
+// number that increases with each newer version of the script. thus,
+// "hazmap v0.1" might be the first script in the "hazmap" script continuum,
+// and "hazmap v3.2" is a more recent version.
+//
+// example usage of the auto-retirement script:
+// default {
+// state_entry() {
+// auto_retire(); // make sure newest addition is only version of script.
+// }
+// }
+// this script is partly based on the self-upgrading scripts from markov brodsky
+// and jippen faddoul.
+//////////////
+auto_retire() {
+ string self = llGetScriptName(); // the name of this script.
+ list split = compute_basename_and_version(self);
+ if (llGetListLength(split) != 2) return; // nothing to do for this script.
+ string basename = llList2String(split, 0); // script name with no version attached.
+ string version_string = llList2String(split, 1); // the version found.
+ integer posn;
+ // find any scripts that match the basename. they are variants of this script.
+ for (posn = llGetInventoryNumber(INVENTORY_SCRIPT) - 1; posn >= 0; posn--) {
+ string curr_script = llGetInventoryName(INVENTORY_SCRIPT, posn);
+ if ( (curr_script != self) && (llSubStringIndex(curr_script, basename) == 0) ) {
+ // found a basic match at least.
+ list inv_split = compute_basename_and_version(curr_script);
+ if (llGetListLength(inv_split) == 2) {
+ // see if this script is more ancient.
+ string inv_version_string = llList2String(inv_split, 1); // the version found.
+ // must make sure that the retiring script is completely the identical basename;
+ // just matching in the front doesn't make it a relative.
+ if ( (llList2String(inv_split, 0) == basename)
+ && ((float)inv_version_string < (float)version_string) ) {
+ // remove script with same name from inventory that has inferior version.
+ llRemoveInventory(curr_script);
+ }
+ }
+ }
+ }
+}
+//
+// separates the base script name and version number. used by auto_retire.
+list compute_basename_and_version(string to_chop_up)
+{
+ // minimum script name is 2 characters plus a version.
+ integer space_v_posn;
+ // find the last useful space and 'v' combo.
+ for (space_v_posn = llStringLength(to_chop_up) - 3;
+ (space_v_posn >= 2) && (llGetSubString(to_chop_up, space_v_posn, space_v_posn + 1) != " v");
+ space_v_posn--) {
+ // look for space and v but do nothing else.
+ }
+ if (space_v_posn < 2) return []; // no space found.
+ // now we zoom through the stuff after our beloved v character and find any evil
+ // space characters, which are most likely from SL having found a duplicate item
+ // name and not so helpfully renamed it for us.
+ integer indy;
+ for (indy = llStringLength(to_chop_up) - 1; indy > space_v_posn; indy--) {
+ if (llGetSubString(to_chop_up, indy, indy) == " ") {
+ // found one; zap it. since we're going backwards we don't need to
+ // adjust the loop at all.
+ to_chop_up = llDeleteSubString(to_chop_up, indy, indy);
+ }
+ }
+ string full_suffix = llGetSubString(to_chop_up, space_v_posn, -1);
+ // ditch the space character for our numerical check.
+ string chop_suffix = llGetSubString(full_suffix, 1, llStringLength(full_suffix) - 1);
+ // strip out a 'v' if there is one.
+ if (llGetSubString(chop_suffix, 0, 0) == "v")
+ chop_suffix = llGetSubString(chop_suffix, 1, llStringLength(chop_suffix) - 1);
+ // if valid floating point number and greater than zero, that works for our version.
+ string basename = to_chop_up; // script name with no version attached.
+ if ((float)chop_suffix > 0.0) {
+ // this is a big success right here.
+ basename = llGetSubString(to_chop_up, 0, -llStringLength(full_suffix) - 1);
+ return [ basename, chop_suffix ];
+ }
+ // seems like we found nothing useful.
+ return [];
+}
+//
+//////////////
+
+default {
+ state_entry() { if (llSubStringIndex(llGetObjectName(), "huffotronic") < 0) state real_default; }
+ on_rez(integer parm) { state rerun; }
+}
+state rerun { state_entry() { state default; } }
+
+state real_default
+{
+ state_entry() { auto_retire(); }
+
+ link_message(integer sender, integer huff_id, string msg, key id) {
+ if (huff_id != JAUNT_HUFFWARE_ID) return; // not our responsibility.
+ handle_link_message(sender, huff_id, msg, id);
+ }
+}
+
projects / feisty_meow.git / commitdiff