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();
        }
    }