X-Git-Url: https://feistymeow.org/gitweb/?a=blobdiff_plain;f=huffware%2Fhuffotronic_tools_n_testers_v6.1%2Fbase_note_read_v0.3.txt;fp=huffware%2Fhuffotronic_tools_n_testers_v6.1%2Fbase_note_read_v0.3.txt;h=23a39dce1477f2e9242d0bab41380eccc8abecdb;hb=620a99face4f2cefadeed9ce69b4fd4f8d6e2b56;hp=0000000000000000000000000000000000000000;hpb=1fe10db9e00c16e771be0e3c4b8835b0c39553cb;p=feisty_meow.git diff --git a/huffware/huffotronic_tools_n_testers_v6.1/base_note_read_v0.3.txt b/huffware/huffotronic_tools_n_testers_v6.1/base_note_read_v0.3.txt new file mode 100755 index 00000000..23a39dce --- /dev/null +++ b/huffware/huffotronic_tools_n_testers_v6.1/base_note_read_v0.3.txt @@ -0,0 +1,217 @@ + +// add-in... huffware script: notecard library, by fred huffhines +// +// 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. +// + +// items controlled by the notecard... + +string NOTECARD_SIGNATURE = "#hoopy"; // the first line of the notecard must be this. + +string current_notecard_name = ""; // the name of the card we're reading now. +key current_query_id = NULL_KEY; // the query ID for the current notecard. +list query_contents; // the lines we have read from the notecard. +integer line_number; // which line are we at in notecard? +integer debug = FALSE; + +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. + +initialize() +{ + // we keep the same notecard name, in case it's still good. we want to + // avoid re-reading the notecard unless we see an inventory change. + current_query_id = NULL_KEY; + query_contents = []; + line_number = 0; +} + +// returns a non-empty string if "to_check" defines contents for "variable_name". +string defines_variable(string to_check, string variable_name) +{ + // clean initial spaces. + while (llGetSubString(to_check, 0, 0) == " ") + to_check = llDeleteSubString(to_check, 0, 0); + if (!is_prefix(to_check, variable_name)) return ""; + to_check = llDeleteSubString(to_check, 0, llStringLength(variable_name) - 1); + // clean any spaces or valid assignment characters. + while ( (llGetSubString(to_check, 0, 0) == " ") + || (llGetSubString(to_check, 0, 0) == "=") + || (llGetSubString(to_check, 0, 0) == ",") ) + to_check = llDeleteSubString(to_check, 0, 0); + if (debug) + log_it("set " + variable_name + " = " + to_check); + // return what's left of the string. + return to_check; +} + +parse_variable_definition(string to_parse) +{ + string content; // filled after finding a variable name. + string texture_name; // temporary used in reading texture name. + +//etc. +// if ( (content = defines_variable(to_parse, "debug")) != "") +// debug = (integer)content; + +} + +process_particle_settings(list particle_definitions) +{ + integer current_item = 0; + integer max_items = llGetListLength(particle_definitions); + while (current_item < max_items) { + string curr_line = llList2String(particle_definitions, current_item); + parse_variable_definition(curr_line); + current_item++; + } +} + +check_for_notecard() +{ + if (current_notecard_name != "") return; + current_notecard_name = llGetInventoryName(INVENTORY_NOTECARD, 0); + // if the notecard is real, then we will start reading it. + if (current_notecard_name != "") { + line_number = 0; + query_contents = []; + current_query_id = llGetNotecardLine(current_notecard_name, 0); + } +} + +////////////// +// 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); +} + +////////////// + +// 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); } + +// handles when blank strings need to come through the pipe. +string wrap_blank_string(string to_wrap) +{ + if (llStringLength(to_wrap)) return to_wrap; // that one is okay. + return "\"\""; // return a quoted nothing as a signal for a blank. +} + +// undoes a previously wrapped blank string. +string interpret_blank_string(string to_unwrap) +{ + if (to_unwrap == "\"\"") return ""; // that was an encoded blank. + return to_unwrap; // no encoding. +} + +////////////// + +// 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) +{ + float to_return = minimum + llFrand(maximum - minimum); + if (allow_negative) { + if (llFrand(1.0) < 0.5) to_return *= -1.0; + } + return to_return; +} + +// the string processing methods are not case sensitive. + +// returns TRUE if the "pattern" is found in the "full_string". +integer matches_substring(string full_string, string pattern) +{ return (find_substring(full_string, pattern) >= 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)); } + +// 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; } + +////////////// + +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(); + check_for_notecard(); + } + + changed(integer change_type) { + if (change_type != CHANGED_INVENTORY) { + // we only care about inventory changes here. + return; + } + if (current_query_id != NULL_KEY) { + // we're already reading a card right now. + return; + } + // make sure we reset the old name. + current_notecard_name = ""; + check_for_notecard(); + } + + dataserver(key query_id, string data) { + if (query_id != current_query_id) { +log_it("not our query id somehow?"); +//log_it("weird query had: " + (string)data); + return; + } + // if we're not at the end of the notecard we're reading... + if (data != EOF) { + if (!line_number) { + if (data != NOTECARD_SIGNATURE) { + // this card has the wrong signature at the top. quit bothering + // with it now. + return; + } + log_it("starting to read notecard " + current_notecard_name + "..."); + } + if (data != "") { + // add the non-blank line to our destination list. + query_contents += data; +//log_it("line " + (string)line_number + ": data=" + data); + } + line_number++; // increase the line count. + // request the next line from the notecard. + current_query_id = llGetNotecardLine(current_notecard_name, line_number); + } else { + // no more data, so we're done with this card. + current_query_id = NULL_KEY; + if (!llGetListLength(query_contents)) { + // nothing was read? the heck with this card. + current_notecard_name = ""; // toss bad card. + return; + } +log_it("notecard said:\n" + (string)(query_contents)); + log_it("done reading notecard " + current_notecard_name + "."); + } + } +} +