====== Myriad Lite Unopposed Test2 ======

<code lsl2>
// Myriad_Lite_Unopposed_Test_2-v0.0.1-20131104.lsl
// Copyright (c) 2013 by Allen Kerensky (OSG/SL) All Rights Reserved.
// This work is dual-licensed under
// Creative Commons Attribution (CC BY) 3.0 Unported
// http://creativecommons.org/licenses/by/3.0/
// - or -
// Modified BSD License (3-clause)
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice, 
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
// * Neither the name of Myriad Lite nor the names of its contributors may be
//   used to endorse or promote products derived from this software without
//   specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The Myriad RPG System was designed, written, and illustrated by Ashok Desai
// Myriad RPG System licensed under:
// Creative Commons Attribution (CC BY) 2.0 UK: England and Wales
// http://creativecommons.org/licenses/by/2.0/uk/

// CONSTANTS - DO NOT CHANGE DURING RUN
string BASENAME = "Myriad Lite Unopposed Test2"; // base name of this script without version or date
string VERSION = "0.0.1"; // Allen Kerensky's script version
string VERSIONDATE = "20131104"; // Allen Kerensky's script yyyymmdd
integer CHANMYRIAD = -999;
integer MOD_UNOPPOSED = -1;

//////////////////////////////////////////////////////////////////////////////
// CONFIGURATION FOR THIS UNOPPOSED TEST
//
// TASK
// A descriptive name for the task
string TASK="Unlock the Locked Door";

// RPEVENT_START - a string to send as an RPEVENT when player starts - tell all
// leave empty for no RPEVENT
string RPEVENT_START = "tries to defeat the lock of an electronically-locked door";

// Statistic to use for the Unopposed Test
// Power, Grace, Intellect, Spirit
// Choose the one that makes sense based on the skill required for the test
string STATISTIC = "Intellect";

// Skill to test again
// See Myriad RPG System p.53 for many sample skill ideas
string SKILL = "Electronics";

// Standard Target Numbers
// Myriad RPG System p.19
// 4 = Foolproof
// 5 = Easy
// 6 = Average
// 7 = Tricky
// 8 = Difficult
// 9 = Very Hard
// 11 = Infeasible
// 13 = Superhuman
// 15 = Godlike
// 17 = Impossible
integer TARGETNUM = 6;

// Success Actions Recipes
// These are recipes based on Myriad Lite's Link Message formats. 
// See the Myriad Lite HUD Modules, specifically the WELL module for many examples.
// Replace the | in standard link messages with a ^ for these recipes
// Separate multiple actions with commas
// Keep it short to stay in LSL message length limits
string ONSUCCESS = "OWNERSAY|You have bypassed the electronic lock and the door can be opened.";

// RPEVENT_SUCCESS - a public chat message this object will say if a player succeeds.
// Leave empty for no RPEVENT event message
string RPEVENT_SUCCESS = "bypassed the door's electronic lock.";

// Success Actions Recipes
// These are recipes based on Myriad Lite's Link Message formats. 
// See the Myriad Lite HUD Modules, specifically the WELL module for many examples.
// Replace the | in standard link messages with a ^ for these recipes
// Separate multiple actions with commas
// Keep it short to stay in LSL message length limits
string ONFAIL = "OWNERSAY|You did not bypass the electronic door lock.";

// RPEVENT_FAIL - a public chat message this object will say if a player fails the task
// Leave empty for no RPEVENT message
string RPEVENT_FAIL = "failed to bypass the door's electronic lock";

// RETRIES
// TRUE or FALSE, retries are allowed
integer RETRIES = TRUE;

// TIME BETWEEN TRIES
// Number of seconds between retries
integer RETRYTIME = 10; // 10 minutes is usually good
string WAITMESSAGE = "You must wait 10 seconds between retries.";

// MAX RETRIES
// Max times before
integer MAX_RETRIES = 10;
string MORETRIES = "You can retry bypassing this lock.";
string NOMORETRIES = "The lock electronics short out and can no longer be bypassed.";

//////////////////////////////////////////////////////////////////////////////
// TEMPORARY STORAGE IN RUNTIME MEMORY
// SHOULD NOT NEED EDITING BEYOND THIS POINT.
list PLAYERS = []; // [ <playeruuid>,<timestried>,<lasttrytime> ] strided list of players accessing this task
integer HANDLE; // listenremove handle for this object's dynamic channel
integer CHANNEL; // calculated dynamic channel number for this object to listen on

// ABILITY TEST
// Requires ATTRIBUTE NAME, SKILL NAME
// Returns the ability test score for use by success fail, opposed rolls, etc
// See Myriad PDF page 18, Myriad Special Edition page 24
integer ABILITY_TEST(integer attribute,integer skill,integer modifiers) {
    integer highroll = 0; // clear out the highest roll
    while( attribute-- ) { // roll a dice for each point of the attribute
        integer roll = 1+(integer)llFrand(6.0); // roll this d6
        if ( roll > highroll) highroll = roll; // if this is highest roll so far, remember it
    } // finished rolling a dice for each point of the base attribute
    return highroll + skill + modifiers; // now, return the total of highest dice roll + skill value + modifiers
}

//
// CHECK ID to see if they pass/fail, and do retry list management - calls unopposed test
//
CHECK(key id) {    
    integer timestried; // place to hold how many times they have tried
    integer lasttime; // place to hold last time they tried
    // is player in list, get data, otherwise start data
    integer pos = llListFindList(PLAYERS,[id]); // find their current record in player list in memory
    if ( pos >= 0 ) { // they already had a record
        timestried = llList2Integer(PLAYERS,pos + 1); // get stored number of times tried
        lasttime = llList2Integer(PLAYERS,pos + 2); // get time of last try
        timestried++; // add one for this attempt
    } else { // no record so let's create and add one
        timestried = 1; // this counts as the first try
        lasttime = 0; // never tried in history
        PLAYERS = PLAYERS + [ id,timestried,lasttime ]; // add the record to the memory list
    }
    if ( timestried > MAX_RETRIES ) llInstantMessage(id,NOMORETRIES); // are they already out of tries? say so
    if ( llGetUnixTime() < ( lasttime + RETRYTIME ) ) llInstantMessage(id,WAITMESSAGE); // are they trying too soon? say so
    if ( timestried <= MAX_RETRIES && llGetUnixTime() >= ( lasttime + RETRYTIME ) ) { // if they have tries, and have waited long enough
        integer chan = (integer)("0x"+llGetSubString(id,0,6)); // calculate their player dynamic channel
        llRegionSay(chan,"UNOPPOSED_TEST2|"+TASK+"|"+STATISTIC+"|"+SKILL); // send the test request to them / their HUD
        if ( RPEVENT_START != "" ) llRegionSay(CHANMYRIAD,"RPEVENT|"+llKey2Name(id)+" "+RPEVENT_START);
    }
    // now update the player list in memory
    pos = llListFindList(PLAYERS,[id]); // where is their record, even if we just added one
    PLAYERS = llListReplaceList(PLAYERS,[id,timestried,llGetUnixTime()],pos, pos + 2); // now update the data in the player list in memory
}


DEBUG(string msg) {
    llSay(PUBLIC_CHANNEL,"DEBUG: "+msg);
}

ERROR(string msg) {
    llSay(PUBLIC_CHANNEL,"ERROR: "+msg);
}

SETUP() {
    llSetText("Easy Intellect/Electronics\nUnopposed Test2\nMyriad Lite Preview 7",<1,1,1>,1);
    
    // Setup This Object's Listener
    if ( HANDLE != 0 ) llListenRemove(HANDLE); // remove an existing handle
    CHANNEL = (integer)("0x"+llGetSubString(llGetKey(),0,6)); // calculate this object's dynamic channel number
    llListen(CHANNEL,"",NULL_KEY,""); // start a new listener on object's dynamic channel
}

// UNOPPOSED_TEST|<target number>|<stat name>|<skill name>|<CSV success actions>|<CSV fail actions>
// CSV success and fail actions are CSV lists action1[,action2[,...]]
// Each action is an embedded link message which uses ^ in place of the usual | used to separate fields
// Example Actions: SAY^<channel#>^<message_with_no_commas> , SHOUT^<channel#>,<message_with_no_commas>
// See the WELL module for a preset library of actions you can stack from, but any valid link message is possible
// FIXME This is a huge cheat and security hole as is without testing for valid actions by players vs. region owners
// Returns TRUE for Success and False for Fail
// UNOPPOSED_TEST2
// integer stat = amount of player's stat (0-10)
integer UNOPPOSED_TEST2(key id,integer stat,integer skill,integer mods) {
    //DEBUG("UNOPPOSED_TEST2 stat=["+(string)stat+"] skill=["+(string)skill+"] mods=["+(string)mods+"]");
    // FIXME check stat range - replace constants with MIN_STAT/MAX_STAT
    if ( stat < 0 || stat > 10 ) { ERROR("Invalid stat amount "+(string)stat+" in unopposed test. Ending unopposed test."); return FALSE;}
    // FIXME check skill range - replace constants with MIN_SKILL/MAX_SKILL
    if ( skill < 0 || skill > 7 ) { ERROR("Invalid skill amount "+(string)skill+" in unopposed test. Ending unopposed test."); return FALSE;}
    // FIXME check tskill
    integer check = ABILITY_TEST(stat,skill,mods); // calculate the player's ability test value
    integer result = FALSE;
    string acts = "" ;
    string rpevent = "";
    if ( check >= TARGETNUM ) {
        result = TRUE;
        acts = ONSUCCESS;
        rpevent = RPEVENT_SUCCESS;
    } else {  // player lost the ability test
        result = FALSE;
        acts = ONFAIL; // fail actions to player
        rpevent = RPEVENT_FAIL; // fail action rpevent to everyone
    }
    integer chan = (integer)("0x"+llGetSubString(id,0,6)); // calculate dynamic channel of player being tested
    llRegionSay(chan,acts);
    if ( rpevent != "" ) llRegionSay(CHANMYRIAD,"RPEVENT|"+llKey2Name(llGetOwnerKey(id))+" "+rpevent);
    return result;
}

default {
    state_entry() {
        SETUP();
    }
    
    link_message(integer sender_num,integer num,string str,key id) {
        if ( str == "UNOPPOSED_TEST2|CHECK" ) {
            CHECK(id);
        }
    }
    
    listen(integer channel,string name,key id,string message) {
        // Listen for responses from player on this objects dynamic channel
        list fields = llParseString2List(message,["|"],[]); // break into list of fields based on DIVider
        string cmd = llToUpper(llStringTrim(llList2String(fields,0),STRING_TRIM)); // assume the first field is a Myriad Lite command        
        if ( cmd == "UNOPPOSED_TEST2" ) { // UNOPPOSED_TEST2|<statamount>|<skillamount>|<modfiiers>
            integer stat = llList2Integer(fields,1);
            integer skill = llList2Integer(fields,2);
            integer mods = llList2Integer(fields,3);
            integer check = UNOPPOSED_TEST2(id,stat,skill,mods);
            if ( check == TRUE ) {
                // do more specific things if the check succeeds - unlock the door, file, etc
                llMessageLinked(LINK_THIS,MOD_UNOPPOSED,"UNOPPOSED_TEST2|SUCCESS",id);
            } else {
                // do more specific things if the check fails - set off trap, explode, sound alarm, etc
                llMessageLinked(LINK_THIS,MOD_UNOPPOSED,"UNOPPOSED_TEST2|FAILURE",id);
            }
            return;
        }
    }
    
    touch_start(integer num_detected) {
        while (num_detected--) {
            key who = llDetectedKey(num_detected); // who is clicking
            CHECK(who);
        }    
    }
}
</code>