Isang mahabang oras ang nakalipas, sa isang blog ngayon, malayo ... maayos, ito ay naging isang mahabang oras ngunit maaaring hindi na mahaba. O marahil ito ay isang mahabang panahon. Ang post na ito ay na-upo sa pila para sa linggo ngayon at pusta ko ang Ener ay pagod ng makita ito :).

Magpatuloy sa isang simula ng tema sa "ng Mono Bytecode Pagbabahagi" , sinundan ng "Ang iyong script ay kailangan medyas" , at pagkatapos ay sa pamamagitan ng "Ilagay ang object paglalarawan sa mahusay na paggamit" , sa post na ito, kami ay tumingin sa gamit ng mga notecards para sa pag-configure ng mga pagpipilian para sa isang script.

Upang sabihin sa maikling pangungusap ang tema muli, upang i-configure ang mga script para sa maramihang mga layunin ay may hindi bababa sa dalawang pakinabang.

Notecard processing sa sl ay talagang medyo madali. Ang kaganapan na nakatuon sa likas na katangian ng LSL scripting kasama ang asynchronous pagpapatupad ng pagbabasa ng mga linya ng notecard ay maaaring nakalilito sa unang. Ngunit matapos na pag-unawa kung ano ang nangyayari, karamihan sa mga tao makitungo sa may kabutihan. At pagkatapos mong bumuo ng isang modelo, kopyahin lamang ito sa at muli.

Kaya bakit namin ginagawa ito?

Ako sa tingin gamit ang mga medyas o object paglalarawan pamamaraan ay madali ngunit may mga limitasyon kung nais mo upang suportahan ang maraming mga opsyon sa configuration. Paggamit ng notecards ay nagbibigay ng isang halos walang limitasyong pagkakataon para sa configuration.

Habang hindi isang ganap na kinakailangan, sa pangkalahatan ay marahil gusto upang makita kung ang iyong notecard umiiral bago sinusubukan na basahin ito. Maaari kang pumili upang gumawa ng mga kinakailangang o opsyonal ang notecard ang ngunit pa rin ito ay magandang malaman kung ito ay doon o hindi.

llGetInventoryType (NOTECARD)

Ang llGetInventoryType sa isang string variable na pagbibigay ng pangalan ng notecard ay kung paano maaari mong sabihin kung mayroong isang notecard sa inaasahan na pangalan sa imbentaryo bagay. Ang variable na ginamit upang tukuyin ang pangalan ng notecard ay malamang na kailangan upang maging isang global variable (na tinukoy sa itaas ng script sa labas ng anumang mga subroutines o estado). Na kinakailangan nito upang maging pandaigdigang gayon ang halaga nito ay magagamit sa loob ng mga kaganapan. Higit pa tungkol sa na mamaya. Function na ang talagang nagbalik ang alinman sa mga uri ng mga item sa ang hiniling na pangalan o isang INVENTORY_NONE bandila kung walang bagay sa pamamagitan ng pangalan na.

Isang sidenote sa aking variable pagbibigay ng pangalan ng mga balarila. Nakuha ko ito mula sa ilang mga estilo ng LSL mungkahi lugar. Para sa isang variable na ituturing ko bilang isang pare-pareho, samantalahin ko ang lahat ng mga titik sa NOTECARD. Para sa isang variable na tinukoy ko na tulad na ito ay pandaigdigang ngunit ay hindi isang constant, simulan ko ang variable na may isang maliit na "g" na sinusundan ng isang malaking titik na nagsisimula ang pangalan na naglalarawan. Para sa isang variable na hindi global ngunit lamang ang buhay sa loob ng isang subroutine o kaganapan, iwanan ako ng lahat ng maliit.

kung (llGetInventoryType (NOTECARD) == INVENTORY_NOTECARD)

Ipagpalagay ang string NOTECARD naglalaman ang ninanais na pangalan ng notecard, ito kung ang pahayag ay totoo kung ang notecard ang umiiral.

Ang llGetNotecardLine function na ang susunod na mahalagang function na.

gQuery = llGetNotecardLine (NOTECARD, gLine);

Sa halimbawang ito, NOTECARD ay pa rin ang mga string na naglalaman ng pangalan ng notecard. Ang gLine variable ay ang aktwal na linya ng notecard upang basahin at ay malamang na kailangan upang maging isang global variable. Ito ay dapat laging magsimula bilang isang zero at ay incremented sa bawat read. Kung hindi mo ang pagdagdag ito, ikaw ay patuloy na basahin ang parehong linya paulit-ulit. Ang variable ng gQuery nagbabalik ng isang natatanging key na maaaring magamit upang makilala ang data na iyon ay bumalik mula sa function na. At oo, ito ay malamang na kailangan upang maging isang global variable.

Ito ay kung saan sa LSL naiiba mula sa pinaka-mataas na mga wika sa antas na maaari mong malaman. Gusto mo normal asahan ng mga data na magagamit sa ang susunod na nanggagalaing pahayag ng pagsunod llGetNotecardLine. Tandaan ako nabanggit kaganapang hinihimok ng at asynchronous bago sa? Sa LSL, ang data ay ibinalik sa pamamagitan ng dataserver kaganapan. LSL nagbabalik ng maraming mga bagay-bagay sa pamamagitan ng ang kaganapan dataserver at na ang dahilan kung bakit kailangan naming i-save ang susi mula sa llGetNotecardLine tulad ng sa halimbawa na gumagamit ng gQuery variable sa matagal ang ibinalik na key, sa itaas.

Ang key point dito ay hindi isulat ang iyong script umaasa na read ang nangyari pagkatapos ng llGetNotecardLine ang function ay tinatawag na. Para sa karamihan ng bahagi, ang natitirang bahagi ng pagkilos ay magdadala sa lugar sa kaganapan dataserver hanggang sa ganap na tapos ka na pagbabasa ng notecard. Ang halimbawang ibinigay ay maaaring maglingkod bilang isang modelo at nagpapakita ng isang pamamaraan upang gamitin upang matulungan ang lohikal mong paghiwalayin ang processing ng data ng notecard mula sa pangunahing pag-andar ng iyong script.

Ngayon upang kaganapan dataserver. Ang unang bagay na kailangan mong gawin ay suriin na ang nag-trigger ng kaganapan ay ang isa na nagbibigay sa iyo ng notecard linya. Gawin mo ito sa pamamagitan ng pagsuri na ang mga key na ibinigay sa iyo sa kaganapan ay tumutugma sa key na na-save mo mula sa huling llGetNotecardLine.

dataserver (ang key query_id, string data)

Sa entry sa dataserver, variable ang naipasa bilang unang parameter ay ang susi na napupunta sa mga kaganapan at ang pangalawang variable ay ang data. Sa kaso ng isang dataserver kaganapan para llGetNotecardLine sa, ang data ay isang string na naglalaman ng notecard linya o isang indikasyon na may Wala nang higit pa linya.

kung (query_id == gQuery)

Patuloy sa aming mga halimbawa, ito ay kung ang pahayag ay totoo kung ito dataserver kaganapan ay napupunta sa huling llGetNotecardLine.

kung (data == EOF)

Kailangan namin na magkaroon ng isang paraan upang malaman na walang higit notecard data. Kung ang mga variable ng string ay naglalaman ng EOF tagapagpahiwatig (Pagtatapos ng File), doon ay hindi na data. Kaya sa halimbawang ito, ang kung pahayag ay totoo kung mayroong hindi hihigit data. Kaya ang code na napupunta sa ang pahayag na ito sa pagiging tunay na mga pangangailangan upang gawin ang anumang nais mo sa mangyayari matapos mong basahin ang lahat ng ang notecard. Minsan ito ay maaaring maging isang maliit na mapandaya mag-isip tungkol sa habang ikaw ay sa loob ang kaganapan dataserver at kung ano ang ikaw ay gonna gawin? Kung ikaw lamang ay may isang bagay na gawin marahil maaari mong lamang tumawag ng isang subroutine o kahit lamang na isama ang code inline na sumusunod ang kung pahayag. Ko nabanggit mas maaga na halimbawa ay naglalarawan ng isang paraan upang lohikal na kakalas ang notecard processing mula sa lahat ng kasunod na aktibidad. Madalas ko gawin ito sa pamamagitan ng pagbabago ng mga estado sa isang bagong estado.

sabihin magsimula;

Sa halimbawang ito, lumipat ako sa isang estado na tumawag ako imaginatively magsimula. Simulan ang bilang sa "ngayon ako ay magsimulang gamitin ang aking data". Ngunit kami ay nakakakuha ng kaunti maaga at hindi pa namin parse ang data. Kaya, kung ang tseke para sa EOF ay hindi totoo, gawin namin ang ibang bahagi ng kung at sa ibang bahagi, namin-parse ang data.

Kung mayroon kang ilang mga kumplikadong pag-parse ng gawin, maaaring ito ay-cleanest upang ilagay ito sa isang subroutine. Sa maraming mga kaso, na gagawing script ang mas madaling basahin at intindihin. Sa kasong ito lamang namin ay pagpunta sa gawin ang isang maliit na bit ng pag-parse kaya hindi namin ay tumawag ng isang subroutine na gawin ito.

Pag-parse ng isang hanay ng mga utos ay maaaring medyo kumplikado. Out sa totoong mundo, mayroong dalawang napaka lumang mga programa na nagmula sa Unix na maaaring magamit upang lumikha ng mga parsers para sa komplikadong command na input. Lex at YACC . Ang pangalan ng Lex dumating mula sa "ang leksiko analisador" at YACC ay nangangahulugang "Ngunit isa pang tagatala tagatala". Lex at YACC ay mahusay na mga kasangkapan at sila o ang kanilang mga derivatives ay ginagamit pa rin ngayon. Ngunit bukod mula sa katotohanan na Lex at YACC makabuo ng C code at hindi LSL, sila malamang na paraan sa mabigat na para sa karamihan ng pag-parse ang mga kinakailangan na kinakailangan para sa LSL. Kaya, kami diskarte sa pag-parse sa isang maliit na bit mas simple paraan.

Ang aming ng grammer ay medyo simple.

keyword = keyvalue;

Ito ay payagan ang isang pulutong ng flexibility ngunit nangangailangan ng napaka simpleng pag-parse.

Bago pagkuha ng malubhang sa pag-parse ang, nais naming gawin ang isang pares ng mga bagay. Suriin upang makita kung ang linya mula sa notecard aktwal na naglalaman ng anumang data at suriin upang makita kung ito ay isang komento. Sa halimbawa na ito namin ay gumagamit ng isang "#" sa unang posisyon sa sinabi linya ay isang komento. Ako laging isama ang kakayahan na magkaroon ng mga komento sa notecard ang bilang na ito ay isang mahusay na paraan upang sarili-dokumento ang syntax ng mga pagpipilian na gusto mo upang suportahan.

Suriin para sa isang walang laman na linya.

kung (llStringTrim (data, STRING_TRIM)! = "")

Kung ang pahayag na ito ay totoo, ang linya ay hindi blangko at patuloy naming iproseso ang mga ito. Ginamit namin llStringTrim upang alisin ang anumang mga mga blanks nangunguna at sumusunod mula sa linya sa kaso lamang ito ay may blanks, kung hindi, Ihambing sa isang null string ay hindi gumana. Dahil ginamit namin ang llStringTrim function sa loob ng kondisyon nang walang paggawa ng isang pagtatalaga, ang string ay kaliwa hindi magbabago para sa karagdagang processing.

Suriin para sa isang linya ng komento.

kung (llGetSubString (data, 0, 0)! = "#")

Kung ang pahayag na ito ay totoo, pagkatapos linya ay hindi naglalaman ng mga napiling karakter komento sa unang posisyon at patuloy kaming. Ang Ang llGetSubString tumatagal ng tatlong mga parameter. String ang gumana, ang panimulang posisyon kung saan upang simulan ang extracting ng mga character at ang pangwakas na posisyon. Ang mga posisyon ay may kaugnayan sa zero at "0, 0" ay nangangahulugang ang 1st karakter mula sa string.

Upang makatulong sa pagkakalag ng sandata isang notecard linya na may mga data ito, kami ay gamitin llSubStringIndex upang hanapin ang "=" at ";". sa aming grammer llParseString2List ay isa pang function na na maaaring magamit upang madaling-parse ang isang linya ng data sa isang listahan ng mga salita o mga string. Ngunit sa halimbawang ito, kami dumikit sa llSubStringIndex.

i = llSubStringIndex (data, "=");
j = llSubStringIndex ang (data, ";");

Ang dalawang mga function ay tumingin para sa aming dalawang separators at magtakda ng kani-kanilang mga variable ng index, i at j, sa kamag-anak na mga lokasyon sa string. Function na nagbalik ng -1 kung wala ay matatagpuan sa ang string.

kung (i == -1 | | j == -1)

Ito kung pahayag ay patunayan na natagpuan namin ang parehong ng aming mga separators. Kung ang alinman sa mga variable ay naka-set sa -1, pagkatapos namin magsulat ng isang mensahe ng error at magpatuloy upang makuha ang susunod na mga data sa card. Kung nakita namin ang parehong ng aming mga separators, at pagkatapos ay patuloy naming pag-parse ang linyang ito.

keyword = llGetSubString ng (data, 0, i-1);

Ito ay itakda ang keyword variable sa ang string na nahanap na naghahanap mula sa simula ng linya sa unang "=", hindi kabilang ang "=". Tandaan ko ang lokasyon sa string ng "=". Kami ay lamang ng paggawa ng simpleng pag-parse ng dito at hindi direkta-check para sa bawat posibleng pagkakamali ng isang tao ay maaaring gumawa. Halimbawa, ang mga tseke ay hindi direkta suriin upang makita na ang "=" dumating bago ang ";". Tumingin lang namin upang makita kung sila ay parehong sa string at makakuha ng mga ang mga substrings na batay sa kanilang lokasyon. Ito ay maaaring sabihin na makakakuha tayo ng basura para sa aming mga variable. Ngunit kung gayon, ang mga sumusunod na mga tseke ay mabibigo pa rin.

Baka gusto mong gawin ang ilang mga bagay upang gumawa ng grammer ang isang maliit na mas mahigpit. Halimbawa, ipalagay namin na walang puwang sa simula ng linya at bago ang "=". Upang payagan para sa posibilidad na mayroong ilang mga puwang at permit bagay na gumagana pa rin, maaari mong isama ang isang function sa drop ang sobrang agwat bago at pagkatapos ang susi salita. Gayundin, kung ang kaso ay hindi mahalaga, maaari mong isalin ang mga bagay na mas mababa kaso at pagkatapos ang lahat sa pag-aako ng code ay sa mas mababang kaso.

keyword = llStringTrim (llToLower (keyword), STRING_TRIM);

Ito ay drop nangunguna at sumusunod na puwang mula sa keyword at isalin ang string sa mas mababang kaso.

keyvalue = llGetSubString (data, i + 1, j - 1);

Susunod na namin itakda ng variable keyvalue, sa substring na nagsisimula sa unang posisyon matapos ang "=" at nagtatapos sa ang posisyon bago sa ";".

keyvalue = llStringTrim (keyvalue, STRING_TRIM);

Sa kasong ito, kami lamang alisin ang nangunguna at sumusunod na puwang. Maaari mong isalin sa mas mababang kaso ngunit maaaring may mga beses kapag ang pag-save ng mga halaga, na nais mong panatilihin ang mga kaso gaya ng tinukoy. Halimbawa, kung ikaw ay supplying ang teksto ng isang mensahe na magsulat, malamang ay nais na magbigay ng isang halo-halong halaga ng kaso.

Kaya sa puntong ito, kami tinipon ng isang mahalagang salita sa keyword variable at halaga sa variable keyvalue. Kaya, kami ay handa na upang simulan ang pagsuri at pagtatakda ng mga pagpipilian.

Mayroon kaming isang simula kung ang pahayag ay sinundan sa pamamagitan ng bilang maraming iba pa kung ang mga pahayag na kailangan namin upang ihambing ang lahat ng aming mga nais na mga keyword. Para sa anumang tugmang salita ng key, ng mga kinakailangang function na ay gumanap na may kaukulang halaga.

gSeconds = (Float) keyvalue;

Hindi namin pumunta sa bawat ng mga naghahambing ngunit ako ay ituro ang isang bagay. Halimbawa ang sa itaas ay kung saan namin kumuha ng isang bagay na basahin sa bilang isang string at convert ang mga ito sa isang lumulutang point halaga.

Mayroong isang mahalagang punto upang tandaan tungkol sa convert string sa iba pang mga uri. Kung nagsagawa ka ng isang tahasang uri ng kast tulad ng (Float) at ang string ay hindi talagang isang numerong string, LSL lamang tahimik na nagbibigay sa iyo ng isang zero. At, walang mga function upang suriin kung anong uri ng mga data ng string ay binubuo ng. Kaya, kung nais mong patunayan na ang isang tao na ipinasok sa isang string ng mga digit at hindi isang string ng mga character ng alpha, malamang ikaw ay iniwan sa constructing isang magulo function na suriin na ang mga nilalaman ng string ay ang lahat ng mga digit o digit at isang panahon. Dahil karamihan ko lumikha ng mga bagay-bagay para sa aking sarili o mga kaibigan, ko lang ipaalam sa isa na ito pumunta at isaalang-alang ang mga ito ay hindi nagkakahalaga ng pagsisikap. Kung ikaw ay lumilikha ng isang bagay upang magbenta, kailangan mong isaalang-alang lamang kung magkano sa tingin mo na kailangan mo upang protektahan ang iyong mga customer mula sa paggawa ng mga pagkakamali.

Kung mahulog namin sa pamamagitan ng kung ang pahayag at lahat ng ang iba kung ang mga pahayag sa ibang pahayag, pagkatapos kami nakatagpo ng isang susi salita / key pares ng halaga na hindi namin alam kung paano upang maproseso.

llOwnerSay ("Configuration notecard ay naglalaman ng hindi kilalang keyword sa linya" + (string) gLine + "\ n Keyword na nahanap." + keyword + "\ nCorrect ang error at i-reset.");

Upang matulungan ang mga tao matukoy ang kanilang mga error, ito ay isang magandang ideya upang bigyan ang mga ito ng mas maraming impormasyon hangga't maaari. Halimbawa na ito ay i-print ang mga keyword at halaga kasama ang mga kamag-anak na linya sa notecard. Tandaan na ang mga linya ng notecard kamag-anak sa zero. Kung ito ay pagpunta sa pagkamalian ng isang tao, maaari kang magdagdag ng isang sa notecard line variable upang makatulong sa isang tao.

Pagkatapos lubos pagproseso ng sa notecard linya na ito, kailangan namin ng isang bagong isa.

+ + GLine;
gQuery = llGetNotecardLine (NOTECARD, gLine);

Ang pagpapaandar ng llGetNotecard bumabasa ng linya na numero ng sabihin mo ito sa. Kaya kailangan muna namin sa pagdagdag ng linya ng numero na may + + gLine at pagkatapos ay tumawag sa llGetNotecardLine function na. Sa aming halimbawa, kami ngayon sa dulo ng kaganapan ng dataserver at walang ibang gawin. Kaya script ay maghintay para sa susunod na kaganapan sa nagaganap na kung saan ay malamang na maging isa pang linya ng notecard. Tulad ng nabanggit mas maaga, ang proseso na ito ay ulitin hanggang sa EOF tagapagpahiwatig ay nagbalik at lumipat kami sa ang magsimula ng estado.

Tulad ng nabanggit mas maaga, gamitin ko ang switch ng estado sa makumpleto ang pagproseso ng notecard, bilang isang paraan upang hatiin nang malinis ang lohika sa pagitan ng pagharap sa ang ng notecard at lahat ng iba pa na mangyayari na depende sa notecard. Ito ay hindi kinakailangan upang gamitin ang mga iba't ibang estado.

Tatlong key salita ay naproseso sa halimbawang ito. Sila ay segundo, debug at teksto. Ang segundo key salita ay gagamitin lamang upang ipakita ang mga conversion ng mga numerong data. Ang debug key salita ay hindi magkano alinman maliban i-print ang ilang karagdagang mga mensahe kung set sa oo. Ang teksto ng salita ng key ay ginagamit upang itakda ang lumulutang na teksto para sa mga bagay.

Halimbawa sa script din ay naglalaman ng dalawang mga kaganapan na ako ay karaniwang isama sa anumang mga script na maproseso notecards. Ang una ay ang on_rez kaganapan na ginagamit upang makita ang object ang rezzed mula sa imbentaryo at i-reset ang script kapag nangyari iyon. Ang iba pang mga kaganapan ay ang nagbago kaganapan na ginagamit upang makita ang isang pagbabago ng imbentaryo. Ang nagbago na kaganapan ay code upang maging sanhi ng isang pag-reset ng script at isang reprocessing ng notecard. Ito ay upang suportahan ang rereading ang notecard kung nagawa mo ang mga pagbabago dito.

At dahil may dalawang estado sa halimbawang ito, parehong on_rez at nagbago mga kaganapan ay code sa bawat estado. Ito ay isang downside ng pagkakaroon ng maramihang mga estado. Mga kaganapan handlers ay epektibo lamang sa estado na ito ay code in Kaya ang anumang mga kaganapan na nais mong upang mahawakan sa anumang estado ay may code sa lahat ng estado.

Ngayon para sa mga halimbawa ng code. Gaya ng dati, ang code na ito halimbawa ay gumagana para sa parehong Ikalawang Buhay at OpenSim . Isang halimbawa notecard sumusunod ang code.

// Config Demo - Notecard // // Sample code to demonstrate using a notecard to set configuration // parameters. // // Micheil Merlin - 05/18/2010 string NOTECARD = "Config"; // Configuration notecard. key gQuery; // Notecard read key. integer gLine = 0; // Notecard line to read. integer gError = FALSE; // Error status. float gSeconds = 0.0; // Seconds value from notecard. integer gDebug = FALSE; // Debug flag from notecard. string gText = ""; // Hover text from notecard. default { state_entry() { llOwnerSay("Initializing..."); // Check to see if a notecard with teh specified name is in the // object inventory. if (llGetInventoryType(NOTECARD) == INVENTORY_NOTECARD) { // If the notecard exists, get the first line. Save the key // so we can use it in the dataserver event to identify that // the event is for this notecard read. gQuery = llGetNotecardLine(NOTECARD, gLine); } else { // If no notecard exists, just switch to the begin state. // There are no configuration parameters to change. state begin; } } // When object is rezzed, reset the script. on_rez(integer num) { llResetScript(); // Reset the script. } // Use the changed event to see if the inventory has changed. We can use // this to detect that the notecard has been changed and reset the script // so the notecard can be reprocessed. There is no way to determine what // in the inventory has changed without doing some sort of processing on the // inventory. So, the script will be reset regardless of what changed in the // inventory. changed(integer change) { // If inventory has changed, assume script reset is needed. Many other // things can trigger the change event but in this case, we are only // looking for changed inventory. if (change == CHANGED_INVENTORY) { llResetScript(); // Reset the script. } } // Dataserver event to process notecard data. dataserver(key query_id, string data) { integer i; // Temp index. integer j; // Temp index. string keyword; // Configuration keyword. string keyvalue; // Configuration value. // The dataserver event is used for many things. To make sure we process // the correct data, check that the key is from the last notecard read // request. In this sample code, the dataserver event should not be // triggered for any other purpose than to present the notecard data. // But it is still a good coding practice to check to make sure // the event is what you think it is. if (query_id == gQuery) { // If 'End of File' is returned, then there is no more data. Switch // to the begin state. if (data == EOF) { state begin; } // Process the notecard data. else { // Compress out blanks and make sure the notecard line is not empty. if ( llStringTrim(data, STRING_TRIM) != "" ) { // A notecard line with a '#' in the first position is taken to be a // comment and will not be further processed. if (llGetSubString(data, 0, 0) != "#") { // If line is not a comment, get keyword and value. // The format of the data we are looking for is... // keyward=keyvalue; i = llSubStringIndex(data, "="); // Look for keyword/keyvalue separator. j = llSubStringIndex(data, ";"); // Look for end of line marker. if (i == -1 || j == -1) { // Check for 'keyword=value;' syntax. llOwnerSay("Configuration notecard contains invalid syntax at list " + (string)gLine + ". Data line follows.\n" + data + "\nCorrect the error and reset."); gError = TRUE; // Set error condition. } else { // Extract the keyword and keyvalue strings. keyword = llGetSubString(data, 0, i - 1); // Translate keyword to lower case to reduce problems from typos and // also remove leading and trailing blanks. keyword = llStringTrim(llToLower(keyword), STRING_TRIM); keyvalue = llGetSubString(data, i + 1, j - 1); // Only remove leading and trailing blanks from keyvalue. Assume // the existing case is what is intended. There may be specific // uses of keyvalue where it still may be desireable to force // everything to one case. keyvalue = llStringTrim(keyvalue, STRING_TRIM); // Process keywords in config notecard. if (keyword == "seconds") // seconds keyword. { // We don't really have anything to do with the seconds value. // We are just demonstrating translating a string from // notecard to a float. gSeconds = (float)keyvalue; // Translate value to float and save. } else if (keyword == "debug") // debug keyword. { // Here is a case where we want to force a compare to lower case // as we are using keyvalue as on on/off switch. // Also, we assume that any other reply than yes means no. If you // really want to make sure someone doesn't just typo the yes and // it is taken as no, you'd want to check for yes or no and then // indicate an error if something else was encountered. if (llToLower(keyvalue) == "yes") { gDebug = TRUE; // Set debug flag. } } else if (keyword == "text") // text keyword. { gText = keyvalue; // Set text value. } else { llOwnerSay( "Configuration notecard contains unknown keyword at line " + (string)gLine + ".\n Keyword found is " + keyword + "\nCorrect the error and reset."); gError = TRUE; // Set error condition. } } } } // Request the next notecard line. ++gLine; gQuery = llGetNotecardLine(NOTECARD, gLine); } } } } state begin { // Initialization completed. state_entry() { // Make some use of the debug flag. Normally, you'd sprinkle this through your // script printing values where ever you wanted to check that things were as // expected. if (gDebug) { llOwnerSay("Debug mode is on."); llOwnerSay("Seconds=" + (string)gSeconds + "."); llOwnerSay("Value of text is " + gText + "."); } // Check to see if the error condidition was set during configuration. We // may not want to do anything else if a configuration error occurred. if (gError == FALSE) { llOwnerSay("Ready to run."); llSetText(gText, <1.0, 1.0, 1.0>, 1.0); // Set text as requested. } else { llOwnerSay("Not ready to run."); } } // Since events are specfiic to a state, we need to duplicate the on_rez event in this // state also. on_rez(integer num) { llResetScript(); // Reset script. } // Since events are specific to a state, we need to duplicate the changed event in this // state also. changed(integer change) { // If inventory has changed, assume script reset is needed. if (change == CHANGED_INVENTORY) { llResetScript(); // Reset script. } } // Use the touch event to report what is in the settings. touch_start(integer num) { string debugstr; // Text string for debug flag. if (gDebug) // Translate debug flag to yes or no. { debugstr="yes"; } else { debugstr="no"; } llOwnerSay("Debug=" + debugstr + "."); llOwnerSay("Seconds=" + (string)gSeconds + "."); llOwnerSay("Text=" + gText + "."); } } 

Ang sumusunod ay ang text para sa isang ng notecard upang pumunta kasama ang mga ang pagkukudigo halimbawa na ito. I-paste ang teksto sa isang notecard pinangalanan config gumagana sa mga halimbawang ito.

 # Config notecard for Config Demo script. # debug may be set to yes or no. debug=yes; # This text will be used to set the floating text of the object. text=Config Demo; # Supply a numeric value for seconds. seconds=5;