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

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