Major reorganizing of DotNetEngine. Moved common script engine parts to ScriptEngine.Common, only .Net-specific code in DotNetEngine. AppDomains, event handling, event execution queue and multithreading, script load/unload queue, etc has been moved to ScriptEngine.Common.

Loads of things has been put into interfaces instead of the specific class. We are now one step closer to ScriptServer, and its very easy to implement new script languages. Just a few lines required to make them a OpenSim script module with all its glory.
author: Tedd Hansen 2008-01-12 14:30:22 +0000
committer: Tedd Hansen 2008-01-12 14:30:22 +0000
commit: bacbade369a5244f9bcc611488b59f3bd4c8a564 (patch)
tree: 2cd909eff401066a69dba96615cbf736fdd73be5 /OpenSim/Region/ScriptEngine/Common
parent: * Trying something to see if it helps teleports and border crossings (diff)
download: opensim-SC-bacbade369a5244f9bcc611488b59f3bd4c8a564.zip
opensim-SC-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.gz
opensim-SC-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.bz2
opensim-SC-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.xz
11 files changed, 6864 insertions, 2 deletions
diff --git a/OpenSim/Region/ScriptEngine/Common/IScript.cs b/OpenSim/Region/ScriptEngine/Common/IScript.cs
index 08c0e9c..c94b187 100644
--- a/OpenSim/Region/ScriptEngine/Common/IScript.cs
+++ b/OpenSim/Region/ScriptEngine/Common/IScript.cs
@@ -32,5 +32,7 @@ namespace OpenSim.Region.ScriptEngine.Common
    {
        string State();
        Executor Exec { get; }
+        string Source { get; set; }
+        void Start(LSL_BuiltIn_Commands_Interface BuiltIn_Commands);
    }
 }
 \ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/LSL_BaseClass.cs b/OpenSim/Region/ScriptEngine/Common/LSL_BaseClass.cs
new file mode 100644
index 0000000..5de9a85
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/LSL_BaseClass.cs
@@ -0,0 +1,2165 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+using System;
+using System.Collections.Generic;
+using System.Runtime.Remoting.Lifetime;
+using System.Threading;
+using OpenSim.Region.ScriptEngine.Common;
+using integer = System.Int32;
+using key = System.String;
+using vector = OpenSim.Region.ScriptEngine.Common.LSL_Types.Vector3;
+using rotation = OpenSim.Region.ScriptEngine.Common.LSL_Types.Quaternion;
+namespace OpenSim.Region.ScriptEngine.Common
+{
+    public class LSL_BaseClass : MarshalByRefObject, LSL_BuiltIn_Commands_Interface, IScript
+    {
+        //
+        // Included as base for any LSL-script that is compiled.
+        // Any function added here will be accessible to the LSL script. But it must also be added to "LSL_BuiltIn_Commands_Interface" in "OpenSim.Region.ScriptEngine.Common" class.
+        //
+        // Security note: This script will be running inside an restricted AppDomain. Currently AppDomain is not very restricted.
+        //
+        // Object never expires
+        public override Object InitializeLifetimeService()
+        {
+            //Console.WriteLine("LSL_BaseClass: InitializeLifetimeService()");
+            //            return null;
+            ILease lease = (ILease)base.InitializeLifetimeService();
+            if (lease.CurrentState == LeaseState.Initial)
+            {
+                lease.InitialLeaseTime = TimeSpan.Zero; // TimeSpan.FromMinutes(1);
+                //lease.SponsorshipTimeout = TimeSpan.FromMinutes(2);
+                //lease.RenewOnCallTime = TimeSpan.FromSeconds(2);
+            }
+            return lease;
+        }
+        private Executor m_Exec;
+        Executor IScript.Exec
+        {
+            get
+            {
+                if (m_Exec == null)
+                    m_Exec = new Executor(this);
+                return m_Exec;
+            }
+        }
+        public LSL_BuiltIn_Commands_Interface m_LSL_Functions;
+        private string _Source = "";
+        public string Source
+        {
+            get
+            {
+                return _Source;
+            }
+            set { _Source = value; }
+        }
+        public LSL_BaseClass()
+        {
+        }
+        public string State()
+        {
+            return m_LSL_Functions.State();
+        }
+        public void Start(LSL_BuiltIn_Commands_Interface LSL_Functions)
+        {
+            m_LSL_Functions = LSL_Functions;
+            //MainLog.Instance.Notice("ScriptEngine", "LSL_BaseClass.Start() called.");
+            // Get this AppDomain's settings and display some of them.
+            AppDomainSetup ads = AppDomain.CurrentDomain.SetupInformation;
+            Console.WriteLine("AppName={0}, AppBase={1}, ConfigFile={2}",
+                              ads.ApplicationName,
+                              ads.ApplicationBase,
+                              ads.ConfigurationFile
+                );
+            // Display the name of the calling AppDomain and the name 
+            // of the second domain.
+            // NOTE: The application's thread has transitioned between 
+            // AppDomains.
+            Console.WriteLine("Calling to '{0}'.",
+                              Thread.GetDomain().FriendlyName
+                );
+            return;
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        // They are only forwarders to LSL_BuiltIn_Commands.cs
+        //
+        public double llSin(double f)
+        {
+            return m_LSL_Functions.llSin(f);
+        }
+        public double llCos(double f)
+        {
+            return m_LSL_Functions.llCos(f);
+        }
+        public double llTan(double f)
+        {
+            return m_LSL_Functions.llTan(f);
+        }
+        public double llAtan2(double x, double y)
+        {
+            return m_LSL_Functions.llAtan2(x, y);
+        }
+        public double llSqrt(double f)
+        {
+            return m_LSL_Functions.llSqrt(f);
+        }
+        public double llPow(double fbase, double fexponent)
+        {
+            return m_LSL_Functions.llPow(fbase, fexponent);
+        }
+        public int llAbs(int i)
+        {
+            return m_LSL_Functions.llAbs(i);
+        }
+        public double llFabs(double f)
+        {
+            return m_LSL_Functions.llFabs(f);
+        }
+        public double llFrand(double mag)
+        {
+            return m_LSL_Functions.llFrand(mag);
+        }
+        public int llFloor(double f)
+        {
+            return m_LSL_Functions.llFloor(f);
+        }
+        public int llCeil(double f)
+        {
+            return m_LSL_Functions.llCeil(f);
+        }
+        public int llRound(double f)
+        {
+            return m_LSL_Functions.llRound(f);
+        }
+        public double llVecMag(vector v)
+        {
+            return m_LSL_Functions.llVecMag(v);
+        }
+        public vector llVecNorm(vector v)
+        {
+            return m_LSL_Functions.llVecNorm(v);
+        }
+        public double llVecDist(vector a, vector b)
+        {
+            return m_LSL_Functions.llVecDist(a, b);
+        }
+        public vector llRot2Euler(rotation r)
+        {
+            return m_LSL_Functions.llRot2Euler(r);
+        }
+        public rotation llEuler2Rot(vector v)
+        {
+            return m_LSL_Functions.llEuler2Rot(v);
+        }
+        public rotation llAxes2Rot(vector fwd, vector left, vector up)
+        {
+            return m_LSL_Functions.llAxes2Rot(fwd, left, up);
+        }
+        public vector llRot2Fwd(rotation r)
+        {
+            return m_LSL_Functions.llRot2Fwd(r);
+        }
+        public vector llRot2Left(rotation r)
+        {
+            return m_LSL_Functions.llRot2Left(r);
+        }
+        public vector llRot2Up(rotation r)
+        {
+            return m_LSL_Functions.llRot2Up(r);
+        }
+        public rotation llRotBetween(vector start, vector end)
+        {
+            return m_LSL_Functions.llRotBetween(start, end);
+        }
+        public void llWhisper(int channelID, string text)
+        {
+            m_LSL_Functions.llWhisper(channelID, text);
+        }
+        public void llSay(int channelID, string text)
+        {
+            m_LSL_Functions.llSay(channelID, text);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llShout(int channelID, string text)
+        {
+            m_LSL_Functions.llShout(channelID, text);
+        }
+        public int llListen(int channelID, string name, string ID, string msg)
+        {
+            return m_LSL_Functions.llListen(channelID, name, ID, msg);
+        }
+        public void llListenControl(int number, int active)
+        {
+            m_LSL_Functions.llListenControl(number, active);
+        }
+        public void llListenRemove(int number)
+        {
+            m_LSL_Functions.llListenRemove(number);
+        }
+        public void llSensor(string name, string id, int type, double range, double arc)
+        {
+            m_LSL_Functions.llSensor(name, id, type, range, arc);
+        }
+        public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate)
+        {
+            m_LSL_Functions.llSensorRepeat(name, id, type, range, arc, rate);
+        }
+        public void llSensorRemove()
+        {
+            m_LSL_Functions.llSensorRemove();
+        }
+        public string llDetectedName(int number)
+        {
+            return m_LSL_Functions.llDetectedName(number);
+        }
+        public string llDetectedKey(int number)
+        {
+            return m_LSL_Functions.llDetectedKey(number);
+        }
+        public string llDetectedOwner(int number)
+        {
+            return m_LSL_Functions.llDetectedOwner(number);
+        }
+        public int llDetectedType(int number)
+        {
+            return m_LSL_Functions.llDetectedType(number);
+        }
+        public vector llDetectedPos(int number)
+        {
+            return m_LSL_Functions.llDetectedPos(number);
+        }
+        public vector llDetectedVel(int number)
+        {
+            return m_LSL_Functions.llDetectedVel(number);
+        }
+        public vector llDetectedGrab(int number)
+        {
+            return m_LSL_Functions.llDetectedGrab(number);
+        }
+        public rotation llDetectedRot(int number)
+        {
+            return m_LSL_Functions.llDetectedRot(number);
+        }
+        public int llDetectedGroup(int number)
+        {
+            return m_LSL_Functions.llDetectedGroup(number);
+        }
+        public int llDetectedLinkNumber(int number)
+        {
+            return m_LSL_Functions.llDetectedLinkNumber(number);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llDie()
+        {
+            m_LSL_Functions.llDie();
+        }
+        public double llGround(vector offset)
+        {
+            return m_LSL_Functions.llGround(offset);
+        }
+        public double llCloud(vector offset)
+        {
+            return m_LSL_Functions.llCloud(offset);
+        }
+        public vector llWind(vector offset)
+        {
+            return m_LSL_Functions.llWind(offset);
+        }
+        public void llSetStatus(int status, int value)
+        {
+            m_LSL_Functions.llSetStatus(status, value);
+        }
+        public int llGetStatus(int status)
+        {
+            return m_LSL_Functions.llGetStatus(status);
+        }
+        public void llSetScale(vector scale)
+        {
+            m_LSL_Functions.llSetScale(scale);
+        }
+        public vector llGetScale()
+        {
+            return m_LSL_Functions.llGetScale();
+        }
+        public void llSetColor(vector color, int face)
+        {
+            m_LSL_Functions.llSetColor(color, face);
+        }
+        public double llGetAlpha(int face)
+        {
+            return m_LSL_Functions.llGetAlpha(face);
+        }
+        public void llSetAlpha(double alpha, int face)
+        {
+            m_LSL_Functions.llSetAlpha(alpha, face);
+        }
+        public vector llGetColor(int face)
+        {
+            return m_LSL_Functions.llGetColor(face);
+        }
+        public void llSetTexture(string texture, int face)
+        {
+            m_LSL_Functions.llSetTexture(texture, face);
+        }
+        public void llScaleTexture(double u, double v, int face)
+        {
+            m_LSL_Functions.llScaleTexture(u, v, face);
+        }
+        public void llOffsetTexture(double u, double v, int face)
+        {
+            m_LSL_Functions.llOffsetTexture(u, v, face);
+        }
+        public void llRotateTexture(double rotation, int face)
+        {
+            m_LSL_Functions.llRotateTexture(rotation, face);
+        }
+        public string llGetTexture(int face)
+        {
+            return m_LSL_Functions.llGetTexture(face);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llSetPos(vector pos)
+        {
+            m_LSL_Functions.llSetPos(pos);
+        }
+        public vector llGetPos()
+        {
+            return m_LSL_Functions.llGetPos();
+        }
+        public vector llGetLocalPos()
+        {
+            return m_LSL_Functions.llGetLocalPos();
+        }
+        public void llSetRot(rotation rot)
+        {
+            m_LSL_Functions.llSetRot(rot);
+        }
+        public rotation llGetRot()
+        {
+            return m_LSL_Functions.llGetRot();
+        }
+        public rotation llGetLocalRot()
+        {
+            return m_LSL_Functions.llGetLocalRot();
+        }
+        public void llSetForce(vector force, int local)
+        {
+            m_LSL_Functions.llSetForce(force, local);
+        }
+        public vector llGetForce()
+        {
+            return m_LSL_Functions.llGetForce();
+        }
+        public int llTarget(vector position, double range)
+        {
+            return m_LSL_Functions.llTarget(position, range);
+        }
+        public void llTargetRemove(int number)
+        {
+            m_LSL_Functions.llTargetRemove(number);
+        }
+        public int llRotTarget(rotation rot, double error)
+        {
+            return m_LSL_Functions.llRotTarget(rot, error);
+        }
+        public void llRotTargetRemove(int number)
+        {
+            m_LSL_Functions.llRotTargetRemove(number);
+        }
+        public void llMoveToTarget(vector target, double tau)
+        {
+            m_LSL_Functions.llMoveToTarget(target, tau);
+        }
+        public void llStopMoveToTarget()
+        {
+            m_LSL_Functions.llStopMoveToTarget();
+        }
+        public void llApplyImpulse(vector force, int local)
+        {
+            m_LSL_Functions.llApplyImpulse(force, local);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llApplyRotationalImpulse(vector force, int local)
+        {
+            m_LSL_Functions.llApplyRotationalImpulse(force, local);
+        }
+        public void llSetTorque(vector torque, int local)
+        {
+            m_LSL_Functions.llSetTorque(torque, local);
+        }
+        public vector llGetTorque()
+        {
+            return m_LSL_Functions.llGetTorque();
+        }
+        public void llSetForceAndTorque(vector force, vector torque, int local)
+        {
+            m_LSL_Functions.llSetForceAndTorque(force, torque, local);
+        }
+        public vector llGetVel()
+        {
+            return m_LSL_Functions.llGetVel();
+        }
+        public vector llGetAccel()
+        {
+            return m_LSL_Functions.llGetAccel();
+        }
+        public vector llGetOmega()
+        {
+            return m_LSL_Functions.llGetOmega();
+        }
+        public double llGetTimeOfDay()
+        {
+            return m_LSL_Functions.llGetTimeOfDay();
+        }
+        public double llGetWallclock()
+        {
+            return m_LSL_Functions.llGetWallclock();
+        }
+        public double llGetTime()
+        {
+            return m_LSL_Functions.llGetTime();
+        }
+        public void llResetTime()
+        {
+            m_LSL_Functions.llResetTime();
+        }
+        public double llGetAndResetTime()
+        {
+            return m_LSL_Functions.llGetAndResetTime();
+        }
+        public void llSound()
+        {
+            m_LSL_Functions.llSound();
+        }
+        public void llPlaySound(string sound, double volume)
+        {
+            m_LSL_Functions.llPlaySound(sound, volume);
+        }
+        public void llLoopSound(string sound, double volume)
+        {
+            m_LSL_Functions.llLoopSound(sound, volume);
+        }
+        public void llLoopSoundMaster(string sound, double volume)
+        {
+            m_LSL_Functions.llLoopSoundMaster(sound, volume);
+        }
+        public void llLoopSoundSlave(string sound, double volume)
+        {
+            m_LSL_Functions.llLoopSoundSlave(sound, volume);
+        }
+        public void llPlaySoundSlave(string sound, double volume)
+        {
+            m_LSL_Functions.llPlaySoundSlave(sound, volume);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llTriggerSound(string sound, double volume)
+        {
+            m_LSL_Functions.llTriggerSound(sound, volume);
+        }
+        public void llStopSound()
+        {
+            m_LSL_Functions.llStopSound();
+        }
+        public void llPreloadSound(string sound)
+        {
+            m_LSL_Functions.llPreloadSound(sound);
+        }
+        public string llGetSubString(string src, int start, int end)
+        {
+            return m_LSL_Functions.llGetSubString(src, start, end);
+        }
+        public string llDeleteSubString(string src, int start, int end)
+        {
+            return m_LSL_Functions.llDeleteSubString(src, start, end);
+        }
+        public string llInsertString(string dst, int position, string src)
+        {
+            return m_LSL_Functions.llInsertString(dst, position, src);
+        }
+        public string llToUpper(string source)
+        {
+            return m_LSL_Functions.llToUpper(source);
+        }
+        public string llToLower(string source)
+        {
+            return m_LSL_Functions.llToLower(source);
+        }
+        public int llGiveMoney(string destination, int amount)
+        {
+            return m_LSL_Functions.llGiveMoney(destination, amount);
+        }
+        public void llMakeExplosion()
+        {
+            m_LSL_Functions.llMakeExplosion();
+        }
+        public void llMakeFountain()
+        {
+            m_LSL_Functions.llMakeFountain();
+        }
+        public void llMakeSmoke()
+        {
+            m_LSL_Functions.llMakeSmoke();
+        }
+        public void llMakeFire()
+        {
+            m_LSL_Functions.llMakeFire();
+        }
+        public void llRezObject(string inventory, vector pos, rotation rot, int param)
+        {
+            m_LSL_Functions.llRezObject(inventory, pos, rot, param);
+        }
+        public void llLookAt(vector target, double strength, double damping)
+        {
+            m_LSL_Functions.llLookAt(target, strength, damping);
+        }
+        public void llStopLookAt()
+        {
+            m_LSL_Functions.llStopLookAt();
+        }
+        public void llSetTimerEvent(double sec)
+        {
+            m_LSL_Functions.llSetTimerEvent(sec);
+        }
+        public void llSleep(double sec)
+        {
+            m_LSL_Functions.llSleep(sec);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public double llGetMass()
+        {
+            return m_LSL_Functions.llGetMass();
+        }
+        public void llCollisionFilter(string name, string id, int accept)
+        {
+            m_LSL_Functions.llCollisionFilter(name, id, accept);
+        }
+        public void llTakeControls(int controls, int accept, int pass_on)
+        {
+            m_LSL_Functions.llTakeControls(controls, accept, pass_on);
+        }
+        public void llReleaseControls()
+        {
+            m_LSL_Functions.llReleaseControls();
+        }
+        public void llAttachToAvatar(int attachment)
+        {
+            m_LSL_Functions.llAttachToAvatar(attachment);
+        }
+        public void llDetachFromAvatar()
+        {
+            m_LSL_Functions.llDetachFromAvatar();
+        }
+        public void llTakeCamera()
+        {
+            m_LSL_Functions.llTakeCamera();
+        }
+        public void llReleaseCamera()
+        {
+            m_LSL_Functions.llReleaseCamera();
+        }
+        public string llGetOwner()
+        {
+            return m_LSL_Functions.llGetOwner();
+        }
+        public void llInstantMessage(string user, string message)
+        {
+            m_LSL_Functions.llInstantMessage(user, message);
+        }
+        public void llEmail(string address, string subject, string message)
+        {
+            m_LSL_Functions.llEmail(address, subject, message);
+        }
+        public void llGetNextEmail(string address, string subject)
+        {
+            m_LSL_Functions.llGetNextEmail(address, subject);
+        }
+        public string llGetKey()
+        {
+            return m_LSL_Functions.llGetKey();
+        }
+        public void llSetBuoyancy(double buoyancy)
+        {
+            m_LSL_Functions.llSetBuoyancy(buoyancy);
+        }
+        public void llSetHoverHeight(double height, int water, double tau)
+        {
+            m_LSL_Functions.llSetHoverHeight(height, water, tau);
+        }
+        public void llStopHover()
+        {
+            m_LSL_Functions.llStopHover();
+        }
+        public void llMinEventDelay(double delay)
+        {
+            m_LSL_Functions.llMinEventDelay(delay);
+        }
+        public void llSoundPreload()
+        {
+            m_LSL_Functions.llSoundPreload();
+        }
+        public void llRotLookAt(rotation target, double strength, double damping)
+        {
+            m_LSL_Functions.llRotLookAt(target, strength, damping);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public int llStringLength(string str)
+        {
+            return m_LSL_Functions.llStringLength(str);
+        }
+        public void llStartAnimation(string anim)
+        {
+            m_LSL_Functions.llStartAnimation(anim);
+        }
+        public void llStopAnimation(string anim)
+        {
+            m_LSL_Functions.llStopAnimation(anim);
+        }
+        public void llPointAt()
+        {
+            m_LSL_Functions.llPointAt();
+        }
+        public void llStopPointAt()
+        {
+            m_LSL_Functions.llStopPointAt();
+        }
+        public void llTargetOmega(vector axis, double spinrate, double gain)
+        {
+            m_LSL_Functions.llTargetOmega(axis, spinrate, gain);
+        }
+        public int llGetStartParameter()
+        {
+            return m_LSL_Functions.llGetStartParameter();
+        }
+        public void llGodLikeRezObject(string inventory, vector pos)
+        {
+            m_LSL_Functions.llGodLikeRezObject(inventory, pos);
+        }
+        public void llRequestPermissions(string agent, int perm)
+        {
+            m_LSL_Functions.llRequestPermissions(agent, perm);
+        }
+        public string llGetPermissionsKey()
+        {
+            return m_LSL_Functions.llGetPermissionsKey();
+        }
+        public int llGetPermissions()
+        {
+            return m_LSL_Functions.llGetPermissions();
+        }
+        public int llGetLinkNumber()
+        {
+            return m_LSL_Functions.llGetLinkNumber();
+        }
+        public void llSetLinkColor(int linknumber, vector color, int face)
+        {
+            m_LSL_Functions.llSetLinkColor(linknumber, color, face);
+        }
+        public void llCreateLink(string target, int parent)
+        {
+            m_LSL_Functions.llCreateLink(target, parent);
+        }
+        public void llBreakLink(int linknum)
+        {
+            m_LSL_Functions.llBreakLink(linknum);
+        }
+        public void llBreakAllLinks()
+        {
+            m_LSL_Functions.llBreakAllLinks();
+        }
+        public string llGetLinkKey(int linknum)
+        {
+            return m_LSL_Functions.llGetLinkKey(linknum);
+        }
+        public string llGetLinkName(int linknum)
+        {
+            return m_LSL_Functions.llGetLinkName(linknum);
+        }
+        public int llGetInventoryNumber(int type)
+        {
+            return m_LSL_Functions.llGetInventoryNumber(type);
+        }
+        public string llGetInventoryName(int type, int number)
+        {
+            return m_LSL_Functions.llGetInventoryName(type, number);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llSetScriptState(string name, int run)
+        {
+            m_LSL_Functions.llSetScriptState(name, run);
+        }
+        public double llGetEnergy()
+        {
+            return m_LSL_Functions.llGetEnergy();
+        }
+        public void llGiveInventory(string destination, string inventory)
+        {
+            m_LSL_Functions.llGiveInventory(destination, inventory);
+        }
+        public void llRemoveInventory(string item)
+        {
+            m_LSL_Functions.llRemoveInventory(item);
+        }
+        public void llSetText(string text, vector color, double alpha)
+        {
+            m_LSL_Functions.llSetText(text, color, alpha);
+        }
+        public double llWater(vector offset)
+        {
+            return m_LSL_Functions.llWater(offset);
+        }
+        public void llPassTouches(int pass)
+        {
+            m_LSL_Functions.llPassTouches(pass);
+        }
+        public string llRequestAgentData(string id, int data)
+        {
+            return m_LSL_Functions.llRequestAgentData(id, data);
+        }
+        public string llRequestInventoryData(string name)
+        {
+            return m_LSL_Functions.llRequestInventoryData(name);
+        }
+        public void llSetDamage(double damage)
+        {
+            m_LSL_Functions.llSetDamage(damage);
+        }
+        public void llTeleportAgentHome(string agent)
+        {
+            m_LSL_Functions.llTeleportAgentHome(agent);
+        }
+        public void llModifyLand(int action, int brush)
+        {
+            m_LSL_Functions.llModifyLand(action, brush);
+        }
+        public void llCollisionSound(string impact_sound, double impact_volume)
+        {
+            m_LSL_Functions.llCollisionSound(impact_sound, impact_volume);
+        }
+        public void llCollisionSprite(string impact_sprite)
+        {
+            m_LSL_Functions.llCollisionSprite(impact_sprite);
+        }
+        public string llGetAnimation(string id)
+        {
+            return m_LSL_Functions.llGetAnimation(id);
+        }
+        public void llResetScript()
+        {
+            m_LSL_Functions.llResetScript();
+        }
+        public void llMessageLinked(int linknum, int num, string str, string id)
+        {
+            m_LSL_Functions.llMessageLinked(linknum, num, str, id);
+        }
+        public void llPushObject(string target, vector impulse, vector ang_impulse, int local)
+        {
+            m_LSL_Functions.llPushObject(target, impulse, ang_impulse, local);
+        }
+        public void llPassCollisions(int pass)
+        {
+            m_LSL_Functions.llPassCollisions(pass);
+        }
+        public string llGetScriptName()
+        {
+            return m_LSL_Functions.llGetScriptName();
+        }
+        public int llGetNumberOfSides()
+        {
+            return m_LSL_Functions.llGetNumberOfSides();
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public rotation llAxisAngle2Rot(vector axis, double angle)
+        {
+            return m_LSL_Functions.llAxisAngle2Rot(axis, angle);
+        }
+        public vector llRot2Axis(rotation rot)
+        {
+            return m_LSL_Functions.llRot2Axis(rot);
+        }
+        public void llRot2Angle()
+        {
+            m_LSL_Functions.llRot2Angle();
+        }
+        public double llAcos(double val)
+        {
+            return m_LSL_Functions.llAcos(val);
+        }
+        public double llAsin(double val)
+        {
+            return m_LSL_Functions.llAsin(val);
+        }
+        public double llAngleBetween(rotation a, rotation b)
+        {
+            return m_LSL_Functions.llAngleBetween(a, b);
+        }
+        public string llGetInventoryKey(string name)
+        {
+            return m_LSL_Functions.llGetInventoryKey(name);
+        }
+        public void llAllowInventoryDrop(int add)
+        {
+            m_LSL_Functions.llAllowInventoryDrop(add);
+        }
+        public vector llGetSunDirection()
+        {
+            return m_LSL_Functions.llGetSunDirection();
+        }
+        public vector llGetTextureOffset(int face)
+        {
+            return m_LSL_Functions.llGetTextureOffset(face);
+        }
+        public vector llGetTextureScale(int side)
+        {
+            return m_LSL_Functions.llGetTextureScale(side);
+        }
+        public double llGetTextureRot(int side)
+        {
+            return m_LSL_Functions.llGetTextureRot(side);
+        }
+        public int llSubStringIndex(string source, string pattern)
+        {
+            return m_LSL_Functions.llSubStringIndex(source, pattern);
+        }
+        public string llGetOwnerKey(string id)
+        {
+            return m_LSL_Functions.llGetOwnerKey(id);
+        }
+        public vector llGetCenterOfMass()
+        {
+            return m_LSL_Functions.llGetCenterOfMass();
+        }
+        public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending)
+        {
+            return m_LSL_Functions.llListSort(src, stride, ascending);
+        }
+        public int llGetListLength(LSL_Types.list src)
+        {
+            return m_LSL_Functions.llGetListLength(src);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public int llList2Integer(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Integer(src, index);
+        }
+        public double osList2Double(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.osList2Double(src, index);
+        }
+        public string llList2String(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2String(src, index);
+        }
+        public string llList2Key(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Key(src, index);
+        }
+        public vector llList2Vector(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Vector(src, index);
+        }
+        public rotation llList2Rot(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Rot(src, index);
+        }
+        public LSL_Types.list llList2List(LSL_Types.list src, int start, int end)
+        {
+            return m_LSL_Functions.llList2List(src, start, end);
+        }
+        public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end)
+        {
+            return m_LSL_Functions.llDeleteSubList(src, start, end);
+        }
+        public int llGetListEntryType(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llGetListEntryType(src, index);
+        }
+        public string llList2CSV(LSL_Types.list src)
+        {
+            return m_LSL_Functions.llList2CSV(src);
+        }
+        public LSL_Types.list llCSV2List(string src)
+        {
+            return m_LSL_Functions.llCSV2List(src);
+        }
+        public LSL_Types.list llListRandomize(LSL_Types.list src, int stride)
+        {
+            return m_LSL_Functions.llListRandomize(src, stride);
+        }
+        public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride)
+        {
+            return m_LSL_Functions.llList2ListStrided(src, start, end, stride);
+        }
+        public vector llGetRegionCorner()
+        {
+            return m_LSL_Functions.llGetRegionCorner();
+        }
+        public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int start)
+        {
+            return m_LSL_Functions.llListInsertList(dest, src, start);
+        }
+        public int llListFindList(LSL_Types.list src, LSL_Types.list test)
+        {
+            return m_LSL_Functions.llListFindList(src, test);
+        }
+        public string llGetObjectName()
+        {
+            return m_LSL_Functions.llGetObjectName();
+        }
+        public void llSetObjectName(string name)
+        {
+            m_LSL_Functions.llSetObjectName(name);
+        }
+        public string llGetDate()
+        {
+            return m_LSL_Functions.llGetDate();
+        }
+        public int llEdgeOfWorld(vector pos, vector dir)
+        {
+            return m_LSL_Functions.llEdgeOfWorld(pos, dir);
+        }
+        public int llGetAgentInfo(string id)
+        {
+            return m_LSL_Functions.llGetAgentInfo(id);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llAdjustSoundVolume(double volume)
+        {
+            m_LSL_Functions.llAdjustSoundVolume(volume);
+        }
+        public void llSetSoundQueueing(int queue)
+        {
+            m_LSL_Functions.llSetSoundQueueing(queue);
+        }
+        public void llSetSoundRadius(double radius)
+        {
+            m_LSL_Functions.llSetSoundRadius(radius);
+        }
+        public string llKey2Name(string id)
+        {
+            return m_LSL_Functions.llKey2Name(id);
+        }
+        public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate)
+        {
+            m_LSL_Functions.llSetTextureAnim(mode, face, sizex, sizey, start, length, rate);
+        }
+        public void llTriggerSoundLimited(string sound, double volume, vector top_north_east, vector bottom_south_west)
+        {
+            m_LSL_Functions.llTriggerSoundLimited(sound, volume, top_north_east, bottom_south_west);
+        }
+        public void llEjectFromLand(string pest)
+        {
+            m_LSL_Functions.llEjectFromLand(pest);
+        }
+        public void llParseString2List()
+        {
+            m_LSL_Functions.llParseString2List();
+        }
+        public int llOverMyLand(string id)
+        {
+            return m_LSL_Functions.llOverMyLand(id);
+        }
+        public string llGetLandOwnerAt(vector pos)
+        {
+            return m_LSL_Functions.llGetLandOwnerAt(pos);
+        }
+        public string llGetNotecardLine(string name, int line)
+        {
+            return m_LSL_Functions.llGetNotecardLine(name, line);
+        }
+        public vector llGetAgentSize(string id)
+        {
+            return m_LSL_Functions.llGetAgentSize(id);
+        }
+        public int llSameGroup(string agent)
+        {
+            return m_LSL_Functions.llSameGroup(agent);
+        }
+        public void llUnSit(string id)
+        {
+            m_LSL_Functions.llUnSit(id);
+        }
+        public vector llGroundSlope(vector offset)
+        {
+            return m_LSL_Functions.llGroundSlope(offset);
+        }
+        public vector llGroundNormal(vector offset)
+        {
+            return m_LSL_Functions.llGroundNormal(offset);
+        }
+        public vector llGroundContour(vector offset)
+        {
+            return m_LSL_Functions.llGroundContour(offset);
+        }
+        public int llGetAttached()
+        {
+            return m_LSL_Functions.llGetAttached();
+        }
+        public int llGetFreeMemory()
+        {
+            return m_LSL_Functions.llGetFreeMemory();
+        }
+        public string llGetRegionName()
+        {
+            return m_LSL_Functions.llGetRegionName();
+        }
+        public double llGetRegionTimeDilation()
+        {
+            return m_LSL_Functions.llGetRegionTimeDilation();
+        }
+        public double llGetRegionFPS()
+        {
+            return m_LSL_Functions.llGetRegionFPS();
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llParticleSystem(List<Object> rules)
+        {
+            m_LSL_Functions.llParticleSystem(rules);
+        }
+        public void llGroundRepel(double height, int water, double tau)
+        {
+            m_LSL_Functions.llGroundRepel(height, water, tau);
+        }
+        public void llGiveInventoryList()
+        {
+            m_LSL_Functions.llGiveInventoryList();
+        }
+        public void llSetVehicleType(int type)
+        {
+            m_LSL_Functions.llSetVehicleType(type);
+        }
+        public void llSetVehicledoubleParam(int param, double value)
+        {
+            m_LSL_Functions.llSetVehicledoubleParam(param, value);
+        }
+        public void llSetVehicleVectorParam(int param, vector vec)
+        {
+            m_LSL_Functions.llSetVehicleVectorParam(param, vec);
+        }
+        public void llSetVehicleRotationParam(int param, rotation rot)
+        {
+            m_LSL_Functions.llSetVehicleRotationParam(param, rot);
+        }
+        public void llSetVehicleFlags(int flags)
+        {
+            m_LSL_Functions.llSetVehicleFlags(flags);
+        }
+        public void llRemoveVehicleFlags(int flags)
+        {
+            m_LSL_Functions.llRemoveVehicleFlags(flags);
+        }
+        public void llSitTarget(vector offset, rotation rot)
+        {
+            m_LSL_Functions.llSitTarget(offset, rot);
+        }
+        public string llAvatarOnSitTarget()
+        {
+            return m_LSL_Functions.llAvatarOnSitTarget();
+        }
+        public void llAddToLandPassList(string avatar, double hours)
+        {
+            m_LSL_Functions.llAddToLandPassList(avatar, hours);
+        }
+        public void llSetTouchText(string text)
+        {
+            m_LSL_Functions.llSetTouchText(text);
+        }
+        public void llSetSitText(string text)
+        {
+            m_LSL_Functions.llSetSitText(text);
+        }
+        public void llSetCameraEyeOffset(vector offset)
+        {
+            m_LSL_Functions.llSetCameraEyeOffset(offset);
+        }
+        public void llSetCameraAtOffset(vector offset)
+        {
+            m_LSL_Functions.llSetCameraAtOffset(offset);
+        }
+        public string llDumpList2String(LSL_Types.list src, string seperator)
+        {
+            return m_LSL_Functions.llDumpList2String(src, seperator);
+        }
+        public void llScriptDanger(vector pos)
+        {
+            m_LSL_Functions.llScriptDanger(pos);
+        }
+        public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel)
+        {
+            m_LSL_Functions.llDialog(avatar, message, buttons, chat_channel);
+        }
+        public void llVolumeDetect(int detect)
+        {
+            m_LSL_Functions.llVolumeDetect(detect);
+        }
+        public void llResetOtherScript(string name)
+        {
+            m_LSL_Functions.llResetOtherScript(name);
+        }
+        public int llGetScriptState(string name)
+        {
+            return m_LSL_Functions.llGetScriptState(name);
+        }
+        public void llRemoteLoadScript()
+        {
+            m_LSL_Functions.llRemoteLoadScript();
+        }
+        public void llSetRemoteScriptAccessPin(int pin)
+        {
+            m_LSL_Functions.llSetRemoteScriptAccessPin(pin);
+        }
+        public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param)
+        {
+            m_LSL_Functions.llRemoteLoadScriptPin(target, name, pin, running, start_param);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public void llOpenRemoteDataChannel()
+        {
+            m_LSL_Functions.llOpenRemoteDataChannel();
+        }
+        public string llSendRemoteData(string channel, string dest, int idata, string sdata)
+        {
+            return m_LSL_Functions.llSendRemoteData(channel, dest, idata, sdata);
+        }
+        public void llRemoteDataReply(string channel, string message_id, string sdata, int idata)
+        {
+            m_LSL_Functions.llRemoteDataReply(channel, message_id, sdata, idata);
+        }
+        public void llCloseRemoteDataChannel(string channel)
+        {
+            m_LSL_Functions.llCloseRemoteDataChannel(channel);
+        }
+        public string llMD5String(string src, int nonce)
+        {
+            return m_LSL_Functions.llMD5String(src, nonce);
+        }
+        public void llSetPrimitiveParams(LSL_Types.list rules)
+        {
+            m_LSL_Functions.llSetPrimitiveParams(rules);
+        }
+        public string llStringToBase64(string str)
+        {
+            return m_LSL_Functions.llStringToBase64(str);
+        }
+        public string llBase64ToString(string str)
+        {
+            return m_LSL_Functions.llBase64ToString(str);
+        }
+        public void llXorBase64Strings()
+        {
+            m_LSL_Functions.llXorBase64Strings();
+        }
+        public void llRemoteDataSetRegion()
+        {
+            m_LSL_Functions.llRemoteDataSetRegion();
+        }
+        public double llLog10(double val)
+        {
+            return m_LSL_Functions.llLog10(val);
+        }
+        public double llLog(double val)
+        {
+            return m_LSL_Functions.llLog(val);
+        }
+        public LSL_Types.list llGetAnimationList(string id)
+        {
+            return m_LSL_Functions.llGetAnimationList(id);
+        }
+        public void llSetParcelMusicURL(string url)
+        {
+            m_LSL_Functions.llSetParcelMusicURL(url);
+        }
+        public vector llGetRootPosition()
+        {
+            return m_LSL_Functions.llGetRootPosition();
+        }
+        public rotation llGetRootRotation()
+        {
+            return m_LSL_Functions.llGetRootRotation();
+        }
+        public string llGetObjectDesc()
+        {
+            return m_LSL_Functions.llGetObjectDesc();
+        }
+        public void llSetObjectDesc(string desc)
+        {
+            m_LSL_Functions.llSetObjectDesc(desc);
+        }
+        public string llGetCreator()
+        {
+            return m_LSL_Functions.llGetCreator();
+        }
+        public string llGetTimestamp()
+        {
+            return m_LSL_Functions.llGetTimestamp();
+        }
+        public void llSetLinkAlpha(int linknumber, double alpha, int face)
+        {
+            m_LSL_Functions.llSetLinkAlpha(linknumber, alpha, face);
+        }
+        public int llGetNumberOfPrims()
+        {
+            return m_LSL_Functions.llGetNumberOfPrims();
+        }
+        public string llGetNumberOfNotecardLines(string name)
+        {
+            return m_LSL_Functions.llGetNumberOfNotecardLines(name);
+        }
+        public LSL_Types.list llGetBoundingBox(string obj)
+        {
+            return m_LSL_Functions.llGetBoundingBox(obj);
+        }
+        public vector llGetGeometricCenter()
+        {
+            return m_LSL_Functions.llGetGeometricCenter();
+        }
+        public void llGetPrimitiveParams()
+        {
+            m_LSL_Functions.llGetPrimitiveParams();
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public string llIntegerToBase64(int number)
+        {
+            return m_LSL_Functions.llIntegerToBase64(number);
+        }
+        public int llBase64ToInteger(string str)
+        {
+            return m_LSL_Functions.llBase64ToInteger(str);
+        }
+        public double llGetGMTclock()
+        {
+            return m_LSL_Functions.llGetGMTclock();
+        }
+        public string llGetSimulatorHostname()
+        {
+            return m_LSL_Functions.llGetSimulatorHostname();
+        }
+        public void llSetLocalRot(rotation rot)
+        {
+            m_LSL_Functions.llSetLocalRot(rot);
+        }
+        public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list seperators, LSL_Types.list spacers)
+        {
+            return m_LSL_Functions.llParseStringKeepNulls(src, seperators, spacers);
+        }
+        public void llRezAtRoot(string inventory, vector position, vector velocity, rotation rot, int param)
+        {
+            m_LSL_Functions.llRezAtRoot(inventory, position, velocity, rot, param);
+        }
+        public int llGetObjectPermMask(int mask)
+        {
+            return m_LSL_Functions.llGetObjectPermMask(mask);
+        }
+        public void llSetObjectPermMask(int mask, int value)
+        {
+            m_LSL_Functions.llSetObjectPermMask(mask, value);
+        }
+        public void llGetInventoryPermMask(string item, int mask)
+        {
+            m_LSL_Functions.llGetInventoryPermMask(item, mask);
+        }
+        public void llSetInventoryPermMask(string item, int mask, int value)
+        {
+            m_LSL_Functions.llSetInventoryPermMask(item, mask, value);
+        }
+        public string llGetInventoryCreator(string item)
+        {
+            return m_LSL_Functions.llGetInventoryCreator(item);
+        }
+        public void llOwnerSay(string msg)
+        {
+            m_LSL_Functions.llOwnerSay(msg);
+        }
+        public void llRequestSimulatorData(string simulator, int data)
+        {
+            m_LSL_Functions.llRequestSimulatorData(simulator, data);
+        }
+        public void llForceMouselook(int mouselook)
+        {
+            m_LSL_Functions.llForceMouselook(mouselook);
+        }
+        public double llGetObjectMass(string id)
+        {
+            return m_LSL_Functions.llGetObjectMass(id);
+        }
+        public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end)
+        {
+            return m_LSL_Functions.llListReplaceList(dest, src, start, end);
+        }
+        public void llLoadURL(string avatar_id, string message, string url)
+        {
+            m_LSL_Functions.llLoadURL(avatar_id, message, url);
+        }
+        public void llParcelMediaCommandList(LSL_Types.list commandList)
+        {
+            m_LSL_Functions.llParcelMediaCommandList(commandList);
+        }
+        public void llParcelMediaQuery()
+        {
+            m_LSL_Functions.llParcelMediaQuery();
+        }
+        public int llModPow(int a, int b, int c)
+        {
+            return m_LSL_Functions.llModPow(a, b, c);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public int llGetInventoryType(string name)
+        {
+            return m_LSL_Functions.llGetInventoryType(name);
+        }
+        public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons)
+        {
+            m_LSL_Functions.llSetPayPrice(price, quick_pay_buttons);
+        }
+        public vector llGetCameraPos()
+        {
+            return m_LSL_Functions.llGetCameraPos();
+        }
+        public rotation llGetCameraRot()
+        {
+            return m_LSL_Functions.llGetCameraRot();
+        }
+        public void llSetPrimURL()
+        {
+            m_LSL_Functions.llSetPrimURL();
+        }
+        public void llRefreshPrimURL()
+        {
+            m_LSL_Functions.llRefreshPrimURL();
+        }
+        public string llEscapeURL(string url)
+        {
+            return m_LSL_Functions.llEscapeURL(url);
+        }
+        public string llUnescapeURL(string url)
+        {
+            return m_LSL_Functions.llUnescapeURL(url);
+        }
+        public void llMapDestination(string simname, vector pos, vector look_at)
+        {
+            m_LSL_Functions.llMapDestination(simname, pos, look_at);
+        }
+        public void llAddToLandBanList(string avatar, double hours)
+        {
+            m_LSL_Functions.llAddToLandBanList(avatar, hours);
+        }
+        public void llRemoveFromLandPassList(string avatar)
+        {
+            m_LSL_Functions.llRemoveFromLandPassList(avatar);
+        }
+        public void llRemoveFromLandBanList(string avatar)
+        {
+            m_LSL_Functions.llRemoveFromLandBanList(avatar);
+        }
+        public void llSetCameraParams(LSL_Types.list rules)
+        {
+            m_LSL_Functions.llSetCameraParams(rules);
+        }
+        public void llClearCameraParams()
+        {
+            m_LSL_Functions.llClearCameraParams();
+        }
+        public double llListStatistics(int operation, LSL_Types.list src)
+        {
+            return m_LSL_Functions.llListStatistics(operation, src);
+        }
+        public int llGetUnixTime()
+        {
+            return m_LSL_Functions.llGetUnixTime();
+        }
+        public int llGetParcelFlags(vector pos)
+        {
+            return m_LSL_Functions.llGetParcelFlags(pos);
+        }
+        public int llGetRegionFlags()
+        {
+            return m_LSL_Functions.llGetRegionFlags();
+        }
+        public string llXorBase64StringsCorrect(string str1, string str2)
+        {
+            return m_LSL_Functions.llXorBase64StringsCorrect(str1, str2);
+        }
+        public string llHTTPRequest(string url, LSL_Types.list parameters, string body)
+        {
+            return m_LSL_Functions.llHTTPRequest(url, parameters, body);
+        }
+        public void llResetLandBanList()
+        {
+            m_LSL_Functions.llResetLandBanList();
+        }
+        public void llResetLandPassList()
+        {
+            m_LSL_Functions.llResetLandPassList();
+        }
+        public int llGetParcelPrimCount(vector pos, int category, int sim_wide)
+        {
+            return m_LSL_Functions.llGetParcelPrimCount(pos, category, sim_wide);
+        }
+        public LSL_Types.list llGetParcelPrimOwners(vector pos)
+        {
+            return m_LSL_Functions.llGetParcelPrimOwners(pos);
+        }
+        public int llGetObjectPrimCount(string object_id)
+        {
+            return m_LSL_Functions.llGetObjectPrimCount(object_id);
+        }
+        //
+        // DO NOT MODIFY HERE: MODIFY IN LSL_BuiltIn_Commands.cs
+        //
+        public int llGetParcelMaxPrims(vector pos, int sim_wide)
+        {
+            return m_LSL_Functions.llGetParcelMaxPrims(pos, sim_wide);
+        }
+        public LSL_Types.list llGetParcelDetails(vector pos, LSL_Types.list param)
+        {
+            return m_LSL_Functions.llGetParcelDetails(pos, param);
+        }
+        //
+        // OpenSim Functions
+        //
+        public string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams,
+                                             int timer)
+        {
+            return m_LSL_Functions.osSetDynamicTextureURL(dynamicID, contentType, url, extraParams, timer);
+        }
+        public double osTerrainGetHeight(int x, int y)
+        {
+            return m_LSL_Functions.osTerrainGetHeight(x, y);
+        }
+        public int osTerrainSetHeight(int x, int y, double val)
+        {
+            return m_LSL_Functions.osTerrainSetHeight(x, y, val);
+        }
+        public int osRegionRestart(double seconds)
+        {
+            return m_LSL_Functions.osRegionRestart(seconds);
+        }
+        // LSL CONSTANTS
+        public const int TRUE = 1;
+        public const int FALSE = 0;
+        public const int STATUS_PHYSICS = 1;
+        public const int STATUS_ROTATE_X = 2;
+        public const int STATUS_ROTATE_Y = 4;
+        public const int STATUS_ROTATE_Z = 8;
+        public const int STATUS_PHANTOM = 16;
+        public const int STATUS_SANDBOX = 32;
+        public const int STATUS_BLOCK_GRAB = 64;
+        public const int STATUS_DIE_AT_EDGE = 128;
+        public const int STATUS_RETURN_AT_EDGE = 256;
+        public const int AGENT = 1;
+        public const int ACTIVE = 2;
+        public const int PASSIVE = 4;
+        public const int SCRIPTED = 8;
+        public const int CONTROL_FWD = 1;
+        public const int CONTROL_BACK = 2;
+        public const int CONTROL_LEFT = 4;
+        public const int CONTROL_RIGHT = 8;
+        public const int CONTROL_UP = 16;
+        public const int CONTROL_DOWN = 32;
+        public const int CONTROL_ROT_LEFT = 256;
+        public const int CONTROL_ROT_RIGHT = 512;
+        public const int CONTROL_LBUTTON = 268435456;
+        public const int CONTROL_ML_LBUTTON = 1073741824;
+        public const int PERMISSION_DEBIT = 2;
+        public const int PERMISSION_TAKE_CONTROLS = 4;
+        public const int PERMISSION_REMAP_CONTROLS = 8;
+        public const int PERMISSION_TRIGGER_ANIMATION = 16;
+        public const int PERMISSION_ATTACH = 32;
+        public const int PERMISSION_RELEASE_OWNERSHIP = 64;
+        public const int PERMISSION_CHANGE_LINKS = 128;
+        public const int PERMISSION_CHANGE_JOINTS = 256;
+        public const int PERMISSION_CHANGE_PERMISSIONS = 512;
+        public const int PERMISSION_TRACK_CAMERA = 1024;
+        public const int AGENT_FLYING = 1;
+        public const int AGENT_ATTACHMENTS = 2;
+        public const int AGENT_SCRIPTED = 4;
+        public const int AGENT_MOUSELOOK = 8;
+        public const int AGENT_SITTING = 16;
+        public const int AGENT_ON_OBJECT = 32;
+        public const int AGENT_AWAY = 64;
+        public const int AGENT_WALKING = 128;
+        public const int AGENT_IN_AIR = 256;
+        public const int AGENT_TYPING = 512;
+        public const int AGENT_CROUCHING = 1024;
+        public const int AGENT_BUSY = 2048;
+        public const int AGENT_ALWAYS_RUN = 4096;
+        public const int PSYS_PART_INTERP_COLOR_MASK = 1;
+        public const int PSYS_PART_INTERP_SCALE_MASK = 2;
+        public const int PSYS_PART_BOUNCE_MASK = 4;
+        public const int PSYS_PART_WIND_MASK = 8;
+        public const int PSYS_PART_FOLLOW_SRC_MASK = 16;
+        public const int PSYS_PART_FOLLOW_VELOCITY_MASK = 32;
+        public const int PSYS_PART_TARGET_POS_MASK = 64;
+        public const int PSYS_PART_TARGET_LINEAR_MASK = 128;
+        public const int PSYS_PART_EMISSIVE_MASK = 256;
+        public const int PSYS_PART_FLAGS = 0;
+        public const int PSYS_PART_START_COLOR = 1;
+        public const int PSYS_PART_START_ALPHA = 2;
+        public const int PSYS_PART_END_COLOR = 3;
+        public const int PSYS_PART_END_ALPHA = 4;
+        public const int PSYS_PART_START_SCALE = 5;
+        public const int PSYS_PART_END_SCALE = 6;
+        public const int PSYS_PART_MAX_AGE = 7;
+        public const int PSYS_SRC_ACCEL = 8;
+        public const int PSYS_SRC_PATTERN = 9;
+        public const int PSYS_SRC_INNERANGLE = 10;
+        public const int PSYS_SRC_OUTERANGLE = 11;
+        public const int PSYS_SRC_TEXTURE = 12;
+        public const int PSYS_SRC_BURST_RATE = 13;
+        public const int PSYS_SRC_BURST_PART_COUNT = 15;
+        public const int PSYS_SRC_BURST_RADIUS = 16;
+        public const int PSYS_SRC_BURST_SPEED_MIN = 17;
+        public const int PSYS_SRC_BURST_SPEED_MAX = 18;
+        public const int PSYS_SRC_MAX_AGE = 19;
+        public const int PSYS_SRC_TARGET_KEY = 20;
+        public const int PSYS_SRC_OMEGA = 21;
+        public const int PSYS_SRC_ANGLE_BEGIN = 22;
+        public const int PSYS_SRC_ANGLE_END = 23;
+        public const int PSYS_SRC_PATTERN_DROP = 1;
+        public const int PSYS_SRC_PATTERN_EXPLODE = 2;
+        public const int PSYS_SRC_PATTERN_ANGLE = 4;
+        public const int PSYS_SRC_PATTERN_ANGLE_CONE = 8;
+        public const int PSYS_SRC_PATTERN_ANGLE_CONE_EMPTY = 16;
+        public const int VEHICLE_TYPE_NONE = 0;
+        public const int VEHICLE_TYPE_SLED = 1;
+        public const int VEHICLE_TYPE_CAR = 2;
+        public const int VEHICLE_TYPE_BOAT = 3;
+        public const int VEHICLE_TYPE_AIRPLANE = 4;
+        public const int VEHICLE_TYPE_BALLOON = 5;
+        public const int VEHICLE_LINEAR_FRICTION_TIMESCALE = 16;
+        public const int VEHICLE_ANGULAR_FRICTION_TIMESCALE = 17;
+        public const int VEHICLE_LINEAR_MOTOR_DIRECTION = 18;
+        public const int VEHICLE_LINEAR_MOTOR_OFFSET = 20;
+        public const int VEHICLE_ANGULAR_MOTOR_DIRECTION = 19;
+        public const int VEHICLE_HOVER_HEIGHT = 24;
+        public const int VEHICLE_HOVER_EFFICIENCY = 25;
+        public const int VEHICLE_HOVER_TIMESCALE = 26;
+        public const int VEHICLE_BUOYANCY = 27;
+        public const int VEHICLE_LINEAR_DEFLECTION_EFFICIENCY = 28;
+        public const int VEHICLE_LINEAR_DEFLECTION_TIMESCALE = 29;
+        public const int VEHICLE_LINEAR_MOTOR_TIMESCALE = 30;
+        public const int VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE = 31;
+        public const int VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY = 32;
+        public const int VEHICLE_ANGULAR_DEFLECTION_TIMESCALE = 33;
+        public const int VEHICLE_ANGULAR_MOTOR_TIMESCALE = 34;
+        public const int VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE = 35;
+        public const int VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY = 36;
+        public const int VEHICLE_VERTICAL_ATTRACTION_TIMESCALE = 37;
+        public const int VEHICLE_BANKING_EFFICIENCY = 38;
+        public const int VEHICLE_BANKING_MIX = 39;
+        public const int VEHICLE_BANKING_TIMESCALE = 40;
+        public const int VEHICLE_REFERENCE_FRAME = 44;
+        public const int VEHICLE_FLAG_NO_DEFLECTION_UP = 1;
+        public const int VEHICLE_FLAG_LIMIT_ROLL_ONLY = 2;
+        public const int VEHICLE_FLAG_HOVER_WATER_ONLY = 4;
+        public const int VEHICLE_FLAG_HOVER_TERRAIN_ONLY = 8;
+        public const int VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT = 16;
+        public const int VEHICLE_FLAG_HOVER_UP_ONLY = 32;
+        public const int VEHICLE_FLAG_LIMIT_MOTOR_UP = 64;
+        public const int VEHICLE_FLAG_MOUSELOOK_STEER = 128;
+        public const int VEHICLE_FLAG_MOUSELOOK_BANK = 256;
+        public const int VEHICLE_FLAG_CAMERA_DECOUPLED = 512;
+        public const int INVENTORY_ALL = -1;
+        public const int INVENTORY_NONE = -1;
+        public const int INVENTORY_TEXTURE = 0;
+        public const int INVENTORY_SOUND = 1;
+        public const int INVENTORY_LANDMARK = 3;
+        public const int INVENTORY_CLOTHING = 5;
+        public const int INVENTORY_OBJECT = 6;
+        public const int INVENTORY_NOTECARD = 7;
+        public const int INVENTORY_SCRIPT = 10;
+        public const int INVENTORY_BODYPART = 13;
+        public const int INVENTORY_ANIMATION = 20;
+        public const int INVENTORY_GESTURE = 21;
+        public const int ATTACH_CHEST = 1;
+        public const int ATTACH_HEAD = 2;
+        public const int ATTACH_LSHOULDER = 3;
+        public const int ATTACH_RSHOULDER = 4;
+        public const int ATTACH_LHAND = 5;
+        public const int ATTACH_RHAND = 6;
+        public const int ATTACH_LFOOT = 7;
+        public const int ATTACH_RFOOT = 8;
+        public const int ATTACH_BACK = 9;
+        public const int ATTACH_PELVIS = 10;
+        public const int ATTACH_MOUTH = 11;
+        public const int ATTACH_CHIN = 12;
+        public const int ATTACH_LEAR = 13;
+        public const int ATTACH_REAR = 14;
+        public const int ATTACH_LEYE = 15;
+        public const int ATTACH_REYE = 16;
+        public const int ATTACH_NOSE = 17;
+        public const int ATTACH_RUARM = 18;
+        public const int ATTACH_RLARM = 19;
+        public const int ATTACH_LUARM = 20;
+        public const int ATTACH_LLARM = 21;
+        public const int ATTACH_RHIP = 22;
+        public const int ATTACH_RULEG = 23;
+        public const int ATTACH_RLLEG = 24;
+        public const int ATTACH_LHIP = 25;
+        public const int ATTACH_LULEG = 26;
+        public const int ATTACH_LLLEG = 27;
+        public const int ATTACH_BELLY = 28;
+        public const int ATTACH_RPEC = 29;
+        public const int ATTACH_LPEC = 30;
+        public const int LAND_LEVEL = 0;
+        public const int LAND_RAISE = 1;
+        public const int LAND_LOWER = 2;
+        public const int LAND_SMOOTH = 3;
+        public const int LAND_NOISE = 4;
+        public const int LAND_REVERT = 5;
+        public const int LAND_SMALL_BRUSH = 1;
+        public const int LAND_MEDIUM_BRUSH = 2;
+        public const int LAND_LARGE_BRUSH = 3;
+        public const int DATA_ONLINE = 1;
+        public const int DATA_NAME = 2;
+        public const int DATA_BORN = 3;
+        public const int DATA_RATING = 4;
+        public const int DATA_SIM_POS = 5;
+        public const int DATA_SIM_STATUS = 6;
+        public const int DATA_SIM_RATING = 7;
+        public const int ANIM_ON = 1;
+        public const int LOOP = 2;
+        public const int REVERSE = 4;
+        public const int PING_PONG = 8;
+        public const int SMOOTH = 16;
+        public const int ROTATE = 32;
+        public const int SCALE = 64;
+        public const int ALL_SIDES = -1;
+        public const int LINK_SET = -1;
+        public const int LINK_ROOT = 1;
+        public const int LINK_ALL_OTHERS = -2;
+        public const int LINK_ALL_CHILDREN = -3;
+        public const int LINK_THIS = -4;
+        public const int CHANGED_INVENTORY = 1;
+        public const int CHANGED_COLOR = 2;
+        public const int CHANGED_SHAPE = 4;
+        public const int CHANGED_SCALE = 8;
+        public const int CHANGED_TEXTURE = 16;
+        public const int CHANGED_LINK = 32;
+        public const int CHANGED_ALLOWED_DROP = 64;
+        public const int CHANGED_OWNER = 128;
+        public const int TYPE_INVALID = 0;
+        public const int TYPE_INTEGER = 1;
+        public const int TYPE_double = 2;
+        public const int TYPE_STRING = 3;
+        public const int TYPE_KEY = 4;
+        public const int TYPE_VECTOR = 5;
+        public const int TYPE_ROTATION = 6;
+        public const int REMOTE_DATA_CHANNEL = 1;
+        public const int REMOTE_DATA_REQUEST = 2;
+        public const int REMOTE_DATA_REPLY = 3;
+        public const int PRIM_MATERIAL = 2;
+        public const int PRIM_PHYSICS = 3;
+        public const int PRIM_TEMP_ON_REZ = 4;
+        public const int PRIM_PHANTOM = 5;
+        public const int PRIM_POSITION = 6;
+        public const int PRIM_SIZE = 7;
+        public const int PRIM_ROTATION = 8;
+        public const int PRIM_TYPE = 9;
+        public const int PRIM_TEXTURE = 17;
+        public const int PRIM_COLOR = 18;
+        public const int PRIM_BUMP_SHINY = 19;
+        public const int PRIM_FULLBRIGHT = 20;
+        public const int PRIM_FLEXIBLE = 21;
+        public const int PRIM_TEXGEN = 22;
+        public const int PRIM_CAST_SHADOWS = 24; // Not implemented, here for completeness sake
+        public const int PRIM_POINT_LIGHT = 23; // Huh?
+        public const int PRIM_TEXGEN_DEFAULT = 0;
+        public const int PRIM_TEXGEN_PLANAR = 1;
+        public const int PRIM_TYPE_BOX = 0;
+        public const int PRIM_TYPE_CYLINDER = 1;
+        public const int PRIM_TYPE_PRISM = 2;
+        public const int PRIM_TYPE_SPHERE = 3;
+        public const int PRIM_TYPE_TORUS = 4;
+        public const int PRIM_TYPE_TUBE = 5;
+        public const int PRIM_TYPE_RING = 6;
+        public const int PRIM_TYPE_SCULPT = 7;
+        public const int PRIM_HOLE_DEFAULT = 0;
+        public const int PRIM_HOLE_CIRCLE = 16;
+        public const int PRIM_HOLE_SQUARE = 32;
+        public const int PRIM_HOLE_TRIANGLE = 48;
+        public const int PRIM_MATERIAL_STONE = 0;
+        public const int PRIM_MATERIAL_METAL = 1;
+        public const int PRIM_MATERIAL_GLASS = 2;
+        public const int PRIM_MATERIAL_WOOD = 3;
+        public const int PRIM_MATERIAL_FLESH = 4;
+        public const int PRIM_MATERIAL_PLASTIC = 5;
+        public const int PRIM_MATERIAL_RUBBER = 6;
+        public const int PRIM_MATERIAL_LIGHT = 7;
+        public const int PRIM_SHINY_NONE = 0;
+        public const int PRIM_SHINY_LOW = 1;
+        public const int PRIM_SHINY_MEDIUM = 2;
+        public const int PRIM_SHINY_HIGH = 3;
+        public const int PRIM_BUMP_NONE = 0;
+        public const int PRIM_BUMP_BRIGHT = 1;
+        public const int PRIM_BUMP_DARK = 2;
+        public const int PRIM_BUMP_WOOD = 3;
+        public const int PRIM_BUMP_BARK = 4;
+        public const int PRIM_BUMP_BRICKS = 5;
+        public const int PRIM_BUMP_CHECKER = 6;
+        public const int PRIM_BUMP_CONCRETE = 7;
+        public const int PRIM_BUMP_TILE = 8;
+        public const int PRIM_BUMP_STONE = 9;
+        public const int PRIM_BUMP_DISKS = 10;
+        public const int PRIM_BUMP_GRAVEL = 11;
+        public const int PRIM_BUMP_BLOBS = 12;
+        public const int PRIM_BUMP_SIDING = 13;
+        public const int PRIM_BUMP_LARGETILE = 14;
+        public const int PRIM_BUMP_STUCCO = 15;
+        public const int PRIM_BUMP_SUCTION = 16;
+        public const int PRIM_BUMP_WEAVE = 17;
+        public const int PRIM_SCULPT_TYPE_SPHERE = 1;
+        public const int PRIM_SCULPT_TYPE_TORUS = 2;
+        public const int PRIM_SCULPT_TYPE_PLANE = 3;
+        public const int PRIM_SCULPT_TYPE_CYLINDER = 4;
+        public const int MASK_BASE = 0;
+        public const int MASK_OWNER = 1;
+        public const int MASK_GROUP = 2;
+        public const int MASK_EVERYONE = 3;
+        public const int MASK_NEXT = 4;
+        public const int PERM_TRANSFER = 8192;
+        public const int PERM_MODIFY = 16384;
+        public const int PERM_COPY = 32768;
+        public const int PERM_MOVE = 524288;
+        public const int PERM_ALL = 2147483647;
+        public const int PARCEL_MEDIA_COMMAND_STOP = 0;
+        public const int PARCEL_MEDIA_COMMAND_PAUSE = 1;
+        public const int PARCEL_MEDIA_COMMAND_PLAY = 2;
+        public const int PARCEL_MEDIA_COMMAND_LOOP = 3;
+        public const int PARCEL_MEDIA_COMMAND_TEXTURE = 4;
+        public const int PARCEL_MEDIA_COMMAND_URL = 5;
+        public const int PARCEL_MEDIA_COMMAND_TIME = 6;
+        public const int PARCEL_MEDIA_COMMAND_AGENT = 7;
+        public const int PARCEL_MEDIA_COMMAND_UNLOAD = 8;
+        public const int PARCEL_MEDIA_COMMAND_AUTO_ALIGN = 9;
+        public const int PAY_HIDE = -1;
+        public const int PAY_DEFAULT = -2;
+        public const string NULL_KEY = "00000000-0000-0000-0000-000000000000";
+        public const string EOF = "\n\n\n";
+        public const double PI = 3.14159274f;
+        public const double TWO_PI = 6.28318548f;
+        public const double PI_BY_TWO = 1.57079637f;
+        public const double DEG_TO_RAD = 0.01745329238f;
+        public const double RAD_TO_DEG = 57.29578f;
+        public const double SQRT2 = 1.414213538f;
+        // Can not be public const?
+        public vector ZERO_VECTOR = new vector(0, 0, 0);
+        public rotation ZERO_ROTATION = new rotation(0, 0, 0, 0);
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/LSL_BuiltIn_Commands.cs b/OpenSim/Region/ScriptEngine/Common/LSL_BuiltIn_Commands.cs
new file mode 100644
index 0000000..f4a1a00
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/LSL_BuiltIn_Commands.cs
@@ -0,0 +1,3003 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+using System;
+using System.Collections.Generic;
+using System.Runtime.Remoting.Lifetime;
+using System.Text;
+using System.Threading;
+using Axiom.Math;
+using libsecondlife;
+using OpenSim.Framework;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Common;
+//using OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSL;
+namespace OpenSim.Region.ScriptEngine.Common
+{
+    /// <summary>
+    /// Contains all LSL ll-functions. This class will be in Default AppDomain.
+    /// </summary>
+    public class LSL_BuiltIn_Commands : MarshalByRefObject, LSL_BuiltIn_Commands_Interface
+    {
+        private ASCIIEncoding enc = new ASCIIEncoding();
+        private ScriptEngineBase.ScriptEngine m_ScriptEngine;
+        private SceneObjectPart m_host;
+        private uint m_localID;
+        private LLUUID m_itemID;
+        private bool throwErrorOnNotImplemented = true;
+        public LSL_BuiltIn_Commands(ScriptEngineBase.ScriptEngine ScriptEngine, SceneObjectPart host, uint localID, LLUUID itemID)
+        {
+            m_ScriptEngine = ScriptEngine;
+            m_host = host;
+            m_localID = localID;
+            m_itemID = itemID;
+            //MainLog.Instance.Notice("ScriptEngine", "LSL_BaseClass.Start() called. Hosted by [" + m_host.Name + ":" + m_host.UUID + "@" + m_host.AbsolutePosition + "]");
+        }
+        private DateTime m_timer = DateTime.Now;
+        private string m_state = "default";
+        public string State()
+        {
+            return m_state;
+        }
+        // Object never expires
+        public override Object InitializeLifetimeService()
+        {
+            //Console.WriteLine("LSL_BuiltIn_Commands: InitializeLifetimeService()");
+            //            return null;
+            ILease lease = (ILease)base.InitializeLifetimeService();
+            if (lease.CurrentState == LeaseState.Initial)
+            {
+                lease.InitialLeaseTime = TimeSpan.Zero; // TimeSpan.FromMinutes(1);
+                //                lease.SponsorshipTimeout = TimeSpan.FromMinutes(2);
+                //                lease.RenewOnCallTime = TimeSpan.FromSeconds(2);
+            }
+            return lease;
+        }
+        public Scene World
+        {
+            get { return m_ScriptEngine.World; }
+        }
+        //These are the implementations of the various ll-functions used by the LSL scripts.
+        //starting out, we use the System.Math library for trig functions. - ckrinke 8-14-07
+        public double llSin(double f)
+        {
+            return (double)Math.Sin(f);
+        }
+        public double llCos(double f)
+        {
+            return (double)Math.Cos(f);
+        }
+        public double llTan(double f)
+        {
+            return (double)Math.Tan(f);
+        }
+        public double llAtan2(double x, double y)
+        {
+            return (double)Math.Atan2(y, x);
+        }
+        public double llSqrt(double f)
+        {
+            return (double)Math.Sqrt(f);
+        }
+        public double llPow(double fbase, double fexponent)
+        {
+            return (double)Math.Pow(fbase, fexponent);
+        }
+        public int llAbs(int i)
+        {
+            return (int)Math.Abs(i);
+        }
+        public double llFabs(double f)
+        {
+            return (double)Math.Abs(f);
+        }
+        public double llFrand(double mag)
+        {
+            lock (Util.RandomClass)
+            {
+                return Util.RandomClass.NextDouble() * mag;
+            }
+        }
+        public int llFloor(double f)
+        {
+            return (int)Math.Floor(f);
+        }
+        public int llCeil(double f)
+        {
+            return (int)Math.Ceiling(f);
+        }
+        public int llRound(double f)
+        {
+            return (int)Math.Round(f, 0);
+        }
+        //This next group are vector operations involving squaring and square root. ckrinke
+        public double llVecMag(LSL_Types.Vector3 v)
+        {
+            return (v.x * v.x + v.y * v.y + v.z * v.z);
+        }
+        public LSL_Types.Vector3 llVecNorm(LSL_Types.Vector3 v)
+        {
+            double mag = v.x * v.x + v.y * v.y + v.z * v.z;
+            LSL_Types.Vector3 nor = new LSL_Types.Vector3();
+            nor.x = v.x / mag;
+            nor.y = v.y / mag;
+            nor.z = v.z / mag;
+            return nor;
+        }
+        public double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b)
+        {
+            double dx = a.x - b.x;
+            double dy = a.y - b.y;
+            double dz = a.z - b.z;
+            return Math.Sqrt(dx * dx + dy * dy + dz * dz);
+        }
+        //Now we start getting into quaternions which means sin/cos, matrices and vectors. ckrinke
+        public LSL_Types.Vector3 llRot2Euler(LSL_Types.Quaternion r)
+        {
+            //This implementation is from http://lslwiki.net/lslwiki/wakka.php?wakka=LibraryRotationFunctions. ckrinke
+            LSL_Types.Quaternion t = new LSL_Types.Quaternion(r.x * r.x, r.y * r.y, r.z * r.z, r.s * r.s);
+            double m = (t.x + t.y + t.z + t.s);
+            if (m == 0) return new LSL_Types.Vector3();
+            double n = 2 * (r.y * r.s + r.x * r.z);
+            double p = m * m - n * n;
+            if (p > 0)
+                return new LSL_Types.Vector3(Math.Atan2(2.0 * (r.x * r.s - r.y * r.z), (-t.x - t.y + t.z + t.s)),
+                                             Math.Atan2(n, Math.Sqrt(p)),
+                                             Math.Atan2(2.0 * (r.z * r.s - r.x * r.y), (t.x - t.y - t.z + t.s)));
+            else if (n > 0)
+                return new LSL_Types.Vector3(0.0, Math.PI / 2, Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z));
+            else
+                return new LSL_Types.Vector3(0.0, -Math.PI / 2, Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z));
+        }
+        public LSL_Types.Quaternion llEuler2Rot(LSL_Types.Vector3 v)
+        {
+            //this comes from from http://lslwiki.net/lslwiki/wakka.php?wakka=LibraryRotationFunctions but is incomplete as of 8/19/07
+            float err = 0.00001f;
+            double ax = Math.Sin(v.x / 2);
+            double aw = Math.Cos(v.x / 2);
+            double by = Math.Sin(v.y / 2);
+            double bw = Math.Cos(v.y / 2);
+            double cz = Math.Sin(v.z / 2);
+            double cw = Math.Cos(v.z / 2);
+            LSL_Types.Quaternion a1 = new LSL_Types.Quaternion(0.0, 0.0, cz, cw);
+            LSL_Types.Quaternion a2 = new LSL_Types.Quaternion(0.0, by, 0.0, bw);
+            LSL_Types.Quaternion a3 = new LSL_Types.Quaternion(ax, 0.0, 0.0, aw);
+            LSL_Types.Quaternion a = (a1 * a2) * a3;
+            //This multiplication doesnt compile, yet.            a = a1 * a2 * a3;
+            LSL_Types.Quaternion b = new LSL_Types.Quaternion(ax * bw * cw + aw * by * cz,
+                                                              aw * by * cw - ax * bw * cz, aw * bw * cz + ax * by * cw,
+                                                              aw * bw * cw - ax * by * cz);
+            LSL_Types.Quaternion c = new LSL_Types.Quaternion();
+            //This addition doesnt compile yet c = a + b;
+            LSL_Types.Quaternion d = new LSL_Types.Quaternion();
+            //This addition doesnt compile yet d = a - b;
+            if ((Math.Abs(c.x) > err && Math.Abs(d.x) > err) ||
+                (Math.Abs(c.y) > err && Math.Abs(d.y) > err) ||
+                (Math.Abs(c.z) > err && Math.Abs(d.z) > err) ||
+                (Math.Abs(c.s) > err && Math.Abs(d.s) > err))
+            {
+                return b;
+                //return a new Quaternion that is null until I figure this out
+                //                return b;
+                //            return a;
+            }
+            return a;
+        }
+        public LSL_Types.Quaternion llAxes2Rot(LSL_Types.Vector3 fwd, LSL_Types.Vector3 left, LSL_Types.Vector3 up)
+        {
+            return new LSL_Types.Quaternion();
+        }
+        public LSL_Types.Vector3 llRot2Fwd(LSL_Types.Quaternion r)
+        {
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Vector3 llRot2Left(LSL_Types.Quaternion r)
+        {
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Vector3 llRot2Up(LSL_Types.Quaternion r)
+        {
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Quaternion llRotBetween(LSL_Types.Vector3 a, LSL_Types.Vector3 b)
+        {
+            //A and B should both be normalized
+            double dotProduct = LSL_Types.Vector3.Dot(a, b);
+            LSL_Types.Vector3 crossProduct = LSL_Types.Vector3.Cross(a, b);
+            double magProduct = LSL_Types.Vector3.Mag(a) * LSL_Types.Vector3.Mag(b);
+            double angle = Math.Acos(dotProduct / magProduct);
+            LSL_Types.Vector3 axis = LSL_Types.Vector3.Norm(crossProduct);
+            double s = Math.Sin(angle / 2);
+            return new LSL_Types.Quaternion(axis.x * s, axis.y * s, axis.z * s, (float)Math.Cos(angle / 2));
+        }
+        public void llWhisper(int channelID, string text)
+        {
+            World.SimChat(Helpers.StringToField(text),
+                          ChatTypeEnum.Whisper, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID);
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(m_host.UUID.ToString(), ChatTypeEnum.Whisper, channelID, m_host.Name, text);
+        }
+        public void llSay(int channelID, string text)
+        {
+            World.SimChat(Helpers.StringToField(text),
+                          ChatTypeEnum.Say, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID);
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(m_host.UUID.ToString(), ChatTypeEnum.Say, channelID, m_host.Name, text);
+        }
+        public void llShout(int channelID, string text)
+        {
+            World.SimChat(Helpers.StringToField(text),
+                          ChatTypeEnum.Shout, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID);
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(m_host.UUID.ToString(), ChatTypeEnum.Shout, channelID, m_host.Name, text);
+        }
+        public int llListen(int channelID, string name, string ID, string msg)
+        {
+            if (ID == "")
+            {
+                ID = LLUUID.Zero.ToString();
+            }
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            return wComm.Listen(m_localID, m_itemID, m_host.UUID, channelID, name, ID, msg);
+        }
+        public void llListenControl(int number, int active)
+        {
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.ListenControl(number, active);
+        }
+        public void llListenRemove(int number)
+        {
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.ListenRemove(number);
+        }
+        public void llSensor(string name, string id, int type, double range, double arc)
+        {
+            NotImplemented("llSensor");
+            return;
+        }
+        public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate)
+        {
+            NotImplemented("llSensorRepeat");
+            return;
+        }
+        public void llSensorRemove()
+        {
+            NotImplemented("llSensorRemove");
+            return;
+        }
+        public string llDetectedName(int number)
+        {
+            NotImplemented("llDetectedName");
+            return "";
+        }
+        public string llDetectedKey(int number)
+        {
+            NotImplemented("llDetectedKey");
+            return "";
+        }
+        public string llDetectedOwner(int number)
+        {
+            NotImplemented("llDetectedOwner");
+            return "";
+        }
+        public int llDetectedType(int number)
+        {
+            NotImplemented("llDetectedType");
+            return 0;
+        }
+        public LSL_Types.Vector3 llDetectedPos(int number)
+        {
+            NotImplemented("llDetectedPos");
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Vector3 llDetectedVel(int number)
+        {
+            NotImplemented("llDetectedVel");
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Vector3 llDetectedGrab(int number)
+        {
+            NotImplemented("llDetectedGrab");
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Quaternion llDetectedRot(int number)
+        {
+            NotImplemented("llDetectedRot");
+            return new LSL_Types.Quaternion();
+        }
+        public int llDetectedGroup(int number)
+        {
+            NotImplemented("llDetectedGroup");
+            return 0;
+        }
+        public int llDetectedLinkNumber(int number)
+        {
+            NotImplemented("llDetectedLinkNumber");
+            return 0;
+        }
+        public void llDie()
+        {
+            World.DeleteSceneObjectGroup(m_host.ParentGroup);
+            return;
+        }
+        public double llGround(LSL_Types.Vector3 offset)
+        {
+            int x = (int)(m_host.AbsolutePosition.X + offset.x);
+            int y = (int)(m_host.AbsolutePosition.Y + offset.y);
+            return World.GetLandHeight(x, y);
+        }
+        public double llCloud(LSL_Types.Vector3 offset)
+        {
+            NotImplemented("llCloud");
+            return 0;
+        }
+        public LSL_Types.Vector3 llWind(LSL_Types.Vector3 offset)
+        {
+            NotImplemented("llWind");
+            return new LSL_Types.Vector3();
+        }
+        public void llSetStatus(int status, int value)
+        {
+            NotImplemented("llSetStatus");
+            return;
+        }
+        public int llGetStatus(int status)
+        {
+            NotImplemented("llGetStatus");
+            return 0;
+        }
+        public void llSetScale(LSL_Types.Vector3 scale)
+        {
+            // TODO: this needs to trigger a persistance save as well
+            LLVector3 tmp = m_host.Scale;
+            tmp.X = (float)scale.x;
+            tmp.Y = (float)scale.y;
+            tmp.Z = (float)scale.z;
+            m_host.Scale = tmp;
+            m_host.SendFullUpdateToAllClients();
+            return;
+        }
+        public LSL_Types.Vector3 llGetScale()
+        {
+            return new LSL_Types.Vector3(m_host.Scale.X, m_host.Scale.Y, m_host.Scale.Z);
+        }
+        public void llSetColor(LSL_Types.Vector3 color, int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            LLColor texcolor;
+            if (face > -1)
+            {
+                texcolor = tex.CreateFace((uint)face).RGBA;
+                texcolor.R = (float)Math.Abs(color.x - 1);
+                texcolor.G = (float)Math.Abs(color.y - 1);
+                texcolor.B = (float)Math.Abs(color.z - 1);
+                tex.FaceTextures[face].RGBA = texcolor;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            else if (face == -1)
+            {
+                for (uint i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        texcolor = tex.FaceTextures[i].RGBA;
+                        texcolor.R = (float)Math.Abs(color.x - 1);
+                        texcolor.G = (float)Math.Abs(color.y - 1);
+                        texcolor.B = (float)Math.Abs(color.z - 1);
+                        tex.FaceTextures[i].RGBA = texcolor;
+                    }
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.R = (float)Math.Abs(color.x - 1);
+                    texcolor.G = (float)Math.Abs(color.y - 1);
+                    texcolor.B = (float)Math.Abs(color.z - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                }
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            NotImplemented("llSetColor");
+            return;
+        }
+        public double llGetAlpha(int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color
+            {
+                return (double)((tex.DefaultTexture.RGBA.A * 255) / 255);
+            }
+            if (face > -1)
+            {
+                return (double)((tex.GetFace((uint)face).RGBA.A * 255) / 255);
+            }
+            return 0;
+        }
+        public void llSetAlpha(double alpha, int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            LLColor texcolor;
+            if (face > -1)
+            {
+                texcolor = tex.CreateFace((uint)face).RGBA;
+                texcolor.A = (float)Math.Abs(alpha - 1);
+                tex.FaceTextures[face].RGBA = texcolor;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            else if (face == -1)
+            {
+                for (int i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        texcolor = tex.FaceTextures[i].RGBA;
+                        texcolor.A = (float)Math.Abs(alpha - 1);
+                        tex.FaceTextures[i].RGBA = texcolor;
+                    }
+                }
+                texcolor = tex.DefaultTexture.RGBA;
+                texcolor.A = (float)Math.Abs(alpha - 1);
+                tex.DefaultTexture.RGBA = texcolor;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            NotImplemented("llSetAlpha");
+            return;
+        }
+        public LSL_Types.Vector3 llGetColor(int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            LLColor texcolor;
+            LSL_Types.Vector3 rgb;
+            if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color
+            {
+                texcolor = tex.DefaultTexture.RGBA;
+                rgb.x = (255 - (texcolor.R * 255)) / 255;
+                rgb.y = (255 - (texcolor.G * 255)) / 255;
+                rgb.z = (255 - (texcolor.B * 255)) / 255;
+                return rgb;
+            }
+            if (face > -1)
+            {
+                texcolor = tex.GetFace((uint)face).RGBA;
+                rgb.x = (255 - (texcolor.R * 255)) / 255;
+                rgb.y = (255 - (texcolor.G * 255)) / 255;
+                rgb.z = (255 - (texcolor.B * 255)) / 255;
+                return rgb;
+            }
+            NotImplemented("llGetColor");
+            return new LSL_Types.Vector3();
+        }
+        public void llSetTexture(string texture, int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
+                texface.TextureID = new LLUUID(texture);
+                tex.FaceTextures[face] = texface;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            else if (face == -1)
+            {
+                for (uint i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        tex.FaceTextures[i].TextureID = new LLUUID(texture);
+                    }
+                }
+                tex.DefaultTexture.TextureID = new LLUUID(texture);
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            NotImplemented("llSetTexture");
+            return;
+        }
+        public void llScaleTexture(double u, double v, int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
+                texface.RepeatU = (float)u;
+                texface.RepeatV = (float)v;
+                tex.FaceTextures[face] = texface;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            if (face == -1)
+            {
+                for (int i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        tex.FaceTextures[i].RepeatU = (float)u;
+                        tex.FaceTextures[i].RepeatV = (float)v;
+                    }
+                }
+                tex.DefaultTexture.RepeatU = (float)u;
+                tex.DefaultTexture.RepeatV = (float)v;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            NotImplemented("llScaleTexture");
+            return;
+        }
+        public void llOffsetTexture(double u, double v, int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
+                texface.OffsetU = (float)u;
+                texface.OffsetV = (float)v;
+                tex.FaceTextures[face] = texface;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            if (face == -1)
+            {
+                for (int i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        tex.FaceTextures[i].OffsetU = (float)u;
+                        tex.FaceTextures[i].OffsetV = (float)v;
+                    }
+                }
+                tex.DefaultTexture.OffsetU = (float)u;
+                tex.DefaultTexture.OffsetV = (float)v;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            NotImplemented("llOffsetTexture");
+            return;
+        }
+        public void llRotateTexture(double rotation, int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
+                texface.Rotation = (float)rotation;
+                tex.FaceTextures[face] = texface;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            if (face == -1)
+            {
+                for (int i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        tex.FaceTextures[i].Rotation = (float)rotation;
+                    }
+                }
+                tex.DefaultTexture.Rotation = (float)rotation;
+                m_host.UpdateTexture(tex);
+                return;
+            }
+            NotImplemented("llRotateTexture");
+            return;
+        }
+        public string llGetTexture(int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face == -1)
+            {
+                face = 0;
+            }
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface;
+                texface = tex.GetFace((uint)face);
+                return texface.TextureID.ToString();
+            }
+            NotImplemented("llGetTexture");
+            return "";
+        }
+        public void llSetPos(LSL_Types.Vector3 pos)
+        {
+            if (m_host.ParentID != 0)
+            {
+                m_host.UpdateOffSet(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z));
+            }
+            else
+            {
+                m_host.UpdateGroupPosition(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z));
+            }
+        }
+        public LSL_Types.Vector3 llGetPos()
+        {
+            return new LSL_Types.Vector3(m_host.AbsolutePosition.X,
+                                         m_host.AbsolutePosition.Y,
+                                         m_host.AbsolutePosition.Z);
+        }
+        public LSL_Types.Vector3 llGetLocalPos()
+        {
+            if (m_host.ParentID != 0)
+            {
+                return new LSL_Types.Vector3(m_host.OffsetPosition.X,
+                                             m_host.OffsetPosition.Y,
+                                             m_host.OffsetPosition.Z);
+            }
+            else
+            {
+                return new LSL_Types.Vector3(m_host.AbsolutePosition.X,
+                                             m_host.AbsolutePosition.Y,
+                                             m_host.AbsolutePosition.Z);
+            }
+        }
+        public void llSetRot(LSL_Types.Quaternion rot)
+        {
+            m_host.UpdateRotation(new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s));
+        }
+        public LSL_Types.Quaternion llGetRot()
+        {
+            LLQuaternion q = m_host.RotationOffset;
+            return new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W);
+        }
+        public LSL_Types.Quaternion llGetLocalRot()
+        {
+            return new LSL_Types.Quaternion(m_host.RotationOffset.X, m_host.RotationOffset.Y, m_host.RotationOffset.Z, m_host.RotationOffset.W);
+        }
+        public void llSetForce(LSL_Types.Vector3 force, int local)
+        {
+            NotImplemented("llSetForce");
+        }
+        public LSL_Types.Vector3 llGetForce()
+        {
+            NotImplemented("llGetForce");
+            return new LSL_Types.Vector3();
+        }
+        public int llTarget(LSL_Types.Vector3 position, double range)
+        {
+            NotImplemented("llTarget");
+            return 0;
+        }
+        public void llTargetRemove(int number)
+        {
+            NotImplemented("llTargetRemove");
+        }
+        public int llRotTarget(LSL_Types.Quaternion rot, double error)
+        {
+            NotImplemented("llRotTarget");
+            return 0;
+        }
+        public void llRotTargetRemove(int number)
+        {
+            NotImplemented("llRotTargetRemove");
+        }
+        public void llMoveToTarget(LSL_Types.Vector3 target, double tau)
+        {
+            NotImplemented("llMoveToTarget");
+        }
+        public void llStopMoveToTarget()
+        {
+            NotImplemented("llStopMoveToTarget");
+        }
+        public void llApplyImpulse(LSL_Types.Vector3 force, int local)
+        {
+            NotImplemented("llApplyImpulse");
+        }
+        public void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local)
+        {
+            NotImplemented("llApplyRotationalImpulse");
+        }
+        public void llSetTorque(LSL_Types.Vector3 torque, int local)
+        {
+            NotImplemented("llSetTorque");
+        }
+        public LSL_Types.Vector3 llGetTorque()
+        {
+            NotImplemented("llGetTorque");
+            return new LSL_Types.Vector3();
+        }
+        public void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local)
+        {
+            NotImplemented("llSetForceAndTorque");
+        }
+        public LSL_Types.Vector3 llGetVel()
+        {
+            return new LSL_Types.Vector3(m_host.Velocity.X, m_host.Velocity.Y, m_host.Velocity.Z);
+        }
+        public LSL_Types.Vector3 llGetAccel()
+        {
+            return new LSL_Types.Vector3(m_host.Acceleration.X, m_host.Acceleration.Y, m_host.Acceleration.Z);
+        }
+        public LSL_Types.Vector3 llGetOmega()
+        {
+            NotImplemented("llGetOmega");
+            return new LSL_Types.Vector3();
+        }
+        public double llGetTimeOfDay()
+        {
+            NotImplemented("llGetTimeOfDay");
+            return 0;
+        }
+        public double llGetWallclock()
+        {
+            return DateTime.Now.TimeOfDay.TotalSeconds;
+        }
+        public double llGetTime()
+        {
+            TimeSpan ScriptTime = DateTime.Now - m_timer;
+            return (double)(ScriptTime.TotalMilliseconds / 1000);
+        }
+        public void llResetTime()
+        {
+            m_timer = DateTime.Now;
+        }
+        public double llGetAndResetTime()
+        {
+            TimeSpan ScriptTime = DateTime.Now - m_timer;
+            m_timer = DateTime.Now;
+            return (double)(ScriptTime.TotalMilliseconds / 1000);
+        }
+        public void llSound()
+        {
+            NotImplemented("llSound");
+        }
+        public void llPlaySound(string sound, double volume)
+        {
+            NotImplemented("llPlaySound");
+        }
+        public void llLoopSound(string sound, double volume)
+        {
+            NotImplemented("llLoopSound");
+        }
+        public void llLoopSoundMaster(string sound, double volume)
+        {
+            NotImplemented("llLoopSoundMaster");
+        }
+        public void llLoopSoundSlave(string sound, double volume)
+        {
+            NotImplemented("llLoopSoundSlave");
+        }
+        public void llPlaySoundSlave(string sound, double volume)
+        {
+            NotImplemented("llPlaySoundSlave");
+        }
+        public void llTriggerSound(string sound, double volume)
+        {
+            NotImplemented("llTriggerSound");
+        }
+        public void llStopSound()
+        {
+            NotImplemented("llStopSound");
+        }
+        public void llPreloadSound(string sound)
+        {
+            NotImplemented("llPreloadSound");
+        }
+        public string llGetSubString(string src, int start, int end)
+        {
+            return src.Substring(start, end);
+        }
+        public string llDeleteSubString(string src, int start, int end)
+        {
+            return src.Remove(start, end - start);
+        }
+        public string llInsertString(string dst, int position, string src)
+        {
+            return dst.Insert(position, src);
+        }
+        public string llToUpper(string src)
+        {
+            return src.ToUpper();
+        }
+        public string llToLower(string src)
+        {
+            return src.ToLower();
+        }
+        public int llGiveMoney(string destination, int amount)
+        {
+            NotImplemented("llGiveMoney");
+            return 0;
+        }
+        public void llMakeExplosion()
+        {
+            NotImplemented("llMakeExplosion");
+        }
+        public void llMakeFountain()
+        {
+            NotImplemented("llMakeFountain");
+        }
+        public void llMakeSmoke()
+        {
+            NotImplemented("llMakeSmoke");
+        }
+        public void llMakeFire()
+        {
+            NotImplemented("llMakeFire");
+        }
+        public void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Quaternion rot, int param)
+        {
+            NotImplemented("llRezObject");
+        }
+        public void llLookAt(LSL_Types.Vector3 target, double strength, double damping)
+        {
+            NotImplemented("llLookAt");
+        }
+        public void llStopLookAt()
+        {
+            NotImplemented("llStopLookAt");
+        }
+        public void llSetTimerEvent(double sec)
+        {
+            // Setting timer repeat
+            m_ScriptEngine.m_LSLLongCmdHandler.SetTimerEvent(m_localID, m_itemID, sec);
+        }
+        public void llSleep(double sec)
+        {
+            Thread.Sleep((int)(sec * 1000));
+        }
+        public double llGetMass()
+        {
+            return m_host.GetMass();
+        }
+        public void llCollisionFilter(string name, string id, int accept)
+        {
+            NotImplemented("llCollisionFilter");
+        }
+        public void llTakeControls(int controls, int accept, int pass_on)
+        {
+            NotImplemented("llTakeControls");
+        }
+        public void llReleaseControls()
+        {
+            NotImplemented("llReleaseControls");
+        }
+        public void llAttachToAvatar(int attachment)
+        {
+            NotImplemented("llAttachToAvatar");
+        }
+        public void llDetachFromAvatar()
+        {
+            NotImplemented("llDetachFromAvatar");
+        }
+        public void llTakeCamera()
+        {
+            NotImplemented("llTakeCamera");
+        }
+        public void llReleaseCamera()
+        {
+            NotImplemented("llReleaseCamera");
+        }
+        public string llGetOwner()
+        {
+            return m_host.ObjectOwner.ToString();
+        }
+        public void llInstantMessage(string user, string message)
+        {
+            NotImplemented("llInstantMessage");
+            // We may be able to use ClientView.SendInstantMessage here, but we need a client instance.
+            // InstantMessageModule.OnInstantMessage searches through a list of scenes for a client matching the toAgent,
+            // but I don't think we have a list of scenes available from here.
+            // (We also don't want to duplicate the code in OnInstantMessage if we can avoid it.)
+            // TODO: figure out values for client, fromSession, and imSessionID
+            // client.SendInstantMessage(m_host.UUID, fromSession, message, user, imSessionID, m_host.Name, AgentManager.InstantMessageDialog.MessageFromAgent, (uint)Util.UnixTimeSinceEpoch());
+        }
+        public void llEmail(string address, string subject, string message)
+        {
+            NotImplemented("llEmail");
+        }
+        public void llGetNextEmail(string address, string subject)
+        {
+            NotImplemented("llGetNextEmail");
+        }
+        public string llGetKey()
+        {
+            return m_host.UUID.ToString();
+        }
+        public void llSetBuoyancy(double buoyancy)
+        {
+            NotImplemented("llSetBuoyancy");
+        }
+        public void llSetHoverHeight(double height, int water, double tau)
+        {
+            NotImplemented("llSetHoverHeight");
+        }
+        public void llStopHover()
+        {
+            NotImplemented("llStopHover");
+        }
+        public void llMinEventDelay(double delay)
+        {
+            NotImplemented("llMinEventDelay");
+        }
+        public void llSoundPreload()
+        {
+            NotImplemented("llSoundPreload");
+        }
+        public void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping)
+        {
+            NotImplemented("llRotLookAt");
+        }
+        public int llStringLength(string str)
+        {
+            if (str.Length > 0)
+            {
+                return str.Length;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+        public void llStartAnimation(string anim)
+        {
+            NotImplemented("llStartAnimation");
+        }
+        public void llStopAnimation(string anim)
+        {
+            NotImplemented("llStopAnimation");
+        }
+        public void llPointAt()
+        {
+            NotImplemented("llPointAt");
+        }
+        public void llStopPointAt()
+        {
+            NotImplemented("llStopPointAt");
+        }
+        public void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain)
+        {
+            m_host.RotationalVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate));
+            m_host.AngularVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate));
+            m_host.ScheduleTerseUpdate();
+            m_host.SendTerseUpdateToAllClients();
+            //NotImplemented("llTargetOmega");
+        }
+        public int llGetStartParameter()
+        {
+            NotImplemented("llGetStartParameter");
+            return 0;
+        }
+        public void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos)
+        {
+            NotImplemented("llGodLikeRezObject");
+        }
+        public void llRequestPermissions(string agent, int perm)
+        {
+            NotImplemented("llRequestPermissions");
+        }
+        public string llGetPermissionsKey()
+        {
+            NotImplemented("llGetPermissionsKey");
+            return "";
+        }
+        public int llGetPermissions()
+        {
+            NotImplemented("llGetPermissions");
+            return 0;
+        }
+        public int llGetLinkNumber()
+        {
+            return m_host.LinkNum;
+        }
+        public void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face)
+        {
+            SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber);
+            if (linknumber > -1)
+            {
+                LLObject.TextureEntry tex = part.Shape.Textures;
+                LLColor texcolor;
+                if (face > -1)
+                {
+                    texcolor = tex.CreateFace((uint)face).RGBA;
+                    texcolor.R = (float)Math.Abs(color.x - 1);
+                    texcolor.G = (float)Math.Abs(color.y - 1);
+                    texcolor.B = (float)Math.Abs(color.z - 1);
+                    tex.FaceTextures[face].RGBA = texcolor;
+                    part.UpdateTexture(tex);
+                    return;
+                }
+                else if (face == -1)
+                {
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.R = (float)Math.Abs(color.x - 1);
+                    texcolor.G = (float)Math.Abs(color.y - 1);
+                    texcolor.B = (float)Math.Abs(color.z - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                    for (uint i = 0; i < 32; i++)
+                    {
+                        if (tex.FaceTextures[i] != null)
+                        {
+                            texcolor = tex.FaceTextures[i].RGBA;
+                            texcolor.R = (float)Math.Abs(color.x - 1);
+                            texcolor.G = (float)Math.Abs(color.y - 1);
+                            texcolor.B = (float)Math.Abs(color.z - 1);
+                            tex.FaceTextures[i].RGBA = texcolor;
+                        }
+                    }
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.R = (float)Math.Abs(color.x - 1);
+                    texcolor.G = (float)Math.Abs(color.y - 1);
+                    texcolor.B = (float)Math.Abs(color.z - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                    part.UpdateTexture(tex);
+                    return;
+                }
+                return;
+            }
+            else if (linknumber == -1)
+            {
+                int num = m_host.ParentGroup.PrimCount;
+                for (int w = 0; w < num; w++)
+                {
+                    linknumber = w;
+                    part = m_host.ParentGroup.GetLinkNumPart(linknumber);
+                    LLObject.TextureEntry tex = part.Shape.Textures;
+                    LLColor texcolor;
+                    if (face > -1)
+                    {
+                        texcolor = tex.CreateFace((uint)face).RGBA;
+                        texcolor.R = (float)Math.Abs(color.x - 1);
+                        texcolor.G = (float)Math.Abs(color.y - 1);
+                        texcolor.B = (float)Math.Abs(color.z - 1);
+                        tex.FaceTextures[face].RGBA = texcolor;
+                        part.UpdateTexture(tex);
+                    }
+                    else if (face == -1)
+                    {
+                        texcolor = tex.DefaultTexture.RGBA;
+                        texcolor.R = (float)Math.Abs(color.x - 1);
+                        texcolor.G = (float)Math.Abs(color.y - 1);
+                        texcolor.B = (float)Math.Abs(color.z - 1);
+                        tex.DefaultTexture.RGBA = texcolor;
+                        for (uint i = 0; i < 32; i++)
+                        {
+                            if (tex.FaceTextures[i] != null)
+                            {
+                                texcolor = tex.FaceTextures[i].RGBA;
+                                texcolor.R = (float)Math.Abs(color.x - 1);
+                                texcolor.G = (float)Math.Abs(color.y - 1);
+                                texcolor.B = (float)Math.Abs(color.z - 1);
+                                tex.FaceTextures[i].RGBA = texcolor;
+                            }
+                        }
+                        texcolor = tex.DefaultTexture.RGBA;
+                        texcolor.R = (float)Math.Abs(color.x - 1);
+                        texcolor.G = (float)Math.Abs(color.y - 1);
+                        texcolor.B = (float)Math.Abs(color.z - 1);
+                        tex.DefaultTexture.RGBA = texcolor;
+                        part.UpdateTexture(tex);
+                    }
+                }
+                return;
+            }
+            else
+            {
+                NotImplemented("llSetLinkColor");
+            }
+        }
+        public void llCreateLink(string target, int parent)
+        {
+            NotImplemented("llCreateLink");
+        }
+        public void llBreakLink(int linknum)
+        {
+            NotImplemented("llBreakLink");
+        }
+        public void llBreakAllLinks()
+        {
+            NotImplemented("llBreakAllLinks");
+        }
+        public string llGetLinkKey(int linknum)
+        {
+            SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum);
+            if (part != null)
+            {
+                return part.UUID.ToString();
+            }
+            else
+            {
+                return "00000000-0000-0000-0000-000000000000";
+            }
+        }
+        public string llGetLinkName(int linknum)
+        {
+            SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum);
+            if (part != null)
+            {
+                return part.Name;
+            }
+            else
+            {
+                return "00000000-0000-0000-0000-000000000000";
+            }
+        }
+        public int llGetInventoryNumber(int type)
+        {
+            NotImplemented("llGetInventoryNumber");
+            return 0;
+        }
+        public string llGetInventoryName(int type, int number)
+        {
+            NotImplemented("llGetInventoryName");
+            return "";
+        }
+        public void llSetScriptState(string name, int run)
+        {
+            NotImplemented("llSetScriptState");
+        }
+        public double llGetEnergy()
+        {
+            return 1.0f;
+        }
+        public void llGiveInventory(string destination, string inventory)
+        {
+            NotImplemented("llGiveInventory");
+        }
+        public void llRemoveInventory(string item)
+        {
+            NotImplemented("llRemoveInventory");
+        }
+        public void llSetText(string text, LSL_Types.Vector3 color, double alpha)
+        {
+            Vector3 av3 = new Vector3((float)color.x, (float)color.y, (float)color.z);
+            m_host.SetText(text, av3, alpha);
+        }
+        public double llWater(LSL_Types.Vector3 offset)
+        {
+            return World.RegionInfo.EstateSettings.waterHeight;
+        }
+        public void llPassTouches(int pass)
+        {
+            NotImplemented("llPassTouches");
+        }
+        public string llRequestAgentData(string id, int data)
+        {
+            NotImplemented("llRequestAgentData");
+            return "";
+        }
+        public string llRequestInventoryData(string name)
+        {
+            NotImplemented("llRequestInventoryData");
+            return "";
+        }
+        public void llSetDamage(double damage)
+        {
+            NotImplemented("llSetDamage");
+        }
+        public void llTeleportAgentHome(string agent)
+        {
+            NotImplemented("llTeleportAgentHome");
+        }
+        public void llModifyLand(int action, int brush)
+        {
+            double dsize;
+            if (World.PermissionsMngr.CanTerraform(m_host.OwnerID, new LLVector3(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, 0)))
+            {
+                switch (brush)
+                {
+                    case 1:
+                        dsize = 2;
+                        break;
+                    case 2:
+                        dsize = 4;
+                        break;
+                    case 3:
+                        dsize = 8;
+                        break;
+                    default:
+                        if (brush < 0)
+                        {
+                            dsize = (double)(-1 * brush);
+                        }
+                        else
+                        {
+                            LSLError("Invalid brush size");
+                            dsize = 0; // Should cease execution, but get unassigned local variable dsize on compile.
+                        }
+                        break;
+                }
+                switch (action)
+                {
+                    case 0:
+                        if (World.Terrain.GetHeight((int)m_host.AbsolutePosition.X, (int)m_host.AbsolutePosition.Y) < m_host.AbsolutePosition.Z)
+                        {
+                            World.Terrain.FlattenTerrain(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, dsize, 1);
+                        }
+                        break;
+                    case 1:
+                        if (World.Terrain.GetHeight((int)m_host.AbsolutePosition.X, (int)m_host.AbsolutePosition.Y) < (double)m_host.AbsolutePosition.Z)
+                        {
+                            World.Terrain.RaiseTerrain(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, dsize, 0.1);
+                        }
+                        break;
+                    case 2:
+                        if (World.Terrain.GetHeight((int)m_host.AbsolutePosition.X, (int)m_host.AbsolutePosition.Y) > 0)
+                        {
+                            World.Terrain.LowerTerrain(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, dsize, 1);
+                        }
+                        break;
+                    case 3:
+                        World.Terrain.SmoothTerrain(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, dsize, 1);
+                        break;
+                    case 4:
+                        World.Terrain.NoiseTerrain(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, dsize, 1);
+                        break;
+                    case 5:
+                        World.Terrain.RevertTerrain(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, dsize, 1);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        public void llCollisionSound(string impact_sound, double impact_volume)
+        {
+            NotImplemented("llCollisionSound");
+        }
+        public void llCollisionSprite(string impact_sprite)
+        {
+            NotImplemented("llCollisionSprite");
+        }
+        public string llGetAnimation(string id)
+        {
+            NotImplemented("llGetAnimation");
+            return "";
+        }
+        public void llResetScript()
+        {
+            m_ScriptEngine.m_ScriptManager.ResetScript(m_localID, m_itemID);
+        }
+        public void llMessageLinked(int linknum, int num, string str, string id)
+        {
+        }
+        public void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local)
+        {
+        }
+        public void llPassCollisions(int pass)
+        {
+        }
+        public string llGetScriptName()
+        {
+            return "";
+        }
+        public int llGetNumberOfSides()
+        {
+            return 0;
+        }
+        public LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle)
+        {
+            return new LSL_Types.Quaternion();
+        }
+        public LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot)
+        {
+            return new LSL_Types.Vector3();
+        }
+        public void llRot2Angle()
+        {
+        }
+        public double llAcos(double val)
+        {
+            return (double)Math.Acos(val);
+        }
+        public double llAsin(double val)
+        {
+            return (double)Math.Asin(val);
+        }
+        public double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b)
+        {
+            return 0;
+        }
+        public string llGetInventoryKey(string name)
+        {
+            return "";
+        }
+        public void llAllowInventoryDrop(int add)
+        {
+        }
+        public LSL_Types.Vector3 llGetSunDirection()
+        {
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Vector3 llGetTextureOffset(int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            LSL_Types.Vector3 offset;
+            if (face == -1)
+            {
+                face = 0;
+            }
+            offset.x = tex.GetFace((uint)face).OffsetU;
+            offset.y = tex.GetFace((uint)face).OffsetV;
+            offset.z = 0.0;
+            return offset;
+        }
+        public LSL_Types.Vector3 llGetTextureScale(int side)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            LSL_Types.Vector3 scale;
+            if (side == -1)
+            {
+                side = 0;
+            }
+            scale.x = tex.GetFace((uint)side).RepeatU;
+            scale.y = tex.GetFace((uint)side).RepeatV;
+            scale.z = 0.0;
+            return scale;
+        }
+        public double llGetTextureRot(int face)
+        {
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face == -1)
+            {
+                face = 0;
+            }
+            return tex.GetFace((uint)face).Rotation;
+        }
+        public int llSubStringIndex(string source, string pattern)
+        {
+            return source.IndexOf(pattern);
+        }
+        public string llGetOwnerKey(string id)
+        {
+            NotImplemented("llGetOwnerKey");
+            return "";
+        }
+        public LSL_Types.Vector3 llGetCenterOfMass()
+        {
+            NotImplemented("llGetCenterOfMass");
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending)
+        {
+            // SortedList<string, LSL_Types.list> sorted = new SortedList<string, LSL_Types.list>();
+            // Add chunks to an array
+            //int s = stride;
+            //if (s < 1)
+            //    s = 1;
+            //int c = 0;
+            //LSL_Types.list chunk = new LSL_Types.list();
+            //string chunkString = "";
+            //foreach (string element in src)
+            //{
+            //    c++;
+            //    if (c > s)
+            //    {
+            //        sorted.Add(chunkString, chunk);
+            //        chunkString = "";
+            //        chunk = new LSL_Types.list();
+            //        c = 0;
+            //    }
+            //    chunk.Add(element);
+            //    chunkString += element.ToString();
+            //}
+            //if (chunk.Count > 0)
+            //    sorted.Add(chunkString, chunk);
+            //LSL_Types.list ret = new LSL_Types.list();
+            //foreach (LSL_Types.list ls in sorted.Values)
+            //{
+            //    ret.AddRange(ls);
+            //}
+            //if (ascending == LSL_BaseClass.TRUE)
+            //    return ret;
+            //ret.Reverse();
+            //return ret;
+            NotImplemented("llListSort");
+            return new LSL_Types.list();
+        }
+        public int llGetListLength(LSL_Types.list src)
+        {
+            return src.Length;
+        }
+        public int llList2Integer(LSL_Types.list src, int index)
+        {
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0;
+            }
+            return Convert.ToInt32(src.Data[index]);
+        }
+        public double osList2Double(LSL_Types.list src, int index)
+        {
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0.0;
+            }
+            return Convert.ToDouble(src.Data[index]);
+        }
+        public double llList2Float(LSL_Types.list src, int index)
+        {
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0.0;
+            }
+            return Convert.ToSingle(src.Data[index]);
+        }
+        public string llList2String(LSL_Types.list src, int index)
+        {
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return "";
+            }
+            return src.Data[index].ToString();
+        }
+        public string llList2Key(LSL_Types.list src, int index)
+        {
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return "00000000-0000-0000-0000-000000000000";
+            }
+            //return OpenSim.Framework.ToString(src[index]);
+            LLUUID tmpkey;
+            if (LLUUID.TryParse(src.Data[index].ToString(), out tmpkey))
+            {
+                return tmpkey.ToString();
+            }
+            else
+            {
+                return "00000000-0000-0000-0000-000000000000";
+            }
+        }
+        public LSL_Types.Vector3 llList2Vector(LSL_Types.list src, int index)
+        {
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return new LSL_Types.Vector3(0, 0, 0);
+            }
+            if (src.Data[index].GetType() == typeof(OpenSim.Region.ScriptEngine.Common.LSL_Types.Vector3))
+            {
+                return (LSL_Types.Vector3)src.Data[index];
+            }
+            else
+            {
+                return new LSL_Types.Vector3(0, 0, 0);
+            }
+        }
+        public LSL_Types.Quaternion llList2Rot(LSL_Types.list src, int index)
+        {
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return new LSL_Types.Quaternion(0, 0, 0, 1);
+            }
+            if (src.Data[index].GetType() == typeof(OpenSim.Region.ScriptEngine.Common.LSL_Types.Quaternion))
+            {
+                return (LSL_Types.Quaternion)src.Data[index];
+            }
+            else
+            {
+                return new LSL_Types.Quaternion(0, 0, 0, 1);
+            }
+        }
+        public LSL_Types.list llList2List(LSL_Types.list src, int start, int end)
+        {
+            return src.GetSublist(start, end);
+        }
+        public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end)
+        {
+            //LSL_Types.list ret = new LSL_Types.list(src);
+            //ret.RemoveRange(start, end - start);
+            //return ret;
+            // Just a hunch - needs testing
+            return src.GetSublist(end, start);
+        }
+        public int llGetListEntryType(LSL_Types.list src, int index)
+        {
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0;
+            }
+            if (src.Data[index] is System.Int32)
+                return 1;
+            if (src.Data[index] is System.Double)
+                return 2;
+            if (src.Data[index] is System.String)
+            {
+                LLUUID tuuid;
+                if (LLUUID.TryParse(src.Data[index].ToString(), out tuuid))
+                {
+                    return 3;
+                }
+                else
+                {
+                    return 4;
+                }
+            }
+            if (src.Data[index] is OpenSim.Region.ScriptEngine.Common.LSL_Types.Vector3)
+                return 5;
+            if (src.Data[index] is OpenSim.Region.ScriptEngine.Common.LSL_Types.Quaternion)
+                return 6;
+            if (src.Data[index] is OpenSim.Region.ScriptEngine.Common.LSL_Types.list)
+                return 7;
+            return 0;
+        }
+        public string llList2CSV(LSL_Types.list src)
+        {
+            string ret = "";
+            foreach (object o in src.Data)
+            {
+                ret = ret + o.ToString() + ",";
+            }
+            ret = ret.Substring(0, ret.Length - 2);
+            return ret;
+        }
+        public LSL_Types.list llCSV2List(string src)
+        {
+            return new LSL_Types.list(src.Split(",".ToCharArray()));
+        }
+        public LSL_Types.list llListRandomize(LSL_Types.list src, int stride)
+        {
+            //int s = stride;
+            //if (s < 1)
+            //    s = 1;
+            // This is a cowardly way of doing it ;)
+            // TODO: Instead, randomize and check if random is mod stride or if it can not be, then array.removerange
+            //List<LSL_Types.list> tmp = new List<LSL_Types.list>();
+            // Add chunks to an array
+            //int c = 0;
+            //LSL_Types.list chunk = new LSL_Types.list();
+            //foreach (string element in src)
+            //{
+            //    c++;
+            //    if (c > s)
+            //    {
+            //        tmp.Add(chunk);
+            //        chunk = new LSL_Types.list();
+            //        c = 0;
+            //    }
+            //    chunk.Add(element);
+            //}
+            //if (chunk.Count > 0)
+            //    tmp.Add(chunk);
+            // Decreate (<- what kind of word is that? :D ) array back into a list
+            //int rnd;
+            //LSL_Types.list ret = new LSL_Types.list();
+            //while (tmp.Count > 0)
+            //{
+            //    rnd = Util.RandomClass.Next(tmp.Count);
+            //    foreach (string str in tmp[rnd])
+            //    {
+            //       ret.Add(str);
+            //    }
+            //    tmp.RemoveAt(rnd);
+            //}
+            //return ret;
+            NotImplemented("llListRandomize");
+            return new LSL_Types.list();
+        }
+        public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride)
+        {
+            LSL_Types.list ret = new LSL_Types.list();
+            //int s = stride;
+            //if (s < 1)
+            //    s = 1;
+            //int sc = s;
+            //for (int i = start; i < src.Count; i++)
+            //{
+            //    sc--;
+            //    if (sc == 0)
+            //    {
+            //        sc = s;
+            //       // Addthis
+            //        ret.Add(src[i]);
+            //    }
+            //    if (i == end)
+            //        break;
+            //}
+            NotImplemented("llList2ListStrided");
+            return ret;
+        }
+        public LSL_Types.Vector3 llGetRegionCorner()
+        {
+            return new LSL_Types.Vector3(World.RegionInfo.RegionLocX * 256, World.RegionInfo.RegionLocY * 256, 0);
+        }
+        public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int start)
+        {
+            return dest.GetSublist(0, start - 1) + src + dest.GetSublist(start, -1);
+        }
+        public int llListFindList(LSL_Types.list src, LSL_Types.list test)
+        {
+            //foreach (string s in test)
+            //{
+            //    for (int ci = 0; ci < src.Count; ci++)
+            //    {
+            //        if (s == src[ci])
+            //            return ci;
+            //    }
+            //}
+            NotImplemented("llListFindList");
+            return -1;
+        }
+        public string llGetObjectName()
+        {
+            return m_host.Name;
+        }
+        public void llSetObjectName(string name)
+        {
+            m_host.Name = name;
+        }
+        public string llGetDate()
+        {
+            DateTime date = DateTime.Now.ToUniversalTime();
+            string result = date.ToString("yyyy-MM-dd");
+            return result;
+        }
+        public int llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir)
+        {
+            NotImplemented("llEdgeOfWorld");
+            return 0;
+        }
+        public int llGetAgentInfo(string id)
+        {
+            NotImplemented("llGetAgentInfo");
+            return 0;
+        }
+        public void llAdjustSoundVolume(double volume)
+        {
+            NotImplemented("llAdjustSoundVolume");
+        }
+        public void llSetSoundQueueing(int queue)
+        {
+            NotImplemented("llSetSoundQueueing");
+        }
+        public void llSetSoundRadius(double radius)
+        {
+            NotImplemented("llSetSoundRadius");
+        }
+        public string llKey2Name(string id)
+        {
+            NotImplemented("llKey2Name");
+            return "";
+        }
+        public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate)
+        {
+            NotImplemented("llSetTextureAnim");
+        }
+        public void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east,
+                                          LSL_Types.Vector3 bottom_south_west)
+        {
+            NotImplemented("llTriggerSoundLimited");
+        }
+        public void llEjectFromLand(string pest)
+        {
+            NotImplemented("llEjectFromLand");
+        }
+        public void llParseString2List()
+        {
+            NotImplemented("llParseString2List");
+        }
+        public int llOverMyLand(string id)
+        {
+            NotImplemented("llOverMyLand");
+            return 0;
+        }
+        public string llGetLandOwnerAt(LSL_Types.Vector3 pos)
+        {
+            return World.GetLandOwner((float)pos.x, (float)pos.y).ToString();
+        }
+        public string llGetNotecardLine(string name, int line)
+        {
+            NotImplemented("llGetNotecardLine");
+            return "";
+        }
+        public LSL_Types.Vector3 llGetAgentSize(string id)
+        {
+            NotImplemented("llGetAgentSize");
+            return new LSL_Types.Vector3();
+        }
+        public int llSameGroup(string agent)
+        {
+            NotImplemented("llSameGroup");
+            return 0;
+        }
+        public void llUnSit(string id)
+        {
+            NotImplemented("llUnSit");
+        }
+        public LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset)
+        {
+            NotImplemented("llGroundSlope");
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset)
+        {
+            NotImplemented("llGroundNormal");
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset)
+        {
+            NotImplemented("llGroundContour");
+            return new LSL_Types.Vector3();
+        }
+        public int llGetAttached()
+        {
+            NotImplemented("llGetAttached");
+            return 0;
+        }
+        public int llGetFreeMemory()
+        {
+            NotImplemented("llGetFreeMemory");
+            return 0;
+        }
+        public string llGetRegionName()
+        {
+            return World.RegionInfo.RegionName;
+        }
+        public double llGetRegionTimeDilation()
+        {
+            return (double)World.TimeDilation;
+        }
+        public double llGetRegionFPS()
+        {
+            return 10.0f;
+        }
+        /* particle system rules should be coming into this routine as doubles, that is
+        rule[0] should be an integer from this list and rule[1] should be the arg
+        for the same integer. wiki.secondlife.com has most of this mapping, but some
+        came from http://www.caligari-designs.com/p4u2
+        We iterate through the list for 'Count' elements, incrementing by two for each
+        iteration and set the members of Primitive.ParticleSystem, one at a time.
+        */
+        public enum PrimitiveRule : int
+        {
+            PSYS_PART_FLAGS = 0,
+            PSYS_PART_START_COLOR = 1,
+            PSYS_PART_START_ALPHA = 2,
+            PSYS_PART_END_COLOR = 3,
+            PSYS_PART_END_ALPHA = 4,
+            PSYS_PART_START_SCALE = 5,
+            PSYS_PART_END_SCALE = 6,
+            PSYS_PART_MAX_AGE = 7,
+            PSYS_SRC_ACCEL = 8,
+            PSYS_SRC_PATTERN = 9,
+            PSYS_SRC_TEXTURE = 12,
+            PSYS_SRC_BURST_RATE = 13,
+            PSYS_SRC_BURST_PART_COUNT = 15,
+            PSYS_SRC_BURST_RADIUS = 16,
+            PSYS_SRC_BURST_SPEED_MIN = 17,
+            PSYS_SRC_BURST_SPEED_MAX = 18,
+            PSYS_SRC_MAX_AGE = 19,
+            PSYS_SRC_TARGET_KEY = 20,
+            PSYS_SRC_OMEGA = 21,
+            PSYS_SRC_ANGLE_BEGIN = 22,
+            PSYS_SRC_ANGLE_END = 23
+        }
+        public void llParticleSystem(List<Object> rules)
+        {
+            Primitive.ParticleSystem prules = new Primitive.ParticleSystem();
+            for (int i = 0; i < rules.Count; i += 2)
+            {
+                switch ((int)rules[i])
+                {
+                    case (int)LSL_BaseClass.PSYS_PART_FLAGS:
+                        prules.PartFlags = (uint)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_PART_START_COLOR:
+                        prules.PartStartColor = (LLColor)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_PART_START_ALPHA:
+                        //what is the cast?                    prules.PartStartColor = (LSL_Types.Vec)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_PART_END_COLOR:
+                        prules.PartEndColor = (LLColor)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_PART_END_ALPHA:
+                        //what is the cast?                    prules.PartStartColor = (LLColor)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_PART_START_SCALE:
+                        //what is the cast?                    prules.PartStartColor = (LLColor)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_PART_END_SCALE:
+                        //what is the cast?                    prules.PartStartColor = (LLColor)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_PART_MAX_AGE:
+                        prules.MaxAge = (float)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_ACCEL:
+                        //what is the cast?                    prules.PartStartColor = (LLColor)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_PATTERN:
+                        //what is the cast?                    prules.PartStartColor = (LLColor)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_TEXTURE:
+                        prules.Texture = (LLUUID)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_BURST_RATE:
+                        prules.BurstRate = (float)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_BURST_PART_COUNT:
+                        prules.BurstPartCount = (byte)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_BURST_RADIUS:
+                        prules.BurstRadius = (float)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_BURST_SPEED_MIN:
+                        prules.BurstSpeedMin = (float)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_BURST_SPEED_MAX:
+                        prules.BurstSpeedMax = (float)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_MAX_AGE:
+                        prules.MaxAge = (float)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_TARGET_KEY:
+                        prules.Target = (LLUUID)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_OMEGA:
+                        //cast??                    prules.MaxAge = (float)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_ANGLE_BEGIN:
+                        prules.InnerAngle = (float)rules[i + 1];
+                        break;
+                    case (int)LSL_BaseClass.PSYS_SRC_ANGLE_END:
+                        prules.OuterAngle = (float)rules[i + 1];
+                        break;
+                }
+            }
+            m_host.AddNewParticleSystem(prules);
+        }
+        public void llGroundRepel(double height, int water, double tau)
+        {
+            NotImplemented("llGroundRepel");
+        }
+        public void llGiveInventoryList()
+        {
+            NotImplemented("llGiveInventoryList");
+        }
+        public void llSetVehicleType(int type)
+        {
+            NotImplemented("llSetVehicleType");
+        }
+        public void llSetVehicledoubleParam(int param, double value)
+        {
+            NotImplemented("llSetVehicledoubleParam");
+        }
+        public void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec)
+        {
+            NotImplemented("llSetVehicleVectorParam");
+        }
+        public void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot)
+        {
+            NotImplemented("llSetVehicleRotationParam");
+        }
+        public void llSetVehicleFlags(int flags)
+        {
+            NotImplemented("llSetVehicleFlags");
+        }
+        public void llRemoveVehicleFlags(int flags)
+        {
+            NotImplemented("llRemoveVehicleFlags");
+        }
+        public void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot)
+        {
+            // LSL quaternions can normalize to 0, normal Quaternions can't.
+            if (rot.s == 0 && rot.x == 0 && rot.y == 0 && rot.z == 0)
+                rot.z = 1; // ZERO_ROTATION = 0,0,0,1
+            m_host.SetSitTarget(new Vector3((float)offset.x, (float)offset.y, (float)offset.z), new Quaternion((float)rot.s, (float)rot.x, (float)rot.y, (float)rot.z));
+        }
+        public string llAvatarOnSitTarget()
+        {
+            LLUUID AVID = m_host.GetAvatarOnSitTarget();
+            if (AVID != LLUUID.Zero)
+                return AVID.ToString();
+            else
+                return "";
+        }
+        public void llAddToLandPassList(string avatar, double hours)
+        {
+            NotImplemented("llAddToLandPassList");
+        }
+        public void llSetTouchText(string text)
+        {
+            m_host.TouchName = text;
+        }
+        public void llSetSitText(string text)
+        {
+            m_host.SitName = text;
+        }
+        public void llSetCameraEyeOffset(LSL_Types.Vector3 offset)
+        {
+            NotImplemented("llSetCameraEyeOffset");
+        }
+        public void llSetCameraAtOffset(LSL_Types.Vector3 offset)
+        {
+            NotImplemented("llSetCameraAtOffset");
+        }
+        public string llDumpList2String(LSL_Types.list src, string seperator)
+        {
+            if (src.Length == 0)
+            {
+                return "";
+            }
+            string ret = "";
+            foreach (object o in src.Data)
+            {
+                ret = ret + o.ToString() + seperator;
+            }
+            ret = ret.Substring(0, ret.Length - seperator.Length);
+            return ret;
+        }
+        public void llScriptDanger(LSL_Types.Vector3 pos)
+        {
+            NotImplemented("llScriptDanger");
+        }
+        public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel)
+        {
+            NotImplemented("llDialog");
+        }
+        public void llVolumeDetect(int detect)
+        {
+            NotImplemented("llVolumeDetect");
+        }
+        public void llResetOtherScript(string name)
+        {
+            NotImplemented("llResetOtherScript");
+        }
+        public int llGetScriptState(string name)
+        {
+            NotImplemented("llGetScriptState");
+            return 0;
+        }
+        public void llRemoteLoadScript()
+        {
+            NotImplemented("llRemoteLoadScript");
+        }
+        public void llSetRemoteScriptAccessPin(int pin)
+        {
+            NotImplemented("llSetRemoteScriptAccessPin");
+        }
+        public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param)
+        {
+            NotImplemented("llRemoteLoadScriptPin");
+        }
+        //  remote_data(integer type, key channel, key message_id, string sender, integer ival, string sval)
+        // Not sure where these constants should live:
+        // REMOTE_DATA_CHANNEL = 1
+        // REMOTE_DATA_REQUEST = 2
+        // REMOTE_DATA_REPLY = 3
+        public void llOpenRemoteDataChannel()
+        {
+            IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            if (xmlrpcMod.IsEnabled())
+            {
+                LLUUID channelID = xmlrpcMod.OpenXMLRPCChannel(m_localID, m_itemID);
+                object[] resobj = new object[] { 1, channelID.ToString(), LLUUID.Zero.ToString(), "", 0, "" };
+                m_ScriptEngine.m_EventQueueManager.AddToScriptQueue(m_localID, m_itemID, "remote_data", resobj);
+            }
+        }
+        public string llSendRemoteData(string channel, string dest, int idata, string sdata)
+        {
+            NotImplemented("llSendRemoteData");
+            return "";
+        }
+        public void llRemoteDataReply(string channel, string message_id, string sdata, int idata)
+        {
+            IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            xmlrpcMod.RemoteDataReply(channel, message_id, sdata, idata);
+        }
+        public void llCloseRemoteDataChannel(string channel)
+        {
+            IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            xmlrpcMod.CloseXMLRPCChannel(channel);
+        }
+        public string llMD5String(string src, int nonce)
+        {
+            return Util.Md5Hash(src + ":" + nonce.ToString());
+        }
+        public void llSetPrimitiveParams(LSL_Types.list rules)
+        {
+            NotImplemented("llSetPrimitiveParams");
+        }
+        public string llStringToBase64(string str)
+        {
+            try
+            {
+                byte[] encData_byte = new byte[str.Length];
+                encData_byte = Encoding.UTF8.GetBytes(str);
+                string encodedData = Convert.ToBase64String(encData_byte);
+                return encodedData;
+            }
+            catch (Exception e)
+            {
+                throw new Exception("Error in base64Encode" + e.Message);
+            }
+        }
+        public string llBase64ToString(string str)
+        {
+            UTF8Encoding encoder = new UTF8Encoding();
+            Decoder utf8Decode = encoder.GetDecoder();
+            try
+            {
+                byte[] todecode_byte = Convert.FromBase64String(str);
+                int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
+                char[] decoded_char = new char[charCount];
+                utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
+                string result = new String(decoded_char);
+                return result;
+            }
+            catch (Exception e)
+            {
+                throw new Exception("Error in base64Decode" + e.Message);
+            }
+        }
+        public void llXorBase64Strings()
+        {
+            throw new Exception("Command deprecated! Use llXorBase64StringsCorrect instead.");
+        }
+        public void llRemoteDataSetRegion()
+        {
+            NotImplemented("llRemoteDataSetRegion");
+        }
+        public double llLog10(double val)
+        {
+            return (double)Math.Log10(val);
+        }
+        public double llLog(double val)
+        {
+            return (double)Math.Log(val);
+        }
+        public LSL_Types.list llGetAnimationList(string id)
+        {
+            NotImplemented("llGetAnimationList");
+            return new LSL_Types.list();
+        }
+        public void llSetParcelMusicURL(string url)
+        {
+            LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y);
+            if (landowner.Equals(null))
+            {
+                return;
+            }
+            if (landowner != m_host.ObjectOwner)
+            {
+                return;
+            }
+            World.SetLandMusicURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url);
+        }
+        public LSL_Types.Vector3 llGetRootPosition()
+        {
+            return new LSL_Types.Vector3(m_host.ParentGroup.AbsolutePosition.X, m_host.ParentGroup.AbsolutePosition.Y, m_host.ParentGroup.AbsolutePosition.Z);
+        }
+        public LSL_Types.Quaternion llGetRootRotation()
+        {
+            return new LSL_Types.Quaternion(m_host.ParentGroup.GroupRotation.X, m_host.ParentGroup.GroupRotation.Y, m_host.ParentGroup.GroupRotation.Z, m_host.ParentGroup.GroupRotation.W);
+        }
+        public string llGetObjectDesc()
+        {
+            return m_host.Description;
+        }
+        public void llSetObjectDesc(string desc)
+        {
+            m_host.Description = desc;
+        }
+        public string llGetCreator()
+        {
+            return m_host.ObjectCreator.ToString();
+        }
+        public string llGetTimestamp()
+        {
+            return DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ");
+        }
+        public void llSetLinkAlpha(int linknumber, double alpha, int face)
+        {
+            SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber);
+            if (linknumber > -1)
+            {
+                LLObject.TextureEntry tex = part.Shape.Textures;
+                LLColor texcolor;
+                if (face > -1)
+                {
+                    texcolor = tex.CreateFace((uint)face).RGBA;
+                    texcolor.A = (float)Math.Abs(alpha - 1);
+                    tex.FaceTextures[face].RGBA = texcolor;
+                    part.UpdateTexture(tex);
+                    return;
+                }
+                else if (face == -1)
+                {
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.A = (float)Math.Abs(alpha - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                    for (uint i = 0; i < 32; i++)
+                    {
+                        if (tex.FaceTextures[i] != null)
+                        {
+                            texcolor = tex.FaceTextures[i].RGBA;
+                            texcolor.A = (float)Math.Abs(alpha - 1);
+                            tex.FaceTextures[i].RGBA = texcolor;
+                        }
+                    }
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.A = (float)Math.Abs(alpha - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                    part.UpdateTexture(tex);
+                    return;
+                }
+                return;
+            }
+            else if (linknumber == -1)
+            {
+                int num = m_host.ParentGroup.PrimCount;
+                for (int w = 0; w < num; w++)
+                {
+                    linknumber = w;
+                    part = m_host.ParentGroup.GetLinkNumPart(linknumber);
+                    LLObject.TextureEntry tex = part.Shape.Textures;
+                    LLColor texcolor;
+                    if (face > -1)
+                    {
+                        texcolor = tex.CreateFace((uint)face).RGBA;
+                        texcolor.A = (float)Math.Abs(alpha - 1);
+                        tex.FaceTextures[face].RGBA = texcolor;
+                        part.UpdateTexture(tex);
+                    }
+                    else if (face == -1)
+                    {
+                        texcolor = tex.DefaultTexture.RGBA;
+                        texcolor.A = (float)Math.Abs(alpha - 1);
+                        tex.DefaultTexture.RGBA = texcolor;
+                        for (uint i = 0; i < 32; i++)
+                        {
+                            if (tex.FaceTextures[i] != null)
+                            {
+                                texcolor = tex.FaceTextures[i].RGBA;
+                                texcolor.A = (float)Math.Abs(alpha - 1);
+                                tex.FaceTextures[i].RGBA = texcolor;
+                            }
+                        }
+                        texcolor = tex.DefaultTexture.RGBA;
+                        texcolor.A = (float)Math.Abs(alpha - 1);
+                        tex.DefaultTexture.RGBA = texcolor;
+                        part.UpdateTexture(tex);
+                    }
+                }
+                return;
+            }
+            else
+            {
+                NotImplemented("llSetLinkAlpha");
+            }
+        }
+        public int llGetNumberOfPrims()
+        {
+            return m_host.ParentGroup.PrimCount;
+        }
+        public string llGetNumberOfNotecardLines(string name)
+        {
+            NotImplemented("llGetNumberOfNotecardLines");
+            return "";
+        }
+        public LSL_Types.list llGetBoundingBox(string obj)
+        {
+            NotImplemented("llGetBoundingBox");
+            return new LSL_Types.list();
+        }
+        public LSL_Types.Vector3 llGetGeometricCenter()
+        {
+            return new LSL_Types.Vector3(m_host.GetGeometricCenter().X, m_host.GetGeometricCenter().Y, m_host.GetGeometricCenter().Z);
+        }
+        public void llGetPrimitiveParams()
+        {
+            NotImplemented("llGetPrimitiveParams");
+        }
+        public string llIntegerToBase64(int number)
+        {
+            NotImplemented("llIntegerToBase64");
+            return "";
+        }
+        public int llBase64ToInteger(string str)
+        {
+            NotImplemented("llBase64ToInteger");
+            return 0;
+        }
+        public double llGetGMTclock()
+        {
+            return DateTime.UtcNow.TimeOfDay.TotalSeconds;
+        }
+        public string llGetSimulatorHostname()
+        {
+            return System.Environment.MachineName;
+        }
+        public void llSetLocalRot(LSL_Types.Quaternion rot)
+        {
+            m_host.RotationOffset = new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s);
+        }
+        public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list seperators, LSL_Types.list spacers)
+        {
+            NotImplemented("llParseStringKeepNulls");
+            return new LSL_Types.list();
+        }
+        public void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity,
+                                LSL_Types.Quaternion rot, int param)
+        {
+            NotImplemented("llRezAtRoot");
+        }
+        public int llGetObjectPermMask(int mask)
+        {
+            NotImplemented("llGetObjectPermMask");
+            return 0;
+        }
+        public void llSetObjectPermMask(int mask, int value)
+        {
+            NotImplemented("llSetObjectPermMask");
+        }
+        public void llGetInventoryPermMask(string item, int mask)
+        {
+            NotImplemented("llGetInventoryPermMask");
+        }
+        public void llSetInventoryPermMask(string item, int mask, int value)
+        {
+            NotImplemented("llSetInventoryPermMask");
+        }
+        public string llGetInventoryCreator(string item)
+        {
+            NotImplemented("llGetInventoryCreator");
+            return "";
+        }
+        public void llOwnerSay(string msg)
+        {
+            //temp fix so that lsl wiki examples aren't annoying to use to test other functions
+            World.SimChat(Helpers.StringToField(msg), ChatTypeEnum.Say, 0, m_host.AbsolutePosition, m_host.Name, m_host.UUID);
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(m_host.UUID.ToString(), ChatTypeEnum.Say, 0, m_host.Name, msg);
+        }
+        public void llRequestSimulatorData(string simulator, int data)
+        {
+            NotImplemented("llRequestSimulatorData");
+        }
+        public void llForceMouselook(int mouselook)
+        {
+            NotImplemented("llForceMouselook");
+        }
+        public double llGetObjectMass(string id)
+        {
+            NotImplemented("llGetObjectMass");
+            return 0;
+        }
+        public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end)
+        {
+            return dest.GetSublist(0, start - 1) + src + dest.GetSublist(end + 1, -1);
+        }
+        public void llLoadURL(string avatar_id, string message, string url)
+        {
+            LLUUID avatarId = new LLUUID(avatar_id);
+            m_ScriptEngine.World.SendUrlToUser(avatarId, m_host.Name, m_host.UUID, m_host.ObjectOwner, false, message,
+                                               url);
+        }
+        public void llParcelMediaCommandList(LSL_Types.list commandList)
+        {
+            NotImplemented("llParcelMediaCommandList");
+        }
+        public void llParcelMediaQuery()
+        {
+            NotImplemented("llParcelMediaQuery");
+        }
+        public int llModPow(int a, int b, int c)
+        {
+            Int64 tmp = 0;
+            Int64 val = Math.DivRem(Convert.ToInt64(Math.Pow(a, b)), c, out tmp);
+            return Convert.ToInt32(tmp);
+        }
+        public int llGetInventoryType(string name)
+        {
+            NotImplemented("llGetInventoryType");
+            return 0;
+        }
+        public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons)
+        {
+            NotImplemented("llSetPayPrice");
+        }
+        public LSL_Types.Vector3 llGetCameraPos()
+        {
+            NotImplemented("llGetCameraPos");
+            return new LSL_Types.Vector3();
+        }
+        public LSL_Types.Quaternion llGetCameraRot()
+        {
+            NotImplemented("llGetCameraRot");
+            return new LSL_Types.Quaternion();
+        }
+        public void llSetPrimURL()
+        {
+            NotImplemented("llSetPrimURL");
+        }
+        public void llRefreshPrimURL()
+        {
+            NotImplemented("llRefreshPrimURL");
+        }
+        public string llEscapeURL(string url)
+        {
+            try
+            {
+                return Uri.EscapeUriString(url);
+            }
+            catch (Exception ex)
+            {
+                return "llEscapeURL: " + ex.ToString();
+            }
+        }
+        public string llUnescapeURL(string url)
+        {
+            try
+            {
+                return Uri.UnescapeDataString(url);
+            }
+            catch (Exception ex)
+            {
+                return "llUnescapeURL: " + ex.ToString();
+            }
+        }
+        public void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at)
+        {
+            NotImplemented("llMapDestination");
+        }
+        public void llAddToLandBanList(string avatar, double hours)
+        {
+            NotImplemented("llAddToLandBanList");
+        }
+        public void llRemoveFromLandPassList(string avatar)
+        {
+            NotImplemented("llRemoveFromLandPassList");
+        }
+        public void llRemoveFromLandBanList(string avatar)
+        {
+            NotImplemented("llRemoveFromLandBanList");
+        }
+        public void llSetCameraParams(LSL_Types.list rules)
+        {
+            NotImplemented("llSetCameraParams");
+        }
+        public void llClearCameraParams()
+        {
+            NotImplemented("llClearCameraParams");
+        }
+        public double llListStatistics(int operation, LSL_Types.list src)
+        {
+            NotImplemented("llListStatistics");
+            return 0;
+        }
+        public int llGetUnixTime()
+        {
+            return Util.UnixTimeSinceEpoch();
+        }
+        public int llGetParcelFlags(LSL_Types.Vector3 pos)
+        {
+            NotImplemented("llGetParcelFlags");
+            return 0;
+        }
+        public int llGetRegionFlags()
+        {
+            NotImplemented("llGetRegionFlags");
+            return 0;
+        }
+        public string llXorBase64StringsCorrect(string str1, string str2)
+        {
+            string ret = "";
+            string src1 = llBase64ToString(str1);
+            string src2 = llBase64ToString(str2);
+            int c = 0;
+            for (int i = 0; i < src1.Length; i++)
+            {
+                ret += src1[i] ^ src2[c];
+                c++;
+                if (c > src2.Length)
+                    c = 0;
+            }
+            return llStringToBase64(ret);
+        }
+        public string llHTTPRequest(string url, LSL_Types.list parameters, string body)
+        {
+            IHttpRequests httpScriptMod =
+                m_ScriptEngine.World.RequestModuleInterface<IHttpRequests>();
+            List<string> param = new List<string>();
+            foreach (object o in parameters.Data)
+            {
+                param.Add(o.ToString());
+            }
+            LLUUID reqID = httpScriptMod.
+                StartHttpRequest(m_localID, m_itemID, url, param, body);
+            if (!reqID.Equals(null))
+                return reqID.ToString();
+            else
+                return null;
+        }
+        public void llResetLandBanList()
+        {
+            NotImplemented("llResetLandBanList");
+        }
+        public void llResetLandPassList()
+        {
+            NotImplemented("llResetLandPassList");
+        }
+        public int llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide)
+        {
+            NotImplemented("llGetParcelPrimCount");
+            return 0;
+        }
+        public LSL_Types.list llGetParcelPrimOwners(LSL_Types.Vector3 pos)
+        {
+            NotImplemented("llGetParcelPrimOwners");
+            return new LSL_Types.list();
+        }
+        public int llGetObjectPrimCount(string object_id)
+        {
+            SceneObjectPart part = World.GetSceneObjectPart(new LLUUID(object_id));
+            if (part == null)
+            {
+                return 0;
+            }
+            else
+            {
+                return part.ParentGroup.Children.Count;
+            }
+        }
+        public int llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide)
+        {
+            // Alondria: This currently just is utilizing the normal grid's 0.22 prims/m2 calculation
+            // Which probably will be irrelevent in OpenSim....
+            LandData land = World.GetLandData((float)pos.x, (float)pos.y);
+            float bonusfactor = World.RegionInfo.EstateSettings.objectBonusFactor;
+            if (land == null)
+            {
+                return 0;
+            }
+            if (sim_wide == 1)
+            {
+                decimal v = land.simwideArea * (decimal)(0.22) * (decimal)bonusfactor;
+                return (int)v;
+            }
+            else
+            {
+                decimal v = land.area * (decimal)(0.22) * (decimal)bonusfactor;
+                return (int)v;
+            }
+        }
+        public LSL_Types.list llGetParcelDetails(LSL_Types.Vector3 pos, LSL_Types.list param)
+        {
+            LandData land = World.GetLandData((float)pos.x, (float)pos.y);
+            if (land == null)
+            {
+                return new LSL_Types.list(0);
+            }
+            LSL_Types.list ret = new LSL_Types.list();
+            foreach (object o in param.Data)
+            {
+                switch (o.ToString())
+                {
+                    case "0":
+                        ret = ret + new LSL_Types.list(land.landName);
+                        break;
+                    case "1":
+                        ret = ret + new LSL_Types.list(land.landDesc);
+                        break;
+                    case "2":
+                        ret = ret + new LSL_Types.list(land.ownerID.ToString());
+                        break;
+                    case "3":
+                        ret = ret + new LSL_Types.list(land.groupID.ToString());
+                        break;
+                    case "4":
+                        ret = ret + new LSL_Types.list(land.area);
+                        break;
+                    default:
+                        ret = ret + new LSL_Types.list(0);
+                        break;
+                }
+            }
+            return ret;
+        }
+        //
+        // OpenSim functions
+        //
+        public int osTerrainSetHeight(int x, int y, double val)
+        {
+            if (x > 255 || x < 0 || y > 255 || y < 0)
+                LSLError("osTerrainSetHeight: Coordinate out of bounds");
+            if (World.PermissionsMngr.CanTerraform(m_host.OwnerID, new LLVector3(x, y, 0)))
+            {
+                World.Terrain.Set(x, y, val);
+                return 1;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+        public double osTerrainGetHeight(int x, int y)
+        {
+            if (x > 255 || x < 0 || y > 255 || y < 0)
+                LSLError("osTerrainGetHeight: Coordinate out of bounds");
+            return World.Terrain.GetHeight(x, y);
+        }
+        public int osRegionRestart(double seconds)
+        {
+            if (World.PermissionsMngr.CanRestartSim(m_host.OwnerID))
+            {
+                World.Restart((float)seconds);
+                return 1;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+        public void osRegionNotice(string msg)
+        {
+            World.SendGeneralAlert(msg);
+        }
+        public string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams,
+                                             int timer)
+        {
+            if (dynamicID == "")
+            {
+                IDynamicTextureManager textureManager = World.RequestModuleInterface<IDynamicTextureManager>();
+                LLUUID createdTexture =
+                    textureManager.AddDynamicTextureURL(World.RegionInfo.RegionID, m_host.UUID, contentType, url,
+                                                        extraParams, timer);
+                return createdTexture.ToString();
+            }
+            else
+            {
+                //TODO update existing dynamic textures
+            }
+            return LLUUID.Zero.ToString();
+        }
+        private void NotImplemented(string Command)
+        {
+            if (throwErrorOnNotImplemented)
+                throw new NotImplementedException("Command not implemented: " + Command);
+        }
+        private void LSLError(string msg)
+        {
+            throw new Exception("LSL Runtime Error: " + msg);
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/AppDomainManager.cs b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/AppDomainManager.cs
new file mode 100644
index 0000000..4eea69a
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/AppDomainManager.cs
@@ -0,0 +1,238 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenSim.Region.ScriptEngine.Common;
+namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+{
+    public class AppDomainManager
+    {
+        //
+        // This class does AppDomain handling and loading/unloading of scripts in it.
+        // It is instanced in "ScriptEngine" and controlled from "ScriptManager"
+        //
+        // 1. Create a new AppDomain if old one is full (or doesn't exist)
+        // 2. Load scripts into AppDomain
+        // 3. Unload scripts from AppDomain (stopping them and marking them as inactive)
+        // 4. Unload AppDomain completely when all scripts in it has stopped
+        //
+        private int maxScriptsPerAppDomain = 1;
+        /// <summary>
+        /// Internal list of all AppDomains
+        /// </summary>
+        private List<AppDomainStructure> appDomains = new List<AppDomainStructure>();
+        /// <summary>
+        /// Structure to keep track of data around AppDomain
+        /// </summary>
+        private class AppDomainStructure
+        {
+            /// <summary>
+            /// The AppDomain itself
+            /// </summary>
+            public AppDomain CurrentAppDomain;
+            /// <summary>
+            /// Number of scripts loaded into AppDomain
+            /// </summary>
+            public int ScriptsLoaded;
+            /// <summary>
+            /// Number of dead scripts
+            /// </summary>
+            public int ScriptsWaitingUnload;
+        }
+        /// <summary>
+        /// Current AppDomain
+        /// </summary>
+        private AppDomainStructure currentAD;
+        private object getLock = new object(); // Mutex
+        private object freeLock = new object(); // Mutex
+        //private ScriptEngine m_scriptEngine;
+        //public AppDomainManager(ScriptEngine scriptEngine)
+        public AppDomainManager()
+        {
+            //m_scriptEngine = scriptEngine;
+        }
+        /// <summary>
+        /// Find a free AppDomain, creating one if necessary
+        /// </summary>
+        /// <returns>Free AppDomain</returns>
+        private AppDomainStructure GetFreeAppDomain()
+        {
+            Console.WriteLine("Finding free AppDomain");
+            lock (getLock)
+            {
+                // Current full?
+                if (currentAD != null && currentAD.ScriptsLoaded >= maxScriptsPerAppDomain)
+                {
+                    // Add it to AppDomains list and empty current
+                    appDomains.Add(currentAD);
+                    currentAD = null;
+                }
+                // No current
+                if (currentAD == null)
+                {
+                    // Create a new current AppDomain
+                    currentAD = new AppDomainStructure();
+                    currentAD.CurrentAppDomain = PrepareNewAppDomain();
+                }
+                Console.WriteLine("Scripts loaded in this Appdomain: " + currentAD.ScriptsLoaded);
+                return currentAD;
+            } // lock
+        }
+        private int AppDomainNameCount;
+        /// <summary>
+        /// Create and prepare a new AppDomain for scripts
+        /// </summary>
+        /// <returns>The new AppDomain</returns>
+        private AppDomain PrepareNewAppDomain()
+        {
+            // Create and prepare a new AppDomain
+            AppDomainNameCount++;
+            // TODO: Currently security match current appdomain
+            // Construct and initialize settings for a second AppDomain.
+            AppDomainSetup ads = new AppDomainSetup();
+            ads.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
+            ads.DisallowBindingRedirects = false;
+            ads.DisallowCodeDownload = true;
+            ads.LoaderOptimization = LoaderOptimization.MultiDomain; // Sounds good ;)
+            ads.ShadowCopyFiles = "true"; // Enabled shadowing
+            ads.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
+            AppDomain AD = AppDomain.CreateDomain("ScriptAppDomain_" + AppDomainNameCount, null, ads);
+            Console.WriteLine("Loading: " +
+                              AssemblyName.GetAssemblyName("OpenSim.Region.ScriptEngine.Common.dll").ToString());
+            AD.Load(AssemblyName.GetAssemblyName("OpenSim.Region.ScriptEngine.Common.dll"));
+            // Return the new AppDomain
+            return AD;
+        }
+        /// <summary>
+        /// Unload appdomains that are full and have only dead scripts
+        /// </summary>
+        private void UnloadAppDomains()
+        {
+            lock (freeLock)
+            {
+                // Go through all
+                foreach (AppDomainStructure ads in new ArrayList(appDomains))
+                {
+                    // Don't process current AppDomain
+                    if (ads.CurrentAppDomain != currentAD.CurrentAppDomain)
+                    {
+                        // Not current AppDomain
+                        // Is number of unloaded bigger or equal to number of loaded?
+                        if (ads.ScriptsLoaded <= ads.ScriptsWaitingUnload)
+                        {
+                            Console.WriteLine("Found empty AppDomain, unloading");
+                            // Remove from internal list
+                            appDomains.Remove(ads);
+#if DEBUG
+                            long m = GC.GetTotalMemory(true);
+#endif
+                            // Unload
+                            AppDomain.Unload(ads.CurrentAppDomain);
+#if DEBUG
+                            Console.WriteLine("AppDomain unload freed " + (m - GC.GetTotalMemory(true)) +
+                                              " bytes of memory");
+#endif
+                        }
+                    }
+                } // foreach
+            } // lock
+        }
+        public IScript LoadScript(string FileName)
+        {
+            // Find next available AppDomain to put it in
+            AppDomainStructure FreeAppDomain = GetFreeAppDomain();
+            Console.WriteLine("Loading into AppDomain: " + FileName);
+            IScript mbrt =
+                (IScript)
+                FreeAppDomain.CurrentAppDomain.CreateInstanceFromAndUnwrap(FileName, "SecondLife.Script");
+            //Console.WriteLine("ScriptEngine AppDomainManager: is proxy={0}", RemotingServices.IsTransparentProxy(mbrt));
+            FreeAppDomain.ScriptsLoaded++;
+            return mbrt;
+        }
+        /// <summary>
+        /// Increase "dead script" counter for an AppDomain
+        /// </summary>
+        /// <param name="ad"></param>
+        //[Obsolete("Needs fixing, needs a real purpose in life!!!")]
+        public void StopScript(AppDomain ad)
+        {
+            lock (freeLock)
+            {
+                Console.WriteLine("Stopping script in AppDomain");
+                // Check if it is current AppDomain
+                if (currentAD.CurrentAppDomain == ad)
+                {
+                    // Yes - increase
+                    currentAD.ScriptsWaitingUnload++;
+                    return;
+                }
+                // Lopp through all AppDomains
+                foreach (AppDomainStructure ads in new ArrayList(appDomains))
+                {
+                    if (ads.CurrentAppDomain == ad)
+                    {
+                        // Found it
+                        ads.ScriptsWaitingUnload++;
+                        break;
+                    }
+                } // foreach
+            } // lock
+            UnloadAppDomains(); // Outsite lock, has its own GetLock
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/Common.cs b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/Common.cs
new file mode 100644
index 0000000..00ea078
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/Common.cs
@@ -0,0 +1,57 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+/* Original code: Tedd Hansen */
+namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+{
+    public static class Common
+    {
+        public static bool debug = true;
+        public static ScriptEngine mySE;
+        // This class just contains some static log stuff used for debugging.
+        //public delegate void SendToDebugEventDelegate(string Message);
+        //public delegate void SendToLogEventDelegate(string Message);
+        //static public event SendToDebugEventDelegate SendToDebugEvent;
+        //static public event SendToLogEventDelegate SendToLogEvent;
+        public static void SendToDebug(string Message)
+        {
+            //if (Debug == true)
+            mySE.Log.Verbose("ScriptEngine", "Debug: " + Message);
+            //SendToDebugEvent("\r\n" + DateTime.Now.ToString("[HH:mm:ss] ") + Message);
+        }
+        public static void SendToLog(string Message)
+        {
+            //if (Debug == true)
+            mySE.Log.Verbose("ScriptEngine", "LOG: " + Message);
+            //SendToLogEvent("\r\n" + DateTime.Now.ToString("[HH:mm:ss] ") + Message);
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventManager.cs b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventManager.cs
new file mode 100644
index 0000000..a5ad911
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventManager.cs
@@ -0,0 +1,259 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+/* Original code: Tedd Hansen */
+using System;
+using libsecondlife;
+using OpenSim.Framework;
+namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+{
+    /// <summary>
+    /// Prepares events so they can be directly executed upon a script by EventQueueManager, then queues it.
+    /// </summary>
+    [Serializable]
+    public class EventManager : OpenSim.Region.ScriptEngine.Common.ScriptServerInterfaces.RemoteEvents
+    {
+        //
+        // Class is instanced in "ScriptEngine" and Uses "EventQueueManager" that is also instanced in "ScriptEngine".
+        // This class needs a bit of explaining:
+        //
+        // This class it the link between an event inside OpenSim and the corresponding event in a user script being executed.
+        //
+        // For example when an user touches an object then the "myScriptEngine.World.EventManager.OnObjectGrab" event is fired inside OpenSim.
+        // We hook up to this event and queue a touch_start in EventQueueManager with the proper LSL parameters.
+        // It will then be delivered to the script by EventQueueManager.
+        //
+        // You can check debug C# dump of an LSL script if you need to verify what exact parameters are needed.
+        //
+        private ScriptEngine myScriptEngine;
+        //public IScriptHost TEMP_OBJECT_ID;
+        public EventManager(ScriptEngine _ScriptEngine, bool performHookUp)
+        {
+            myScriptEngine = _ScriptEngine;
+            // Hook up to events from OpenSim
+            // We may not want to do it because someone is controlling us and will deliver events to us
+            if (performHookUp)
+            {
+                myScriptEngine.Log.Verbose("ScriptEngine", "Hooking up to server events");
+                myScriptEngine.World.EventManager.OnObjectGrab += touch_start;
+                myScriptEngine.World.EventManager.OnRezScript += OnRezScript;
+                myScriptEngine.World.EventManager.OnRemoveScript += OnRemoveScript;
+                // TODO: HOOK ALL EVENTS UP TO SERVER!
+            }
+        }
+        public void touch_start(uint localID, LLVector3 offsetPos, IClientAPI remoteClient)
+        {
+            // Add to queue for all scripts in ObjectID object
+            myScriptEngine.m_EventQueueManager.AddToObjectQueue(localID, "touch_start", new object[] {(int) 1});
+        }
+        public void OnRezScript(uint localID, LLUUID itemID, string script)
+        {
+            Console.WriteLine("OnRezScript localID: " + localID + " LLUID: " + itemID.ToString() + " Size: " +
+                              script.Length);
+            myScriptEngine.m_ScriptManager.StartScript(localID, itemID, script);
+        }
+        public void OnRemoveScript(uint localID, LLUUID itemID)
+        {
+            Console.WriteLine("OnRemoveScript localID: " + localID + " LLUID: " + itemID.ToString());
+            myScriptEngine.m_ScriptManager.StopScript(
+                localID,
+                itemID
+                );
+        }
+        // TODO: Replace placeholders below
+        // NOTE! THE PARAMETERS FOR THESE FUNCTIONS ARE NOT CORRECT!
+        //  These needs to be hooked up to OpenSim during init of this class
+        //   then queued in EventQueueManager.
+        // When queued in EventQueueManager they need to be LSL compatible (name and params)
+        public void state_exit(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "state_exit");
+        }
+        public void touch(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "touch");
+        }
+        public void touch_end(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "touch_end");
+        }
+        public void collision_start(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "collision_start");
+        }
+        public void collision(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "collision");
+        }
+        public void collision_end(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "collision_end");
+        }
+        public void land_collision_start(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "land_collision_start");
+        }
+        public void land_collision(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "land_collision");
+        }
+        public void land_collision_end(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "land_collision_end");
+        }
+        // Handled by long commands
+        public void timer(uint localID, LLUUID itemID)
+        {
+            //myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "");
+        }
+        public void listen(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "listen");
+        }
+        public void on_rez(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "on_rez");
+        }
+        public void sensor(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "sensor");
+        }
+        public void no_sensor(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "no_sensor");
+        }
+        public void control(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "control");
+        }
+        public void money(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "money");
+        }
+        public void email(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "email");
+        }
+        public void at_target(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "at_target");
+        }
+        public void not_at_target(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "not_at_target");
+        }
+        public void at_rot_target(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "at_rot_target");
+        }
+        public void not_at_rot_target(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "not_at_rot_target");
+        }
+        public void run_time_permissions(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "run_time_permissions");
+        }
+        public void changed(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "changed");
+        }
+        public void attach(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "attach");
+        }
+        public void dataserver(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "dataserver");
+        }
+        public void link_message(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "link_message");
+        }
+        public void moving_start(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "moving_start");
+        }
+        public void moving_end(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "moving_end");
+        }
+        public void object_rez(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "object_rez");
+        }
+        public void remote_data(uint localID, LLUUID itemID)
+        {
+            myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "remote_data");
+        }
+        // Handled by long commands
+        public void http_response(uint localID, LLUUID itemID)
+        {
+            //    myScriptEngine.m_EventQueueManager.AddToScriptQueue(localID, itemID, "http_response");
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueManager.cs b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueManager.cs
new file mode 100644
index 0000000..62194df
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueManager.cs
@@ -0,0 +1,363 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+/* Original code: Tedd Hansen */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using libsecondlife;
+using OpenSim.Framework;
+using OpenSim.Region.Environment.Scenes.Scripting;
+namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+{
+    /// <summary>
+    /// EventQueueManager handles event queues
+    /// Events are queued and executed in separate thread
+    /// </summary>
+    [Serializable]
+    public class EventQueueManager
+    {
+        //
+        // Class is instanced in "ScriptEngine" and used by "EventManager" also instanced in "ScriptEngine".
+        //
+        // Class purpose is to queue and execute functions that are received by "EventManager":
+        //   - allowing "EventManager" to release its event thread immediately, thus not interrupting server execution.
+        //   - allowing us to prioritize and control execution of script functions.
+        // Class can use multiple threads for simultaneous execution. Mutexes are used for thread safety.
+        //
+        // 1. Hold an execution queue for scripts
+        // 2. Use threads to process queue, each thread executes one script function on each pass.
+        // 3. Catch any script error and process it
+        //
+        //
+        // Notes:
+        // * Current execution load balancing is optimized for 1 thread, and can cause unfair execute balancing between scripts.
+        //   Not noticeable unless server is under high load.
+        // * This class contains the number of threads used for script executions. Since we are not microthreading scripts yet,
+        //   increase number of threads to allow more concurrent script executions in OpenSim.
+        //
+        /// <summary>
+        /// List of threads processing event queue
+        /// </summary>
+        private List<Thread> eventQueueThreads = new List<Thread>();
+        private object queueLock = new object(); // Mutex lock object
+        /// <summary>
+        /// How many ms to sleep if queue is empty
+        /// </summary>
+        private int nothingToDoSleepms = 50;
+        /// <summary>
+        /// How many threads to process queue with
+        /// </summary>
+        private int numberOfThreads = 2;
+        /// <summary>
+        /// Queue containing events waiting to be executed
+        /// </summary>
+        private Queue<QueueItemStruct> eventQueue = new Queue<QueueItemStruct>();
+        /// <summary>
+        /// Queue item structure
+        /// </summary>
+        private struct QueueItemStruct
+        {
+            public uint localID;
+            public LLUUID itemID;
+            public string functionName;
+            public object[] param;
+        }
+        /// <summary>
+        /// List of localID locks for mutex processing of script events
+        /// </summary>
+        private List<uint> objectLocks = new List<uint>();
+        private object tryLockLock = new object(); // Mutex lock object
+        private ScriptEngine m_ScriptEngine;
+        public EventQueueManager(ScriptEngine _ScriptEngine)
+        {
+            m_ScriptEngine = _ScriptEngine;
+            //
+            // Start event queue processing threads (worker threads)
+            //
+            for (int ThreadCount = 0; ThreadCount <= numberOfThreads; ThreadCount++)
+            {
+                Thread EventQueueThread = new Thread(EventQueueThreadLoop);
+                eventQueueThreads.Add(EventQueueThread);
+                EventQueueThread.IsBackground = true;
+                EventQueueThread.Priority = ThreadPriority.BelowNormal;
+                EventQueueThread.Name = "EventQueueManagerThread_" + ThreadCount;
+                EventQueueThread.Start();
+            }
+        }
+        ~EventQueueManager()
+        {
+            // Kill worker threads
+            foreach (Thread EventQueueThread in new ArrayList(eventQueueThreads))
+            {
+                if (EventQueueThread != null && EventQueueThread.IsAlive == true)
+                {
+                    try
+                    {
+                        EventQueueThread.Abort();
+                        EventQueueThread.Join();
+                    }
+                    catch (Exception)
+                    {
+                        //myScriptEngine.Log.Verbose("ScriptEngine", "EventQueueManager Exception killing worker thread: " + e.ToString());
+                    }
+                }
+            }
+            eventQueueThreads.Clear();
+            // Todo: Clean up our queues
+            eventQueue.Clear();
+        }
+        /// <summary>
+        /// Queue processing thread loop
+        /// </summary>
+        private void EventQueueThreadLoop()
+        {
+            //myScriptEngine.m_logger.Verbose("ScriptEngine", "EventQueueManager Worker thread spawned");
+            try
+            {
+                QueueItemStruct BlankQIS = new QueueItemStruct();
+                while (true)
+                {
+                    try
+                    {
+                        QueueItemStruct QIS = BlankQIS;
+                        bool GotItem = false;
+                        if (eventQueue.Count == 0)
+                        {
+                            // Nothing to do? Sleep a bit waiting for something to do
+                            Thread.Sleep(nothingToDoSleepms);
+                        }
+                        else
+                        {
+                            // Something in queue, process
+                            //myScriptEngine.m_logger.Verbose("ScriptEngine", "Processing event for localID: " + QIS.localID + ", itemID: " + QIS.itemID + ", FunctionName: " + QIS.FunctionName);
+                            // OBJECT BASED LOCK - TWO THREADS WORKING ON SAME OBJECT IS NOT GOOD
+                            lock (queueLock)
+                            {
+                                GotItem = false;
+                                for (int qc = 0; qc < eventQueue.Count; qc++)
+                                {
+                                    // Get queue item
+                                    QIS = eventQueue.Dequeue();
+                                    // Check if object is being processed by someone else
+                                    if (TryLock(QIS.localID) == false)
+                                    {
+                                        // Object is already being processed, requeue it
+                                        eventQueue.Enqueue(QIS);
+                                    }
+                                    else
+                                    {
+                                        // We have lock on an object and can process it
+                                        GotItem = true;
+                                        break;
+                                    }
+                                } // go through queue
+                            } // lock
+                            if (GotItem == true)
+                            {
+                                // Execute function
+                                try
+                                {
+#if DEBUG
+                                    m_ScriptEngine.Log.Debug("ScriptEngine", "Executing event:\r\n"
+                                                                             + "QIS.localID: " + QIS.localID
+                                                                             + ", QIS.itemID: " + QIS.itemID
+                                                                             + ", QIS.functionName: " + QIS.functionName);
+#endif
+                                    m_ScriptEngine.m_ScriptManager.ExecuteEvent(QIS.localID, QIS.itemID,
+                                                                                QIS.functionName, QIS.param);
+                                }
+                                catch (Exception e)
+                                {
+                                    // DISPLAY ERROR INWORLD
+                                    string text = "Error executing script function \"" + QIS.functionName + "\":\r\n";
+                                    //if (e.InnerException != null)
+                                    //{
+                                    // Send inner exception
+                                    text += e.InnerException.Message.ToString();
+                                    //}
+                                    //else
+                                    //{
+                                    text += "\r\n";
+                                    // Send normal
+                                    text += e.Message.ToString();
+                                    //}
+                                    try
+                                    {
+                                        if (text.Length > 1500)
+                                            text = text.Substring(0, 1500);
+                                        IScriptHost m_host = m_ScriptEngine.World.GetSceneObjectPart(QIS.localID);
+                                        //if (m_host != null)
+                                        //{
+                                        m_ScriptEngine.World.SimChat(Helpers.StringToField(text), ChatTypeEnum.Say, 0,
+                                                                     m_host.AbsolutePosition, m_host.Name, m_host.UUID);
+                                    }
+                                    catch
+                                    {
+                                        //}
+                                        //else
+                                        //{
+                                        // T oconsole
+                                        m_ScriptEngine.Log.Error("ScriptEngine",
+                                                                 "Unable to send text in-world:\r\n" + text);
+                                    }
+                                }
+                                finally
+                                {
+                                    ReleaseLock(QIS.localID);
+                                }
+                            }
+                        } // Something in queue
+                    }
+                    catch (ThreadAbortException tae)
+                    {
+                        throw tae;
+                    }
+                    catch (Exception e)
+                    {
+                        m_ScriptEngine.Log.Error("ScriptEngine", "Exception in EventQueueThreadLoop: " + e.ToString());
+                    }
+                } // while
+            } // try
+            catch (ThreadAbortException)
+            {
+                //myScriptEngine.Log.Verbose("ScriptEngine", "EventQueueManager Worker thread killed: " + tae.Message);
+            }
+        }
+        /// <summary>
+        /// Try to get a mutex lock on localID
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <returns></returns>
+        private bool TryLock(uint localID)
+        {
+            lock (tryLockLock)
+            {
+                if (objectLocks.Contains(localID) == true)
+                {
+                    return false;
+                }
+                else
+                {
+                    objectLocks.Add(localID);
+                    return true;
+                }
+            }
+        }
+        /// <summary>
+        /// Release mutex lock on localID
+        /// </summary>
+        /// <param name="localID"></param>
+        private void ReleaseLock(uint localID)
+        {
+            lock (tryLockLock)
+            {
+                if (objectLocks.Contains(localID) == true)
+                {
+                    objectLocks.Remove(localID);
+                }
+            }
+        }
+        /// <summary>
+        /// Add event to event execution queue
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="FunctionName">Name of the function, will be state + "_event_" + FunctionName</param>
+        /// <param name="param">Array of parameters to match event mask</param>
+        public void AddToObjectQueue(uint localID, string FunctionName, params object[] param)
+        {
+            // Determine all scripts in Object and add to their queue
+            //myScriptEngine.m_logger.Verbose("ScriptEngine", "EventQueueManager Adding localID: " + localID + ", FunctionName: " + FunctionName);
+            // Do we have any scripts in this object at all? If not, return
+            if (m_ScriptEngine.m_ScriptManager.Scripts.ContainsKey(localID) == false)
+            {
+                //Console.WriteLine("Event \"" + FunctionName + "\" for localID: " + localID + ". No scripts found on this localID.");
+                return;
+            }
+            Dictionary<LLUUID, IScript>.KeyCollection scriptKeys =
+                m_ScriptEngine.m_ScriptManager.GetScriptKeys(localID);
+            foreach (LLUUID itemID in scriptKeys)
+            {
+                // Add to each script in that object
+                // TODO: Some scripts may not subscribe to this event. Should we NOT add it? Does it matter?
+                AddToScriptQueue(localID, itemID, FunctionName, param);
+            }
+        }
+        /// <summary>
+        /// Add event to event execution queue
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="itemID"></param>
+        /// <param name="FunctionName">Name of the function, will be state + "_event_" + FunctionName</param>
+        /// <param name="param">Array of parameters to match event mask</param>
+        public void AddToScriptQueue(uint localID, LLUUID itemID, string FunctionName, params object[] param)
+        {
+            lock (queueLock)
+            {
+                // Create a structure and add data
+                QueueItemStruct QIS = new QueueItemStruct();
+                QIS.localID = localID;
+                QIS.itemID = itemID;
+                QIS.functionName = FunctionName;
+                QIS.param = param;
+                // Add it to queue
+                eventQueue.Enqueue(QIS);
+            }
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/LSLLongCmdHandler.cs b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/LSLLongCmdHandler.cs
new file mode 100644
index 0000000..94241eb
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/LSLLongCmdHandler.cs
@@ -0,0 +1,295 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using libsecondlife;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Modules;
+namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+{
+    /// <summary>
+    /// Handles LSL commands that takes long time and returns an event, for example timers, HTTP requests, etc.
+    /// </summary>
+    public class LSLLongCmdHandler
+    {
+        private Thread cmdHandlerThread;
+        private int cmdHandlerThreadCycleSleepms = 100;
+        private ScriptEngine m_ScriptEngine;
+        public LSLLongCmdHandler(ScriptEngine _ScriptEngine)
+        {
+            m_ScriptEngine = _ScriptEngine;
+            // Start the thread that will be doing the work
+            cmdHandlerThread = new Thread(CmdHandlerThreadLoop);
+            cmdHandlerThread.Name = "CmdHandlerThread";
+            cmdHandlerThread.Priority = ThreadPriority.BelowNormal;
+            cmdHandlerThread.IsBackground = true;
+            cmdHandlerThread.Start();
+        }
+        ~LSLLongCmdHandler()
+        {
+            // Shut down thread
+            try
+            {
+                if (cmdHandlerThread != null)
+                {
+                    if (cmdHandlerThread.IsAlive == true)
+                    {
+                        cmdHandlerThread.Abort();
+                        cmdHandlerThread.Join();
+                    }
+                }
+            }
+            catch
+            {
+            }
+        }
+        private void CmdHandlerThreadLoop()
+        {
+            while (true)
+            {
+                // Check timers
+                CheckTimerEvents();
+                Thread.Sleep(25);
+                // Check HttpRequests
+                CheckHttpRequests();
+                Thread.Sleep(25);
+                // Check XMLRPCRequests
+                CheckXMLRPCRequests();
+                Thread.Sleep(25);
+                // Check Listeners
+                CheckListeners();
+                Thread.Sleep(25);
+                // Sleep before next cycle
+                //Thread.Sleep(cmdHandlerThreadCycleSleepms);
+            }
+        }
+        /// <summary>
+        /// Remove a specific script (and all its pending commands)
+        /// </summary>
+        /// <param name="m_localID"></param>
+        /// <param name="m_itemID"></param>
+        public void RemoveScript(uint localID, LLUUID itemID)
+        {
+            // Remove a specific script
+            // Remove from: Timers
+            UnSetTimerEvents(localID, itemID);
+            // Remove from: HttpRequest
+            IHttpRequests iHttpReq =
+                m_ScriptEngine.World.RequestModuleInterface<IHttpRequests>();
+            iHttpReq.StopHttpRequest(localID, itemID);
+        }
+        #region TIMER
+        //
+        // TIMER
+        //
+        private class TimerClass
+        {
+            public uint localID;
+            public LLUUID itemID;
+            public double interval;
+            public DateTime next;
+        }
+        private List<TimerClass> Timers = new List<TimerClass>();
+        private object TimerListLock = new object();
+        public void SetTimerEvent(uint m_localID, LLUUID m_itemID, double sec)
+        {
+            Console.WriteLine("SetTimerEvent");
+            // Always remove first, in case this is a re-set
+            UnSetTimerEvents(m_localID, m_itemID);
+            if (sec == 0) // Disabling timer
+                return;
+            // Add to timer
+            TimerClass ts = new TimerClass();
+            ts.localID = m_localID;
+            ts.itemID = m_itemID;
+            ts.interval = sec;
+            ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval);
+            lock (TimerListLock)
+            {
+                Timers.Add(ts);
+            }
+        }
+        public void UnSetTimerEvents(uint m_localID, LLUUID m_itemID)
+        {
+            // Remove from timer
+            lock (TimerListLock)
+            {
+                List<TimerClass> NewTimers = new List<TimerClass>();
+                foreach (TimerClass ts in Timers)
+                {
+                    if (ts.localID != m_localID && ts.itemID != m_itemID)
+                    {
+                        NewTimers.Add(ts);
+                    }
+                }
+                Timers.Clear();
+                Timers = NewTimers;
+            }
+        }
+        public void CheckTimerEvents()
+        {
+            // Nothing to do here?
+            if (Timers.Count == 0)
+                return;
+            lock (TimerListLock)
+            {
+                // Go through all timers
+                foreach (TimerClass ts in Timers)
+                {
+                    // Time has passed?
+                    if (ts.next.ToUniversalTime() < DateTime.Now.ToUniversalTime())
+                    {
+                        // Add it to queue
+                        m_ScriptEngine.m_EventQueueManager.AddToScriptQueue(ts.localID, ts.itemID, "timer",
+                                                                            new object[] {});
+                        // set next interval
+                        ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval);
+                    }
+                }
+            } // lock
+        }
+        #endregion
+        #region HTTP REQUEST
+        public void CheckHttpRequests()
+        {
+            if (m_ScriptEngine.World == null)
+                return;
+            IHttpRequests iHttpReq =
+                m_ScriptEngine.World.RequestModuleInterface<IHttpRequests>();
+            HttpRequestClass httpInfo = null;
+            if (iHttpReq != null)
+                httpInfo = iHttpReq.GetNextCompletedRequest();
+            while (httpInfo != null)
+            {
+                //Console.WriteLine("PICKED HTTP REQ:" + httpInfo.response_body + httpInfo.status);
+                // Deliver data to prim's remote_data handler
+                //
+                // TODO: Returning null for metadata, since the lsl function
+                // only returns the byte for HTTP_BODY_TRUNCATED, which is not
+                // implemented here yet anyway.  Should be fixed if/when maxsize
+                // is supported
+                object[] resobj = new object[]
+                    {
+                        httpInfo.reqID.ToString(), httpInfo.status, null, httpInfo.response_body
+                    };
+                m_ScriptEngine.m_EventQueueManager.AddToScriptQueue(
+                    httpInfo.localID, httpInfo.itemID, "http_response", resobj
+                    );
+                httpInfo.Stop();
+                httpInfo = null;
+                httpInfo = iHttpReq.GetNextCompletedRequest();
+            }
+        }
+        #endregion
+        public void CheckXMLRPCRequests()
+        {
+            if (m_ScriptEngine.World == null)
+                return;
+            IXMLRPC xmlrpc = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            if (xmlrpc != null)
+            {
+                while (xmlrpc.hasRequests())
+                {
+                    RPCRequestInfo rInfo = xmlrpc.GetNextRequest();
+                    //Console.WriteLine("PICKED REQUEST");
+                    //Deliver data to prim's remote_data handler
+                    object[] resobj = new object[]
+                        {
+                            2, rInfo.GetChannelKey().ToString(), rInfo.GetMessageID().ToString(), "",
+                            rInfo.GetIntValue(),
+                            rInfo.GetStrVal()
+                        };
+                    m_ScriptEngine.m_EventQueueManager.AddToScriptQueue(
+                        rInfo.GetLocalID(), rInfo.GetItemID(), "remote_data", resobj
+                        );
+                }
+            }
+        }
+        public void CheckListeners()
+        {
+            if (m_ScriptEngine.World == null)
+                return;
+            IWorldComm comms = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            while (comms.HasMessages())
+            {
+                ListenerInfo lInfo = comms.GetNextMessage();
+                //Deliver data to prim's listen handler
+                object[] resobj = new object[]
+                    {
+                        lInfo.GetChannel(), lInfo.GetName(), lInfo.GetID().ToString(), lInfo.GetMessage()
+                    };
+                m_ScriptEngine.m_EventQueueManager.AddToScriptQueue(
+                    lInfo.GetLocalID(), lInfo.GetItemID(), "listen", resobj
+                    );
+            }
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/ScriptEngine.cs b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/ScriptEngine.cs
new file mode 100644
index 0000000..9637252
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/ScriptEngine.cs
@@ -0,0 +1,131 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+/* Original code: Tedd Hansen */
+using System;
+using Nini.Config;
+using OpenSim.Framework.Console;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Common;
+using OpenSim.Region.ScriptEngine.Common.ScriptEngineBase;
+namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+{
+    /// <summary>
+    /// This is the root object for ScriptEngine. Objects access each other trough this class.
+    /// </summary>
+    /// 
+    [Serializable]
+    public abstract class ScriptEngine : IRegionModule, OpenSim.Region.ScriptEngine.Common.ScriptServerInterfaces.ScriptEngine
+    {
+        public Scene World;
+        public EventManager m_EventManager; // Handles and queues incoming events from OpenSim
+        public EventQueueManager m_EventQueueManager; // Executes events
+        public ScriptManager m_ScriptManager; // Load, unload and execute scripts
+        public AppDomainManager m_AppDomainManager;
+        public LSLLongCmdHandler m_LSLLongCmdHandler;
+        public ScriptManager GetScriptManager()
+        {
+            return _GetScriptManager();
+        }
+        public abstract ScriptManager _GetScriptManager();
+        private LogBase m_log;
+        public ScriptEngine()
+        {
+            //Common.SendToDebug("ScriptEngine Object Initialized");
+            Common.mySE = this;
+        }
+        public LogBase Log
+        {
+            get { return m_log; }
+        }
+        public void InitializeEngine(Scene Sceneworld, LogBase logger, bool HookUpToServer, ScriptManager newScriptManager)
+        {
+            World = Sceneworld;
+            m_log = logger;
+            Log.Verbose("ScriptEngine", "DotNet & LSL ScriptEngine initializing");
+            //m_logger.Status("ScriptEngine", "InitializeEngine");
+            // Create all objects we'll be using
+            m_EventQueueManager = new EventQueueManager(this);
+            m_EventManager = new EventManager(this, HookUpToServer);
+            m_ScriptManager = newScriptManager;
+            //m_ScriptManager = new ScriptManager(this);
+            m_AppDomainManager = new AppDomainManager();
+            m_LSLLongCmdHandler = new LSLLongCmdHandler(this);
+            // Should we iterate the region for scripts that needs starting?
+            // Or can we assume we are loaded before anything else so we can use proper events?
+        }
+        public void Shutdown()
+        {
+            // We are shutting down
+        }
+        ScriptServerInterfaces.RemoteEvents ScriptServerInterfaces.ScriptEngine.EventManager()
+        {
+            return this.m_EventManager;
+        }
+        #region IRegionModule
+        public abstract void Initialise(Scene scene, IConfigSource config);
+        
+        public void PostInitialise()
+        {
+        }
+        public void Close()
+        {
+        }
+        public string Name
+        {
+            get { return "DotNetEngine"; }
+        }
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+        
+        #endregion
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/ScriptManager.cs b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/ScriptManager.cs
new file mode 100644
index 0000000..55c9545
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/ScriptManager.cs
@@ -0,0 +1,347 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* 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 the OpenSim Project 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.
+* 
+*/
+/* Original code: Tedd Hansen */
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Threading;
+using libsecondlife;
+using OpenSim.Framework;
+using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Common;
+namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+{
+    /// <summary>
+    /// Loads scripts
+    /// Compiles them if necessary
+    /// Execute functions for EventQueueManager (Sends them to script on other AppDomain for execution)
+    /// </summary>
+    /// 
+    // This class is as close as you get to the script without being inside script class. It handles all the dirty work for other classes.
+    // * Keeps track of running scripts
+    // * Compiles script if necessary (through "Compiler")
+    // * Loads script (through "AppDomainManager" called from for example "EventQueueManager")
+    // * Executes functions inside script (called from for example "EventQueueManager" class)
+    // * Unloads script (through "AppDomainManager" called from for example "EventQueueManager")
+    // * Dedicated load/unload thread, and queues loading/unloading.
+    //   This so that scripts starting or stopping will not slow down other theads or whole system.
+    //
+    [Serializable]
+    public abstract class ScriptManager
+    {
+        #region Declares
+        private Thread scriptLoadUnloadThread;
+        private int scriptLoadUnloadThread_IdleSleepms = 100;
+        private Queue<LUStruct> LUQueue = new Queue<LUStruct>();
+        // Load/Unload structure
+        private struct LUStruct
+        {
+            public uint localID;
+            public LLUUID itemID;
+            public string script;
+            public LUType Action;
+        }
+        private enum LUType
+        {
+            Unknown = 0,
+            Load = 1,
+            Unload = 2
+        }
+        // Object<string, Script<string, script>>
+        // IMPORTANT: Types and MemberInfo-derived objects require a LOT of memory.
+        // Instead use RuntimeTypeHandle, RuntimeFieldHandle and RunTimeHandle (IntPtr) instead!
+        public Dictionary<uint, Dictionary<LLUUID, IScript>> Scripts =
+            new Dictionary<uint, Dictionary<LLUUID, IScript>>();
+        public Scene World
+        {
+            get { return m_scriptEngine.World; }
+        }
+        #endregion
+        #region Object init/shutdown
+        public ScriptEngineBase.ScriptEngine m_scriptEngine;
+        public ScriptManager(ScriptEngineBase.ScriptEngine scriptEngine)
+        {
+            m_scriptEngine = scriptEngine;
+            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
+            scriptLoadUnloadThread = new Thread(ScriptLoadUnloadThreadLoop);
+            scriptLoadUnloadThread.Name = "ScriptLoadUnloadThread";
+            scriptLoadUnloadThread.IsBackground = true;
+            scriptLoadUnloadThread.Priority = ThreadPriority.BelowNormal;
+            scriptLoadUnloadThread.Start();
+        }
+        ~ScriptManager()
+        {
+            // Abort load/unload thread
+            try
+            {
+                if (scriptLoadUnloadThread != null)
+                {
+                    if (scriptLoadUnloadThread.IsAlive == true)
+                    {
+                        scriptLoadUnloadThread.Abort();
+                        scriptLoadUnloadThread.Join();
+                    }
+                }
+            }
+            catch
+            {
+            }
+        }
+        #endregion
+        #region Load / Unload scripts (Thread loop)
+        private void ScriptLoadUnloadThreadLoop()
+        {
+            try
+            {
+                while (true)
+                {
+                    if (LUQueue.Count == 0)
+                        Thread.Sleep(scriptLoadUnloadThread_IdleSleepms);
+                    if (LUQueue.Count > 0)
+                    {
+                        LUStruct item = LUQueue.Dequeue();
+                        lock (startStopLock)        // Lock so we have only 1 thread working on loading/unloading of scripts
+                        {
+                            if (item.Action == LUType.Unload)
+                            {
+                                _StopScript(item.localID, item.itemID);
+                            }
+                            if (item.Action == LUType.Load)
+                            {
+                                _StartScript(item.localID, item.itemID, item.script);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (ThreadAbortException tae)
+            {
+                string a = tae.ToString();
+                a = "";
+                // Expected
+            }
+        }
+        #endregion
+        #region Helper functions
+        private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            //Console.WriteLine("ScriptManager.CurrentDomain_AssemblyResolve: " + args.Name);
+            return Assembly.GetExecutingAssembly().FullName == args.Name ? Assembly.GetExecutingAssembly() : null;
+        }
+        #endregion
+  
+        #region Start/Stop/Reset script
+        private readonly Object startStopLock = new Object();
+        /// <summary>
+        /// Fetches, loads and hooks up a script to an objects events
+        /// </summary>
+        /// <param name="itemID"></param>
+        /// <param name="localID"></param>
+        public void StartScript(uint localID, LLUUID itemID, string Script)
+        {
+            LUStruct ls = new LUStruct();
+            ls.localID = localID;
+            ls.itemID = itemID;
+            ls.script = Script;
+            ls.Action = LUType.Load;
+            LUQueue.Enqueue(ls);
+        }
+        /// <summary>
+        /// Disables and unloads a script
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="itemID"></param>
+        public void StopScript(uint localID, LLUUID itemID)
+        {
+            LUStruct ls = new LUStruct();
+            ls.localID = localID;
+            ls.itemID = itemID;
+            ls.Action = LUType.Unload;
+            LUQueue.Enqueue(ls);
+        }
+        // Create a new instance of the compiler (reuse)
+        //private Compiler.LSL.Compiler LSLCompiler = new Compiler.LSL.Compiler();
+        public abstract void _StartScript(uint localID, LLUUID itemID, string Script);
+        public abstract void _StopScript(uint localID, LLUUID itemID);
+        #endregion
+        #region Perform event execution in script
+        /// <summary>
+        /// Execute a LL-event-function in Script
+        /// </summary>
+        /// <param name="localID">Object the script is located in</param>
+        /// <param name="itemID">Script ID</param>
+        /// <param name="FunctionName">Name of function</param>
+        /// <param name="args">Arguments to pass to function</param>
+        internal void ExecuteEvent(uint localID, LLUUID itemID, string FunctionName, object[] args)
+        {
+#if DEBUG
+            Console.WriteLine("ScriptEngine: Inside ExecuteEvent for event " + FunctionName);
+#endif
+            // Execute a function in the script
+            //m_scriptEngine.Log.Verbose("ScriptEngine", "Executing Function localID: " + localID + ", itemID: " + itemID + ", FunctionName: " + FunctionName);
+            //ScriptBaseInterface Script = (ScriptBaseInterface)GetScript(localID, itemID);
+            IScript Script = GetScript(localID, itemID);
+            if (Script == null)
+                return;
+#if DEBUG
+            Console.WriteLine("ScriptEngine: Executing event: " + FunctionName);
+#endif
+            // Must be done in correct AppDomain, so leaving it up to the script itself
+            Script.Exec.ExecuteEvent(FunctionName, args);
+        }
+        #endregion
+        #region Internal functions to keep track of script
+        public Dictionary<LLUUID, IScript>.KeyCollection GetScriptKeys(uint localID)
+        {
+            if (Scripts.ContainsKey(localID) == false)
+                return null;
+            Dictionary<LLUUID, IScript> Obj;
+            Scripts.TryGetValue(localID, out Obj);
+            return Obj.Keys;
+        }
+        public IScript GetScript(uint localID, LLUUID itemID)
+        {
+            if (Scripts.ContainsKey(localID) == false)
+                return null;
+            Dictionary<LLUUID, IScript> Obj;
+            Scripts.TryGetValue(localID, out Obj);
+            if (Obj.ContainsKey(itemID) == false)
+                return null;
+            // Get script
+            IScript Script;
+            Obj.TryGetValue(itemID, out Script);
+            return Script;
+        }
+        public void SetScript(uint localID, LLUUID itemID, IScript Script)
+        {
+            // Create object if it doesn't exist
+            if (Scripts.ContainsKey(localID) == false)
+            {
+                Scripts.Add(localID, new Dictionary<LLUUID, IScript>());
+            }
+            // Delete script if it exists
+            Dictionary<LLUUID, IScript> Obj;
+            Scripts.TryGetValue(localID, out Obj);
+            if (Obj.ContainsKey(itemID) == true)
+                Obj.Remove(itemID);
+            // Add to object
+            Obj.Add(itemID, Script);
+        }
+        public void RemoveScript(uint localID, LLUUID itemID)
+        {
+            // Don't have that object?
+            if (Scripts.ContainsKey(localID) == false)
+                return;
+            // Delete script if it exists
+            Dictionary<LLUUID, IScript> Obj;
+            Scripts.TryGetValue(localID, out Obj);
+            if (Obj.ContainsKey(itemID) == true)
+                Obj.Remove(itemID);
+        }
+        #endregion
+        public void ResetScript(uint localID, LLUUID itemID)
+        {
+            string script = GetScript(localID, itemID).Source;
+            StopScript(localID, itemID);
+            StartScript(localID, itemID, script);
+        }
+        #region Script serialization/deserialization
+        public void GetSerializedScript(uint localID, LLUUID itemID)
+        {
+            // Serialize the script and return it
+            // Should not be a problem
+            FileStream fs = File.Create("SERIALIZED_SCRIPT_" + itemID);
+            BinaryFormatter b = new BinaryFormatter();
+            b.Serialize(fs, GetScript(localID, itemID));
+            fs.Close();
+        }
+        public void PutSerializedScript(uint localID, LLUUID itemID)
+        {
+            // Deserialize the script and inject it into an AppDomain
+            // How to inject into an AppDomain?
+        }
+        #endregion
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptServerInterfaces.cs b/OpenSim/Region/ScriptEngine/Common/ScriptServerInterfaces.cs
index 23ef126..8a3354f 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptServerInterfaces.cs
+++ b/OpenSim/Region/ScriptEngine/Common/ScriptServerInterfaces.cs
@@ -2,6 +2,7 @@
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
 using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Common.ScriptEngineBase;
 namespace OpenSim.Region.ScriptEngine.Common
 {
@@ -44,7 +45,7 @@ namespace OpenSim.Region.ScriptEngine.Common
            void remote_data(uint localID, LLUUID itemID);
            void http_response(uint localID, LLUUID itemID);
        }
+        
        public interface ServerRemotingObject
        {
            RemoteEvents Events();
@@ -52,7 +53,8 @@ namespace OpenSim.Region.ScriptEngine.Common
        public interface ScriptEngine
        {
            RemoteEvents EventManager();
-            void InitializeEngine(Scene Sceneworld, LogBase logger, bool DontHookUp);
+            void InitializeEngine(Scene Sceneworld, LogBase logger, bool DontHookUp, ScriptManager newScriptManager);
+            ScriptManager GetScriptManager();
        }
    }
author	Tedd Hansen	2008-01-12 14:30:22 +0000
committer	Tedd Hansen	2008-01-12 14:30:22 +0000
commit	bacbade369a5244f9bcc611488b59f3bd4c8a564 (patch)
tree	2cd909eff401066a69dba96615cbf736fdd73be5 /OpenSim/Region/ScriptEngine/Common
parent	* Trying something to see if it helps teleports and border crossings (diff)
download	opensim-SC-bacbade369a5244f9bcc611488b59f3bd4c8a564.zip opensim-SC-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.gz opensim-SC-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.bz2 opensim-SC-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.xz