From 1a47ff8094ee414a47aebd310826906d89428a09 Mon Sep 17 00:00:00 2001 From: Teravus Ovares Date: Fri, 30 May 2008 12:27:06 +0000 Subject: * This is Melanie's XEngine script engine. I've not tested this real well, however, it's confirmed to compile and OpenSimulator to run successfully without this script engine active. --- .../XEngine/AsyncCommandPlugins/Dataserver.cs | 127 +++++++ .../XEngine/AsyncCommandPlugins/Eventstream.cs | 76 ++++ .../XEngine/AsyncCommandPlugins/HttpRequest.cs | 89 +++++ .../XEngine/AsyncCommandPlugins/Listener.cs | 91 +++++ .../XEngine/AsyncCommandPlugins/SensorRepeat.cs | 391 +++++++++++++++++++++ .../XEngine/AsyncCommandPlugins/Timer.cs | 163 +++++++++ .../XEngine/AsyncCommandPlugins/XmlRequest.cs | 115 ++++++ 7 files changed, 1052 insertions(+) create mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Dataserver.cs create mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Eventstream.cs create mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/HttpRequest.cs create mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Listener.cs create mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/SensorRepeat.cs create mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Timer.cs create mode 100644 OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/XmlRequest.cs (limited to 'OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins') diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Dataserver.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Dataserver.cs new file mode 100644 index 0000000..794a015 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Dataserver.cs @@ -0,0 +1,127 @@ +/* + * 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 libsecondlife; +using OpenSim.Region.ScriptEngine.XEngine.Script; + +namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins +{ + public class Dataserver + { + public AsyncCommandManager m_CmdManager; + + private Dictionary DataserverRequests = + new Dictionary(); + + public Dataserver(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + private class DataserverRequest + { + public uint localID; + public LLUUID itemID; + + public LLUUID ID; + public string handle; + + public DateTime startTime; + } + + public LLUUID RegisterRequest(uint localID, LLUUID itemID, + string identifier) + { + lock(DataserverRequests) + { + if(DataserverRequests.ContainsKey(identifier)) + return LLUUID.Zero; + + DataserverRequest ds = new DataserverRequest(); + + ds.localID = localID; + ds.itemID = itemID; + + ds.ID = LLUUID.Random(); + ds.handle = identifier; + + ds.startTime = DateTime.Now; + + DataserverRequests[identifier]=ds; + + return ds.ID; + } + } + + public void DataserverReply(string identifier, string reply) + { + DataserverRequest ds; + + lock(DataserverRequests) + { + if(!DataserverRequests.ContainsKey(identifier)) + return; + + ds=DataserverRequests[identifier]; + DataserverRequests.Remove(identifier); + } + + m_CmdManager.m_ScriptEngine.PostObjectEvent(ds.localID, + new XEventParams( "dataserver", new Object[] + { new LSL_Types.LSLString(ds.ID.ToString()), + new LSL_Types.LSLString(reply)}, + new XDetectParams[0])); + } + + public void RemoveEvents(uint localID, LLUUID itemID) + { + lock(DataserverRequests) + { + foreach (DataserverRequest ds in new List(DataserverRequests.Values)) + { + if(ds.itemID == itemID) + DataserverRequests.Remove(ds.handle); + } + } + } + + public void ExpireRequests() + { + lock(DataserverRequests) + { + foreach (DataserverRequest ds in new List(DataserverRequests.Values)) + { + if(ds.startTime > DateTime.Now.AddSeconds(30)) + DataserverRequests.Remove(ds.handle); + } + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Eventstream.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Eventstream.cs new file mode 100644 index 0000000..9112b9c --- /dev/null +++ b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Eventstream.cs @@ -0,0 +1,76 @@ +/* + * 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 libsecondlife; +using OpenSim.Region.Environment.Scenes; + +namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins +{ + public class Eventstream + { + public AsyncCommandManager m_CmdManager; + + private class Event + { + public uint LocalID; + public string EventName; + public Dictionary DetectParams; + } + + private Dictionary > m_Events = + new Dictionary >(); + + public Eventstream(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public void AddObjectEvent(uint localID, string eventName, XDetectParams det) + { + SceneObjectPart part = m_CmdManager.m_ScriptEngine.World. + GetSceneObjectPart(localID); + + if(part == null) // Can't register events for non-prims + return; + + if(!part.ContainsScripts()) + return; + + } + + public void RemoveObjectEvent(uint localID, string eventName, LLUUID id) + { + } + + public void RemoveObjects(uint localID) + { + } + } +} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/HttpRequest.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/HttpRequest.cs new file mode 100644 index 0000000..977e3f9 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/HttpRequest.cs @@ -0,0 +1,89 @@ +/* + * 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 OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.Environment.Modules.Scripting.HttpRequest; +using OpenSim.Region.ScriptEngine.XEngine.Script; + +namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins +{ + public class HttpRequest + { + public AsyncCommandManager m_CmdManager; + + public HttpRequest(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public void CheckHttpRequests() + { + if (m_CmdManager.m_ScriptEngine.World == null) + return; + + IHttpRequests iHttpReq = + m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + HttpRequestClass httpInfo = null; + + if (iHttpReq != null) + httpInfo = iHttpReq.GetNextCompletedRequest(); + + while (httpInfo != null) + { + //m_ScriptEngine.Log.Info("[AsyncLSL]:" + 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 + + iHttpReq.RemoveCompletedRequest(httpInfo.reqID); + + object[] resobj = new object[] + { + new LSL_Types.LSLString(httpInfo.reqID.ToString()), + new LSL_Types.LSLInteger(httpInfo.status), + new LSL_Types.list(), + new LSL_Types.LSLString(httpInfo.response_body) + }; + + foreach (XEngine xe in XEngine.ScriptEngines) + { + if(xe.PostObjectEvent(httpInfo.localID, + new XEventParams("http_response", + resobj, new XDetectParams[0]))) + break; + } + httpInfo = iHttpReq.GetNextCompletedRequest(); + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Listener.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Listener.cs new file mode 100644 index 0000000..1144c00 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Listener.cs @@ -0,0 +1,91 @@ +/* + * 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 libsecondlife; +using OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.Environment.Modules.Scripting.WorldComm; +using OpenSim.Region.ScriptEngine.XEngine.Script; + +namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins +{ + public class Listener + { + // private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); + + public AsyncCommandManager m_CmdManager; + + public Listener(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public void CheckListeners() + { + if (m_CmdManager.m_ScriptEngine.World == null) + return; + IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + if (comms != null) + { + while (comms.HasMessages()) + { + ListenerInfo lInfo = comms.GetNextMessage(); + + //Deliver data to prim's listen handler + object[] resobj = new object[] + { + new LSL_Types.LSLInteger(lInfo.GetChannel()), + new LSL_Types.LSLString(lInfo.GetName()), + new LSL_Types.LSLString(lInfo.GetID().ToString()), + new LSL_Types.LSLString(lInfo.GetMessage()) + }; + + m_CmdManager.m_ScriptEngine.PostScriptEvent( + lInfo.GetItemID(), new XEventParams( + "listen", resobj, + new XDetectParams[0])); + } + } + } + + public Object[] GetSerializationData(LLUUID itemID) + { + IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + return comms.GetSerializationData(itemID); + } + + public void CreateFromData(uint localID, LLUUID itemID, LLUUID hostID, + Object[] data) + { + IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + comms.CreateFromData(localID, itemID, hostID, data); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/SensorRepeat.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/SensorRepeat.cs new file mode 100644 index 0000000..5a87bb0 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/SensorRepeat.cs @@ -0,0 +1,391 @@ +/* + * 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 libsecondlife; +using OpenSim.Framework; +using OpenSim.Region.Environment.Scenes; +using OpenSim.Region.ScriptEngine.XEngine.Script; + +namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins +{ + public class SensorRepeat + { + public AsyncCommandManager m_CmdManager; + + public SensorRepeat(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public Dictionary> SenseEvents = + new Dictionary>(); + private Object SenseLock = new Object(); + + // + // SenseRepeater and Sensors + // + private class SenseRepeatClass + { + public uint localID; + public LLUUID itemID; + public double interval; + public DateTime next; + + public string name; + public LLUUID keyID; + public int type; + public double range; + public double arc; + public SceneObjectPart host; + } + + private List SenseRepeaters = new List(); + private object SenseRepeatListLock = new object(); + + public void SetSenseRepeatEvent(uint m_localID, LLUUID m_itemID, + string name, LLUUID keyID, int type, double range, double arc, double sec, SceneObjectPart host) + { + Console.WriteLine("SetSensorEvent"); + + // Always remove first, in case this is a re-set + UnSetSenseRepeaterEvents(m_localID, m_itemID); + if (sec == 0) // Disabling timer + return; + + // Add to timer + SenseRepeatClass ts = new SenseRepeatClass(); + ts.localID = m_localID; + ts.itemID = m_itemID; + ts.interval = sec; + ts.name = name; + ts.keyID = keyID; + ts.type = type; + ts.range = range; + ts.arc = arc; + ts.host = host; + + ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + lock (SenseRepeatListLock) + { + SenseRepeaters.Add(ts); + } + } + + public void UnSetSenseRepeaterEvents(uint m_localID, LLUUID m_itemID) + { + // Remove from timer + lock (SenseRepeatListLock) + { + List NewSensors = new List(); + foreach (SenseRepeatClass ts in SenseRepeaters) + { + if (ts.localID != m_localID && ts.itemID != m_itemID) + { + NewSensors.Add(ts); + } + } + SenseRepeaters.Clear(); + SenseRepeaters = NewSensors; + } + } + + public void CheckSenseRepeaterEvents() + { + // Nothing to do here? + if (SenseRepeaters.Count == 0) + return; + + lock (SenseRepeatListLock) + { + // Go through all timers + foreach (SenseRepeatClass ts in SenseRepeaters) + { + // Time has passed? + if (ts.next.ToUniversalTime() < DateTime.Now.ToUniversalTime()) + { + SensorSweep(ts); + // set next interval + ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + } + } + } // lock + } + + public void SenseOnce(uint m_localID, LLUUID m_itemID, + string name, LLUUID keyID, int type, + double range, double arc, SceneObjectPart host) + { + // Add to timer + SenseRepeatClass ts = new SenseRepeatClass(); + ts.localID = m_localID; + ts.itemID = m_itemID; + ts.interval = 0; + ts.name = name; + ts.keyID = keyID; + ts.type = type; + ts.range = range; + ts.arc = arc; + ts.host = host; + SensorSweep(ts); + } + + public LSL_Types.list GetSensorList(uint m_localID, LLUUID m_itemID) + { + lock (SenseLock) + { + Dictionary Obj = null; + if (!SenseEvents.TryGetValue(m_localID, out Obj)) + { + m_CmdManager.m_ScriptEngine.Log.Info("[AsyncLSL]: GetSensorList missing localID: " + m_localID); + return null; + } + lock (Obj) + { + // Get script + LSL_Types.list SenseList = null; + if (!Obj.TryGetValue(m_itemID, out SenseList)) + { + m_CmdManager.m_ScriptEngine.Log.Info("[AsyncLSL]: GetSensorList missing itemID: " + m_itemID); + return null; + } + return SenseList; + } + } + } + + private void SensorSweep(SenseRepeatClass ts) + { + //m_ScriptEngine.Log.Info("[AsyncLSL]:Enter SensorSweep"); + SceneObjectPart SensePoint = ts.host; + + if (SensePoint == null) + { + //m_ScriptEngine.Log.Info("[AsyncLSL]: Enter SensorSweep (SensePoint == null) for "+ts.itemID.ToString()); + return; + } + //m_ScriptEngine.Log.Info("[AsyncLSL]: Enter SensorSweep Scan"); + + LLVector3 sensorPos = SensePoint.AbsolutePosition; + LLVector3 regionPos = new LLVector3(m_CmdManager.m_ScriptEngine.World.RegionInfo.RegionLocX * Constants.RegionSize, m_CmdManager.m_ScriptEngine.World.RegionInfo.RegionLocY * Constants.RegionSize, 0); + LLVector3 fromRegionPos = sensorPos + regionPos; + + LLQuaternion q = SensePoint.RotationOffset; + LSL_Types.Quaternion r = new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W); + LSL_Types.Vector3 forward_dir = (new LSL_Types.Vector3(1, 0, 0) * r); + double mag_fwd = LSL_Types.Vector3.Mag(forward_dir); + + // Here we should do some smart culling ... + // math seems quicker than strings so try that first + LSL_Types.list SensedObjects = new LSL_Types.list(); + LSL_Types.Vector3 ZeroVector = new LSL_Types.Vector3(0, 0, 0); + + foreach (EntityBase ent in m_CmdManager.m_ScriptEngine.World.Entities.Values) + { + LLVector3 toRegionPos = ent.AbsolutePosition + regionPos; + double dis = Math.Abs((double)Util.GetDistanceTo(toRegionPos, fromRegionPos)); + if (dis <= ts.range) + { + // In Range, is it the right Type ? + int objtype = 0; + + if (m_CmdManager.m_ScriptEngine.World.GetScenePresence(ent.UUID) != null) objtype |= 0x01; // actor + if (ent.Velocity.Equals(ZeroVector)) + objtype |= 0x04; // passive non-moving + else + objtype |= 0x02; // active moving + if (ent is IScript) objtype |= 0x08; // Scripted. It COULD have one hidden ... + + if (((ts.type & objtype) != 0) || ((ts.type & objtype) == ts.type)) + { + // docs claim AGENT|ACTIVE should find agent objects OR active objects + // so the bitwise AND with object type should be non-zero + + // Right type too, what about the other params , key and name ? + bool keep = true; + if (ts.arc < Math.PI) + { + // not omni-directional. Can you see it ? + // vec forward_dir = llRot2Fwd(llGetRot()) + // vec obj_dir = toRegionPos-fromRegionPos + // dot=dot(forward_dir,obj_dir) + // mag_fwd = mag(forward_dir) + // mag_obj = mag(obj_dir) + // ang = acos(dot /(mag_fwd*mag_obj)) + double ang_obj = 0; + try + { + LLVector3 diff = toRegionPos - fromRegionPos; + LSL_Types.Vector3 obj_dir = new LSL_Types.Vector3(diff.X, diff.Y, diff.Z); + double dot = LSL_Types.Vector3.Dot(forward_dir, obj_dir); + double mag_obj = LSL_Types.Vector3.Mag(obj_dir); + ang_obj = Math.Acos(dot / (mag_fwd * mag_obj)); + } + catch + { + } + + if (ang_obj > ts.arc) keep = false; + } + + if (keep && (ts.keyID != LLUUID.Zero) && (ts.keyID != ent.UUID)) + { + keep = false; + } + + if (keep && (ts.name.Length > 0)) + { + string avatarname=null; + string objectname=null; + string entname =ent.Name; + + // try avatar username surname + UserProfileData profile = m_CmdManager.m_ScriptEngine.World.CommsManager.UserService.GetUserProfile(ent.UUID); + if (profile != null) + { + avatarname = profile.FirstName + " " + profile.SurName; + } + // try an scene object + SceneObjectPart SOP = m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart(ent.UUID); + if (SOP != null) + { + objectname = SOP.Name; + } + + if ((ts.name != entname) && (ts.name != avatarname) && (ts.name != objectname)) + { + keep = false; + } + } + + if (keep == true) SensedObjects.Add(ent.UUID); + } + } + } + //m_ScriptEngine.Log.Info("[AsyncLSL]: Enter SensorSweep SenseLock"); + + lock (SenseLock) + { + // Create object if it doesn't exist + if (SenseEvents.ContainsKey(ts.localID) == false) + { + SenseEvents.Add(ts.localID, new Dictionary()); + } + // clear if previous traces exist + Dictionary Obj; + SenseEvents.TryGetValue(ts.localID, out Obj); + if (Obj.ContainsKey(ts.itemID) == true) + Obj.Remove(ts.itemID); + + // note list may be zero length + Obj.Add(ts.itemID, SensedObjects); + + if (SensedObjects.Length == 0) + { + // send a "no_sensor" + // Add it to queue + m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, + new XEventParams("no_sensor", new Object[0], + new XDetectParams[0])); + } + else + { + XDetectParams[] detect = + new XDetectParams[SensedObjects.Length]; + + int idx; + for(idx = 0 ; idx < SensedObjects.Length; idx++) + { + detect[idx].Key=(LLUUID)(SensedObjects.Data[idx]); + } + + m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, + new XEventParams("sensor", + new Object[] { + new LSL_Types.LSLInteger(SensedObjects.Length) }, + detect)); + } + } + } + + public Object[] GetSerializationData(LLUUID itemID) + { + List data = new List(); + + foreach (SenseRepeatClass ts in SenseRepeaters) + { + if(ts.itemID == itemID) + { + data.Add(ts.interval); + data.Add(ts.name); + data.Add(ts.keyID); + data.Add(ts.type); + data.Add(ts.range); + data.Add(ts.arc); + } + } + return data.ToArray(); + } + + public void CreateFromData(uint localID, LLUUID itemID, LLUUID objectID, + Object[] data) + { + SceneObjectPart part = + m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart( + objectID); + + if(part == null) + return; + + int idx=0; + + while(idx < data.Length) + { + SenseRepeatClass ts = new SenseRepeatClass(); + + ts.localID = localID; + ts.itemID = itemID; + + ts.interval = (double)data[idx]; + ts.name = (string)data[idx+1]; + ts.keyID = (LLUUID)data[idx+2]; + ts.type = (int)data[idx+3]; + ts.range = (double)data[idx+4]; + ts.arc = (double)data[idx+5]; + ts.host = part; + + ts.next = + DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + + SenseRepeaters.Add(ts); + idx += 6; + } + } + + } +} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Timer.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Timer.cs new file mode 100644 index 0000000..09a5818 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/Timer.cs @@ -0,0 +1,163 @@ +/* + * 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 libsecondlife; + +namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins +{ + public class Timer + { + public AsyncCommandManager m_CmdManager; + + public Timer(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + // + // TIMER + // + private class TimerClass + { + public uint localID; + public LLUUID itemID; + //public double interval; + public long interval; + //public DateTime next; + public long next; + } + + private List Timers = new List(); + 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 = Convert.ToInt64(sec * 10000000); // How many 100 nanoseconds (ticks) should we wait + // 2193386136332921 ticks + // 219338613 seconds + + //ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + ts.next = DateTime.Now.Ticks + ts.interval; + lock (TimerListLock) + { + Timers.Add(ts); + } + } + + public void UnSetTimerEvents(uint m_localID, LLUUID m_itemID) + { + // Remove from timer + lock (TimerListLock) + { + foreach (TimerClass ts in new ArrayList(Timers)) + { + if (ts.localID == m_localID && ts.itemID == m_itemID) + Timers.Remove(ts); + } + } + } + + 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 < DateTime.Now.Ticks) + { + // Console.WriteLine("Time has passed: Now: " + DateTime.Now.Ticks + ", Passed: " + ts.next); + // Add it to queue + m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID, + new XEventParams("timer", new Object[0], + new XDetectParams[0])); + // set next interval + + //ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval); + ts.next = DateTime.Now.Ticks + ts.interval; + } + } + } + } + + public Object[] GetSerializationData(LLUUID itemID) + { + List data = new List(); + + lock (TimerListLock) + { + foreach (TimerClass ts in Timers) + { + if(ts.itemID == itemID) + { + data.Add(ts.interval); + data.Add(ts.next-DateTime.Now.Ticks); + } + } + } + return data.ToArray(); + } + + public void CreateFromData(uint localID, LLUUID itemID, LLUUID objectID, + Object[] data) + { + int idx=0; + + while(idx < data.Length) + { + TimerClass ts = new TimerClass(); + + ts.localID = localID; + ts.itemID = itemID; + ts.interval = (long)data[idx]; + ts.next = DateTime.Now.Ticks + (long)data[idx+1]; + idx += 2; + + Timers.Add(ts); + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/XmlRequest.cs b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/XmlRequest.cs new file mode 100644 index 0000000..2714d11 --- /dev/null +++ b/OpenSim/Region/ScriptEngine/XEngine/AsyncCommandPlugins/XmlRequest.cs @@ -0,0 +1,115 @@ +/* + * 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 OpenSim.Region.Environment.Interfaces; +using OpenSim.Region.Environment.Modules.Scripting.XMLRPC; +using OpenSim.Region.ScriptEngine.XEngine.Script; + +namespace OpenSim.Region.ScriptEngine.XEngine.AsyncCommandPlugins +{ + public class XmlRequest + { + public AsyncCommandManager m_CmdManager; + + public XmlRequest(AsyncCommandManager CmdManager) + { + m_CmdManager = CmdManager; + } + + public void CheckXMLRPCRequests() + { + if (m_CmdManager.m_ScriptEngine.World == null) + return; + + IXMLRPC xmlrpc = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface(); + + if (xmlrpc != null) + { + RPCRequestInfo rInfo = xmlrpc.GetNextCompletedRequest(); + + while (rInfo != null) + { + xmlrpc.RemoveCompletedRequest(rInfo.GetMessageID()); + + //Deliver data to prim's remote_data handler + object[] resobj = new object[] + { + new LSL_Types.LSLInteger(2), + new LSL_Types.LSLString( + rInfo.GetChannelKey().ToString()), + new LSL_Types.LSLString( + rInfo.GetMessageID().ToString()), + new LSL_Types.LSLString(String.Empty), + new LSL_Types.LSLInteger(rInfo.GetIntValue()), + new LSL_Types.LSLString(rInfo.GetStrVal()) + }; + + foreach (XEngine xe in XEngine.ScriptEngines) + { + if(xe.PostScriptEvent( + rInfo.GetItemID(), new XEventParams( + "remote_data", resobj, + new XDetectParams[0]))) + break; + } + + rInfo = xmlrpc.GetNextCompletedRequest(); + } + + SendRemoteDataRequest srdInfo = xmlrpc.GetNextCompletedSRDRequest(); + + while (srdInfo != null) + { + xmlrpc.RemoveCompletedSRDRequest(srdInfo.GetReqID()); + + //Deliver data to prim's remote_data handler + object[] resobj = new object[] + { + new LSL_Types.LSLInteger(3), + new LSL_Types.LSLString(srdInfo.channel.ToString()), + new LSL_Types.LSLString(srdInfo.GetReqID().ToString()), + new LSL_Types.LSLString(String.Empty), + new LSL_Types.LSLInteger(srdInfo.idata), + new LSL_Types.LSLString(srdInfo.sdata) + }; + + foreach (XEngine xe in XEngine.ScriptEngines) + { + if(xe.PostScriptEvent( + srdInfo.m_itemID, new XEventParams( + "remote_data", resobj, + new XDetectParams[0]))) + break; + } + + srdInfo = xmlrpc.GetNextCompletedSRDRequest(); + } + } + } + } +} -- cgit v1.1