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

Loads of things has been put into interfaces instead of the specific class. We are now one step closer to ScriptServer, and its very easy to implement new script languages. Just a few lines required to make them a OpenSim script module with all its glory.
author: Tedd Hansen 2008-01-12 14:30:22 +0000
committer: Tedd Hansen 2008-01-12 14:30:22 +0000
commit: bacbade369a5244f9bcc611488b59f3bd4c8a564 (patch)
tree: 2cd909eff401066a69dba96615cbf736fdd73be5 /OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/ScriptManager.cs
parent: * Trying something to see if it helps teleports and border crossings (diff)
download: opensim-SC_OLD-bacbade369a5244f9bcc611488b59f3bd4c8a564.zip
opensim-SC_OLD-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.gz
opensim-SC_OLD-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.bz2
opensim-SC_OLD-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.xz
1 files changed, 347 insertions, 0 deletions
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
author	Tedd Hansen	2008-01-12 14:30:22 +0000
committer	Tedd Hansen	2008-01-12 14:30:22 +0000
commit	bacbade369a5244f9bcc611488b59f3bd4c8a564 (patch)
tree	2cd909eff401066a69dba96615cbf736fdd73be5 /OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/ScriptManager.cs
parent	* Trying something to see if it helps teleports and border crossings (diff)
download	opensim-SC_OLD-bacbade369a5244f9bcc611488b59f3bd4c8a564.zip opensim-SC_OLD-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.gz opensim-SC_OLD-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.bz2 opensim-SC_OLD-bacbade369a5244f9bcc611488b59f3bd4c8a564.tar.xz

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 @@
	1	/*
	2	* Copyright (c) Contributors, http://opensimulator.org/
	3	* See CONTRIBUTORS.TXT for a full list of copyright holders.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions are met:
	7	* * Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* * Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	* * Neither the name of the OpenSim Project nor the
	13	* names of its contributors may be used to endorse or promote products
	14	* derived from this software without specific prior written permission.
	15	*
	16	* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
	17	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	18	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	19	* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
	20	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	21	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	22	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	23	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	24	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	25	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	26	*
	27	*/
	28	/* Original code: Tedd Hansen */
	29	using System;
	30	using System.Collections.Generic;
	31	using System.IO;
	32	using System.Reflection;
	33	using System.Runtime.Serialization.Formatters.Binary;
	34	using System.Threading;
	35	using libsecondlife;
	36	using OpenSim.Framework;
	37	using OpenSim.Region.Environment.Scenes;
	38	using OpenSim.Region.ScriptEngine.Common;
	39
	40	namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
	41	{
	42	/// <summary>
	43	/// Loads scripts
	44	/// Compiles them if necessary
	45	/// Execute functions for EventQueueManager (Sends them to script on other AppDomain for execution)
	46	/// </summary>
	47	///
	48
	49	// 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.
	50	// * Keeps track of running scripts
	51	// * Compiles script if necessary (through "Compiler")
	52	// * Loads script (through "AppDomainManager" called from for example "EventQueueManager")
	53	// * Executes functions inside script (called from for example "EventQueueManager" class)
	54	// * Unloads script (through "AppDomainManager" called from for example "EventQueueManager")
	55	// * Dedicated load/unload thread, and queues loading/unloading.
	56	// This so that scripts starting or stopping will not slow down other theads or whole system.
	57	//
	58	[Serializable]
	59	public abstract class ScriptManager
	60	{
	61	#region Declares
	62
	63	private Thread scriptLoadUnloadThread;
	64	private int scriptLoadUnloadThread_IdleSleepms = 100;
	65	private Queue<LUStruct> LUQueue = new Queue<LUStruct>();
	66
	67
	68	// Load/Unload structure
	69	private struct LUStruct
	70	{
	71	public uint localID;
	72	public LLUUID itemID;
	73	public string script;
	74	public LUType Action;
	75	}
	76
	77	private enum LUType
	78	{
	79	Unknown = 0,
	80	Load = 1,
	81	Unload = 2
	82	}
	83
	84	// Object<string, Script<string, script>>
	85	// IMPORTANT: Types and MemberInfo-derived objects require a LOT of memory.
	86	// Instead use RuntimeTypeHandle, RuntimeFieldHandle and RunTimeHandle (IntPtr) instead!
	87	public Dictionary<uint, Dictionary<LLUUID, IScript>> Scripts =
	88	new Dictionary<uint, Dictionary<LLUUID, IScript>>();
	89
	90	public Scene World
	91	{
	92	get { return m_scriptEngine.World; }
	93	}
	94
	95	#endregion
	96
	97	#region Object init/shutdown
	98
	99	public ScriptEngineBase.ScriptEngine m_scriptEngine;
	100
	101	public ScriptManager(ScriptEngineBase.ScriptEngine scriptEngine)
	102	{
	103	m_scriptEngine = scriptEngine;
	104	AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
	105	scriptLoadUnloadThread = new Thread(ScriptLoadUnloadThreadLoop);
	106	scriptLoadUnloadThread.Name = "ScriptLoadUnloadThread";
	107	scriptLoadUnloadThread.IsBackground = true;
	108	scriptLoadUnloadThread.Priority = ThreadPriority.BelowNormal;
	109	scriptLoadUnloadThread.Start();
	110	}
	111
	112	~ScriptManager()
	113	{
	114	// Abort load/unload thread
	115	try
	116	{
	117	if (scriptLoadUnloadThread != null)
	118	{
	119	if (scriptLoadUnloadThread.IsAlive == true)
	120	{
	121	scriptLoadUnloadThread.Abort();
	122	scriptLoadUnloadThread.Join();
	123	}
	124	}
	125	}
	126	catch
	127	{
	128	}
	129	}
	130
	131	#endregion
	132
	133	#region Load / Unload scripts (Thread loop)
	134
	135	private void ScriptLoadUnloadThreadLoop()
	136	{
	137	try
	138	{
	139	while (true)
	140	{
	141	if (LUQueue.Count == 0)
	142	Thread.Sleep(scriptLoadUnloadThread_IdleSleepms);
	143	if (LUQueue.Count > 0)
	144	{
	145	LUStruct item = LUQueue.Dequeue();
	146	lock (startStopLock) // Lock so we have only 1 thread working on loading/unloading of scripts
	147	{
	148	if (item.Action == LUType.Unload)
	149	{
	150	_StopScript(item.localID, item.itemID);
	151	}
	152	if (item.Action == LUType.Load)
	153	{
	154	_StartScript(item.localID, item.itemID, item.script);
	155	}
	156	}
	157	}
	158	}
	159	}
	160	catch (ThreadAbortException tae)
	161	{
	162	string a = tae.ToString();
	163	a = "";
	164	// Expected
	165	}
	166	}
	167
	168	#endregion
	169
	170	#region Helper functions
	171
	172	private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
	173	{
	174	//Console.WriteLine("ScriptManager.CurrentDomain_AssemblyResolve: " + args.Name);
	175	return Assembly.GetExecutingAssembly().FullName == args.Name ? Assembly.GetExecutingAssembly() : null;
	176	}
	177
	178	#endregion
	179
	180
	181
	182	#region Start/Stop/Reset script
	183
	184	private readonly Object startStopLock = new Object();
	185
	186	/// <summary>
	187	/// Fetches, loads and hooks up a script to an objects events
	188	/// </summary>
	189	/// <param name="itemID"></param>
	190	/// <param name="localID"></param>
	191	public void StartScript(uint localID, LLUUID itemID, string Script)
	192	{
	193	LUStruct ls = new LUStruct();
	194	ls.localID = localID;
	195	ls.itemID = itemID;
	196	ls.script = Script;
	197	ls.Action = LUType.Load;
	198	LUQueue.Enqueue(ls);
	199	}
	200
	201	/// <summary>
	202	/// Disables and unloads a script
	203	/// </summary>
	204	/// <param name="localID"></param>
	205	/// <param name="itemID"></param>
	206	public void StopScript(uint localID, LLUUID itemID)
	207	{
	208	LUStruct ls = new LUStruct();
	209	ls.localID = localID;
	210	ls.itemID = itemID;
	211	ls.Action = LUType.Unload;
	212	LUQueue.Enqueue(ls);
	213	}
	214
	215	// Create a new instance of the compiler (reuse)
	216	//private Compiler.LSL.Compiler LSLCompiler = new Compiler.LSL.Compiler();
	217
	218	public abstract void _StartScript(uint localID, LLUUID itemID, string Script);
	219
	220	public abstract void _StopScript(uint localID, LLUUID itemID);
	221
	222
	223	#endregion
	224
	225	#region Perform event execution in script
	226
	227	/// <summary>
	228	/// Execute a LL-event-function in Script
	229	/// </summary>
	230	/// <param name="localID">Object the script is located in</param>
	231	/// <param name="itemID">Script ID</param>
	232	/// <param name="FunctionName">Name of function</param>
	233	/// <param name="args">Arguments to pass to function</param>
	234	internal void ExecuteEvent(uint localID, LLUUID itemID, string FunctionName, object[] args)
	235	{
	236	#if DEBUG
	237	Console.WriteLine("ScriptEngine: Inside ExecuteEvent for event " + FunctionName);
	238	#endif
	239	// Execute a function in the script
	240	//m_scriptEngine.Log.Verbose("ScriptEngine", "Executing Function localID: " + localID + ", itemID: " + itemID + ", FunctionName: " + FunctionName);
	241	//ScriptBaseInterface Script = (ScriptBaseInterface)GetScript(localID, itemID);
	242	IScript Script = GetScript(localID, itemID);
	243	if (Script == null)
	244	return;
	245	#if DEBUG
	246	Console.WriteLine("ScriptEngine: Executing event: " + FunctionName);
	247	#endif
	248	// Must be done in correct AppDomain, so leaving it up to the script itself
	249	Script.Exec.ExecuteEvent(FunctionName, args);
	250	}
	251
	252	#endregion
	253
	254	#region Internal functions to keep track of script
	255
	256	public Dictionary<LLUUID, IScript>.KeyCollection GetScriptKeys(uint localID)
	257	{
	258	if (Scripts.ContainsKey(localID) == false)
	259	return null;
	260
	261	Dictionary<LLUUID, IScript> Obj;
	262	Scripts.TryGetValue(localID, out Obj);
	263
	264	return Obj.Keys;
	265	}
	266
	267	public IScript GetScript(uint localID, LLUUID itemID)
	268	{
	269	if (Scripts.ContainsKey(localID) == false)
	270	return null;
	271
	272	Dictionary<LLUUID, IScript> Obj;
	273	Scripts.TryGetValue(localID, out Obj);
	274	if (Obj.ContainsKey(itemID) == false)
	275	return null;
	276
	277	// Get script
	278	IScript Script;
	279	Obj.TryGetValue(itemID, out Script);
	280
	281	return Script;
	282	}
	283
	284	public void SetScript(uint localID, LLUUID itemID, IScript Script)
	285	{
	286	// Create object if it doesn't exist
	287	if (Scripts.ContainsKey(localID) == false)
	288	{
	289	Scripts.Add(localID, new Dictionary<LLUUID, IScript>());
	290	}
	291
	292	// Delete script if it exists
	293	Dictionary<LLUUID, IScript> Obj;
	294	Scripts.TryGetValue(localID, out Obj);
	295	if (Obj.ContainsKey(itemID) == true)
	296	Obj.Remove(itemID);
	297
	298	// Add to object
	299	Obj.Add(itemID, Script);
	300	}
	301
	302	public void RemoveScript(uint localID, LLUUID itemID)
	303	{
	304	// Don't have that object?
	305	if (Scripts.ContainsKey(localID) == false)
	306	return;
	307
	308	// Delete script if it exists
	309	Dictionary<LLUUID, IScript> Obj;
	310	Scripts.TryGetValue(localID, out Obj);
	311	if (Obj.ContainsKey(itemID) == true)
	312	Obj.Remove(itemID);
	313	}
	314
	315	#endregion
	316
	317
	318	public void ResetScript(uint localID, LLUUID itemID)
	319	{
	320	string script = GetScript(localID, itemID).Source;
	321	StopScript(localID, itemID);
	322	StartScript(localID, itemID, script);
	323	}
	324
	325
	326	#region Script serialization/deserialization
	327
	328	public void GetSerializedScript(uint localID, LLUUID itemID)
	329	{
	330	// Serialize the script and return it
	331	// Should not be a problem
	332	FileStream fs = File.Create("SERIALIZED_SCRIPT_" + itemID);
	333	BinaryFormatter b = new BinaryFormatter();
	334	b.Serialize(fs, GetScript(localID, itemID));
	335	fs.Close();
	336	}
	337
	338	public void PutSerializedScript(uint localID, LLUUID itemID)
	339	{
	340	// Deserialize the script and inject it into an AppDomain
	341
	342	// How to inject into an AppDomain?
	343	}
	344
	345	#endregion
	346	}
	347	} \ No newline at end of file