normalized perms on all files, to avoid relying on any stored executable bits in...

[feisty_meow.git] / huffware / huffotronic_scripts / jaunt_wik_rez_v86.3.txt


// huffware script: jaunt wik rez, by fred huffhines,  released under GPL license.
//
// this is a jaunter (teleporter) script with some useful and uncommon features.
// it can work around certain types of complicated land permissions on neighboring land
// that might otherwise lead to blocked jaunts.
// the usage of "jaunt" for teleportation is inspired by the alfred bester novel, "the stars
// my destination".  if you like science fiction and have not read this book, it is highly
// recommended.
// parts of this script are based on "Teleporter Script v 3.0 by Asira Sakai", from
// the LSL wiki.
//
// use jaunt wik rez by placing a notecard in the inventory of your jaunter object.  the notecard
// should start with "#jaunt" on the first line and then should have alternating lines of
// (1) jaunt target (as a vector) and (2) readable target name, for example:
//      #jaunt
//      <23, 18, 92>
//      gracy square
//      <182, 32, 56>
//      tourmaline palace
//      <23, 18, 92>|<118, 19, 108>|<120, 33, 57>
//      unblocked pathway, hurrah
// note the last destination; the script also supports a list of intermediate destinations.
// this feature can enable one to route a teleport around blocked lands by using waypoints
// that are still accessible.  but since the current version of the script automatically
// finds routes for most destinations, this is not needed very frequently.
//
// 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.
//

//////////////

integer DEBUGGING = FALSE;
    // make true to print diagnostic logging.

// configurable options (set in notecard):

integer SHOW_TEXT = TRUE;
    // if true, then the jaunter will show a text label for the destination.
    // this can be configured from the notecard with ":show_text=0" to turn off,
    // or 1 to turn on.
integer ADD_NAME = FALSE;
    // if this is true, then the text shown will include the object's name.

string TEXT_COLOR = "<0.3, 0.9, 0.7>";
    // set float text color to a nice color.
///hmmm: doesn't seem to be in the notecard yet!

//////////////

// the jaunter button pushing API.
//////////////
integer BUTTON_PUSHER_HUFFWARE_ID = 10029;
    // a unique ID within the huffware system for this script.
//////////////
string BUTTON_PUSHED_ALERT = "#btnp";
    // this event is generated when the button is pushed.  the number parameter will be
    // the huffware id plus the reply distance.  the id parameter in the link message will
    // contain the name of the button that was 
string JAUNT_NEXT_BUTTON_NAME = "next";
string JAUNT_MENU_BUTTON_NAME = "menu";

//////////////
    
// requires the jaunt config API.
//////////////
// do not redefine these constants.
integer JAUNT_CONFIGURATION_HUFFWARE_ID = 10022;
    // the unique id within the huffware system for this script's commands.
    // it's 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 from the jaunt config library:
string LOAD_ALL_CONFIGURATIONS = "#rdcfg#";
    // this starts the process of loading jaunt destinations from the notecards and
    // landmarks that we find in the object.  the parms are: private channel
    // and conveyance mode.
string JAUNT_CFG_DATA_EVENT = "#yodata#";
    // this event is generated from this script back to the caller.  when we have some
    // landmark data or configuration information, it's passed back in chunks.  the
    // deluge of pieces will continue until the JAUNT_CFG_EOF event is passed.  the
    // parameters include packed destination name and vector pairs (which form 2 elements
    // in the list) and packed config variable definitions (where config items start
    // with a colon, and the definition is only one element in the list).
string JAUNT_CFG_EOF = "#done#";
    // sent after all valid configuration items that we could find were processed.
//
//////////////

// requires jaunting library 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.
//////////////
// commands available via the jaunting library:
string FULL_STOP_COMMAND = "#fullstop#";
    // command used to bring object to a halt.
string JAUNT_LIST_COMMAND = "#jauntlist#";
    // like regular jaunt, but expects a string in jaunt notecard format with vectors.
    // the second parameter, if any, should be 1 for forwards traversal and 0 for backwards.
//
//////////////

// requires menutini API.
//////////////
// do not redefine these constants.
integer MENUTINI_HUFFWARE_ID = 10009;
    // 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 SHOW_MENU_COMMAND = "#menu#";
    // the command that tells menutini to show a menu defined by parameters
    // that are passed along.  these must be: the menu name, the menu's title
    // (which is really the info to show as content in the main box of the menu),
    // the wrapped list of commands to show as menu buttons, the menu system
    // channel's for listening, and the key to listen to.

// requires data cow library API.
//////////////
// do not redefine these constants.
integer DATA_COW_HUFFWARE_ID = 10017;
    // 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 RESET_LIST_COMMAND = "reset_L";
    // flushes out the currently held list.  does not send a reply.
string ADD_ITEM_COMMAND = "add_I";
    // adds items to the list.  this is a list of pairs of name/value, where the name is
    // how the item will be looked up from the list, and the value is the contents to be stored.
    // this command has no reply.
string GET_COW_LENGTH = "get_Lc";
    // returns a single integer which is the length of the cow's list currently.
//string REMOVE_ITEM_COMMAND = "rm_I";
    // accepts a list of names for items.  all the mentioned ones will be removed from the list.
    // this command also has no reply.
//string GET_ITEM_COMMAND = "get_I";
    // retrieves the item's contents for a given name.  first parm is the name.  if there
    // are other parameters, then they are taken as other items to return also.
    // the return data will be pairs of <name, entry> for each of the names in the request.
    // if the data was not located, then the entry will be empty.
string TAGGED_GET_ITEM_COMMAND = "get_T";
    // like get item, except the first parameter is an identifier that the caller wants to
    // use to tag this request.  the other parameters are still taken as names.  the response
    // will contain the tag as the first item, then the <name, entry> pairs that were found.

//////////////

// requires click action API...
//////////////
integer CHANGE_CLICK_ACTION_HUFFWARE_ID = 10024;
    // a unique ID within the huffware system for this script.
// the API only supports the service number; there are no commands to pass in the "msg"
// parameter.  the id does accept a parameter, which is the type of click action to begin
// using for this prim.
//////////////

// the API for this library script to be used in other scripts.
//////////////
// do not redefine these constants.
integer JAUNT_REZOLATOR_HUFFWARE_ID = 10025;
    // the unique id within the huffware system for this script's commands.
    // it's used in llMessageLinked as the num parameter.
//////////////
// commands available from the library:
string RESET_REZOLATOR = "#reset";
    // tells the script to stop any previous efforts to rez children.
string REZ_CHILD_NOW = "#rezkd#";
    // requests this script to create a new child object.  this requires several
    // parameters to succeed: 1) object to rez, 2) conveyance mode for the rezzed object
    // to implement, 3) the chat channel to listen for and speak to new child on,
    // 4) the destination name for where the child should go, 5) a count of the full
    // set of known destinations, 6) the target where the jaunt should arrive at.
//////////////
// events generated by the library:
string REZOLATOR_EVENT_REZZED_CHILD = "#donekd";
    // an event generated for a previous rez child request.  this lets the caller know that
    // the child has been created and told what to do.  the single parameter is where the
    // jaunter has been rezzed.
string REZOLATOR_EVENT_RECON_FINISHED = "#rzcnfn";
    // an event generated when the recon process has concluded.  this includes parms:
    // number of good destinations.
//
//////////////

// important constants used internally...  these should not be changed willy nilly.

////////////// jaunt base API

// the following constants define how the script should behave (i.e., its conveyance mode).
// TWO_WAY_TRIP: the script jaunts using the current target vectors to get somewhere
//   and then takes the same pathway back, but in reverse order.
// AUTOREZ_JAUNTER: the script rezzes the first regular object in its inventory next to
//   the root telehub.  that object is loaded with the destination notecard and this script.
//   the rezzed object can then be used for the next few minutes to jaunt to the selected
//   destination.  the temporary object will use the ONE_WAY_TRIP mode.
// ONE_WAY_TRIP: the object containing this script will take the user to a particular
//   destination, but the object does not survive the trip.  it self-destructs after
//   reaching the destination.  this mode is used in conjunction with the AUTOREZ_JAUNTER
//   mode and should generally never be used on its own.
// RECONNAISSANCE_TRIP: a survey run to test out a particular path to get to a
//   destination.
integer TWO_WAY_TRIP = 1;
integer AUTOREZ_JAUNTER = 2;
integer ONE_WAY_TRIP = 3;
integer RECONNAISSANCE_TRIP = 4;

// values used to represent different stages of verification.
integer VERIFY_UNTESTED = -3;  // don't know destinations state yet.
integer VERIFY_SAFE = -4;  // the destination last tested safe.
integer VERIFY_UNSAFE_SO_FAR = -5;  // this cannot be done with simple jaunt.
integer VERIFY_UNSAFE_DECIDED = -6;  // this means the destination seems intractable.

integer MAXIMUM_PRIV_CHAN = 90000;
    // the largest amount we will ever subtract from the tricky parms in order to
    // tell the sub-jaunter which channel to listen on.

string VECTOR_SEPARATOR = "|";
    // how we separate components of vectors from each other.
string DB_SEPARATOR = "``";  // separating items in lists.

////////////// end jaunt base API

integer MAX_DEST_NAME = 24;  // the longest name that we store.

float NORMAL_TIMER_PERIOD = 1.0;  // our normal timer rate.

string RESET_COMMAND = "jreset";  // forget everything and start over.
string SHOW_COMMAND = "show";  // describe the known destinations.
string RECON_COMMAND = "recon";  // tells the jaunter to run reconnaissance on destinations.

float POSITION_CHECKING_INTERVAL = 0.11;
    // how frequently the waiting for arrival state will check where we are.

integer MAXIMUM_SLACKNESS = 108;
    // how many timer hits we'll allow before reverting to the default state.

integer FREE_MEM_REQUIRED = 1600;
    // we need at least this much memory before adding new targets.

// somewhere between two and 10 minutes (default) will elapse before first recon testing.
float MIN_RECON_SNOOZE = 120;
float MAX_RECON_SNOOZE = 1200;

// the actions that can be held in the action queue.
integer AQ_SHOW_DEST_RECORD = 23;  // a record to be shown to the user.
integer AQ_FINISH_SHOW_DESTS = 24;  // last record in a jaunt destinations list.
integer AQ_CLICK_ACTION_REQUEST = 25;  // the response should set our click action.
integer AQ_SELECT_DESTINATION = 27;  // the user has chosen a different destination.
integer AQ_DONE_CONFIGURING = 28;  // the last step of the configuration process has finished.

string OUR_COW_TAG = "jwkrz_dc";  // unique id for this script to talk to the data cow with.

//////////////

// global variables.

integer private_chat_channel;  // where sub-jaunters communicate with root.
integer conveyance_mode;  /// = TWO_WAY_TRIP;
    // default is a standard two way trip, there and back again.  note that the object
    // will fail to return if any lands in between are blocking object entry.  those
    // situations should use an auto-rez jaunter, which is specified by prefixing the
    // target vectors with AR.
integer last_verification_state;  // the verification state of the last destination we asked for.
string last_pathway;  // similar, but the last pathway we heard.
integer current_target_index;  // the location in the list that we would currently jaunt to.

integer good_destinations;  // computed during the recon process.

// jaunter target configuration...
list global_names;  // the names for each destination.

// jaunt trip variables...
vector eventual_destination;  // where we're headed, if we're headed anywhere.
integer slackness_counter;  // snoozes had while waiting for destination.
list full_journey;  // the full pathway we expect to jaunt on.
integer jaunt_responses_awaited;  // number of pending jumps in progress.

// root jaunter variables...
integer child_needs_setup;
    // true when a child has been rezzed and still needs to be filled with the script.

integer recon_started_yet = FALSE;
    // true if we've finished running through the reconnaissance process yet.

//////////////

// makes our click action change to the type requested, and sends the request
// out to all our sub-prims also.
set_click_action(integer action)
{
    llSetClickAction(action);
    // secret message to other prims to change click action.
    llMessageLinked(LINK_SET, CHANGE_CLICK_ACTION_HUFFWARE_ID, "", (string)action);
}

integer random_channel() { return -(integer)(llFrand(40000) + 20000); }

// show the list of options for someone who used the click-hold feature.
show_jaunt_menu(key last_toucher)
{
    llMessageLinked(LINK_THIS, MENUTINI_HUFFWARE_ID, SHOW_MENU_COMMAND,
        "jm" + HUFFWARE_PARM_SEPARATOR
        + "Jaunt to..." + HUFFWARE_PARM_SEPARATOR
        + wrap_item_list(global_names)
        + HUFFWARE_PARM_SEPARATOR
        + (string)random_channel() + HUFFWARE_PARM_SEPARATOR
        + (string)last_toucher);
}

// respond to the user's choice.
react_to_menu(string which_choice)
{
    integer indy;
    // find the specified destination and select it.
    indy = llListFindList(global_names, [which_choice]);
    if (indy >= 0) {
        current_target_index = indy;
        select_destination(current_target_index);
    }
}

// asks the jaunting library to take us to the target using a list of waypoints.
request_jaunt(list journey, integer forwards)
{
    // ask for a jump.
    jaunt_responses_awaited++;
    llMessageLinked(LINK_THIS, JAUNT_HUFFWARE_ID, JAUNT_LIST_COMMAND,
        wrap_item_list(journey) + HUFFWARE_PARM_SEPARATOR + (string)forwards);
    // stops the jaunter in its tracks.
    llMessageLinked(LINK_THIS, JAUNT_HUFFWARE_ID, FULL_STOP_COMMAND, ""); 
}

// this function returns TRUE if we are close enough to the "destination".
integer close_enough(vector destination)
{
    float PROXIMITY_REQUIRED = 0.1;
        // how close we must be to the target location to call it done.
        // matches current jaunting library proximity.
    return (llVecDist(llGetPos(), destination) <= PROXIMITY_REQUIRED);
}

// returns appropriate sit text for our current jaunt mode.
string sit_text()
{
    if (conveyance_mode == AUTOREZ_JAUNTER) return "Rez Ride";
    return "Jaunt";
}

// plops a new destination on the end of the lists.
add_destination(string name, string path, integer verif)
{
//    if (DEBUGGING) log_it("adding " + name + " with path " + path);
    global_names += [ name ];
    // send our new information to the data cow.  we store the information encoded as
    // two separated items, where the first element is the destination and the second
    // is the verification state.
    string new_entry = wrap_item_list([path, verif]);
    llMessageLinked(LINK_THIS, DATA_COW_HUFFWARE_ID, ADD_ITEM_COMMAND,
        wrap_parameters([name, new_entry]));
}

// sets up the initial state, if this script has just started, or it
// cleans up the state, if the script was already running.
initialize_jaunter()
{
    llSetTimerEvent(0.0);  // cancel any existing timers.

    // reset all the important variables.
    global_names = [];
    current_target_index = 0;
    good_destinations = 0;

    llSitTarget(<0, 0, 0.1>, ZERO_ROTATION);
        // set a rudimentary sit target or opensim won't give us our changed events.
    // load up an arrival sound if any exist.
    if (llGetInventoryNumber(INVENTORY_SOUND))
        llPreloadSound(llGetInventoryName(INVENTORY_SOUND, 0));
    // reset the parallel processing scripts since we've restarted.
    llMessageLinked(LINK_THIS, DATA_COW_HUFFWARE_ID, RESET_LIST_COMMAND, "");
    llMessageLinked(LINK_THIS, JAUNT_REZOLATOR_HUFFWARE_ID, RESET_REZOLATOR, "");
    
    // see if we can load our configuration from notecards and landmarks.
    // we pick a private channel that fits in between our rez parm ranges.
    private_chat_channel = (integer)randomize_within_range(-MAXIMUM_PRIV_CHAN, -1, FALSE);
    // request that all the config get loaded up.
    llMessageLinked(LINK_THIS, JAUNT_CONFIGURATION_HUFFWARE_ID, LOAD_ALL_CONFIGURATIONS,
         wrap_parameters([private_chat_channel, conveyance_mode]));
    // during a normal trip, we will make sure the notecard reading doesn't stall.
    // the recon and one way jaunters don't need this; they're temporary.
    // we allow this number of seconds before notecard reader is awol.
    llSetTimerEvent(94);

    conveyance_mode = TWO_WAY_TRIP;  // default init in opensim friendly way.

    // set up some of the object properties...
    string msg;
    if (SHOW_TEXT) msg = "?...";
    llSetText(msg, (vector)TEXT_COLOR, 1.0);  // initial floating text for jaunter.
    llSetSitText(sit_text());  // change to the proper text for our mode.
}

init_normal_runtime()
{
    child_needs_setup = FALSE;
    // listen to the general public for commands.
    llListen(0, "", NULL_KEY, "");
    // set up a root jaunter.
    recon_started_yet = FALSE;        
    llSetTimerEvent(randomize_within_range(MIN_RECON_SNOOZE, MAX_RECON_SNOOZE, FALSE));
}

// signal that we are where we were going.
proclaim_arrival()
{
    if (conveyance_mode == TWO_WAY_TRIP) {
        // sing a little song, if there's a sound to use.
        if (llGetInventoryNumber(INVENTORY_SOUND))
            llTriggerSound(llGetInventoryName(INVENTORY_SOUND, 0), 1.0);
    }
}

string verification_name(integer enumtype)
{
    if (enumtype == VERIFY_SAFE) return "ok";
    else if (enumtype == VERIFY_UNSAFE_SO_FAR) return "uhh";
    else if (enumtype == VERIFY_UNSAFE_DECIDED) return "far";
    // catch-all, including untested.
    return "?";
}

// returns true if the slackness counter awaiting things has elapsed.
integer check_for_timeout()
{
    if (slackness_counter++ > MAXIMUM_SLACKNESS) {
        // go back to the main state.  we took too long.
        log_it("timed out!");
        llUnSit(llAvatarOnSitTarget());  // don't hang onto the avatar for this error.
        llSetTimerEvent(0.0);
        return TRUE;
    }
    return FALSE;
}

//////////////

// action queue for postponed activities.  the first field held in a list item here
// is an integer action code.  the format of the remaining parameters is up to the
// caller, and they can be used as the final parameters for when the queued action
// gets handled.
list action_queue;

// looks at the action code at the head of the queue without removing the action.
integer peek_action_code()
{
    list fields = llParseString2List(llList2String(action_queue, 0), [HUFFWARE_PARM_SEPARATOR], []);
    return extract_action_code(fields);
}

// extracts the action code from a retrieved list.
integer extract_action_code(list to_parse) { return llList2Integer(to_parse, 0); }

// removes the current head of the action queue and returns it.
list pop_action_record()
{
    if (llGetListLength(action_queue) == 0) {
//        if (DEBUGGING) log_it("failure in action q: no entries.");
        return [];
    }
    list top_action = llParseString2List(llList2String(action_queue, 0), [HUFFWARE_PARM_SEPARATOR], []);
    action_queue = llDeleteSubList(action_queue, 0, 0);
    jaunt_responses_awaited--;  // one less thing to wait for.
    return top_action;
}

// adds a new action to the end of the action queue.
push_action_record(integer action, list added_parms)
{
    action_queue += [ wrap_parameters([action] + added_parms) ];
    jaunt_responses_awaited++;  // add one counter to our pending responses.
}

//////////////

string show_buffer;  // used by the destination list showing code below.

// requests a dump of all the jaunt destinations so we can show them to the user.
get_destination_records()
{
    show_buffer = "[mem " + (string)llGetFreeMemory() + "]";  // set the first line in the output.
    
    integer indy;
    for (indy = 0; indy < llGetListLength(global_names); indy++) {
        string curr = llList2String(global_names, indy);
        // ask for this destination record.
        llMessageLinked(LINK_THIS, DATA_COW_HUFFWARE_ID, TAGGED_GET_ITEM_COMMAND,
            wrap_parameters([OUR_COW_TAG, curr]));
        integer action = AQ_SHOW_DEST_RECORD;
        if (indy == llGetListLength(global_names) - 1) {
            // if it's the last item, make sure we signal that.
            action = AQ_FINISH_SHOW_DESTS;
        }
        push_action_record(action, []);
    }
}

// displays the list of destinations in normal chat that the data cow is handing us.
show_destination_record(string loc_name, string pathway, integer verif, integer action)
{
    integer MAX_CHAT = 512;  // the largest we let the buffer get before saying it.
    show_buffer += "   " + loc_name + " ("
        + verification_name(verif) + ") ↣ " + pathway;
    // if we're done, add a note about quality of targets.
    if (action == AQ_FINISH_SHOW_DESTS) {
        show_buffer += "\n  (" + (string)good_destinations + " safe & "
            + (string)(llGetListLength(global_names) - good_destinations)
            + " tough ones)";
    }
        
    // if we're done or if the string gets too big, print and reset it.
    if ( (action == AQ_FINISH_SHOW_DESTS) || (llStringLength(show_buffer) >= MAX_CHAT) ) {
        llWhisper(0, show_buffer);
        show_buffer = "";
    }
}

// returns the value of a boolean variable definition.
integer parse_bool_def(string def)
{ return !(llGetSubString(def, find_substring(def, "=") + 1, -1) == "0"); }

// processes a configuration option from the notecard.
handle_config_item(string item)
{
    item = llGetSubString(item, 1, -1);  // chop the command signifier character.
    if (is_prefix(item, "show_text")) {
        // they are controlling whether to show the text label or not.
        SHOW_TEXT = parse_bool_def(item);
    } else if (is_prefix(item, "add_name")) {
        ADD_NAME = parse_bool_def(item);
    }
}

// processes items coming from the configuration library.
consume_configuration_items(string msg, string id)
{
    list parms = llParseString2List(id, [HUFFWARE_PARM_SEPARATOR], []);
    integer mem_okay = llGetFreeMemory() >= FREE_MEM_REQUIRED;  // false if we're low on memory.
    if (!mem_okay) return;
    integer indy;
    for (indy = 0; indy < llGetListLength(parms); indy += 2) {
        string name = llList2String(parms, indy);
        if (is_prefix(name, ":")) {
            handle_config_item(name);
            indy--;  // skip back so we continue looking for destinations.
        } else {
            // this should be a normal pair of destination vector and name.
            integer verif_state = VERIFY_UNTESTED;
            // check if it's a wacky location.
            string map_coord = llList2String(parms, indy + 1);
            list chewed = chewed_destination(map_coord);
            if (outside_of_sim((vector)llList2String(chewed, 0))) {
                if (DEBUGGING) log_it("ruled map_coor " + (string)map_coord + " out of sim.");
                // make sure we consider the tp location "unsafe", since we can't run in-sim
                // reconnaissance against it.  also, we must postpone marking it until
                // the destination is listed, given current implementation.
                verif_state = VERIFY_UNSAFE_DECIDED;
            }
            add_destination(name, llList2String(parms, indy + 1), verif_state);
        }
    }
}

// handles responses about our list coming back from the data cow.
integer answer_to_the_cow(string msg, string id, list parms)
{
    string tag = llList2String(parms, 0);
    if (tag != OUR_COW_TAG) return FALSE;  // was not for us.
    parms = llDeleteSubList(parms, 0, 0);  // trim out the tag.
    list action_record = pop_action_record();
    integer actyo = extract_action_code(action_record);
    list split = llParseString2List(llList2String(parms, 1), [HUFFWARE_ITEM_SEPARATOR], []);
    if ( (actyo == AQ_SHOW_DEST_RECORD) || (actyo == AQ_FINISH_SHOW_DESTS) ) {
        show_destination_record(llList2String(parms, 0), llList2String(split, 0),
            llList2Integer(split, 1), actyo);
    } else if (actyo == AQ_CLICK_ACTION_REQUEST) {
        // make sure we're in the right mode for clicking based on how
        // many destinations we have.  if there's only one, we might as
        // well make this jaunter just go there.
        // note: just discovered that we cannot set the click action if the jaunter
        // is multiple prims.  that's totally fubar.  it means we cannot correctly
        // set the jaunter main body to show 'sit' as the option, even when jaunting
        // directly to the destination is possible.  freaking lindens.  maybe osgrid
        // will fix this someday.
        if (llGetListLength(global_names) == 1) {
            if (llList2Integer(split, 1) != VERIFY_UNSAFE_DECIDED)
                set_click_action(CLICK_ACTION_SIT);
            else
                // we have a non-local jaunter, so set up for map clicking.
                set_click_action(CLICK_ACTION_TOUCH);
        } else set_click_action(CLICK_ACTION_TOUCH);
    } else if (actyo == AQ_SELECT_DESTINATION) {
        integer verif = llList2Integer(split, 1);
        // we only switch conveyance mode if we have not been told to
        // do the one-way trip or recon.
        if (verif == VERIFY_SAFE) conveyance_mode = TWO_WAY_TRIP;
        else conveyance_mode = AUTOREZ_JAUNTER;
        llSetSitText(sit_text());  // change to the proper text for our mode.
        full_journey = [ vector_chop(llGetPos()) ] + chewed_destination(llList2String(split, 0));
        integer last_selecting_index = llList2Integer(action_record, 1);
        string destname = llList2String(global_names, last_selecting_index);
        llWhisper(0, "Next stop: " + destname);
        text_label_for_destination(destname);
        last_verification_state = verif;
        last_pathway = llList2String(split, 0);
    } else if (actyo == AQ_DONE_CONFIGURING) {
        // done with notecard reading, but we still need reconnaissance.
        // we'll do that in the normal runtime state.
        return TRUE;        
    }
    return FALSE;  // unknown request or a fall-through.
}

// asks the data cow for our current set of configured destinations and their
// requisite click actions.
request_destinations()
{
    push_action_record(AQ_CLICK_ACTION_REQUEST, []);
    llMessageLinked(LINK_THIS, DATA_COW_HUFFWARE_ID, TAGGED_GET_ITEM_COMMAND,
        wrap_parameters([OUR_COW_TAG, llList2String(global_names, 0)]));
}

// processes link messages received from support libraries.
integer handle_link_message(integer which, integer num, string msg, string id)
{
    // is it an answer about our configuration?
    if (num == JAUNT_CONFIGURATION_HUFFWARE_ID + REPLY_DISTANCE) {
        if (msg == JAUNT_CFG_DATA_EVENT) {
            // eat these configuration items we were given.
            consume_configuration_items(msg, id);
        } else if (msg == JAUNT_CFG_EOF) {
            // we have finished up on the configuration.
            completed_configuration();
        }
        return FALSE;
    }
    
    // is it a jaunting library response?
    if (num == JAUNT_HUFFWARE_ID + REPLY_DISTANCE) {
        jaunt_responses_awaited--;  // one less response being awaited.
        if (jaunt_responses_awaited < 0) {
            if (DEBUGGING) log_it("error: j-rsp-awtd<0");
            jaunt_responses_awaited = 0;
        }
        return FALSE;
    }
    
    // is it an event from the rezolator script?
    if (num == JAUNT_REZOLATOR_HUFFWARE_ID + REPLY_DISTANCE) {
        list parms = llParseString2List(id, [HUFFWARE_PARM_SEPARATOR], []);
        if (msg == REZOLATOR_EVENT_REZZED_CHILD) {
            // we know the child is ready for us now.
            child_needs_setup = FALSE;
//            if (DEBUGGING) log_it("setting journey to rez place " + vector_chop(llGetPos()));
            full_journey = [ vector_chop(llGetPos()), llList2String(parms, 0) ];
            if (DEBUGGING) log_it("heard kid is ready, helping.");
            request_jaunt(full_journey, TRUE);
            eventual_destination = (vector)llList2String(full_journey, llGetListLength(full_journey) - 1);
            llSetTimerEvent(POSITION_CHECKING_INTERVAL);
        } else if (msg == REZOLATOR_EVENT_RECON_FINISHED) {
            good_destinations = llList2Integer(parms, 0);
            if (DEBUGGING) log_it("recon finished, total=" + llGetListLength(global_names) + " good=" + good_destinations);
            request_destinations();
            select_destination(current_target_index);
        }
        return FALSE;
    }

    // is this a menu response from the user?
    if (num == MENUTINI_HUFFWARE_ID + REPLY_DISTANCE) {
        // all we care about in our parms is the choice made.
        react_to_menu(llList2String(llParseString2List(id, [HUFFWARE_PARM_SEPARATOR], []), 1));
        return FALSE;
    }
    // or maybe it's a piece of data from the data cow.
    if (num == DATA_COW_HUFFWARE_ID + REPLY_DISTANCE) {
        return answer_to_the_cow(msg, id, llParseString2List(id, [HUFFWARE_PARM_SEPARATOR], []));
    }
    // perhaps it's a click on a button.
    if (num == BUTTON_PUSHER_HUFFWARE_ID + REPLY_DISTANCE) {
        if (msg == BUTTON_PUSHED_ALERT) {
            list parms = llParseString2List(id, [HUFFWARE_PARM_SEPARATOR], []);
            if (llList2String(parms, 0) == JAUNT_NEXT_BUTTON_NAME) {
                select_next_destination();
            } else if (llList2String(parms, 0) == JAUNT_MENU_BUTTON_NAME) {
                show_jaunt_menu(llList2String(parms, 1));
            }
        }
    }

    return FALSE;
}

// make some noise about getting configured right.
completed_configuration()
{
    current_target_index = 0;  // set proper index.    
    get_destination_records();

    // set up the first destination.
    select_destination(current_target_index);

    // schedule the request asking how many destinations there are.
    request_destinations();
/*    push_action_record(AQ_CLICK_ACTION_REQUEST, []);
    llMessageLinked(LINK_THIS, DATA_COW_HUFFWARE_ID, TAGGED_GET_ITEM_COMMAND,
        wrap_parameters([OUR_COW_TAG, llList2String(global_names, 0)]));*/

    // add an item in the queue to actually begin jaunt services.
    push_action_record(AQ_DONE_CONFIGURING, []);
    llMessageLinked(LINK_THIS, DATA_COW_HUFFWARE_ID, TAGGED_GET_ITEM_COMMAND,
            wrap_parameters([OUR_COW_TAG, llList2String(global_names, 0)]));
}

// process what we hear in open chat and on our special channels.
// this function should always return FALSE unless it's been given enough info
// to enter a new state, in which case it should return true.
integer listen_to_voices(integer channel, string name, key id, string message)
{
    if (channel == 0) {
        // provide common command handling.
        if (message == SHOW_COMMAND) {
            // anyone can use this command.
            get_destination_records();
            return FALSE;
        }
        // the rest of the commands only listen to the owner.
        if (id != llGetOwner()) return FALSE;
        if (message == RESET_COMMAND) llResetScript();
        else if (message == RECON_COMMAND) {
            // if they want a recon, we'll do it right away.
            recon_started_yet = FALSE;
            // we want to reset the rezolator's state, in case it had done this before.
            llMessageLinked(LINK_THIS, JAUNT_REZOLATOR_HUFFWARE_ID, RESET_REZOLATOR, "");
            llSetTimerEvent(0.4);
        }
        return FALSE;
    }

    return FALSE;  // we do not want to go to next state; stay in current one.
}

// shows our next target for jaunting above the object.
text_label_for_destination(string target)
{
    string msg;
    if (SHOW_TEXT) {
        if (ADD_NAME) msg += llGetObjectName() + ":\n";
        msg += "↣ " + target;
    }
    llSetText(msg, (vector)TEXT_COLOR, 1.0);
}

select_next_destination()
{
    // picks the next place in the list for the destination, or wraps around.
    current_target_index++;
    if (current_target_index >= llGetListLength(global_names))
        current_target_index = 0;
    select_destination(current_target_index);
}
        
touchy_feely()
{
    // check the safety of the target and show the map if the conditions are right.
    vector check_posn = (vector)llList2String(chewed_destination(last_pathway), 0);
///    if (outside_of_sim(check_posn)) {
    /////old && (llGetListLength(global_names) == 1) ) {
        // bring up the map; maybe we can't get there from here.  definitely out of sim.
        llMapDestination(llGetRegionName(), check_posn, ZERO_VECTOR);
        proclaim_arrival();
///    }
}

// if the string "to_chew" looks like an offset vector, we return the calculated position.
// otherwise we just convert the string to a list of vectors.
list chewed_destination(string dests)
{

//hmmm: document this!!!
//      as in, we support the offset format!

    // look for our special start character for offsets.
    if (is_prefix(dests, "o"))
        return [ (vector)llDeleteSubString(dests, 0, find_substring(dests, "<") - 1) + llGetPos() ];

//        if (DEBUGGING) log_it("decided for normal jaunt instead.");        
    // jaunt to list of absolute coordinates.
    return llParseString2List(dests, [VECTOR_SEPARATOR], []);
}

// sets the current destination to the vector at "which_index".
select_destination(integer which_index)
{
    push_action_record(AQ_SELECT_DESTINATION, [which_index]);
    llMessageLinked(LINK_THIS, DATA_COW_HUFFWARE_ID, TAGGED_GET_ITEM_COMMAND,
        wrap_parameters([OUR_COW_TAG, llList2String(global_names, which_index)]));
}

// processes the timer events from normal runtime.
handle_normal_runtime_timer()
{
    if (!recon_started_yet) {
        if (DEBUGGING) log_it("moving on to recon finally.");
        llMessageLinked(LINK_THIS, JAUNT_REZOLATOR_HUFFWARE_ID, REZ_CHILD_NOW,
            wrap_parameters( [llGetInventoryName(INVENTORY_OBJECT, 1),
                RECONNAISSANCE_TRIP, private_chat_channel,
                "n",  // don't care about a particular name.
                llGetListLength(global_names),
                "n"  // no particular path.
                ]));
        recon_started_yet = TRUE;  // well, started really.                
    }
    llSetTimerEvent(0.0);  // stop coming here.
}

//////////////

//////////////
// 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, (string)debug_num + "- " + to_say);
}

///////////////

// 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;
}

// returns TRUE if the "to_check" vector is a location outside of the current sim.
integer outside_of_sim(vector to_check)
{
    return !valid_sim_value(to_check.x) || !valid_sim_value(to_check.y);
}

// returns text for a floating point number, but includes only
// two digits after the decimal point.
string float_chop(float to_show)
{
    integer mant = llAbs(llRound(to_show * 100.0) / 100);
    string neg_sign;
    if (to_show < 0.0) neg_sign = "-";
    string dec_s = (string)((llRound(to_show * 100.0) - mant * 100) / 100.0);
    dec_s = llGetSubString(llGetSubString(dec_s, find_substring(dec_s, ".") + 1, -1), 0, 2);
    // strip off all trailing zeros.
    while (llGetSubString(dec_s, -1, -1) == "0")
        dec_s = llDeleteSubString(dec_s, -1, -1);
    string to_return = neg_sign + (string)mant;
    if (llStringLength(dec_s)) to_return += "." + dec_s;
    return to_return;
}

// returns a prettier form for vector text, with chopped floats.
string vector_chop(vector to_show)
{
    return "<" + float_chop(to_show.x) + ","
        + float_chop(to_show.y) + ","
        + float_chop(to_show.z) + ">";
}

// joins a list of parameters using the parameter sentinel for the library.
string wrap_parameters(list to_flatten)
{ return llDumpList2String(to_flatten, HUFFWARE_PARM_SEPARATOR); }
//
// joins a list of sub-items using the item sentinel for the library.
string wrap_item_list(list to_wrap)
{ return llDumpList2String(to_wrap, HUFFWARE_ITEM_SEPARATOR); }

// returns a number at most "maximum" and at least "minimum".
// if "allow_negative" is TRUE, then the return may be positive or negative.
float randomize_within_range(float minimum, float maximum, integer allow_negative)
{
    if (minimum > maximum) {
        // flip the two if they are reversed.
        float temp = minimum; minimum = maximum; maximum = temp;
    }
    float to_return = minimum + llFrand(maximum - minimum);
    if (allow_negative) {
        if (llFrand(1.0) < 0.5) to_return *= -1.0;
    }
    return to_return;
}

// 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);
}

// returns the index of the first occurrence of "pattern" inside
// the "full_string".  if it is not found, then a negative number is returned.
integer find_substring(string full_string, string pattern)
{
    string full_lower = llToLower(full_string);
    return llSubStringIndex(full_lower, pattern);
}

// returns TRUE if the "prefix" string is the first part of "compare_with".
integer is_prefix(string compare_with, string prefix)
{ return find_substring(compare_with, prefix) == 0; }

//////////////
// huffware script: auto-retire, by fred huffhines, version 2.8.
// 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 scrounges for information in a notecard and looks for landmarks in
// inventory to add as destinations.
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();
        if (DEBUGGING) log_it("=> default, mem=" + (string)llGetFreeMemory());
        initialize_jaunter();
    }

    timer() {
        // config loading timed out.
        log_it("config timeout; resetting.");
        llResetScript();
    }
    
    // process the response from the noteworthy library.
    link_message(integer which, integer num, string msg, key id) {
        if (handle_link_message(which, num, msg, id)) {
            state normal_runtime;
        }
    }
    
    on_rez(integer parm) { state default; }  // start-up from scratch.
}

// the normal state is pretty calm; the jaunter just sits there waiting for
// an avatar who needs it to do something.
state normal_runtime
{
    state_entry() {
        if (DEBUGGING) log_it("=> normal");
        init_normal_runtime();
    }

    listen(integer channel, string name, key id, string message) {
        if (listen_to_voices(channel, name, id, message)) {
            // we're ready to take off now.
            state jaunting_now;
        }
    }

    timer() { handle_normal_runtime_timer(); }

    touch_end(integer total_number)
    {
        if (llDetectedLinkNumber(0) != llGetLinkNumber()) return;
        touchy_feely();
    }

    changed(integer change) {
        // always react to a change by resetting the label, in hopes we'll see
        // the targeting arrow properly.
        string destname = llList2String(global_names, current_target_index);
        text_label_for_destination(destname);
        // now do our 'real' activities for changes.
        if (change & CHANGED_INVENTORY) {
            log_it("inventory changed; restarting.");
            llResetScript();
        }
        if (!(change & CHANGED_LINK)) return;  // don't care then.
        if (llAvatarOnSitTarget() == NULL_KEY) return;  // there is no one sitting now.
        state jaunting_now;  // sweet, we're off.
    }
        
    // process the response from the menu library.
    link_message(integer which, integer num, string msg, key id) {
        handle_link_message(which, num, msg, id);
    }

    on_rez(integer parm) { state default; }  // start-up from scratch.
}

// once someone is trying to jump to a target, this state processes the request.
state jaunting_now
{
    state_entry() {
        if (DEBUGGING) log_it("=> jauntnow, posn=" + vector_chop(llGetPos()));
        jaunt_responses_awaited = 0;  // nothing pending right now.
        slackness_counter = 0;
        if (conveyance_mode == AUTOREZ_JAUNTER) {
            // we're going to create a kid, so we will not change state until we hear from it.
            child_needs_setup = TRUE;
            // give the person a vehicle to ride to the unsafe locale.  we assume the
            // one way jaunter is the first inventory item.
            llMessageLinked(LINK_THIS, JAUNT_REZOLATOR_HUFFWARE_ID, REZ_CHILD_NOW,
                wrap_parameters([llGetInventoryName(INVENTORY_OBJECT, 0),
                    ONE_WAY_TRIP, private_chat_channel,
                    llList2String(global_names, current_target_index),
                    llGetListLength(global_names),
                    llDumpList2String(full_journey, VECTOR_SEPARATOR) ]));
        } else {
//            if (DEBUGGING) log_it("now going to first locat: " + (string)full_journey);
            // patch the journey list for our most current location.
            full_journey = [ vector_chop(llGetPos()) ] + llDeleteSubList(full_journey, 0, 0);

            // most jaunters go to at least the first location...
            request_jaunt(full_journey, TRUE);
            eventual_destination = (vector)llList2String(full_journey, llGetListLength(full_journey) - 1);
            llSetTimerEvent(POSITION_CHECKING_INTERVAL);
        }
    }

    listen(integer channel, string name, key id, string message) {
        listen_to_voices(channel, name, id, message);
    }

    timer() {
        if (jaunt_responses_awaited || child_needs_setup) {
            // we are not quite there yet.
            if (check_for_timeout()) state normal_runtime;  // oops.
            return;  // not time yet.
        }
        // we got to where we were going, maybe.
        // now unseat the avatar.  this leaves her at the destination.
        llUnSit(llAvatarOnSitTarget());
        state arrived_at_target;
    }

    // process the response from the jaunting library.
    link_message(integer which, integer num, string msg, key id)
    { handle_link_message(which, num, msg, id); }

    on_rez(integer parm) { state default; }  // start-up from scratch.
}

// this state is activated when the first jaunt is complete.
state arrived_at_target
{
    state_entry() {
        if (DEBUGGING) log_it("=> arv_targ, pos=" + vector_chop(llGetPos()));
        // we are close enough; get back to work.
        jaunt_responses_awaited = 0;  // nothing pending right now.
        if ( ///(conveyance_mode != RECONNAISSANCE_TRIP) && 
        (conveyance_mode != AUTOREZ_JAUNTER) )
            llWhisper(0, "↣ " + llList2String(global_names, current_target_index));

        // we've gotten where we were going.
        proclaim_arrival();

        // reverse direction and head back without rider.
        eventual_destination = (vector)llList2String(full_journey, 0);
        request_jaunt(full_journey, FALSE);
        llSetTimerEvent(POSITION_CHECKING_INTERVAL);
        slackness_counter = 0;
    }

    timer() {
        if (jaunt_responses_awaited) {
            // we are not quite there yet.
            if (check_for_timeout()) state normal_runtime;  // oops.
            return;  // not time yet.
        }
        if (!close_enough(eventual_destination))
            log_it("far away, path okay?");
        state normal_runtime;
    }
    
    // process the response from the jaunting library.
    link_message(integer which, integer num, string msg, key id)
    { handle_link_message(which, num, msg, id); }

    on_rez(integer parm) { state default; }  // start-up from scratch.
}