8 files changed, 721 insertions, 24 deletions

diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/AppDomainManager.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/AppDomainManager.cs
index 262d75f..969a05e 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/AppDomainManager.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/AppDomainManager.cs
@@ -29,8 +29,9 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
+using OpenSim.Region.ScriptEngine.Common;
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     public class AppDomainManager : iScriptEngineFunctionModule
     {
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/Common.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Common.cs
index d5ec9b4..3d9e19b 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/Common.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Common.cs
@@ -25,7 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     public static class Common
     {
diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/Compiler.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/Compiler.cs
index b50e823..4cb74fa 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/Compiler.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/Compiler.cs
@@ -83,8 +83,8 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSL
         private static int instanceID = new Random().Next(0, int.MaxValue);                 // Unique number to use on our compiled files
         private static UInt64 scriptCompileCounter = 0;                                     // And a counter
 
-        public Common.ScriptEngineBase.ScriptEngine m_scriptEngine;
-        public Compiler(Common.ScriptEngineBase.ScriptEngine scriptEngine)
+        public ScriptEngine m_scriptEngine;
+        public Compiler(ScriptEngine scriptEngine)
         {
             m_scriptEngine = scriptEngine;
             ReadConfig();
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueManager.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/EventQueueManager.cs
index b13ab21..7805d67 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueManager.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/EventQueueManager.cs
@@ -31,7 +31,7 @@ using System.Collections.Generic;
 using OpenMetaverse;
 using OpenSim.Region.ScriptEngine.Shared;
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     /// <summary>
     /// EventQueueManager handles event queues
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueThreadClass.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/EventQueueThreadClass.cs
index 7f52793..db3f89f 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueThreadClass.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/EventQueueThreadClass.cs
@@ -36,7 +36,7 @@ using log4net;
 using OpenSim.Framework;
 using OpenSim.Region.Environment.Scenes.Scripting;
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     /// <summary>
     /// Because every thread needs some data set for it (time started to execute current function), it will do its work within a class
@@ -103,7 +103,7 @@ namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
                             break;
                         default:
                             MyThreadPriority = ThreadPriority.BelowNormal; // Default
-                            m_ScriptEngine.Log.Error("[ScriptEngineBase]: Unknown priority type \"" + pri +
+                            m_ScriptEngine.Log.Error("[ScriptEngine.DotNetEngine]: Unknown priority type \"" + pri +
                                                      "\" in config file. Defaulting to \"BelowNormal\".");
                             break;
                     }
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/MaintenanceThread.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/MaintenanceThread.cs
index ef87b2f..6c1528f 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/MaintenanceThread.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/MaintenanceThread.cs
@@ -32,7 +32,7 @@ using System.Threading;
 using log4net;
 using OpenSim.Framework;
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     /// <summary>
     /// This class does maintenance on script engine.
diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptEngine.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptEngine.cs
index e785cc0..7ec71c2 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptEngine.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptEngine.cs
@@ -26,29 +26,281 @@
  */
 
 using System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
 using Nini.Config;
+using OpenSim.Region.Interfaces;
+using OpenSim.Region.Environment.Interfaces;
 using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenMetaverse;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Common;
 
 namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     [Serializable]
-    public class ScriptEngine : Common.ScriptEngineBase.ScriptEngine
+    public class ScriptEngine : IRegionModule, IEventReceiver, IScriptModule
     {
-        // We need to override a few things for our DotNetEngine
-        public override void Initialise(Scene scene, IConfigSource config)
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public static List<ScriptEngine> ScriptEngines = new List<ScriptEngine>();
+        private Scene m_Scene;
+        public Scene World
         {
-            ConfigSource = config;
-            InitializeEngine(scene, config, true, GetScriptManager());
+            get { return m_Scene; }
         }
+        public EventManager m_EventManager;                         // Handles and queues incoming events from OpenSim
+        public EventQueueManager m_EventQueueManager;               // Executes events, handles script threads
+        public ScriptManager m_ScriptManager;                       // Load, unload and execute scripts
+        public AppDomainManager m_AppDomainManager;                 // Handles loading/unloading of scripts into AppDomains
+        public static MaintenanceThread m_MaintenanceThread;        // Thread that does different kinds of maintenance, for example refreshing config and killing scripts that has been running too long
+
+        public IConfigSource ConfigSource;
+        public IConfig ScriptConfigSource;
+        private bool m_enabled = false;
 
-        public override Common.ScriptEngineBase.ScriptManager _GetScriptManager()
+        public IConfig Config
         {
-            return new ScriptManager(this);
+            get { return ScriptConfigSource; }
         }
 
-        public override string ScriptEngineName
+        /// <summary>
+        /// How many seconds between re-reading config-file. 0 = never. ScriptEngine will try to adjust to new config changes.
+        /// </summary>
+        public int RefreshConfigFileSeconds {
+            get { return (int)(RefreshConfigFilens / 10000000); }
+            set { RefreshConfigFilens = value * 10000000; }
+        }
+        public long RefreshConfigFilens;
+
+        public string ScriptEngineName
         {
             get { return "ScriptEngine.DotNetEngine"; }
         }
+        
+        public ILog Log
+        {
+            get { return m_log; }
+        }
+
+        public ScriptEngine()
+        {
+            Common.mySE = this;                 // For logging, just need any instance, doesn't matter
+            lock (ScriptEngines)
+            {
+                ScriptEngines.Add(this); // Keep a list of ScriptEngines for shared threads to process all instances
+            }
+        }
+
+        public void Initialise(Scene Sceneworld, IConfigSource config)
+        {
+            m_log.Info("[" + ScriptEngineName + "]: ScriptEngine initializing");
+
+            ConfigSource = config;
+            m_Scene = Sceneworld;
+
+            // Make sure we have config
+            if (ConfigSource.Configs[ScriptEngineName] == null)
+                ConfigSource.AddConfig(ScriptEngineName);
+            ScriptConfigSource = ConfigSource.Configs[ScriptEngineName];
+
+            m_enabled = ScriptConfigSource.GetBoolean("Enabled", true);
+            if (!m_enabled)
+                return;
+
+            //m_log.Info("[" + ScriptEngineName + "]: InitializeEngine");
+
+            // Create all objects we'll be using
+            m_EventQueueManager = new EventQueueManager(this);
+            m_EventManager = new EventManager(this, true);
+            // We need to start it
+            m_ScriptManager = new ScriptManager(this);
+            m_ScriptManager.Setup();
+            m_AppDomainManager = new AppDomainManager(this);
+            if (m_MaintenanceThread == null)
+                m_MaintenanceThread = new MaintenanceThread();
+
+            m_log.Info("[" + ScriptEngineName + "]: Reading configuration from config section \"" + ScriptEngineName + "\"");
+            ReadConfig();
+
+            m_Scene.StackModuleInterface<IScriptModule>(this);
+        }
+
+        public void PostInitialise()
+        {
+            if (!m_enabled)
+                return;
+
+            m_EventManager.HookUpEvents();
+
+            m_ScriptManager.Start();
+        }
+
+        public void Shutdown()
+        {
+            // We are shutting down
+            lock (ScriptEngines)
+            {
+                ScriptEngines.Remove(this);
+            }
+        }
+
+        public void ReadConfig()
+        {
+#if DEBUG
+            //m_log.Debug("[" + ScriptEngineName + "]: Refreshing configuration for all modules");
+#endif
+            RefreshConfigFileSeconds = ScriptConfigSource.GetInt("RefreshConfig", 30);
+
+
+        // Create a new object (probably not necessary?)
+//            ScriptConfigSource = ConfigSource.Configs[ScriptEngineName];
+
+            if (m_EventQueueManager != null) m_EventQueueManager.ReadConfig();
+            if (m_EventManager != null) m_EventManager.ReadConfig();
+            if (m_ScriptManager != null) m_ScriptManager.ReadConfig();
+            if (m_AppDomainManager != null) m_AppDomainManager.ReadConfig();
+            if (m_MaintenanceThread != null) m_MaintenanceThread.ReadConfig();
+        }
+
+        #region IRegionModule
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "Common." + ScriptEngineName; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+
+        public bool PostObjectEvent(uint localID, EventParams p)
+        {
+            return m_EventQueueManager.AddToObjectQueue(localID, p.EventName, p.DetectParams, p.Params);
+        }
+
+        public bool PostScriptEvent(UUID itemID, EventParams p)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            return m_EventQueueManager.AddToScriptQueue(localID, itemID, p.EventName, p.DetectParams, p.Params);
+        }
+
+        public DetectParams GetDetectParams(UUID itemID, int number)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return null;
+
+            IScript Script = m_ScriptManager.GetScript(localID, itemID);
+
+            if (Script == null)
+                return null;
+
+            DetectParams[] det = m_ScriptManager.GetDetectParams(Script);
+
+            if (number < 0 || number >= det.Length)
+                return null;
+
+            return det[number];
+        }
+
+        public int GetStartParameter(UUID itemID)
+        {
+            return 0;
+        }
+        #endregion
+
+        public void SetState(UUID itemID, string state)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return;
+
+            IScript Script = m_ScriptManager.GetScript(localID, itemID);
+
+            if (Script == null)
+                return;
+
+            string currentState = Script.State;
+
+            if (currentState != state)
+            {
+                try
+                {
+                    m_EventManager.state_exit(localID);
+
+                }
+                catch (AppDomainUnloadedException)
+                {
+                    Console.WriteLine("[SCRIPT]: state change called when script was unloaded.  Nothing to worry about, but noting the occurance");
+                }
+
+                Script.State = state;
+
+                try
+                {
+                    int eventFlags = m_ScriptManager.GetStateEventFlags(localID, itemID);
+                    SceneObjectPart part = m_Scene.GetSceneObjectPart(itemID);
+                    if (part != null)
+                        part.SetScriptEvents(itemID, eventFlags);
+                    m_EventManager.state_entry(localID);
+                }
+                catch (AppDomainUnloadedException)
+                {
+                    Console.WriteLine("[SCRIPT]: state change called when script was unloaded.  Nothing to worry about, but noting the occurance");
+                }
+            }
+        }
+
+        public bool GetScriptState(UUID itemID)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return false;
+
+            IScript script = m_ScriptManager.GetScript(localID, itemID);
+            if (script == null)
+                return false;
+
+            return script.Exec.Running?true:false;
+        }
+
+        public void SetScriptState(UUID itemID, bool state)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return;
+
+            IScript script = m_ScriptManager.GetScript(localID, itemID);
+            if (script == null)
+                return;
+
+            script.Exec.Running = state;
+        }
+
+        public void ApiResetScript(UUID itemID)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return;
+
+            m_ScriptManager.ResetScript(localID, itemID);
+        }
+
+        public void ResetScript(UUID itemID)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return;
+
+            m_ScriptManager.ResetScript(localID, itemID);
+        }
     }
 }
diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptManager.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptManager.cs
index 8ff3bfd..12a8fe4 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptManager.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptManager.cs
@@ -34,22 +34,66 @@ using OpenSim.Region.Environment.Scenes;
 using OpenSim.Region.ScriptEngine.Common;
 using OpenSim.Region.ScriptEngine.Shared;
 using OpenSim.Region.ScriptEngine.Shared.Api;
-using OpenSim.Region.ScriptEngine.Common.ScriptEngineBase;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Threading;
 
 namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
-    public class ScriptManager : Common.ScriptEngineBase.ScriptManager
+    public class ScriptManager
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        public ScriptManager(Common.ScriptEngineBase.ScriptEngine scriptEngine)
-            : base(scriptEngine)
+        #region Declares
+
+        private Thread scriptLoadUnloadThread;
+        private static Thread staticScriptLoadUnloadThread;
+        // private int scriptLoadUnloadThread_IdleSleepms;
+        private Queue<LUStruct> LUQueue = new Queue<LUStruct>();
+        private static bool PrivateThread;
+        private int LoadUnloadMaxQueueSize;
+        private Object scriptLock = new Object();
+        private bool m_started = false;
+        private Dictionary<IScript, DetectParams[]> detparms = new Dictionary<IScript, DetectParams[]>();
+
+        // Load/Unload structure
+        private struct LUStruct
+        {
+            public uint localID;
+            public UUID itemID;
+            public string script;
+            public LUType Action;
+            public int startParam;
+            public bool postOnRez;
+        }
+
+        private enum LUType
+        {
+            Unknown = 0,
+            Load = 1,
+            Unload = 2
+        }
+
+        // Xantor 20080525: Keep a list of compiled scripts this session for reuse
+        public Dictionary<UUID, String> scriptList = new Dictionary<UUID, string>();
+
+        // 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<UUID, IScript>> Scripts =
+            new Dictionary<uint, Dictionary<UUID, IScript>>();
+
+
+        public Scene World
         {
-            base.m_scriptEngine = scriptEngine;
+            get { return m_scriptEngine.World; }
         }
+
+        #endregion
         private Compiler.LSL.Compiler LSLCompiler;
 
-        public override void Initialize()
+        public void Initialize()
         {
             // Create our compiler
             LSLCompiler = new Compiler.LSL.Compiler(m_scriptEngine);
@@ -62,7 +106,7 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine
         // PROVIDE SCRIPT WITH ITS INTERFACE TO OpenSim
 
 
-        public override void _StartScript(uint localID, UUID itemID, string Script, int startParam, bool postOnRez)
+        public void _StartScript(uint localID, UUID itemID, string Script, int startParam, bool postOnRez)
         {
             m_log.DebugFormat(
                 "[{0}]: ScriptManager StartScript: localID: {1}, itemID: {2}",
@@ -173,7 +217,7 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine
             }
         }
 
-        public override void _StopScript(uint localID, UUID itemID)
+        public void _StopScript(uint localID, UUID itemID)
         {
             IScript LSLBC = GetScript(localID, itemID);
             if (LSLBC == null)
@@ -202,5 +246,405 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine
                                             ": " + e.ToString());
             }
         }
+
+        public void ReadConfig()
+        {
+            // scriptLoadUnloadThread_IdleSleepms = m_scriptEngine.ScriptConfigSource.GetInt("ScriptLoadUnloadLoopms", 30);
+            // TODO: Requires sharing of all ScriptManagers to single thread
+            PrivateThread = true; // m_scriptEngine.ScriptConfigSource.GetBoolean("PrivateScriptLoadUnloadThread", false);
+            LoadUnloadMaxQueueSize = m_scriptEngine.ScriptConfigSource.GetInt("LoadUnloadMaxQueueSize", 100);
+        }
+
+        #region Object init/shutdown
+
+        public ScriptEngine m_scriptEngine;
+
+        public ScriptManager(ScriptEngine scriptEngine)
+        {
+            m_scriptEngine = scriptEngine;
+        }
+        public void Setup()
+        {
+            ReadConfig();
+            Initialize();
+        }
+        public void Start()
+        {
+            m_started = true;
+
+
+            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
+
+            //
+            // CREATE THREAD
+            // Private or shared
+            //
+            if (PrivateThread)
+            {
+                // Assign one thread per region
+                //scriptLoadUnloadThread = StartScriptLoadUnloadThread();
+            }
+            else
+            {
+                // Shared thread - make sure one exist, then assign it to the private
+                if (staticScriptLoadUnloadThread == null)
+                {
+                    //staticScriptLoadUnloadThread = StartScriptLoadUnloadThread();
+                }
+                scriptLoadUnloadThread = staticScriptLoadUnloadThread;
+            }
+        }
+
+// TODO: unused
+//        private static int privateThreadCount = 0;
+//         private Thread StartScriptLoadUnloadThread()
+//         {
+//             Thread t = new Thread(ScriptLoadUnloadThreadLoop);
+//             string name = "ScriptLoadUnloadThread:";
+//             if (PrivateThread)
+//             {
+//                 name += "Private:" + privateThreadCount;
+//                 privateThreadCount++;
+//             }
+//             else
+//             {
+//                 name += "Shared";
+//             }
+//             t.Name = name;
+//             t.IsBackground = true;
+//             t.Priority = ThreadPriority.Normal;
+//             t.Start();
+//             OpenSim.Framework.ThreadTracker.Add(t);
+//             return t;
+//         }
+
+        ~ScriptManager()
+        {
+            // Abort load/unload thread
+            try
+            {
+                //PleaseShutdown = true;
+                //Thread.Sleep(100);
+                if (scriptLoadUnloadThread != null && scriptLoadUnloadThread.IsAlive == true)
+                {
+                    scriptLoadUnloadThread.Abort();
+                    //scriptLoadUnloadThread.Join();
+                }
+            }
+            catch
+            {
+            }
+        }
+
+        #endregion
+
+        #region Load / Unload scripts (Thread loop)
+
+// TODO: unused
+//         private void ScriptLoadUnloadThreadLoop()
+//         {
+//             try
+//             {
+//                 while (true)
+//                 {
+//                     if (LUQueue.Count == 0)
+//                         Thread.Sleep(scriptLoadUnloadThread_IdleSleepms);
+//                     //if (PleaseShutdown)
+//                     //    return;
+//                     DoScriptLoadUnload();
+//                 }
+//             }
+//             catch (ThreadAbortException tae)
+//             {
+//                 string a = tae.ToString();
+//                 a = String.Empty;
+//                 // Expected
+//             }
+//         }
+
+        public void DoScriptLoadUnload()
+        {
+            if (!m_started)
+                return;
+
+            lock (LUQueue)
+            {
+                if (LUQueue.Count > 0)
+                {
+m_scriptEngine.Log.InfoFormat("[{0}]: Loading script", m_scriptEngine.ScriptEngineName);
+                    LUStruct item = LUQueue.Dequeue();
+
+                    if (item.Action == LUType.Unload)
+                    {
+                        _StopScript(item.localID, item.itemID);
+                        RemoveScript(item.localID, item.itemID);
+                    }
+                    else if (item.Action == LUType.Load)
+                    {
+                        _StartScript(item.localID, item.itemID, item.script, item.startParam, item.postOnRez);
+                    }
+                }
+            }
+        }
+
+        #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, UUID itemID, string Script, int startParam, bool postOnRez)
+        {
+            lock (LUQueue)
+            {
+                if ((LUQueue.Count >= LoadUnloadMaxQueueSize) && m_started)
+                {
+                    m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: ERROR: Load/unload queue item count is at " + LUQueue.Count + ". Config variable \"LoadUnloadMaxQueueSize\" is set to " + LoadUnloadMaxQueueSize + ", so ignoring new script.");
+                    return;
+                }
+
+                LUStruct ls = new LUStruct();
+                ls.localID = localID;
+                ls.itemID = itemID;
+                ls.script = Script;
+                ls.Action = LUType.Load;
+                ls.startParam = startParam;
+                ls.postOnRez = postOnRez;
+                LUQueue.Enqueue(ls);
+m_scriptEngine.Log.InfoFormat("[{0}]: Queued script for load", m_scriptEngine.ScriptEngineName);
+            }
+        }
+
+        /// <summary>
+        /// Disables and unloads a script
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="itemID"></param>
+        public void StopScript(uint localID, UUID itemID)
+        {
+            LUStruct ls = new LUStruct();
+            ls.localID = localID;
+            ls.itemID = itemID;
+            ls.Action = LUType.Unload;
+            ls.startParam = 0;
+            ls.postOnRez = false;
+            lock (LUQueue)
+            {
+                LUQueue.Enqueue(ls);
+            }
+        }
+
+        // Create a new instance of the compiler (reuse)
+        //private Compiler.LSL.Compiler LSLCompiler = new Compiler.LSL.Compiler();
+
+
+        #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, UUID itemID, string FunctionName, DetectParams[] qParams, object[] args)
+        {
+            //cfk 2-7-08 dont need this right now and the default Linux build has DEBUG defined
+            ///#if DEBUG
+            ///            Console.WriteLine("ScriptEngine: Inside ExecuteEvent for event " + FunctionName);
+            ///#endif
+            // Execute a function in the script
+            //m_scriptEngine.Log.Info("[" + ScriptEngineName + "]: Executing Function localID: " + localID + ", itemID: " + itemID + ", FunctionName: " + FunctionName);
+            //ScriptBaseInterface Script = (ScriptBaseInterface)GetScript(localID, itemID);
+            IScript Script = GetScript(localID, itemID);
+            if (Script == null)
+            {
+                return;
+            }
+            //cfk 2-7-08 dont need this right now and the default Linux build has DEBUG defined
+            ///#if DEBUG
+            ///            Console.WriteLine("ScriptEngine: Executing event: " + FunctionName);
+            ///#endif
+            // Must be done in correct AppDomain, so leaving it up to the script itself
+            detparms[Script] = qParams;
+            Script.Exec.ExecuteEvent(FunctionName, args);
+            detparms.Remove(Script);
+        }
+
+        public uint GetLocalID(UUID itemID)
+        {
+            foreach (KeyValuePair<uint, Dictionary<UUID, IScript> > k in Scripts)
+            {
+                if (k.Value.ContainsKey(itemID))
+                    return k.Key;
+            }
+            return 0;
+        }
+
+        public int GetStateEventFlags(uint localID, UUID itemID)
+        {
+            // Console.WriteLine("GetStateEventFlags for <" + localID + "," + itemID + ">");
+            try
+            {
+                IScript Script = GetScript(localID, itemID);
+                if (Script == null)
+                {
+                    return 0;
+                }
+                ExecutorBase.scriptEvents evflags = Script.Exec.GetStateEventFlags();
+                return (int)evflags;
+            }
+            catch (Exception)
+            {
+            }
+
+            return 0;
+        }
+
+
+        #endregion
+
+        #region Internal functions to keep track of script
+
+        public List<UUID> GetScriptKeys(uint localID)
+        {
+            if (Scripts.ContainsKey(localID) == false)
+                return new List<UUID>();
+
+            Dictionary<UUID, IScript> Obj;
+            Scripts.TryGetValue(localID, out Obj);
+
+            return new List<UUID>(Obj.Keys);
+        }
+
+        public IScript GetScript(uint localID, UUID itemID)
+        {
+            lock (scriptLock)
+            {
+                IScript Script = null;
+
+                if (Scripts.ContainsKey(localID) == false)
+                    return null;
+
+                Dictionary<UUID, IScript> Obj;
+                Scripts.TryGetValue(localID, out Obj);
+                if (Obj.ContainsKey(itemID) == false)
+                    return null;
+
+                // Get script
+                Obj.TryGetValue(itemID, out Script);
+                return Script;
+            }
+        }
+
+        public void SetScript(uint localID, UUID itemID, IScript Script)
+        {
+            lock (scriptLock)
+            {
+                // Create object if it doesn't exist
+                if (Scripts.ContainsKey(localID) == false)
+                {
+                    Scripts.Add(localID, new Dictionary<UUID, IScript>());
+                }
+
+                // Delete script if it exists
+                Dictionary<UUID, 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, UUID itemID)
+        {
+            if (localID == 0)
+                localID = GetLocalID(itemID);
+
+            // Don't have that object?
+            if (Scripts.ContainsKey(localID) == false)
+                return;
+
+            // Delete script if it exists
+            Dictionary<UUID, IScript> Obj;
+            Scripts.TryGetValue(localID, out Obj);
+            if (Obj.ContainsKey(itemID) == true)
+                Obj.Remove(itemID);
+        }
+
+        #endregion
+
+
+        public void ResetScript(uint localID, UUID itemID)
+        {
+            IScript s = GetScript(localID, itemID);
+            string script = s.Source;
+            StopScript(localID, itemID);
+            SceneObjectPart part = World.GetSceneObjectPart(localID);
+            part.GetInventoryItem(itemID).PermsMask = 0;
+            part.GetInventoryItem(itemID).PermsGranter = UUID.Zero;
+            StartScript(localID, itemID, script, s.StartParam, false);
+        }
+
+
+        #region Script serialization/deserialization
+
+        public void GetSerializedScript(uint localID, UUID 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, UUID itemID)
+        {
+            // Deserialize the script and inject it into an AppDomain
+
+            // How to inject into an AppDomain?
+        }
+
+        #endregion
+
+        ///// <summary>
+        ///// If set to true then threads and stuff should try to make a graceful exit
+        ///// </summary>
+        //public bool PleaseShutdown
+        //{
+        //    get { return _PleaseShutdown; }
+        //    set { _PleaseShutdown = value; }
+        //}
+        //private bool _PleaseShutdown = false;
+        
+        public DetectParams[] GetDetectParams(IScript script)
+        {
+            if (detparms.ContainsKey(script))
+                return detparms[script];
+
+            return null;
+        }
     }
 }