X-Git-Url: https://feistymeow.org/gitweb/?a=blobdiff_plain;f=huffware%2Fhuffotronic_scripts%2Fmediatron_control_v7.2.txt;fp=huffware%2Fhuffotronic_scripts%2Fmediatron_control_v7.2.txt;h=0855fa5b3b1524f648c28e8b80f6d7094e3e443a;hb=2ad923922ef5c1e212dd45aa5074f08d54ea9371;hp=0000000000000000000000000000000000000000;hpb=1809c04b7499a188d1c2a7df3ec588bc8591a2e3;p=feisty_meow.git diff --git a/huffware/huffotronic_scripts/mediatron_control_v7.2.txt b/huffware/huffotronic_scripts/mediatron_control_v7.2.txt new file mode 100755 index 00000000..0855fa5b --- /dev/null +++ b/huffware/huffotronic_scripts/mediatron_control_v7.2.txt @@ -0,0 +1,727 @@ + +// huffware script: mediatron control, by fred huffhines. +// +// controls the mediatron device and manages menus for the user. +// when buttons are clicked, this is the script that arranges for things to +// happen. this script also processes the spoken commands from the user. +// +// 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. +// + +// configurable constants... + +integer MEDIATRON_CHANNEL = 1008; + // fairly arbitrary channel for listening. + +integer ONLY_OWNER = FALSE; + // only listen to the owner's chats? + +vector TEXT_COLOR = <0.5, 0.7, 0.92>; + // the color that the current chapter is displayed in. + +string LATEX_DRIVER_URL = "http://universalbuilds.com/tib/gif.php?l="; + // the URL for turning tex code into tibetan and english bitmaps. + +// global constants that really should stay constant... + +//////// +// link ids for flinging messages at them. +//----these are useless until the OAR link number bug is fixed. +//integer ROOT_PRIM_LINK = 1; // by SL conventions. +//integer MAIN_VIEWSCREEN_LINK = 2; // the next prim after the root is our viewer. +//integer NEXT_BUTTON_LINK = 3; +//integer PREVIOUS_BUTTON_LINK = 4; +//integer UHHH_BUTTON_LINK = 5; +//integer MENU_BUTTON_LINK = 6; +//integer BACKGROUND_PLATE_LINK = 7; // the blank whitish plank underneath the main viewscreen. +//////// + +integer DEFAULT_CHANNEL = 1008; // this must remain unchanged so we can dynamically modify help. + +// commands that can begin the line of text spoken on our special channel. +// these are also used for interchange with sub-prims, such as when a button is pushed. +string TIBETAN_CHUNK = "tib"; +string ENGLISH_CHUNK = "en"; +string NEW_LINE_CMD = "line"; +string SHOW_BUFFER_CMD = "go"; + +string NEXT_PAGE_CMD = "next"; +string PREVIOUS_PAGE_CMD = "prev"; + +string RESET_MEDIATRON_CMD = "Reset"; +string CLEAR_MEDIATRON_CMD = "Clear"; + +string OPEN_MENU_CMD = "menu"; +string CHAPTER_PICKER_CMD = "chapter"; + +string CHANNEL_CHANGE_CMD = "channel"; +string DRIVER_WEB_SITE_CMD = "urldriver"; +string LOAD_WEB_PAGE_CMD = "loadweb"; + +string TEXT_COLOR_CHANGE_CMD = "textcolor"; + +string HELP_CMD = "Help"; + +// config / control menus that we support. +string STATUS_ITEM = "Status"; +string AUTHORIZE_ITEM = "Authorize"; +string TEXT_COLOR_ITEM = "Text Color"; +string CHANNEL_ITEM = "Channel"; +string WEB_SITE_ITEM = "Driver URL"; + +// API for the viewscreen blitter library... +////////////// +integer VIEWSCREEN_BLITTER_HUFFWARE_ID = 10027; + // unique ID for the viewscreen services. +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. +// +string SHOW_URL_COMMAND = "#shurl"; + // requests the viewscreen to show a particular URL as its texture. +string RESET_VIEWSCREEN_COMMAND = "#shrz"; + // resets the viewscreen script to the default state. +string SHOW_TEXTURE_COMMAND = "#shtex"; + // displays a texture on the prim. the first parameter is the texture key or name. +////////////// + +// API for moving between the active notecards. +////////////// +// do not redefine these constants. +integer SLATE_READER_HUFFWARE_ID = 10028; + // the unique id within the huffware system for the noteworthy script to + // accept commands on. this is used in llMessageLinked as the num parameter. +////////////// +string RESET_SLATE_READER_COMMAND = "#rsslt"; + // causes the notecard information to be forgotten and the script restarted. +string SR_GET_INFORMATION_COMMAND = "#infy"; + // used by clients to ask for information about the current number of notecards + // available, and their names. this information is sent back on the huffware ID + // plus the reply distance. first parm is the number, and the rest are the names. +string SR_PLAY_CARD_COMMAND = "#playvo"; + // picks a particular notecard for reading and send the notecard's contents in a + // series of link messages, using this command and the reply distance. there are + // two parameters: an integer for the notecard number to read (from 0 through the + // number of notecards - 1) and the link number to send the messages to. +////////////// + +// the 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 pushed. +////////////// + +// menutini link message 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. + // the reply will include: the menu name, the choice made and the key for + // the avatar. +////////////// + +// global variables... + +string buffer_text; // the buffer being accumulated for display. + +integer page_number; // current page shown: ranges from zero to number of notecards - 1. + +integer maximum_notecards; // the maximum notecards that can be shown. + +list notecard_choices; // the chapters that can be chosen. + +integer listening_handle; // tracks our listening so we can change channels. + +set_viewscreen_texture() +{ + // get the video texture they want to use for the parcel. + key texture_key = llList2Key(llParcelMediaQuery([PARCEL_MEDIA_COMMAND_TEXTURE]), 0); + if (texture_key == NULL_KEY) { + // there wasn't one set yet. we can't do much about that here. we'll use the + // last inventory texture instead, which usually will be our proper image. + texture_key = llGetInventoryKey(llGetInventoryName(INVENTORY_TEXTURE, + llGetInventoryNumber(INVENTORY_TEXTURE) - 1)); + if (texture_key == NULL_KEY) return; // now we're hosed; there's no texture. + } + // set the main viewer prim to the chosen texture... + llMessageLinked(LINK_SET, VIEWSCREEN_BLITTER_HUFFWARE_ID, + SHOW_TEXTURE_COMMAND, (string)texture_key); +} + +// checks the parcel's media texture to make sure it's set. if it's not, we reset it to +// our favorite version. +fix_parcel_media_texture() +{ + // get the video texture they want to use for the parcel. + key texture_key = llList2Key(llParcelMediaQuery([PARCEL_MEDIA_COMMAND_TEXTURE]), 0); + if (texture_key == NULL_KEY) { + // there wasn't one set yet, so we need to fix that. we'll use the last inventory + // texture, which usually will be our proper image. this is a distinct chore from + // setting the viewscreen's texture, since we don't know that we have the capability + // to change the parcel media texture yet. + texture_key = llGetInventoryKey(llGetInventoryName(INVENTORY_TEXTURE, + llGetInventoryNumber(INVENTORY_TEXTURE) - 1)); + if (texture_key != NULL_KEY) { + llParcelMediaCommandList([PARCEL_MEDIA_COMMAND_TEXTURE, texture_key]); + if (llGetLandOwnerAt(llGetPos()) != llGetOwner()) { + log_it("There is a problem with the parcel media: " + + llGetObjectName() + " is not owned by the parcel owner."); + } else { + log_it("No media texture found for video on this parcel. Using default texture: " + + (string)texture_key); + } + } else { + log_it("The object does not seem to contain any textures; we need at " + + "least one for a default viewscreen image."); + } + } +} + +// asks the slate reader to find out what cards there are for us. +reload_notecards() +{ + // now we find out what's really present so we can offer a menu. + llMessageLinked(LINK_THIS, SLATE_READER_HUFFWARE_ID, + SR_GET_INFORMATION_COMMAND, ""); +} + +// fixes the viewscreen face and parcel media texture, if needed, and gets the mediatron +// ready for commands. +initialize_mediatron() +{ + fix_parcel_media_texture(); + set_viewscreen_texture(); + llSetText("", TEXT_COLOR, 0.0); + page_number = -1; + reload_notecards(); + + // listening for commands from the user. + listening_handle = llListen(MEDIATRON_CHANNEL, "", NULL_KEY, ""); + + llSay(0, "Now listening for commands on channel /" + (string)MEDIATRON_CHANNEL); +} + +// locates the space boundaries between words and returns just a list of the words, +// with no spaces remaining. +list break_on_spaces(string msg) +{ + if (!llStringLength(msg)) return []; // no length means no list. + integer indy; + list to_return; + for (indy = 0; indy < llStringLength(msg); indy++) { + integer space_posn = llSubStringIndex(msg, " "); + if (space_posn < 0) { + // no spaces left, so use the whole string. + to_return += [ msg ]; + indy = 2 * llStringLength(msg); + } else { + // we found a space. chop out the first part to add to the list and + // keep the second part for further scanning. + to_return += [ llGetSubString(msg, 0, space_posn - 1) ]; + // we also trash any additional spaces that were after the one we found. + msg = llStringTrim(llGetSubString(msg, space_posn + 1, -1), STRING_TRIM); + indy = -1; // start over at top of string. + } + } + return to_return; +} + +integer random_channel() { return -(integer)(llFrand(40000) + 20000); } + +simply_display_menu(string menu_name, string title, list buttons) +{ + integer menu_channel = random_channel(); + key listen_to = llGetOwner(); + llMessageLinked(LINK_THIS, MENUTINI_HUFFWARE_ID, SHOW_MENU_COMMAND, + menu_name + HUFFWARE_PARM_SEPARATOR + + title + HUFFWARE_PARM_SEPARATOR + + wrap_item_list(buttons) + HUFFWARE_PARM_SEPARATOR + + (string)menu_channel + HUFFWARE_PARM_SEPARATOR + + (string)listen_to); +} + +// handles when a button on the device has been clicked. +process_button_clicks(string msg, key id) +{ + if (msg != BUTTON_PUSHED_ALERT) return; // uhhhh, not sure what that was. + if (id == NEXT_PAGE_CMD) { + hear_voices(FALSE, "self", llGetOwner(), id); + } else if (id == PREVIOUS_PAGE_CMD) { + hear_voices(FALSE, "self", llGetOwner(), id); + } else if (id == CHAPTER_PICKER_CMD) { + list pruned_choices; + string list_as_block; + integer indy; + for (indy = 0; indy < llGetListLength(notecard_choices); indy++) { + string curr_name = prune_notecard_name(llList2String(notecard_choices, indy)); + pruned_choices += [ curr_name ]; + list_as_block += (string)(indy + 1) + ". " + curr_name; + if (indy < llGetListLength(notecard_choices) - 1) list_as_block += "\n"; + } + simply_display_menu(CHAPTER_PICKER_CMD, "Pick the Chapter to display...\n" + list_as_block, + pruned_choices); + } else if (id == OPEN_MENU_CMD) { + simply_display_menu(OPEN_MENU_CMD, "TibSlate Mediatron Control Menu", + [ HELP_CMD, STATUS_ITEM, AUTHORIZE_ITEM, TEXT_COLOR_ITEM, CHANNEL_ITEM, + WEB_SITE_ITEM, CLEAR_MEDIATRON_CMD, RESET_MEDIATRON_CMD ]); + } +} + +string bool_string_for_int(integer truth) +{ + if (truth) return "true"; else return "false"; +} + +tell_not_authorized() +{ + llSay(0, "The operation you have chosen can only be performed by the owner."); +} + +// handles the response message when the user chooses a button. +react_to_menu(string msg, key id) +{ + list parms = llParseString2List(id, [HUFFWARE_PARM_SEPARATOR], []); + string menu_name = llList2String(parms, 0); + string which_choice = llList2String(parms, 1); + key av_key = llList2String(parms, 2); + if (ONLY_OWNER && (av_key != llGetOwner())) { + tell_not_authorized(); + return; + } +//log_it("you clicked " + which_choice + " item for av " + av_key); + + if (menu_name == CHAPTER_PICKER_CMD) { + // find the index of the choice if we can, and make the choice be the new page. + page_number = find_similar_in_list(notecard_choices, which_choice); + play_chapter(); + return; + } else if (menu_name == OPEN_MENU_CMD) { + // show the main control menu. + if (which_choice == STATUS_ITEM) { + llSay(0, "Status...\n\tMemory Free " + (string)llGetFreeMemory() + + "\n\tListening Channel " + (string)MEDIATRON_CHANNEL + + "\n\tOwner Only? " + bool_string_for_int(ONLY_OWNER)); + return; + } else if (which_choice == AUTHORIZE_ITEM) { + if (av_key != llGetOwner()) { + // this option isn't allowed for anyone but the owner, ever. + tell_not_authorized(); + return; + } + simply_display_menu(AUTHORIZE_ITEM, "Authorization required to use device...", + [ "Any User", "Only Owner" ]); + return; + } else if (which_choice == TEXT_COLOR_ITEM) { + llSay(0, "To change the text color, say\n\t/" + + (string)MEDIATRON_CHANNEL + " " + TEXT_COLOR_CHANGE_CMD + + " \nwhere r, g, and b are the red, green and blue components of the color.\n" + + "Note that r, g & b can range from 0 to 1 inclusive."); + return; + } else if (which_choice == CHANNEL_ITEM) { + llSay(0, "To change the channel of the viewer, say\n\t/" + + (string)MEDIATRON_CHANNEL + " " + CHANNEL_CHANGE_CMD + + " N\nwhere N is a number for the new channel."); + return; + } else if (which_choice == WEB_SITE_ITEM) { + llSay(0, "Current driver web URL: " + LATEX_DRIVER_URL + + "\nTo replace this site, say:\n\t/" + + (string)MEDIATRON_CHANNEL + " " + DRIVER_WEB_SITE_CMD + + " newURL\nNote that this site must be capable of accepting LaTex code and\n" + + "converting that into simulator compatible bitmaps."); + return; + } else { + // handle all the others by just passing this on to the hear voices function. + // if it's a known command, we handle it. otherwise we bounce it off the couch. + hear_voices(FALSE, "self", llGetOwner(), which_choice); + return; + } + // the remainder of these handle the menu button's menu options... + } else if (menu_name == AUTHORIZE_ITEM) { + // they chose an option for authorization, so see if it was for only the owner. + ONLY_OWNER = is_prefix(which_choice, "only"); + llSay(0, "now, Owner Only = " + bool_string_for_int(ONLY_OWNER)); + return; + } + +log_it("i do not understand item " + which_choice + " in "+ menu_name); +} + +// processes the responses from the slate reader. +handle_slate_items(string msg, key id) +{ + if (msg == SR_PLAY_CARD_COMMAND) { + // we have gotten some data from our reader. + hear_voices(FALSE, "self", llGetOwner(), id); + } else if (msg == SR_GET_INFORMATION_COMMAND) { + list parms = llParseString2List(id, [HUFFWARE_PARM_SEPARATOR], []); + maximum_notecards = llList2Integer(parms, 0); +//log_it("got info response, num notes=" + (string)maximum_notecards); + notecard_choices = llList2List(parms, 1, -1); + } +} + +// strips off any numerical info to make a more useful notecard name. +string prune_notecard_name(string note_name) +{ + // we look at the name and remove any numbers in front, so we can avoid cluttering up the + // user facing text with the numbers that are used for ordering the notecards. + list rip_these = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", " ", "." ]; + while (llListFindList(rip_these, [ llGetSubString(note_name, 0, 0) ]) >= 0) { + // found a number or space or period. rip it off. + note_name = llDeleteSubString(note_name, 0, 0); + } + return note_name; +} + +show_chapter_name() +{ + string note_name = prune_notecard_name(llList2String(notecard_choices, page_number)); + llSetText("Page #" + (string)(page_number + 1) + + " -- " + note_name, TEXT_COLOR, 1.0); +} + +// shows the contents of the current page's notecard on the viewscreen. +play_chapter() +{ + show_chapter_name(); + llMessageLinked(LINK_THIS, SLATE_READER_HUFFWARE_ID, + SR_PLAY_CARD_COMMAND, wrap_parameters([page_number, LINK_THIS])); +} + +// tell the viewscreen to display this possible tibetan. +// spoken reports whether it's a user speaking or not. if spoken is false, then +// the voice is internal from getting notecard info or button clicks. +hear_voices(integer spoken, string name, key id, string msg) +{ + msg = llStringTrim(msg, STRING_TRIM); // toss extra spaces. + if (msg == CLEAR_MEDIATRON_CMD) { + // wipe out anything on the screen. + set_viewscreen_texture(); + buffer_text = ""; // toss out any partial buffer also. + if (spoken) llSay(0, "Clearing viewscreen."); + page_number = -1; // reset page to the spot before the first. + llSetText("", TEXT_COLOR, 0.0); + return; + } else if ( (msg == RESET_MEDIATRON_CMD) && (id == llGetOwner()) ) { + llMessageLinked(LINK_SET, VIEWSCREEN_BLITTER_HUFFWARE_ID, + RESET_VIEWSCREEN_COMMAND, ""); + llMessageLinked(LINK_THIS, SLATE_READER_HUFFWARE_ID, + RESET_SLATE_READER_COMMAND, ""); + if (spoken) llSay(0, "Resetting scripts."); + llResetScript(); + } else if (is_prefix(msg, CHANNEL_CHANGE_CMD)) { + integer new_channel = (integer)llGetSubString(msg, llStringLength(CHANNEL_CHANGE_CMD), -1); + llSay(0, "New channel is " + (string)new_channel); + MEDIATRON_CHANNEL = new_channel; + llListenRemove(listening_handle); + listening_handle = llListen(MEDIATRON_CHANNEL, "", NULL_KEY, ""); + return; + } else if (is_prefix(msg, TEXT_COLOR_CHANGE_CMD)) { + vector new_col = (vector)llGetSubString(msg, llStringLength(TEXT_COLOR_CHANGE_CMD), -1); + llSay(0, "New text color is " + (string)new_col); + TEXT_COLOR = new_col; + show_chapter_name(); + return; + } else if (is_prefix(msg, DRIVER_WEB_SITE_CMD)) { + string new_url = llGetSubString(msg, llStringLength(DRIVER_WEB_SITE_CMD), -1); + llSay(0, "New driver URL for LaTex: " + (string)new_url); + LATEX_DRIVER_URL = new_url; + return; + } else if (is_prefix(msg, NEXT_PAGE_CMD)) { + page_number++; + if (page_number >= maximum_notecards) { + page_number = 0; + } + play_chapter(); + return; + } else if (is_prefix(msg, PREVIOUS_PAGE_CMD)) { + page_number--; + if (page_number < 0) { + page_number = maximum_notecards - 1; + } + show_chapter_name(); + llMessageLinked(LINK_THIS, SLATE_READER_HUFFWARE_ID, + SR_PLAY_CARD_COMMAND, wrap_parameters([page_number, LINK_THIS])); + return; + } else if (is_prefix(msg, HELP_CMD)) { + provide_help(); + return; + } else if (is_prefix(msg, LOAD_WEB_PAGE_CMD)) { + string new_url = llGetSubString(msg, llStringLength(LOAD_WEB_PAGE_CMD), -1); + llSay(0, "Loading web site: " + (string)new_url); + llMessageLinked(LINK_SET, VIEWSCREEN_BLITTER_HUFFWARE_ID, SHOW_URL_COMMAND, new_url); + buffer_text = ""; // clear the buffer out. + } + + // now we try to process the screen buffer commands which we suspect + // are in the text that was spoken. + list sentence = break_on_spaces(msg); + string first_word = llList2String(sentence, 0); +//log_it("first word is: " + first_word); + string remainder; + integer indo; + for (indo = 1; indo < llGetListLength(sentence); indo++) { + if (indo != 1) remainder += " "; + remainder += llList2String(sentence, indo); + } +//log_it("remainder is: " + remainder); + + if (first_word == TIBETAN_CHUNK) { + if (spoken) llSay(0, "Added Tibetan: " + remainder); + buffer_text += "{\\tib " + remainder + "}{ }"; + } else if (first_word == ENGLISH_CHUNK) { + if (spoken) llSay(0, "Added English: " + remainder); + buffer_text += "{" + remainder + " }"; + } else if (first_word == NEW_LINE_CMD) { + if (spoken) llSay(0, "Inserted blank line."); + buffer_text += "{\\\\}"; + } else if (first_word == SHOW_BUFFER_CMD) { + if (spoken) llSay(0, "Displaying buffered screen."); + // reset text label since that's no longer our page. + if (spoken) llSetText("", TEXT_COLOR, 0.0); + string url = LATEX_DRIVER_URL + buffer_text; + llMessageLinked(LINK_SET, VIEWSCREEN_BLITTER_HUFFWARE_ID, SHOW_URL_COMMAND, url); + buffer_text = ""; // clear the buffer out. + } else { + // treat this as english. +//mostly redundant! + if (spoken) llSay(0, "Added English: " + first_word + " " + remainder); + buffer_text += "{" + first_word + " " + remainder + "}"; + // if we're assuming this is english, we will plug in a blank line afterwards. + // otherwise a text document will look right awful. + buffer_text += "{\\\\}"; + } +} + +// hands out any notecards with help in their names. +provide_help() +{ + integer count = llGetInventoryNumber(INVENTORY_NOTECARD); + integer indy; + list help_cards = []; + for (indy = 0; indy < count; indy++) { + string note_name = llGetInventoryName(INVENTORY_NOTECARD, indy); + if (find_substring(note_name, "help") >= 0) + help_cards += [ note_name ]; + } + + if (llGetListLength(help_cards)) llOwnerSay("Here is the built-in help file..."); + else llOwnerSay("There are currently no help notecards; sorry."); + // iterate on helper cards and give them out. + count = llGetListLength(help_cards); + for (indy = 0; indy < count; indy++) { + string note_name = llList2String(help_cards, indy); + llGiveInventory(llGetOwner(), note_name); + } +} + + +////////////// +// 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 an unusual channel for chat if it's not intended for general public. +// llSay(108, llGetScriptName() + "[" + (string)debug_num + "] " + to_say); + // say this on open chat that anyone can hear. we take off the bling for this one. +// llSay(0, to_say); +} + +////////////// + +// 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 TRUE if the "prefix" string is the first part of "compare_with". +integer is_prefix(string compare_with, string prefix) +{ return (llSubStringIndex(llToLower(compare_with), llToLower(prefix)) == 0); } + +// 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) +{ return llSubStringIndex(llToLower(full_string), llToLower(pattern)); } + +// locates the string "text" as a partial match in the list to "search_in". +integer find_similar_in_list(list search_in, string text) +{ + integer len = llGetListLength(search_in); + integer i; + for (i = 0; i < len; i++) { + if (find_substring(llList2String(search_in, i), text) >= 0) + return i; + } + return -1; +} + +////////////// +// 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 []; +} +// +////////////// + +// end hufflets. +////////////// + +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(); + initialize_mediatron(); + } + + listen(integer chan, string name, key id, string msg) { + if (chan != MEDIATRON_CHANNEL) return; // how are we even hearing that? + if (ONLY_OWNER && (id != llGetOwner())) return; // unauthorized talker. + hear_voices(TRUE, name, id, msg); + } + + on_rez(integer start_parm) { + llResetScript(); + } + + changed(integer change) { + if (change & CHANGED_INVENTORY) { + reload_notecards(); + } + } + + link_message(integer sender, integer num, string msg, key id) { + if (num == BUTTON_PUSHER_HUFFWARE_ID + REPLY_DISTANCE) { + process_button_clicks(msg, id); + return; + } + if (num == MENUTINI_HUFFWARE_ID + REPLY_DISTANCE) { + react_to_menu(msg, id); + } + + if (num != SLATE_READER_HUFFWARE_ID + REPLY_DISTANCE) return; // not for us. + handle_slate_items(msg, id); + } +} +