//c#
///////////////////////////////////////////////////////////////////////////
//  Copyright (C) Wizardry and Steamworks 2011 - License: GNU GPLv3      //
//  Please see: http://www.gnu.org/licenses/gpl.html for legal details,  //
//  rights of fair usage, the disclaimer and warranty conditions.        //
///////////////////////////////////////////////////////////////////////////

LSL_Types.LSLString nQuery = "";
LSL_Types.LSLInteger nLine = 0;

string commands = "";
//pragma inline
string nName = "LOGO";

LSL_Types.Vector3 _px = new LSL_Types.Vector3(1,0,0);
LSL_Types.Vector3 _nx = new LSL_Types.Vector3(-1,0,0);
LSL_Types.Vector3 _py = new LSL_Types.Vector3(0,1,0);
LSL_Types.Vector3 _ny = new LSL_Types.Vector3(0,-1,0);
LSL_Types.Vector3 _pz = new LSL_Types.Vector3(0,0,1);
LSL_Types.Vector3 _nz = new LSL_Types.Vector3(0,0,-1);

LSL_Types.list spc = new LSL_Types.list(" ");
LSL_Types.list emp = new LSL_Types.list("");

public void default_event_state_entry()
{
    // Listen for input.
    llListen(0, "", llGetOwner(), "");
    LSL_Types.LSLInteger itra = llGetInventoryNumber(INVENTORY_NOTECARD)-1;
    do {
        if(llGetInventoryName(INVENTORY_NOTECARD, itra) == nName) {
            nQuery = llGetNotecardLine(nName, nLine);
            break;
        }
    } while(--itra>=0);
}

public void default_event_listen(LSL_Types.LSLInteger channelIn, LSL_Types.LSLString name, LSL_Types.LSLString id, LSL_Types.LSLString message) {
    parse(llParseString2List(message, spc, emp));
}

private void parse(LSL_Types.list commands) {
    if(!llGetListLength(commands)) return; // Empty list.
    
    string command = llList2String(commands, 0);
    LSL_Types.LSLInteger steps = llAbs(llList2Integer(commands,1));
    switch(command) {
        case "FR":
            front(steps);
            break;
        case "BA":
            back(steps);
            break;
        case "LE":
            left(steps);
            break;
        case "RI":
            right(steps);
            break;
        case "UP":
            up(steps);
            break;
        case "DO":
            down(steps);
            break;
        case "RR":
            rollRight(steps);
            break;
        case "RL":
            rollLeft(steps);
            break;
        case "PU":
            pitchUp(steps);
            break;
        case "PD":
            pitchDown(steps);
            break;
        case "YR":
            yawRight(steps);
            break;
        case "YL":
            yawLeft(steps);
            break;
        default:
            break;
    }
    parse(commands = llDeleteSubList(commands, 0, 0));
}

private void front(LSL_Types.LSLInteger step) {
    if(step == 0) return;
    llSetPos(llGetPos() + _px*llGetRootRotation());
    front(--step);
}

private void back(LSL_Types.LSLInteger step) {
    if(step == 0) return;
    llSetPos(llGetPos() + _nx*llGetRootRotation());
    back(--step);
}
 
private void left(LSL_Types.LSLInteger step) {
    if(step == 0) return;
    llSetPos(llGetPos() + _py*llGetRootRotation());
    front(--step);
}
 
private void right(LSL_Types.LSLInteger step) {
    if(step == 0) return;
    llSetPos(llGetPos() + _ny*llGetRootRotation());
    back(--step);
}
 
private void up(LSL_Types.LSLInteger step) {
    if(step == 0) return;
    llSetPos(llGetPos() + _pz*llGetRootRotation());
    up(--step);
}
 
private void down(LSL_Types.LSLInteger step) {
    if(step == 0) return;
    llSetPos(llGetPos() + _nz*llGetRootRotation());
    down(--step);
}
 
private void rollLeft(LSL_Types.LSLInteger degrees) {
    if(degrees == 0) return;
    llSetRot(llGetRot() / llEuler2Rot(_px * DEG_TO_RAD));
    rollLeft(--degrees);
}
 
private void rollRight(LSL_Types.LSLInteger degrees) {
    if(degrees == 0) return;
    llSetRot(llGetRot() * llEuler2Rot(_px * DEG_TO_RAD));
    rollRight(--degrees);
}
 
private void pitchUp(LSL_Types.LSLInteger degrees) {
    if(degrees == 0) return;
    llSetRot(llGetRot() / llEuler2Rot(_py * DEG_TO_RAD));
    pitchUp(--degrees);
}
 
private void pitchDown(LSL_Types.LSLInteger degrees) {
    if(degrees == 0) return;
    llSetRot(llGetRot() * llEuler2Rot(_py * DEG_TO_RAD));
    pitchDown(--degrees);
}
 
private void yawLeft(LSL_Types.LSLInteger degrees) {
    if(degrees == 0) return;
    llSetRot(llGetRot() / llEuler2Rot(_pz * DEG_TO_RAD));
    yawLeft(--degrees);
}
 
private void yawRight(LSL_Types.LSLInteger degrees) {
    if(degrees == 0) return;
    llSetRot(llGetRot() * llEuler2Rot(_pz * DEG_TO_RAD));
    yawRight(--degrees);
}