Merge branch 'master' into presence-refactor

This was a large, heavily conflicted merge and things MAY have got broken.
Please check!

12 files changed, 1780 insertions, 493 deletions

diff --git a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
index 67395fa..fa9bf19 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
@@ -71,13 +71,18 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <summary>
         /// Start all the scripts contained in this entity's inventory
         /// </summary>
-       void CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource);
+        void CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource);
+        
         ArrayList GetScriptErrors(UUID itemID);
 
         /// <summary>
         /// Stop all the scripts in this entity.
         /// </summary>
-        void RemoveScriptInstances();
+        /// <param name="sceneObjectBeingDeleted">
+        /// Should be true if these scripts are being removed because the scene
+        /// object is being deleted.  This will prevent spurious updates to the client.
+        /// </param>
+        void RemoveScriptInstances(bool sceneObjectBeingDeleted);
 
         /// <summary>
         /// Start a script which is in this entity's inventory.
@@ -103,7 +108,11 @@ namespace OpenSim.Region.Framework.Interfaces
         /// Stop a script which is in this prim's inventory.
         /// </summary>
         /// <param name="itemId"></param>
-        void RemoveScriptInstance(UUID itemId);
+        /// <param name="sceneObjectBeingDeleted">
+        /// Should be true if these scripts are being removed because the scene
+        /// object is being deleted.  This will prevent spurious updates to the client.
+        /// </param>
+        void RemoveScriptInstance(UUID itemId, bool sceneObjectBeingDeleted);
 
         /// <summary>
         /// Add an item to this entity's inventory.  If an item with the same name already exists, then an alternative
@@ -135,6 +144,16 @@ namespace OpenSim.Region.Framework.Interfaces
         TaskInventoryItem GetInventoryItem(UUID itemId);
 
         /// <summary>
+        /// Get inventory items by name.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns>
+        /// A list of inventory items with that name.
+        /// If no inventory item has that name then an empty list is returned.
+        /// </returns>        
+        IList<TaskInventoryItem> GetInventoryItems(string name);
+
+        /// <summary>
         /// Update an existing inventory item.
         /// </summary>
         /// <param name="item">The updated item.  An item with the same id must already exist
diff --git a/OpenSim/Region/Framework/Interfaces/IWorldComm.cs b/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
index 74526c4..948b9dc 100644
--- a/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
+++ b/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
@@ -49,10 +49,49 @@ namespace OpenSim.Region.Framework.Interfaces
 
     public interface IWorldComm
     {
+        /// <summary>
+        /// Create a listen event callback with the specified filters.
+        /// The parameters localID,itemID are needed to uniquely identify
+        /// the script during 'peek' time. Parameter hostID is needed to
+        /// determine the position of the script.
+        /// </summary>
+        /// <param name="localID">localID of the script engine</param>
+        /// <param name="itemID">UUID of the script engine</param>
+        /// <param name="hostID">UUID of the SceneObjectPart</param>
+        /// <param name="channel">channel to listen on</param>
+        /// <param name="name">name to filter on</param>
+        /// <param name="id">key to filter on (user given, could be totally faked)</param>
+        /// <param name="msg">msg to filter on</param>
+        /// <returns>number of the scripts handle</returns>        
         int Listen(uint LocalID, UUID itemID, UUID hostID, int channel, string name, UUID id, string msg);
+
+        /// <summary>
+        /// This method scans over the objects which registered an interest in listen callbacks.
+        /// For everyone it finds, it checks if it fits the given filter. If it does,  then
+        /// enqueue the message for delivery to the objects listen event handler.
+        /// The enqueued ListenerInfo no longer has filter values, but the actually trigged values.
+        /// Objects that do an llSay have their messages delivered here and for nearby avatars,
+        /// the OnChatFromClient event is used.
+        /// </summary>
+        /// <param name="type">type of delvery (whisper,say,shout or regionwide)</param>
+        /// <param name="channel">channel to sent on</param>
+        /// <param name="name">name of sender (object or avatar)</param>
+        /// <param name="id">key of sender (object or avatar)</param>
+        /// <param name="msg">msg to sent</param>        
         void DeliverMessage(ChatTypeEnum type, int channel, string name, UUID id, string msg);
+
+        /// <summary>
+        /// Are there any listen events ready to be dispatched?
+        /// </summary>
+        /// <returns>boolean indication</returns>        
         bool HasMessages();
+
+        /// <summary>
+        /// Pop the first availlable listen event from the queue
+        /// </summary>
+        /// <returns>ListenerInfo with filter filled in</returns>        
         IWorldCommListenerInfo GetNextMessage();
+        
         void ListenControl(UUID itemID, int handle, int active);
         void ListenRemove(UUID itemID, int handle);
         void DeleteListener(UUID itemID);
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 399379e..473920e 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -27,11 +27,13 @@
 
 using System;
 using System.Collections.Generic;
+using System.Reflection;
+using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Framework.Client;
 using OpenSim.Region.Framework.Interfaces;
-using Caps=OpenSim.Framework.Capabilities.Caps;
+using Caps = OpenSim.Framework.Capabilities.Caps;
 using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
 namespace OpenSim.Region.Framework.Scenes
@@ -41,6 +43,8 @@ namespace OpenSim.Region.Framework.Scenes
     /// </summary>
     public class EventManager
     {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
         public delegate void OnFrameDelegate();
 
         public event OnFrameDelegate OnFrame;
@@ -92,8 +96,7 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void OnShutdownDelegate();
 
         public event OnShutdownDelegate OnShutdown;
-
-        public delegate void ObjectGrabDelegate(uint localID, uint originalID, Vector3 offsetPos, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs);
+        
         public delegate void ObjectDeGrabDelegate(uint localID, uint originalID, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs);
         public delegate void ScriptResetDelegate(uint localID, UUID itemID);
 
@@ -103,62 +106,57 @@ namespace OpenSim.Region.Framework.Scenes
 
         public event OnSetRootAgentSceneDelegate OnSetRootAgentScene;
 
+        /// <summary>
+        /// Called when an object is touched/grabbed.
+        /// </summary>
+        /// The originalID is the local ID of the part that was actually touched.  The localID itself is always that of
+        /// the root part.
+        public delegate void ObjectGrabDelegate(uint localID, uint originalID, Vector3 offsetPos, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs);
         public event ObjectGrabDelegate OnObjectGrab;
+        
+        public event ObjectGrabDelegate OnObjectGrabbing;
         public event ObjectDeGrabDelegate OnObjectDeGrab;
         public event ScriptResetDelegate OnScriptReset;
 
         public event OnPermissionErrorDelegate OnPermissionError;
 
         public delegate void NewRezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine, int stateSource);
-
         public event NewRezScript OnRezScript;
 
         public delegate void RemoveScript(uint localID, UUID itemID);
-
         public event RemoveScript OnRemoveScript;
 
         public delegate void StartScript(uint localID, UUID itemID);
-
         public event StartScript OnStartScript;
 
         public delegate void StopScript(uint localID, UUID itemID);
-
         public event StopScript OnStopScript;
 
         public delegate bool SceneGroupMoved(UUID groupID, Vector3 delta);
-
         public event SceneGroupMoved OnSceneGroupMove;
 
         public delegate void SceneGroupGrabed(UUID groupID, Vector3 offset, UUID userID);
-
         public event SceneGroupGrabed OnSceneGroupGrab;
 
         public delegate bool SceneGroupSpinStarted(UUID groupID);
-
         public event SceneGroupSpinStarted OnSceneGroupSpinStart;
 
         public delegate bool SceneGroupSpun(UUID groupID, Quaternion rotation);
-
         public event SceneGroupSpun OnSceneGroupSpin;
 
         public delegate void LandObjectAdded(ILandObject newParcel);
-
         public event LandObjectAdded OnLandObjectAdded;
 
         public delegate void LandObjectRemoved(UUID globalID);
-
         public event LandObjectRemoved OnLandObjectRemoved;
 
         public delegate void AvatarEnteringNewParcel(ScenePresence avatar, int localLandID, UUID regionID);
-
         public event AvatarEnteringNewParcel OnAvatarEnteringNewParcel;
 
         public delegate void SignificantClientMovement(IClientAPI remote_client);
-
         public event SignificantClientMovement OnSignificantClientMovement;
 
         public delegate void IncomingInstantMessage(GridInstantMessage message);
-
         public event IncomingInstantMessage OnIncomingInstantMessage;
 
         public event IncomingInstantMessage OnUnhandledInstantMessage;
@@ -214,14 +212,16 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void RequestChangeWaterHeight(float height);
 
         public event RequestChangeWaterHeight OnRequestChangeWaterHeight;
-
-        public delegate void AvatarKillData(uint KillerLocalID, ScenePresence avatar);
-
+        
+        /// <summary>
+        /// Fired if any avatar is 'killed' due to its health falling to zero
+        /// </summary>
         public event AvatarKillData OnAvatarKilled;
+        public delegate void AvatarKillData(uint KillerLocalID, ScenePresence avatar);
 
-        public delegate void ScriptTimerEvent(uint localID, double timerinterval);
+//        public delegate void ScriptTimerEvent(uint localID, double timerinterval);
 
-        public event ScriptTimerEvent OnScriptTimerEvent;
+//        public event ScriptTimerEvent OnScriptTimerEvent;
 
         public delegate void EstateToolsSunUpdate(ulong regionHandle, bool FixedTime, bool EstateSun, float LindenHour);
         public delegate void GetScriptRunning(IClientAPI controllingClient, UUID objectID, UUID itemID);
@@ -312,9 +312,10 @@ namespace OpenSim.Region.Framework.Scenes
         public event EmptyScriptCompileQueue OnEmptyScriptCompileQueue;
 
         /// <summary>
-        /// Called whenever an object is attached, or detached
-        /// from an in-world presence.
+        /// Called whenever an object is attached, or detached from an in-world presence.
         /// </summary>
+        /// If the object is being attached, then the avatarID will be present.  If the object is being detached then
+        /// the avatarID is UUID.Zero (I know, this doesn't make much sense but now it's historical).
         public delegate void Attach(uint localID, UUID itemID, UUID avatarID);
         public event Attach OnAttach;
 
@@ -387,607 +388,1263 @@ namespace OpenSim.Region.Framework.Scenes
         public event LandBuy OnLandBuy;
         public event LandBuy OnValidateLandBuy;
 
-        /* Designated Event Deletage Instances */
-
-        private ScriptChangedEvent handlerScriptChangedEvent = null; //OnScriptChangedEvent;
-        private ScriptAtTargetEvent handlerScriptAtTargetEvent = null;
-        private ScriptNotAtTargetEvent handlerScriptNotAtTargetEvent = null;
-        private ScriptAtRotTargetEvent handlerScriptAtRotTargetEvent = null;
-        private ScriptNotAtRotTargetEvent handlerScriptNotAtRotTargetEvent = null;
-        private ClientMovement handlerClientMovement = null; //OnClientMovement;
-        private OnPermissionErrorDelegate handlerPermissionError = null; //OnPermissionError;
-        private OnPluginConsoleDelegate handlerPluginConsole = null; //OnPluginConsole;
-        private OnFrameDelegate handlerFrame = null; //OnFrame;
-        private OnNewClientDelegate handlerNewClient = null; //OnNewClient;
-        private OnClientConnectCoreDelegate handlerClientConnect = null; //OnClientConnect
-        private OnNewPresenceDelegate handlerNewPresence = null; //OnNewPresence;
-        private OnRemovePresenceDelegate handlerRemovePresence = null; //OnRemovePresence;
-        private OnBackupDelegate handlerBackup = null; //OnBackup;
-        private OnParcelPrimCountUpdateDelegate handlerParcelPrimCountUpdate = null; //OnParcelPrimCountUpdate;
-        private MoneyTransferEvent handlerMoneyTransfer = null; //OnMoneyTransfer;
-        private OnParcelPrimCountAddDelegate handlerParcelPrimCountAdd = null; //OnParcelPrimCountAdd;
-        private OnShutdownDelegate handlerShutdown = null; //OnShutdown;
-        private ObjectGrabDelegate handlerObjectGrab = null; //OnObjectGrab;
-        private ObjectDeGrabDelegate handlerObjectDeGrab = null; //OnObjectDeGrab;
-        private ScriptResetDelegate handlerScriptReset = null; // OnScriptReset
-        private NewRezScript handlerRezScript = null; //OnRezScript;
-        private RemoveScript handlerRemoveScript = null; //OnRemoveScript;
-        private StartScript handlerStartScript = null; //OnStartScript;
-        private StopScript handlerStopScript = null; //OnStopScript;
-        private SceneGroupMoved handlerSceneGroupMove = null; //OnSceneGroupMove;
-        private SceneGroupGrabed handlerSceneGroupGrab = null; //OnSceneGroupGrab;
-        private SceneGroupSpinStarted handlerSceneGroupSpinStarted = null; //OnSceneGroupSpinStart;
-        private SceneGroupSpun handlerSceneGroupSpin = null; //OnSceneGroupSpin;
-        private LandObjectAdded handlerLandObjectAdded = null; //OnLandObjectAdded;
-        private LandObjectRemoved handlerLandObjectRemoved = null; //OnLandObjectRemoved;
-        private AvatarEnteringNewParcel handlerAvatarEnteringNewParcel = null; //OnAvatarEnteringNewParcel;
-        private IncomingInstantMessage handlerIncomingInstantMessage = null; //OnIncomingInstantMessage;
-        private IncomingInstantMessage handlerUnhandledInstantMessage = null; //OnUnhandledInstantMessage;
-        private ClientClosed handlerClientClosed = null; //OnClientClosed;
-        private OnMakeChildAgentDelegate handlerMakeChildAgent = null; //OnMakeChildAgent;
-        private OnMakeRootAgentDelegate handlerMakeRootAgent = null; //OnMakeRootAgent;
-        private OnTerrainTickDelegate handlerTerrainTick = null; // OnTerainTick;
-        private RegisterCapsEvent handlerRegisterCaps = null; // OnRegisterCaps;
-        private DeregisterCapsEvent handlerDeregisterCaps = null; // OnDeregisterCaps;
-        private ChatFromWorldEvent handlerChatFromWorld = null; // OnChatFromWorld;
-        private ChatFromClientEvent handlerChatFromClient = null; // OnChatFromClient;
-        private ChatBroadcastEvent handlerChatBroadcast = null; // OnChatBroadcast;
-        private NewInventoryItemUploadComplete handlerNewInventoryItemUpdateComplete = null;
-        private RequestChangeWaterHeight handlerRequestChangeWaterHeight = null; //OnRequestChangeWaterHeight
-        private ScriptControlEvent handlerScriptControlEvent = null;
-        private SignificantClientMovement handlerSignificantClientMovement = null;
-
-        private LandBuy handlerLandBuy = null;
-        private LandBuy handlerValidateLandBuy = null;
-        private AvatarKillData handlerAvatarKill = null;
-
-        private NoticeNoLandDataFromStorage handlerNoticeNoLandDataFromStorage = null;
-        private IncomingLandDataFromStorage handlerIncomingLandDataFromStorage = null;
-        private SetAllowForcefulBan handlerSetAllowForcefulBan = null;
-        private RequestParcelPrimCountUpdate handlerRequestParcelPrimCountUpdate = null;
-        private ParcelPrimCountTainted handlerParcelPrimCountTainted = null;
-        private ObjectBeingRemovedFromScene handlerObjectBeingRemovedFromScene = null;
-        // TODO: unused: private ScriptTimerEvent handlerScriptTimerEvent = null;
-        private EstateToolsSunUpdate handlerEstateToolsSunUpdate = null;
-
-        private ScriptColliding handlerCollidingStart = null;
-        private ScriptColliding handlerColliding = null;
-        private ScriptColliding handlerCollidingEnd = null;
-        private ScriptColliding handlerLandCollidingStart = null;
-        private ScriptColliding handlerLandColliding = null;
-        private ScriptColliding handlerLandCollidingEnd = null;
-        private GetScriptRunning handlerGetScriptRunning = null;
-
-        private SunLindenHour handlerCurrentTimeAsLindenSunHour = null;
-        private OnSetRootAgentSceneDelegate handlerSetRootAgentScene = null;
-
-        private OarFileLoaded handlerOarFileLoaded = null;
-        private OarFileSaved handlerOarFileSaved = null;
-        
-        private EmptyScriptCompileQueue handlerEmptyScriptCompileQueue = null;
-
-        private Attach handlerOnAttach = null;
-        private RegionUp handlerOnRegionUp = null;
-
         public void TriggerOnAttach(uint localID, UUID itemID, UUID avatarID)
         {
-            handlerOnAttach = OnAttach;
+            Attach handlerOnAttach = OnAttach;
             if (handlerOnAttach != null)
-                handlerOnAttach(localID, itemID, avatarID);
+            {
+                foreach (Attach d in handlerOnAttach.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, itemID, avatarID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnAttach failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
         }
 
         public void TriggerGetScriptRunning(IClientAPI controllingClient, UUID objectID, UUID itemID)
         {
-            handlerGetScriptRunning = OnGetScriptRunning;
+            GetScriptRunning handlerGetScriptRunning = OnGetScriptRunning;
             if (handlerGetScriptRunning != null)
-                handlerGetScriptRunning(controllingClient, objectID, itemID);
+            {
+                foreach (GetScriptRunning d in handlerGetScriptRunning.GetInvocationList())
+                {
+                    try
+                    {
+                        d(controllingClient, objectID, itemID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerGetScriptRunning failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnScriptChangedEvent(uint localID, uint change)
         {
-            handlerScriptChangedEvent = OnScriptChangedEvent;
+            ScriptChangedEvent handlerScriptChangedEvent = OnScriptChangedEvent;
             if (handlerScriptChangedEvent != null)
-                handlerScriptChangedEvent(localID, change);
+            {
+                foreach (ScriptChangedEvent d in handlerScriptChangedEvent.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, change);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnScriptChangedEvent failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnClientMovement(ScenePresence avatar)
         {
-            handlerClientMovement = OnClientMovement;
+            ClientMovement handlerClientMovement = OnClientMovement;
             if (handlerClientMovement != null)
-                handlerClientMovement(avatar);
+            {
+                foreach (ClientMovement d in handlerClientMovement.GetInvocationList())
+                {
+                    try
+                    {
+                        d(avatar);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnClientMovement failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerPermissionError(UUID user, string reason)
         {
-            handlerPermissionError = OnPermissionError;
+            OnPermissionErrorDelegate handlerPermissionError = OnPermissionError;
             if (handlerPermissionError != null)
-                handlerPermissionError(user, reason);
+            {
+                foreach (OnPermissionErrorDelegate d in handlerPermissionError.GetInvocationList())
+                {
+                    try
+                    {
+                        d(user, reason);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerPermissionError failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnPluginConsole(string[] args)
         {
-            handlerPluginConsole = OnPluginConsole;
+            OnPluginConsoleDelegate handlerPluginConsole = OnPluginConsole;
             if (handlerPluginConsole != null)
-                handlerPluginConsole(args);
+            {
+                foreach (OnPluginConsoleDelegate d in handlerPluginConsole.GetInvocationList())
+                {
+                    try
+                    {
+                        d(args);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnPluginConsole failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnFrame()
         {
-            handlerFrame = OnFrame;
+            OnFrameDelegate handlerFrame = OnFrame;
             if (handlerFrame != null)
             {
-                handlerFrame();
-            }
+                foreach (OnFrameDelegate d in handlerFrame.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnFrame failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnNewClient(IClientAPI client)
-        {
-            handlerNewClient = OnNewClient;
+        {          
+            OnNewClientDelegate handlerNewClient = OnNewClient;
             if (handlerNewClient != null)
-                handlerNewClient(client);
+            {
+                foreach (OnNewClientDelegate d in handlerNewClient.GetInvocationList())
+                {
+                    try
+                    {
+                        d(client);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnNewClient failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
 
             if (client is IClientCore)
-            {
-                handlerClientConnect = OnClientConnect;
+            {              
+                OnClientConnectCoreDelegate handlerClientConnect = OnClientConnect;
                 if (handlerClientConnect != null)
-                    handlerClientConnect((IClientCore)client);
+                {
+                    foreach (OnClientConnectCoreDelegate d in handlerClientConnect.GetInvocationList())
+                    {
+                        try
+                        {
+                            d((IClientCore)client);
+                        }
+                        catch (Exception e)
+                        {
+                            m_log.ErrorFormat(
+                                "[EVENT MANAGER]: Delegate for TriggerOnNewClient (IClientCore) failed - continuing.  {0} {1}", 
+                                e.Message, e.StackTrace);
+                        }
+                    }
+                }                
             }
         }
 
         public void TriggerOnNewPresence(ScenePresence presence)
         {
-            handlerNewPresence = OnNewPresence;
+            OnNewPresenceDelegate handlerNewPresence = OnNewPresence;
             if (handlerNewPresence != null)
-                handlerNewPresence(presence);
+            {
+                foreach (OnNewPresenceDelegate d in handlerNewPresence.GetInvocationList())
+                {
+                    try
+                    {
+                        d(presence);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnNewPresence failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnRemovePresence(UUID agentId)
-        {
-            handlerRemovePresence = OnRemovePresence;
+        {          
+            OnRemovePresenceDelegate handlerRemovePresence = OnRemovePresence;
             if (handlerRemovePresence != null)
             {
-                handlerRemovePresence(agentId);
-            }
+                foreach (OnRemovePresenceDelegate d in handlerRemovePresence.GetInvocationList())
+                {
+                    try
+                    {
+                        d(agentId);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnRemovePresence failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnBackup(IRegionDataStore dstore)
-        {
-            handlerBackup = OnBackup;
-            if (handlerBackup != null)
+        {          
+            OnBackupDelegate handlerOnAttach = OnBackup;
+            if (handlerOnAttach != null)
             {
-                handlerBackup(dstore, false);
-            }
+                foreach (OnBackupDelegate d in handlerOnAttach.GetInvocationList())
+                {
+                    try
+                    {
+                        d(dstore, false);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnBackup failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerParcelPrimCountUpdate()
         {
-            handlerParcelPrimCountUpdate = OnParcelPrimCountUpdate;
+            OnParcelPrimCountUpdateDelegate handlerParcelPrimCountUpdate = OnParcelPrimCountUpdate;
             if (handlerParcelPrimCountUpdate != null)
             {
-                handlerParcelPrimCountUpdate();
-            }
-        }
-
-        public void TriggerMoneyTransfer(Object sender, MoneyTransferArgs e)
-        {
-            handlerMoneyTransfer = OnMoneyTransfer;
+                foreach (OnParcelPrimCountUpdateDelegate d in handlerParcelPrimCountUpdate.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerParcelPrimCountUpdate failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
+        }
+
+        public void TriggerMoneyTransfer(Object sender, MoneyTransferArgs args)
+        {
+            MoneyTransferEvent handlerMoneyTransfer = OnMoneyTransfer;
             if (handlerMoneyTransfer != null)
             {
-                handlerMoneyTransfer(sender, e);
-            }
+                foreach (MoneyTransferEvent d in handlerMoneyTransfer.GetInvocationList())
+                {
+                    try
+                    {
+                        d(sender, args);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerMoneyTransfer failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerTerrainTick()
         {
-            handlerTerrainTick = OnTerrainTick;
+            OnTerrainTickDelegate handlerTerrainTick = OnTerrainTick;
             if (handlerTerrainTick != null)
             {
-                handlerTerrainTick();
-            }
+                foreach (OnTerrainTickDelegate d in handlerTerrainTick.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerTerrainTick failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerParcelPrimCountAdd(SceneObjectGroup obj)
         {
-            handlerParcelPrimCountAdd = OnParcelPrimCountAdd;
+            OnParcelPrimCountAddDelegate handlerParcelPrimCountAdd = OnParcelPrimCountAdd;
             if (handlerParcelPrimCountAdd != null)
             {
-                handlerParcelPrimCountAdd(obj);
-            }
+                foreach (OnParcelPrimCountAddDelegate d in handlerParcelPrimCountAdd.GetInvocationList())
+                {
+                    try
+                    {
+                        d(obj);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerParcelPrimCountAdd failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerObjectBeingRemovedFromScene(SceneObjectGroup obj)
         {
-            handlerObjectBeingRemovedFromScene = OnObjectBeingRemovedFromScene;
+            ObjectBeingRemovedFromScene handlerObjectBeingRemovedFromScene = OnObjectBeingRemovedFromScene;
             if (handlerObjectBeingRemovedFromScene != null)
             {
-                handlerObjectBeingRemovedFromScene(obj);
-            }
+                foreach (ObjectBeingRemovedFromScene d in handlerObjectBeingRemovedFromScene.GetInvocationList())
+                {
+                    try
+                    {
+                        d(obj);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerObjectBeingRemovedFromScene failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerShutdown()
-        {
-            handlerShutdown = OnShutdown;
+        {          
+            OnShutdownDelegate handlerShutdown = OnShutdown;
             if (handlerShutdown != null)
-                handlerShutdown();
+            {
+                foreach (OnShutdownDelegate d in handlerShutdown.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerShutdown failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerObjectGrab(uint localID, uint originalID, Vector3 offsetPos, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs)
-        {
-            handlerObjectGrab = OnObjectGrab;
+        {        
+            ObjectGrabDelegate handlerObjectGrab = OnObjectGrab;
             if (handlerObjectGrab != null)
             {
-                handlerObjectGrab(localID, originalID, offsetPos, remoteClient, surfaceArgs);
-            }
-        }
+                foreach (ObjectGrabDelegate d in handlerObjectGrab.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, originalID, offsetPos, remoteClient, surfaceArgs);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerObjectGrab failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
+        }
+
+        public void TriggerObjectGrabbing(uint localID, uint originalID, Vector3 offsetPos, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs)
+        {          
+            ObjectGrabDelegate handlerObjectGrabbing = OnObjectGrabbing;
+            if (handlerObjectGrabbing != null)
+            {
+                foreach (ObjectGrabDelegate d in handlerObjectGrabbing.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, originalID, offsetPos, remoteClient, surfaceArgs);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerObjectGrabbing failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
+         }
 
         public void TriggerObjectDeGrab(uint localID, uint originalID, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs)
-        {
-            handlerObjectDeGrab = OnObjectDeGrab;
+        {         
+            ObjectDeGrabDelegate handlerObjectDeGrab = OnObjectDeGrab;
             if (handlerObjectDeGrab != null)
             {
-                handlerObjectDeGrab(localID, originalID, remoteClient, surfaceArgs);
-            }
+                foreach (ObjectDeGrabDelegate d in handlerObjectDeGrab.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, originalID, remoteClient, surfaceArgs);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerObjectDeGrab failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerScriptReset(uint localID, UUID itemID)
-        {
-            handlerScriptReset = OnScriptReset;
+        {          
+            ScriptResetDelegate handlerScriptReset = OnScriptReset;
             if (handlerScriptReset != null)
             {
-                handlerScriptReset(localID, itemID);
-            }
+                foreach (ScriptResetDelegate d in handlerScriptReset.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, itemID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerScriptReset failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerRezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine, int stateSource)
-        {
-            handlerRezScript = OnRezScript;
+        {           
+            NewRezScript handlerRezScript = OnRezScript;
             if (handlerRezScript != null)
             {
-                handlerRezScript(localID, itemID, script, startParam,
-                        postOnRez, engine, stateSource);
-            }
+                foreach (NewRezScript d in handlerRezScript.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, itemID, script, startParam, postOnRez, engine, stateSource);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerRezScript failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerStartScript(uint localID, UUID itemID)
         {
-            handlerStartScript = OnStartScript;
+            StartScript handlerStartScript = OnStartScript;
             if (handlerStartScript != null)
             {
-                handlerStartScript(localID, itemID);
-            }
+                foreach (StartScript d in handlerStartScript.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, itemID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerStartScript failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerStopScript(uint localID, UUID itemID)
         {
-            handlerStopScript = OnStopScript;
+            StopScript handlerStopScript = OnStopScript;
             if (handlerStopScript != null)
             {
-                handlerStopScript(localID, itemID);
-            }
+                foreach (StopScript d in handlerStopScript.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, itemID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerStopScript failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerRemoveScript(uint localID, UUID itemID)
-        {
-            handlerRemoveScript = OnRemoveScript;
+        {          
+            RemoveScript handlerRemoveScript = OnRemoveScript;
             if (handlerRemoveScript != null)
             {
-                handlerRemoveScript(localID, itemID);
-            }
+                foreach (RemoveScript d in handlerRemoveScript.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, itemID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerRemoveScript failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public bool TriggerGroupMove(UUID groupID, Vector3 delta)
         {
-            handlerSceneGroupMove = OnSceneGroupMove;
-
+            bool result = true;
+            
+            SceneGroupMoved handlerSceneGroupMove = OnSceneGroupMove;
             if (handlerSceneGroupMove != null)
             {
-                return handlerSceneGroupMove(groupID, delta);
+                foreach (SceneGroupMoved d in handlerSceneGroupMove.GetInvocationList())
+                {
+                    try
+                    {
+                        if (d(groupID, delta) == false)
+                            result = false;
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnAttach failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
             }
-            return true;
+            
+            return result;
         }
 
         public bool TriggerGroupSpinStart(UUID groupID)
         {
-            handlerSceneGroupSpinStarted = OnSceneGroupSpinStart;
-
+            bool result = true;
+            
+            SceneGroupSpinStarted handlerSceneGroupSpinStarted = OnSceneGroupSpinStart;
             if (handlerSceneGroupSpinStarted != null)
             {
-                return handlerSceneGroupSpinStarted(groupID);
+                foreach (SceneGroupSpinStarted d in handlerSceneGroupSpinStarted.GetInvocationList())
+                {
+                    try
+                    {
+                        if (d(groupID) == false)
+                            result = false;
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerGroupSpinStart failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
             }
-            return true;
+            
+            return result;
         }
 
         public bool TriggerGroupSpin(UUID groupID, Quaternion rotation)
         {
-            handlerSceneGroupSpin = OnSceneGroupSpin;
-
+            bool result = true;
+            
+            SceneGroupSpun handlerSceneGroupSpin = OnSceneGroupSpin;
             if (handlerSceneGroupSpin != null)
             {
-                return handlerSceneGroupSpin(groupID, rotation);
+                foreach (SceneGroupSpun d in handlerSceneGroupSpin.GetInvocationList())
+                {
+                    try
+                    {
+                        if (d(groupID, rotation) == false)
+                            result = false;
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerGroupSpin failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
             }
-            return true;
+            
+            return result;
         }
 
         public void TriggerGroupGrab(UUID groupID, Vector3 offset, UUID userID)
         {
-            handlerSceneGroupGrab = OnSceneGroupGrab;
+            SceneGroupGrabed handlerSceneGroupGrab = OnSceneGroupGrab;
             if (handlerSceneGroupGrab != null)
             {
-                handlerSceneGroupGrab(groupID, offset, userID);
-            }
+                foreach (SceneGroupGrabed d in handlerSceneGroupGrab.GetInvocationList())
+                {
+                    try
+                    {
+                        d(groupID, offset, userID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerGroupGrab failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerLandObjectAdded(ILandObject newParcel)
         {
-            handlerLandObjectAdded = OnLandObjectAdded;
-
+            LandObjectAdded handlerLandObjectAdded = OnLandObjectAdded;
             if (handlerLandObjectAdded != null)
             {
-                handlerLandObjectAdded(newParcel);
-            }
+                foreach (LandObjectAdded d in handlerLandObjectAdded.GetInvocationList())
+                {
+                    try
+                    {
+                        d(newParcel);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerLandObjectAdded failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerLandObjectRemoved(UUID globalID)
         {
-            handlerLandObjectRemoved = OnLandObjectRemoved;
+            LandObjectRemoved handlerLandObjectRemoved = OnLandObjectRemoved;
             if (handlerLandObjectRemoved != null)
             {
-                handlerLandObjectRemoved(globalID);
-            }
+                foreach (LandObjectRemoved d in handlerLandObjectRemoved.GetInvocationList())
+                {
+                    try
+                    {
+                        d(globalID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerLandObjectRemoved failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerLandObjectUpdated(uint localParcelID, ILandObject newParcel)
         {
-            //triggerLandObjectRemoved(localParcelID);
-
             TriggerLandObjectAdded(newParcel);
         }
 
         public void TriggerAvatarEnteringNewParcel(ScenePresence avatar, int localLandID, UUID regionID)
         {
-            handlerAvatarEnteringNewParcel = OnAvatarEnteringNewParcel;
-
+            AvatarEnteringNewParcel handlerAvatarEnteringNewParcel = OnAvatarEnteringNewParcel;
             if (handlerAvatarEnteringNewParcel != null)
             {
-                handlerAvatarEnteringNewParcel(avatar, localLandID, regionID);
-            }
+                foreach (AvatarEnteringNewParcel d in handlerAvatarEnteringNewParcel.GetInvocationList())
+                {
+                    try
+                    {
+                        d(avatar, localLandID, regionID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerAvatarEnteringNewParcel failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerIncomingInstantMessage(GridInstantMessage message)
         {
-            handlerIncomingInstantMessage = OnIncomingInstantMessage;
+            IncomingInstantMessage handlerIncomingInstantMessage = OnIncomingInstantMessage;
             if (handlerIncomingInstantMessage != null)
             {
-                handlerIncomingInstantMessage(message);
-            }
+                foreach (IncomingInstantMessage d in handlerIncomingInstantMessage.GetInvocationList())
+                {
+                    try
+                    {
+                        d(message);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerIncomingInstantMessage failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerUnhandledInstantMessage(GridInstantMessage message)
         {
-            handlerUnhandledInstantMessage = OnUnhandledInstantMessage;
+            IncomingInstantMessage handlerUnhandledInstantMessage = OnUnhandledInstantMessage;
             if (handlerUnhandledInstantMessage != null)
             {
-                handlerUnhandledInstantMessage(message);
-            }
+                foreach (IncomingInstantMessage d in handlerUnhandledInstantMessage.GetInvocationList())
+                {
+                    try
+                    {
+                        d(message);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnAttach failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerClientClosed(UUID ClientID, Scene scene)
         {
-            handlerClientClosed = OnClientClosed;
+            ClientClosed handlerClientClosed = OnClientClosed;
             if (handlerClientClosed != null)
             {
-                handlerClientClosed(ClientID, scene);
-            }
+                foreach (ClientClosed d in handlerClientClosed.GetInvocationList())
+                {
+                    try
+                    {
+                        d(ClientID, scene);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerClientClosed failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnMakeChildAgent(ScenePresence presence)
         {
-            handlerMakeChildAgent = OnMakeChildAgent;
+            OnMakeChildAgentDelegate handlerMakeChildAgent = OnMakeChildAgent;
             if (handlerMakeChildAgent != null)
             {
-                handlerMakeChildAgent(presence);
-            }
+                foreach (OnMakeChildAgentDelegate d in handlerMakeChildAgent.GetInvocationList())
+                {
+                    try
+                    {
+                        d(presence);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnMakeChildAgent failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnMakeRootAgent(ScenePresence presence)
         {
-            handlerMakeRootAgent = OnMakeRootAgent;
+            OnMakeRootAgentDelegate handlerMakeRootAgent = OnMakeRootAgent;
             if (handlerMakeRootAgent != null)
             {
-                handlerMakeRootAgent(presence);
-            }
+                foreach (OnMakeRootAgentDelegate d in handlerMakeRootAgent.GetInvocationList())
+                {
+                    try
+                    {
+                        d(presence);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnMakeRootAgent failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnRegisterCaps(UUID agentID, Caps caps)
-        {
-            handlerRegisterCaps = OnRegisterCaps;
+        {          
+            RegisterCapsEvent handlerRegisterCaps = OnRegisterCaps;
             if (handlerRegisterCaps != null)
             {
-                handlerRegisterCaps(agentID, caps);
-            }
+                foreach (RegisterCapsEvent d in handlerRegisterCaps.GetInvocationList())
+                {
+                    try
+                    {
+                        d(agentID, caps);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnRegisterCaps failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnDeregisterCaps(UUID agentID, Caps caps)
         {
-            handlerDeregisterCaps = OnDeregisterCaps;
+            DeregisterCapsEvent handlerDeregisterCaps = OnDeregisterCaps;
             if (handlerDeregisterCaps != null)
             {
-                handlerDeregisterCaps(agentID, caps);
-            }
+                foreach (DeregisterCapsEvent d in handlerDeregisterCaps.GetInvocationList())
+                {
+                    try
+                    {
+                        d(agentID, caps);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnDeregisterCaps failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnNewInventoryItemUploadComplete(UUID agentID, UUID AssetID, String AssetName, int userlevel)
         {
-            handlerNewInventoryItemUpdateComplete = OnNewInventoryItemUploadComplete;
+            NewInventoryItemUploadComplete handlerNewInventoryItemUpdateComplete = OnNewInventoryItemUploadComplete;
             if (handlerNewInventoryItemUpdateComplete != null)
             {
-                handlerNewInventoryItemUpdateComplete(agentID, AssetID, AssetName, userlevel);
-            }
-        }
-
-        public void TriggerLandBuy(Object sender, LandBuyArgs e)
-        {
-            handlerLandBuy = OnLandBuy;
+                foreach (NewInventoryItemUploadComplete d in handlerNewInventoryItemUpdateComplete.GetInvocationList())
+                {
+                    try
+                    {
+                        d(agentID, AssetID, AssetName, userlevel);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnNewInventoryItemUploadComplete failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
+        }
+
+        public void TriggerLandBuy(Object sender, LandBuyArgs args)
+        {
+            LandBuy handlerLandBuy = OnLandBuy;
             if (handlerLandBuy != null)
             {
-                handlerLandBuy(sender, e);
-            }
-        }
-
-        public void TriggerValidateLandBuy(Object sender, LandBuyArgs e)
-        {
-            handlerValidateLandBuy = OnValidateLandBuy;
+                foreach (LandBuy d in handlerLandBuy.GetInvocationList())
+                {
+                    try
+                    {
+                        d(sender, args);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerLandBuy failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
+        }
+
+        public void TriggerValidateLandBuy(Object sender, LandBuyArgs args)
+        {
+            LandBuy handlerValidateLandBuy = OnValidateLandBuy;
             if (handlerValidateLandBuy != null)
             {
-                handlerValidateLandBuy(sender, e);
-            }
+                foreach (LandBuy d in handlerValidateLandBuy.GetInvocationList())
+                {
+                    try
+                    {
+                        d(sender, args);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerValidateLandBuy failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerAtTargetEvent(uint localID, uint handle, Vector3 targetpos, Vector3 currentpos)
-        {
-            handlerScriptAtTargetEvent = OnScriptAtTargetEvent;
+        {           
+            ScriptAtTargetEvent handlerScriptAtTargetEvent = OnScriptAtTargetEvent;
             if (handlerScriptAtTargetEvent != null)
             {
-                handlerScriptAtTargetEvent(localID, handle, targetpos, currentpos);
-            }
+                foreach (ScriptAtTargetEvent d in handlerScriptAtTargetEvent.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, handle, targetpos, currentpos);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerAtTargetEvent failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerNotAtTargetEvent(uint localID)
         {
-            handlerScriptNotAtTargetEvent = OnScriptNotAtTargetEvent;
+            ScriptNotAtTargetEvent handlerScriptNotAtTargetEvent = OnScriptNotAtTargetEvent;
             if (handlerScriptNotAtTargetEvent != null)
             {
-                handlerScriptNotAtTargetEvent(localID);
-            }
+                foreach (ScriptNotAtTargetEvent d in handlerScriptNotAtTargetEvent.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerNotAtTargetEvent failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerAtRotTargetEvent(uint localID, uint handle, Quaternion targetrot, Quaternion currentrot)
-        {
-            handlerScriptAtRotTargetEvent = OnScriptAtRotTargetEvent;
+        {            
+            ScriptAtRotTargetEvent handlerScriptAtRotTargetEvent = OnScriptAtRotTargetEvent;
             if (handlerScriptAtRotTargetEvent != null)
             {
-                handlerScriptAtRotTargetEvent(localID, handle, targetrot, currentrot);
-            }
+                foreach (ScriptAtRotTargetEvent d in handlerScriptAtRotTargetEvent.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID, handle, targetrot, currentrot);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerAtRotTargetEvent failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerNotAtRotTargetEvent(uint localID)
         {
-            handlerScriptNotAtRotTargetEvent = OnScriptNotAtRotTargetEvent;
+            ScriptNotAtRotTargetEvent handlerScriptNotAtRotTargetEvent = OnScriptNotAtRotTargetEvent;
             if (handlerScriptNotAtRotTargetEvent != null)
             {
-                handlerScriptNotAtRotTargetEvent(localID);
-            }
+                foreach (ScriptNotAtRotTargetEvent d in handlerScriptNotAtRotTargetEvent.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerNotAtRotTargetEvent failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerRequestChangeWaterHeight(float height)
         {
-            handlerRequestChangeWaterHeight = OnRequestChangeWaterHeight;
+            RequestChangeWaterHeight handlerRequestChangeWaterHeight = OnRequestChangeWaterHeight;
             if (handlerRequestChangeWaterHeight != null)
             {
-                handlerRequestChangeWaterHeight(height);
-            }
+                foreach (RequestChangeWaterHeight d in handlerRequestChangeWaterHeight.GetInvocationList())
+                {
+                    try
+                    {
+                        d(height);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerRequestChangeWaterHeight failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerAvatarKill(uint KillerObjectLocalID, ScenePresence DeadAvatar)
         {
-            handlerAvatarKill = OnAvatarKilled;
+            AvatarKillData handlerAvatarKill = OnAvatarKilled;
             if (handlerAvatarKill != null)
             {
-                handlerAvatarKill(KillerObjectLocalID, DeadAvatar);
-            }
+                foreach (AvatarKillData d in handlerAvatarKill.GetInvocationList())
+                {
+                    try
+                    {
+                        d(KillerObjectLocalID, DeadAvatar);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerAvatarKill failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerSignificantClientMovement(IClientAPI client)
         {
-            handlerSignificantClientMovement = OnSignificantClientMovement;
+            SignificantClientMovement handlerSignificantClientMovement = OnSignificantClientMovement;
             if (handlerSignificantClientMovement != null)
             {
-                handlerSignificantClientMovement(client);
-            }
+                foreach (SignificantClientMovement d in handlerSignificantClientMovement.GetInvocationList())
+                {
+                    try
+                    {
+                        d(client);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerSignificantClientMovement failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnChatFromWorld(Object sender, OSChatMessage chat)
         {
-            handlerChatFromWorld = OnChatFromWorld;
+            ChatFromWorldEvent handlerChatFromWorld = OnChatFromWorld;
             if (handlerChatFromWorld != null)
             {
-                handlerChatFromWorld(sender, chat);
-            }
+                foreach (ChatFromWorldEvent d in handlerChatFromWorld.GetInvocationList())
+                {
+                    try
+                    {
+                        d(sender, chat);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnChatFromWorld failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnChatFromClient(Object sender, OSChatMessage chat)
         {
-            handlerChatFromClient = OnChatFromClient;
+            ChatFromClientEvent handlerChatFromClient = OnChatFromClient;
             if (handlerChatFromClient != null)
             {
-                handlerChatFromClient(sender, chat);
-            }
+                foreach (ChatFromClientEvent d in handlerChatFromClient.GetInvocationList())
+                {
+                    try
+                    {
+                        d(sender, chat);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnChatFromClient failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnChatBroadcast(Object sender, OSChatMessage chat)
         {
-            handlerChatBroadcast = OnChatBroadcast;
+            ChatBroadcastEvent handlerChatBroadcast = OnChatBroadcast;
             if (handlerChatBroadcast != null)
             {
-                handlerChatBroadcast(sender, chat);
-            }
+                foreach (ChatBroadcastEvent d in handlerChatBroadcast.GetInvocationList())
+                {
+                    try
+                    {
+                        d(sender, chat);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnChatBroadcast failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         internal void TriggerControlEvent(uint p, UUID scriptUUID, UUID avatarID, uint held, uint _changed)
         {
-            handlerScriptControlEvent = OnScriptControlEvent;
+            ScriptControlEvent handlerScriptControlEvent = OnScriptControlEvent;
             if (handlerScriptControlEvent != null)
             {
-                handlerScriptControlEvent(p, scriptUUID,  avatarID, held, _changed);
-            }
+                foreach (ScriptControlEvent d in handlerScriptControlEvent.GetInvocationList())
+                {
+                    try
+                    {
+                        d(p, scriptUUID,  avatarID, held, _changed);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerControlEvent failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerNoticeNoLandDataFromStorage()
         {
-            handlerNoticeNoLandDataFromStorage = OnNoticeNoLandDataFromStorage;
+            NoticeNoLandDataFromStorage handlerNoticeNoLandDataFromStorage = OnNoticeNoLandDataFromStorage;
             if (handlerNoticeNoLandDataFromStorage != null)
             {
-                handlerNoticeNoLandDataFromStorage();
-
-            }
+                foreach (NoticeNoLandDataFromStorage d in handlerNoticeNoLandDataFromStorage.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerNoticeNoLandDataFromStorage failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerIncomingLandDataFromStorage(List<LandData> landData)
         {
-            handlerIncomingLandDataFromStorage = OnIncomingLandDataFromStorage;
+            IncomingLandDataFromStorage handlerIncomingLandDataFromStorage = OnIncomingLandDataFromStorage;
             if (handlerIncomingLandDataFromStorage != null)
             {
-                handlerIncomingLandDataFromStorage(landData);
-
-            }
+                foreach (IncomingLandDataFromStorage d in handlerIncomingLandDataFromStorage.GetInvocationList())
+                {
+                    try
+                    {
+                        d(landData);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerIncomingLandDataFromStorage failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerSetAllowForcefulBan(bool allow)
         {
-            handlerSetAllowForcefulBan = OnSetAllowForcefulBan;
+            SetAllowForcefulBan handlerSetAllowForcefulBan = OnSetAllowForcefulBan;
             if (handlerSetAllowForcefulBan != null)
             {
-                handlerSetAllowForcefulBan(allow);
-
-            }
+                foreach (SetAllowForcefulBan d in handlerSetAllowForcefulBan.GetInvocationList())
+                {
+                    try
+                    {
+                        d(allow);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerSetAllowForcefulBan failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerRequestParcelPrimCountUpdate()
         {
-            handlerRequestParcelPrimCountUpdate = OnRequestParcelPrimCountUpdate;
+            RequestParcelPrimCountUpdate handlerRequestParcelPrimCountUpdate = OnRequestParcelPrimCountUpdate;
             if (handlerRequestParcelPrimCountUpdate != null)
             {
-                handlerRequestParcelPrimCountUpdate();
-            }
+                foreach (RequestParcelPrimCountUpdate d in handlerRequestParcelPrimCountUpdate.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerRequestParcelPrimCountUpdate failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerParcelPrimCountTainted()
         {
-            handlerParcelPrimCountTainted = OnParcelPrimCountTainted;
+            ParcelPrimCountTainted handlerParcelPrimCountTainted = OnParcelPrimCountTainted;
             if (handlerParcelPrimCountTainted != null)
             {
-                handlerParcelPrimCountTainted();
-            }
+                foreach (ParcelPrimCountTainted d in handlerParcelPrimCountTainted.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerParcelPrimCountTainted failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         // this lets us keep track of nasty script events like timer, etc.
@@ -1010,99 +1667,277 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="FixedSunHour">The hour 0.0 <= FixedSunHour <= 24.0 at which the sun is fixed at. Sun Hour 0 is sun-rise, when Day/Night ratio is 1:1</param>
         public void TriggerEstateToolsSunUpdate(ulong regionHandle, bool FixedTime, bool useEstateTime, float FixedSunHour)
         {
-            handlerEstateToolsSunUpdate = OnEstateToolsSunUpdate;
+            EstateToolsSunUpdate handlerEstateToolsSunUpdate = OnEstateToolsSunUpdate;
             if (handlerEstateToolsSunUpdate != null)
             {
-                handlerEstateToolsSunUpdate(regionHandle, FixedTime, useEstateTime, FixedSunHour);
-            }
+                foreach (EstateToolsSunUpdate d in handlerEstateToolsSunUpdate.GetInvocationList())
+                {
+                    try
+                    {
+                        d(regionHandle, FixedTime, useEstateTime, FixedSunHour);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerEstateToolsSunUpdate failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public float GetCurrentTimeAsSunLindenHour()
         {
-            handlerCurrentTimeAsLindenSunHour = OnGetCurrentTimeAsLindenSunHour;
+            SunLindenHour handlerCurrentTimeAsLindenSunHour = OnGetCurrentTimeAsLindenSunHour;
             if (handlerCurrentTimeAsLindenSunHour != null)
             {
-                return handlerCurrentTimeAsLindenSunHour();
+                foreach (SunLindenHour d in handlerCurrentTimeAsLindenSunHour.GetInvocationList())
+                {
+                    try
+                    {
+                        return d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnAttach failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
             }
+            
             return 6;
         }
 
         public void TriggerOarFileLoaded(Guid requestId, string message)
-        {
-            handlerOarFileLoaded = OnOarFileLoaded;
+        {           
+            OarFileLoaded handlerOarFileLoaded = OnOarFileLoaded;
             if (handlerOarFileLoaded != null)
-                handlerOarFileLoaded(requestId, message);
+            {
+                foreach (OarFileLoaded d in handlerOarFileLoaded.GetInvocationList())
+                {
+                    try
+                    {
+                        d(requestId, message);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOarFileLoaded failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
         
         public void TriggerOarFileSaved(Guid requestId, string message)
         {
-            handlerOarFileSaved = OnOarFileSaved;
+            OarFileSaved handlerOarFileSaved = OnOarFileSaved;
             if (handlerOarFileSaved != null)
-                handlerOarFileSaved(requestId, message);
+            {
+                foreach (OarFileSaved d in handlerOarFileSaved.GetInvocationList())
+                {
+                    try
+                    {
+                        d(requestId, message);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOarFileSaved failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerEmptyScriptCompileQueue(int numScriptsFailed, string message)
         {
-            handlerEmptyScriptCompileQueue = OnEmptyScriptCompileQueue;
+            EmptyScriptCompileQueue handlerEmptyScriptCompileQueue = OnEmptyScriptCompileQueue;
             if (handlerEmptyScriptCompileQueue != null)
-                handlerEmptyScriptCompileQueue(numScriptsFailed, message);
+            {
+                foreach (EmptyScriptCompileQueue d in handlerEmptyScriptCompileQueue.GetInvocationList())
+                {
+                    try
+                    {
+                        d(numScriptsFailed, message);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerEmptyScriptCompileQueue failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerScriptCollidingStart(uint localId, ColliderArgs colliders)
         {
-            handlerCollidingStart = OnScriptColliderStart;
+            ScriptColliding handlerCollidingStart = OnScriptColliderStart;
             if (handlerCollidingStart != null)
-                handlerCollidingStart(localId, colliders);
+            {
+                foreach (ScriptColliding d in handlerCollidingStart.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localId, colliders);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerScriptCollidingStart failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerScriptColliding(uint localId, ColliderArgs colliders)
         {
-            handlerColliding = OnScriptColliding;
+            ScriptColliding handlerColliding = OnScriptColliding;
             if (handlerColliding != null)
-                handlerColliding(localId, colliders);
+            {
+                foreach (ScriptColliding d in handlerColliding.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localId, colliders);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerScriptColliding failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerScriptCollidingEnd(uint localId, ColliderArgs colliders)
         {
-            handlerCollidingEnd = OnScriptCollidingEnd;
+            ScriptColliding handlerCollidingEnd = OnScriptCollidingEnd;
             if (handlerCollidingEnd != null)
-                handlerCollidingEnd(localId, colliders);
+            {
+                foreach (ScriptColliding d in handlerCollidingEnd.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localId, colliders);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerScriptCollidingEnd failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerScriptLandCollidingStart(uint localId, ColliderArgs colliders)
         {
-            handlerLandCollidingStart = OnScriptLandColliderStart;
+            ScriptColliding handlerLandCollidingStart = OnScriptLandColliderStart;
             if (handlerLandCollidingStart != null)
-                handlerLandCollidingStart(localId, colliders);
+            {
+                foreach (ScriptColliding d in handlerLandCollidingStart.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localId, colliders);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerScriptLandCollidingStart failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerScriptLandColliding(uint localId, ColliderArgs colliders)
         {
-            handlerLandColliding = OnScriptLandColliding;
+            ScriptColliding handlerLandColliding = OnScriptLandColliding;
             if (handlerLandColliding != null)
-                handlerLandColliding(localId, colliders);
+            {
+                foreach (ScriptColliding d in handlerLandColliding.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localId, colliders);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerScriptLandColliding failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerScriptLandCollidingEnd(uint localId, ColliderArgs colliders)
         {
-            handlerLandCollidingEnd = OnScriptLandColliderEnd;
+            ScriptColliding handlerLandCollidingEnd = OnScriptLandColliderEnd;
             if (handlerLandCollidingEnd != null)
-                handlerLandCollidingEnd(localId, colliders);
+            {
+                foreach (ScriptColliding d in handlerLandCollidingEnd.GetInvocationList())
+                {
+                    try
+                    {
+                        d(localId, colliders);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerScriptLandCollidingEnd failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerSetRootAgentScene(UUID agentID, Scene scene)
-        {
-            handlerSetRootAgentScene = OnSetRootAgentScene;
+        {            
+            OnSetRootAgentSceneDelegate handlerSetRootAgentScene = OnSetRootAgentScene;
             if (handlerSetRootAgentScene != null)
-                handlerSetRootAgentScene(agentID, scene);
+            {
+                foreach (OnSetRootAgentSceneDelegate d in handlerSetRootAgentScene.GetInvocationList())
+                {
+                    try
+                    {
+                        d(agentID, scene);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerSetRootAgentScene failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
 
         public void TriggerOnRegionUp(GridRegion otherRegion)
         {
-            handlerOnRegionUp = OnRegionUp;
+            RegionUp handlerOnRegionUp = OnRegionUp;
             if (handlerOnRegionUp != null)
-                handlerOnRegionUp(otherRegion);
+            {
+                foreach (RegionUp d in handlerOnRegionUp.GetInvocationList())
+                {
+                    try
+                    {
+                        d(otherRegion);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnRegionUp failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }            
         }
-
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 45806dd..e032a07 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -197,7 +197,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (isScriptRunning)
             {
-                part.Inventory.RemoveScriptInstance(item.ItemID);
+                part.Inventory.RemoveScriptInstance(item.ItemID, false);
             }
 
             // Update item with new asset
@@ -794,8 +794,10 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (item.Type == 10)
                 {
+                    part.RemoveScriptEvents(itemID);
                     EventManager.TriggerRemoveScript(localID, itemID);
                 }
+                
                 group.RemoveInventoryItem(localID, itemID);
                 part.GetProperties(remoteClient);
             }
@@ -1879,9 +1881,19 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void AttachObject(IClientAPI controllingClient, uint localID, uint attachPoint, Quaternion rot, Vector3 pos, bool silent)
+        /// <summary>
+        /// Attach an object.
+        /// </summary>
+        /// <param name="controllingClient"></param>
+        /// <param name="localID"></param>
+        /// <param name="attachPoint"></param>
+        /// <param name="rot"></param>
+        /// <param name="pos"></param>
+        /// <param name="silent"></param>
+        /// <returns>true if the object was successfully attached, false otherwise</returns>
+        public bool AttachObject(IClientAPI controllingClient, uint localID, uint attachPoint, Quaternion rot, Vector3 pos, bool silent)
         {
-            m_sceneGraph.AttachObject(controllingClient, localID, attachPoint, rot, pos, silent);
+            return m_sceneGraph.AttachObject(controllingClient, localID, attachPoint, rot, pos, silent);
         }
 
         public void AttachObject(IClientAPI remoteClient, uint AttachmentPt, UUID itemID, SceneObjectGroup att)
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index 342b3c5..bc10230 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -292,6 +292,46 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public virtual void ProcessObjectGrabUpdate(UUID objectID, Vector3 offset, Vector3 pos, IClientAPI remoteClient, List<SurfaceTouchEventArgs> surfaceArgs)
+        {
+            List<EntityBase> EntityList = GetEntities();
+
+            SurfaceTouchEventArgs surfaceArg = null;
+            if (surfaceArgs != null && surfaceArgs.Count > 0)
+                surfaceArg = surfaceArgs[0];
+
+            foreach (EntityBase ent in EntityList)
+            {
+                if (ent is SceneObjectGroup)
+                {
+                    SceneObjectGroup obj = ent as SceneObjectGroup;
+                    if (obj != null)
+                    {
+                        // Is this prim part of the group
+                        if (obj.HasChildPrim(objectID))
+                        {
+                            SceneObjectPart part = obj.GetChildPart(objectID);
+
+                            // If the touched prim handles touches, deliver it
+                            // If not, deliver to root prim
+                            if ((part.ScriptEvents & scriptEvents.touch) != 0)
+                                EventManager.TriggerObjectGrabbing(part.LocalId, 0, part.OffsetPosition, remoteClient, surfaceArg);
+                            // Deliver to the root prim if the touched prim doesn't handle touches
+                            // or if we're meant to pass on touches anyway. Don't send to root prim
+                            // if prim touched is the root prim as we just did it
+                            if (((part.ScriptEvents & scriptEvents.touch) == 0) ||
+                                (part.PassTouches && (part.LocalId != obj.RootPart.LocalId)))
+                            {
+                                EventManager.TriggerObjectGrabbing(obj.RootPart.LocalId, part.LocalId, part.OffsetPosition, remoteClient, surfaceArg);
+                            }
+
+                            return;
+                        }
+                    }
+                }
+            }
+         }
+
         public virtual void ProcessObjectDeGrab(uint localID, IClientAPI remoteClient, List<SurfaceTouchEventArgs> surfaceArgs)
         {
             List<EntityBase> EntityList = GetEntities();
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index f800d5f..f109589 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -1102,7 +1102,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if (ent is SceneObjectGroup)
                         {
-                            ((SceneObjectGroup) ent).RemoveScriptInstances();
+                            ((SceneObjectGroup) ent).RemoveScriptInstances(false);
                         }
                     }
                 }
@@ -1977,13 +1977,15 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="silent">Suppress broadcasting changes to other clients.</param>
         public void DeleteSceneObject(SceneObjectGroup group, bool silent)
         {
+//            m_log.DebugFormat("[SCENE]: Deleting scene object {0} {1}", group.Name, group.UUID);
+            
             //SceneObjectPart rootPart = group.GetChildPart(group.UUID);
 
             // Serialise calls to RemoveScriptInstances to avoid
             // deadlocking on m_parts inside SceneObjectGroup
             lock (m_deleting_scene_object)
             {
-                group.RemoveScriptInstances();
+                group.RemoveScriptInstances(true);
             }
 
             foreach (SceneObjectPart part in group.Children.Values)
@@ -2011,6 +2013,8 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             group.DeleteGroup(silent);
+
+//            m_log.DebugFormat("[SCENE]: Exit DeleteSceneObject() for {0} {1}", group.Name, group.UUID);
         }
 
         /// <summary>
@@ -2539,6 +2543,7 @@ namespace OpenSim.Region.Framework.Scenes
             client.OnRequestObjectPropertiesFamily += m_sceneGraph.RequestObjectPropertiesFamily;
             client.OnObjectPermissions += HandleObjectPermissionsUpdate;
             client.OnGrabObject += ProcessObjectGrab;
+            client.OnGrabUpdate += ProcessObjectGrabUpdate; 
             client.OnDeGrabObject += ProcessObjectDeGrab;
             client.OnUndo += m_sceneGraph.HandleUndo;
             client.OnObjectDescription += m_sceneGraph.PrimDescription;
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index fbd11c6..7bd4329 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -479,25 +479,35 @@ namespace OpenSim.Region.Framework.Scenes
             if (part == null)
                 return;
 
-            if (!m_parentScene.Permissions.CanTakeObject(
-                    part.UUID, remoteClient.AgentId))
+            if (!m_parentScene.Permissions.CanTakeObject(part.UUID, remoteClient.AgentId))
                 return;
 
             // Calls attach with a Zero position
-            AttachObject(remoteClient, objectLocalID, AttachmentPt, rot, Vector3.Zero, false);
-            m_parentScene.SendAttachEvent(objectLocalID, part.ParentGroup.GetFromItemID(), remoteClient.AgentId);
-
-            // Save avatar attachment information
-            ScenePresence presence;
-            if (m_parentScene.AvatarFactory != null && m_parentScene.TryGetAvatar(remoteClient.AgentId, out presence))
+            if (AttachObject(remoteClient, objectLocalID, AttachmentPt, rot, Vector3.Zero, false))
             {
-                m_log.Info("[SCENE]: Saving avatar attachment. AgentID: " + remoteClient.AgentId + ", AttachmentPoint: " + AttachmentPt);
-                m_parentScene.AvatarFactory.UpdateDatabase(remoteClient.AgentId, presence.Appearance);
+                m_parentScene.SendAttachEvent(objectLocalID, part.ParentGroup.GetFromItemID(), remoteClient.AgentId);
+    
+                // Save avatar attachment information
+                ScenePresence presence;
+                if (m_parentScene.AvatarFactory != null && m_parentScene.TryGetAvatar(remoteClient.AgentId, out presence))
+                {
+                    m_log.Info(
+                        "[SCENE]: Saving avatar attachment. AgentID: " + remoteClient.AgentId 
+                            + ", AttachmentPoint: " + AttachmentPt);
+                    
+                    m_parentScene.AvatarFactory.UpdateDatabase(remoteClient.AgentId, presence.Appearance);
+                }
             }
         }
 
-        public SceneObjectGroup RezSingleAttachment(
-            IClientAPI remoteClient, UUID itemID, uint AttachmentPt)
+        /// <summary>
+        /// Rez an attachment
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="itemID"></param>
+        /// <param name="AttachmentPt"></param>
+        /// <returns>The scene object that was attached.  Null if the scene object could not be found</returns>
+        public SceneObjectGroup RezSingleAttachment(IClientAPI remoteClient, UUID itemID, uint AttachmentPt)
         {
             IInventoryAccessModule invAccess = m_parentScene.RequestModuleInterface<IInventoryAccessModule>();
             if (invAccess != null)
@@ -560,7 +570,17 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        protected internal void AttachObject(
+        /// <summary>
+        /// Attach a scene object to an avatar.
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="objectLocalID"></param>
+        /// <param name="AttachmentPt"></param>
+        /// <param name="rot"></param>
+        /// <param name="attachPos"></param>
+        /// <param name="silent"></param>
+        /// <returns>true if the attachment was successful, false otherwise</returns>
+        protected internal bool AttachObject(
             IClientAPI remoteClient, uint objectLocalID, uint AttachmentPt, Quaternion rot, Vector3 attachPos, bool silent)
         {
             SceneObjectGroup group = GetGroupByPrim(objectLocalID);
@@ -589,10 +609,8 @@ namespace OpenSim.Region.Framework.Scenes
                         // Stick it on left hand with Zero Offset from the attachment point.
                         AttachmentPt = (uint)AttachmentPoint.LeftHand;
                         attachPos = Vector3.Zero;
-
                     }
 
-
                     group.SetAttachmentPoint((byte)AttachmentPt);
                     group.AbsolutePosition = attachPos;
 
@@ -615,15 +633,21 @@ namespace OpenSim.Region.Framework.Scenes
                     // it get cleaned up
                     //
                     group.RootPart.RemFlag(PrimFlags.TemporaryOnRez);
-                    group.HasGroupChanged = false;
+                    group.HasGroupChanged = false;                   
                 }
                 else
                 {
                     remoteClient.SendAgentAlertMessage("You don't have sufficient permissions to attach this object", false);
+                    return false;
                 }
             }
             else
+            {
                 m_log.DebugFormat("[SCENE GRAPH]: AttachObject found no such scene object {0}", objectLocalID);
+                return false;
+            }
+
+            return true;
         }
 
         protected internal ScenePresence CreateAndAddChildScenePresence(IClientAPI client, AvatarAppearance appearance)
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
index 5a06bdb..71354b4 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
@@ -74,13 +74,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Stop the scripts contained in all the prims in this group
         /// </summary>
-        public void RemoveScriptInstances()
+        /// <param name="sceneObjectBeingDeleted">
+        /// Should be true if these scripts are being removed because the scene
+        /// object is being deleted.  This will prevent spurious updates to the client.
+        /// </param>
+        public void RemoveScriptInstances(bool sceneObjectBeingDeleted)
         {
             lock (m_parts)
             {
                 foreach (SceneObjectPart part in m_parts.Values)
                 {
-                    part.Inventory.RemoveScriptInstances();
+                    part.Inventory.RemoveScriptInstances(sceneObjectBeingDeleted);
                 }
             }
         }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index ec41ac7..8c56870 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -235,6 +235,9 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_rootPart.GroupID = value; }
         }
 
+        /// <value>
+        /// The parts of this scene object group.  You must lock this property before using it.
+        /// </value>
         public Dictionary<UUID, SceneObjectPart> Children
         {
             get { return m_parts; }
@@ -2097,7 +2100,7 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Get a child part with a given UUID
+        /// Get a part with a given UUID
         /// </summary>
         /// <param name="primID"></param>
         /// <returns>null if a child part with the primID was not found</returns>
@@ -2112,7 +2115,7 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Get a child part with a given local ID
+        /// Get a part with a given local ID
         /// </summary>
         /// <param name="localID"></param>
         /// <returns>null if a child part with the local ID was not found</returns>
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 56b2f13..dd797fc 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -90,12 +90,38 @@ namespace OpenSim.Region.Framework.Scenes
         SCALE = 0x40
     }
 
+    public enum PrimType : int
+    {
+        BOX = 0,
+        CYLINDER = 1,
+        PRISM = 2,
+        SPHERE = 3,
+        TORUS = 4,
+        TUBE = 5,
+        RING = 6,
+        SCULPT = 7
+    }
+
     #endregion Enumerations
 
     public class SceneObjectPart : IScriptHost
     {
+        /// <value>
+        /// Denote all sides of the prim
+        /// </value>
+        public const int ALL_SIDES = -1;
+        
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        /// <value>
+        /// Is this sop a root part?
+        /// </value>
+        [XmlIgnore]
+        public bool IsRoot 
+        {
+           get { return ParentGroup.RootPart == this; } 
+        }
+
         // use only one serializer to give the runtime a chance to optimize it (it won't do that if you
         // use a new instance every time)
         private static XmlSerializer serializer = new XmlSerializer(typeof (SceneObjectPart));
@@ -737,6 +763,9 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <value>
+        /// Text color.
+        /// </value>
         public Color Color
         {
             get { return m_color; }
@@ -1901,7 +1930,7 @@ namespace OpenSim.Region.Framework.Scenes
                     foreach (uint localId in startedColliders)
                     {
                         if (localId == 0)
-                            return;
+                            continue;
                         // always running this check because if the user deletes the object it would return a null reference.
                         if (m_parentGroup == null)
                             return;
@@ -2037,7 +2066,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         // always running this check because if the user deletes the object it would return a null reference.
                         if (localId == 0)
-                            return;
+                            continue;
 
                         if (m_parentGroup == null)
                             return;
@@ -2169,7 +2198,7 @@ namespace OpenSim.Region.Framework.Scenes
                     foreach (uint localId in endedColliders)
                     {
                         if (localId == 0)
-                            return;
+                            continue;
 
                         // always running this check because if the user deletes the object it would return a null reference.
                         if (m_parentGroup == null)
@@ -2479,7 +2508,7 @@ namespace OpenSim.Region.Framework.Scenes
             //m_log.Debug("prev: " + prevflag.ToString() + " curr: " + Flags.ToString());
             //ScheduleFullUpdate();
         }
-
+        
         public void RemoveScriptEvents(UUID scriptid)
         {
             lock (m_scriptEvents)
@@ -2533,6 +2562,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void ScheduleFullUpdate()
         {
+//            m_log.DebugFormat("[SCENE OBJECT PART]: Scheduling full update for {0} {1}", Name, LocalId);
+            
             if (m_parentGroup != null)
             {
                 m_parentGroup.QueueForUpdateCheck();
@@ -2953,6 +2984,178 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Set the color of prim faces
+        /// </summary>
+        /// <param name="color"></param>
+        /// <param name="face"></param>
+        public void SetFaceColor(Vector3 color, int face)
+        {
+            Primitive.TextureEntry tex = Shape.Textures;
+            Color4 texcolor;
+            if (face >= 0 && face < GetNumberOfSides())
+            {
+                texcolor = tex.CreateFace((uint)face).RGBA;
+                texcolor.R = Util.Clip((float)color.X, 0.0f, 1.0f);
+                texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
+                texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                tex.FaceTextures[face].RGBA = texcolor;
+                UpdateTexture(tex);
+                return;
+            }
+            else if (face == ALL_SIDES)
+            {
+                for (uint i = 0; i < GetNumberOfSides(); i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        texcolor = tex.FaceTextures[i].RGBA;
+                        texcolor.R = Util.Clip((float)color.X, 0.0f, 1.0f);
+                        texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
+                        texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                        tex.FaceTextures[i].RGBA = texcolor;
+                    }
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.R = Util.Clip((float)color.X, 0.0f, 1.0f);
+                    texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
+                    texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                    tex.DefaultTexture.RGBA = texcolor;
+                }
+                UpdateTexture(tex);
+                return;
+            }
+        }
+
+        /// <summary>
+        /// Get the number of sides that this part has.
+        /// </summary>
+        /// <returns></returns>
+        public int GetNumberOfSides()
+        {
+            int ret = 0;
+            bool hasCut;
+            bool hasHollow;
+            bool hasDimple;
+            bool hasProfileCut;
+
+            PrimType primType = GetPrimType();
+            HasCutHollowDimpleProfileCut(primType, Shape, out hasCut, out hasHollow, out hasDimple, out hasProfileCut);
+
+            switch (primType)
+            {
+                case PrimType.BOX:
+                    ret = 6;
+                    if (hasCut) ret += 2;
+                    if (hasHollow) ret += 1;
+                    break;
+                case PrimType.CYLINDER:
+                    ret = 3;
+                    if (hasCut) ret += 2;
+                    if (hasHollow) ret += 1;
+                    break;
+                case PrimType.PRISM:
+                    ret = 5;
+                    if (hasCut) ret += 2;
+                    if (hasHollow) ret += 1;
+                    break;
+                case PrimType.SPHERE:
+                    ret = 1;
+                    if (hasCut) ret += 2;
+                    if (hasDimple) ret += 2;
+                    if (hasHollow) ret += 1;
+                    break;
+                case PrimType.TORUS:
+                    ret = 1;
+                    if (hasCut) ret += 2;
+                    if (hasProfileCut) ret += 2;
+                    if (hasHollow) ret += 1;
+                    break;
+                case PrimType.TUBE:
+                    ret = 4;
+                    if (hasCut) ret += 2;
+                    if (hasProfileCut) ret += 2;
+                    if (hasHollow) ret += 1;
+                    break;
+                case PrimType.RING:
+                    ret = 3;
+                    if (hasCut) ret += 2;
+                    if (hasProfileCut) ret += 2;
+                    if (hasHollow) ret += 1;
+                    break;
+                case PrimType.SCULPT:
+                    ret = 1;
+                    break;
+            }
+            return ret;
+        }
+
+        /// <summary>
+        /// Tell us what type this prim is
+        /// </summary>
+        /// <param name="primShape"></param>
+        /// <returns></returns>
+        public PrimType GetPrimType()
+        {
+            if (Shape.SculptEntry)
+                return PrimType.SCULPT;
+            if ((Shape.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
+            {
+                if (Shape.PathCurve == (byte)Extrusion.Straight)
+                    return PrimType.BOX;
+                else if (Shape.PathCurve == (byte)Extrusion.Curve1)
+                    return PrimType.TUBE;
+            }
+            else if ((Shape.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
+            {
+                if (Shape.PathCurve == (byte)Extrusion.Straight)
+                    return PrimType.CYLINDER;
+                // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
+                else if (Shape.PathCurve == (byte)Extrusion.Curve1)
+                    return PrimType.TORUS;
+            }
+            else if ((Shape.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
+            {
+                if (Shape.PathCurve == (byte)Extrusion.Curve1 || Shape.PathCurve == (byte)Extrusion.Curve2)
+                    return PrimType.SPHERE;
+            }
+            else if ((Shape.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
+            {
+                if (Shape.PathCurve == (byte)Extrusion.Straight)
+                    return PrimType.PRISM;
+                else if (Shape.PathCurve == (byte)Extrusion.Curve1)
+                    return PrimType.RING;
+            }
+            
+            return PrimType.BOX;
+        }
+        
+        /// <summary>
+        /// Tell us if this object has cut, hollow, dimple, and other factors affecting the number of faces 
+        /// </summary>
+        /// <param name="primType"></param>
+        /// <param name="shape"></param>
+        /// <param name="hasCut"></param>
+        /// <param name="hasHollow"></param>
+        /// <param name="hasDimple"></param>
+        /// <param name="hasProfileCut"></param>
+        protected static void HasCutHollowDimpleProfileCut(PrimType primType, PrimitiveBaseShape shape, out bool hasCut, out bool hasHollow,
+            out bool hasDimple, out bool hasProfileCut)
+        {
+            if (primType == PrimType.BOX
+                ||
+                primType == PrimType.CYLINDER
+                ||
+                primType == PrimType.PRISM)
+
+                hasCut = (shape.ProfileBegin > 0) || (shape.ProfileEnd > 0);
+            else
+                hasCut = (shape.PathBegin > 0) || (shape.PathEnd > 0);
+
+            hasHollow = shape.ProfileHollow > 0;
+            hasDimple = (shape.ProfileBegin > 0) || (shape.ProfileEnd > 0); // taken from llSetPrimitiveParms
+            hasProfileCut = hasDimple; // is it the same thing?
+        }
+        
         public void SetGroup(UUID groupID, IClientAPI client)
         {
             _groupID = groupID;
@@ -2984,6 +3187,11 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Set the events that this part will pass on to listeners.
+        /// </summary>
+        /// <param name="scriptid"></param>
+        /// <param name="events"></param>
         public void SetScriptEvents(UUID scriptid, int events)
         {
             // scriptEvents oldparts;
@@ -3936,9 +4144,13 @@ namespace OpenSim.Region.Framework.Scenes
             ScheduleFullUpdate();
         }
 
-        // Added to handle bug in libsecondlife's TextureEntry.ToBytes()
-        // not handling RGBA properly. Cycles through, and "fixes" the color
-        // info
+        /// <summary>
+        /// Update the textures on the part.
+        /// </summary>
+        /// Added to handle bug in libsecondlife's TextureEntry.ToBytes()
+        /// not handling RGBA properly. Cycles through, and "fixes" the color
+        /// info
+        /// <param name="tex"></param>
         public void UpdateTexture(Primitive.TextureEntry tex)
         {
             //Color4 tmpcolor;
@@ -4042,6 +4254,8 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (m_parentGroup == null)
             {
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT PART]: Scheduling part {0} {1} for full update in aggregateScriptEvents() since m_parentGroup == null", Name, LocalId);
                 ScheduleFullUpdate();
                 return;
             }
@@ -4058,9 +4272,15 @@ namespace OpenSim.Region.Framework.Scenes
             LocalFlags=(PrimFlags)objectflagupdate;
 
             if (m_parentGroup != null && m_parentGroup.RootPart == this)
+            {
                 m_parentGroup.aggregateScriptEvents();
+            }
             else
+            {
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT PART]: Scheduling part {0} {1} for full update in aggregateScriptEvents()", Name, LocalId);                
                 ScheduleFullUpdate();
+            }
         }
 
         public int registerTargetWaypoint(Vector3 target, float tolerance)
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index 168912e..d0de513 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -229,7 +229,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Stop all the scripts in this prim.
         /// </summary>
-        public void RemoveScriptInstances()
+        /// <param name="sceneObjectBeingDeleted">
+        /// Should be true if these scripts are being removed because the scene
+        /// object is being deleted.  This will prevent spurious updates to the client.
+        /// </param>
+        public void RemoveScriptInstances(bool sceneObjectBeingDeleted)
         {
             lock (Items)
             {
@@ -237,8 +241,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     if ((int)InventoryType.LSL == item.InvType)
                     {
-                        RemoveScriptInstance(item.ItemID);
-                        m_part.RemoveScriptEvents(item.ItemID);
+                        RemoveScriptInstance(item.ItemID, sceneObjectBeingDeleted);
                     }
                 }
             }
@@ -266,8 +269,12 @@ namespace OpenSim.Region.Framework.Scenes
                 if (stateSource == 1 && // Prim crossing
                         m_part.ParentGroup.Scene.m_trustBinaries)
                 {
-                    m_items[item.ItemID].PermsMask = 0;
-                    m_items[item.ItemID].PermsGranter = UUID.Zero;
+                    lock (m_items)
+                    {
+                        m_items[item.ItemID].PermsMask = 0;
+                        m_items[item.ItemID].PermsGranter = UUID.Zero;
+                    }
+                    
                     m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
                         m_part.LocalId, item.ItemID, String.Empty, startParam, postOnRez, engine, stateSource);
                     m_part.ParentGroup.AddActiveScriptCount(1);
@@ -275,33 +282,38 @@ namespace OpenSim.Region.Framework.Scenes
                     return;
                 }
 
-                m_part.ParentGroup.Scene.AssetService.Get(item.AssetID.ToString(), this, delegate(string id, object sender, AssetBase asset)
-                               {
-                                   if (null == asset)
-                                   {
-                                       m_log.ErrorFormat(
-                                           "[PRIM INVENTORY]: " +
-                                           "Couldn't start script {0}, {1} at {2} in {3} since asset ID {4} could not be found",
-                                           item.Name, item.ItemID, m_part.AbsolutePosition, 
-                                           m_part.ParentGroup.Scene.RegionInfo.RegionName, item.AssetID);
-                                   }
-                                   else
-                                   {
-                                       if (m_part.ParentGroup.m_savedScriptState != null)
-                                           RestoreSavedScriptState(item.OldItemID, item.ItemID);
-                                       m_items[item.ItemID].PermsMask = 0;
-                                       m_items[item.ItemID].PermsGranter = UUID.Zero;
-                                       string script = Utils.BytesToString(asset.Data);
-                                       m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
-                                            m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
-                                       m_part.ParentGroup.AddActiveScriptCount(1);
-                                       m_part.ScheduleFullUpdate();
-                                   }
-                               });
-            }
-        }
-
-        static System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
+                m_part.ParentGroup.Scene.AssetService.Get(
+                    item.AssetID.ToString(), this, delegate(string id, object sender, AssetBase asset)
+                    {
+                        if (null == asset)
+                        {
+                            m_log.ErrorFormat(
+                                "[PRIM INVENTORY]: " +
+                                "Couldn't start script {0}, {1} at {2} in {3} since asset ID {4} could not be found",
+                                item.Name, item.ItemID, m_part.AbsolutePosition, 
+                                m_part.ParentGroup.Scene.RegionInfo.RegionName, item.AssetID);
+                        }
+                        else
+                        {
+                            if (m_part.ParentGroup.m_savedScriptState != null)
+                                RestoreSavedScriptState(item.OldItemID, item.ItemID);
+
+                            lock (m_items)
+                            {
+                                m_items[item.ItemID].PermsMask = 0;
+                                m_items[item.ItemID].PermsGranter = UUID.Zero;
+                            }
+                        
+                            string script = Utils.BytesToString(asset.Data);
+                            m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
+                                m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
+                            m_part.ParentGroup.AddActiveScriptCount(1);
+                            m_part.ScheduleFullUpdate();
+                        }
+                    }
+                );
+            }
+        }        
 
         private void RestoreSavedScriptState(UUID oldID, UUID newID)
         {
@@ -387,10 +399,25 @@ namespace OpenSim.Region.Framework.Scenes
         /// Stop a script which is in this prim's inventory.
         /// </summary>
         /// <param name="itemId"></param>
-        public void RemoveScriptInstance(UUID itemId)
+        /// <param name="sceneObjectBeingDeleted">
+        /// Should be true if this script is being removed because the scene
+        /// object is being deleted.  This will prevent spurious updates to the client.
+        /// </param>
+        public void RemoveScriptInstance(UUID itemId, bool sceneObjectBeingDeleted)
         {
-            if (m_items.ContainsKey(itemId))
+            bool scriptPresent = false;
+
+            lock (m_items)
+            {
+                if (m_items.ContainsKey(itemId))
+                    scriptPresent = true;
+            }
+            
+            if (scriptPresent)
             {
+                if (!sceneObjectBeingDeleted)
+                    m_part.RemoveScriptEvents(itemId);
+                
                 m_part.ParentGroup.Scene.EventManager.TriggerRemoveScript(m_part.LocalId, itemId);
                 m_part.ParentGroup.AddActiveScriptCount(-1);
             }
@@ -458,13 +485,19 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="item"></param>
         public void AddInventoryItemExclusive(TaskInventoryItem item, bool allowedDrop)
         {
-            List<TaskInventoryItem> il = new List<TaskInventoryItem>(m_items.Values);
+            List<TaskInventoryItem> il;
+
+            lock (m_items)
+            {
+                il = new List<TaskInventoryItem>(m_items.Values);
+            }
+            
             foreach (TaskInventoryItem i in il)
             {
                 if (i.Name == item.Name)
                 {
                     if (i.InvType == (int)InventoryType.LSL)
-                        RemoveScriptInstance(i.ItemID);
+                        RemoveScriptInstance(i.ItemID, false);
 
                     RemoveInventoryItem(i.ItemID);
                     break;
@@ -540,11 +573,37 @@ namespace OpenSim.Region.Framework.Scenes
         public TaskInventoryItem GetInventoryItem(UUID itemId)
         {
             TaskInventoryItem item;
-            m_items.TryGetValue(itemId, out item);
+
+            lock (m_items)
+                m_items.TryGetValue(itemId, out item);
 
             return item;
-        }
+        }    
+
+        /// <summary>
+        /// Get inventory items by name.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns>
+        /// A list of inventory items with that name.
+        /// If no inventory item has that name then an empty list is returned.
+        /// </returns>        
+        public IList<TaskInventoryItem> GetInventoryItems(string name)
+        {
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>();
+
+            lock (m_items)
+            {
+                foreach (TaskInventoryItem item in m_items.Values)
+                {
+                    if (item.Name == name)
+                        items.Add(item);
+                }
+            }
 
+            return items;
+        }
+        
         /// <summary>
         /// Update an existing inventory item.
         /// </summary>
@@ -612,6 +671,7 @@ namespace OpenSim.Region.Framework.Scenes
                     int type = m_items[itemID].InvType;
                     if (type == 10) // Script
                     {
+                        m_part.RemoveScriptEvents(itemID);
                         m_part.ParentGroup.Scene.EventManager.TriggerRemoveScript(m_part.LocalId, itemID);
                     }
                     m_items.Remove(itemID);
@@ -841,54 +901,61 @@ namespace OpenSim.Region.Framework.Scenes
         {
             uint mask=0x7fffffff;
 
-            foreach (TaskInventoryItem item in m_items.Values)
+            lock (m_items)
             {
-                if (item.InvType != (int)InventoryType.Object)
-                {
-                    if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Copy) == 0)
-                        mask &= ~((uint)PermissionMask.Copy >> 13);
-                    if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Transfer) == 0)
-                        mask &= ~((uint)PermissionMask.Transfer >> 13);
-                    if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Modify) == 0)
-                        mask &= ~((uint)PermissionMask.Modify >> 13);
-                }
-                else
+                foreach (TaskInventoryItem item in m_items.Values)
                 {
-                    if ((item.CurrentPermissions & ((uint)PermissionMask.Copy >> 13)) == 0)
-                        mask &= ~((uint)PermissionMask.Copy >> 13);
-                    if ((item.CurrentPermissions & ((uint)PermissionMask.Transfer >> 13)) == 0)
-                        mask &= ~((uint)PermissionMask.Transfer >> 13);
-                    if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
-                        mask &= ~((uint)PermissionMask.Modify >> 13);
+                    if (item.InvType != (int)InventoryType.Object)
+                    {
+                        if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Copy) == 0)
+                            mask &= ~((uint)PermissionMask.Copy >> 13);
+                        if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Transfer) == 0)
+                            mask &= ~((uint)PermissionMask.Transfer >> 13);
+                        if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Modify) == 0)
+                            mask &= ~((uint)PermissionMask.Modify >> 13);
+                    }
+                    else
+                    {
+                        if ((item.CurrentPermissions & ((uint)PermissionMask.Copy >> 13)) == 0)
+                            mask &= ~((uint)PermissionMask.Copy >> 13);
+                        if ((item.CurrentPermissions & ((uint)PermissionMask.Transfer >> 13)) == 0)
+                            mask &= ~((uint)PermissionMask.Transfer >> 13);
+                        if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
+                            mask &= ~((uint)PermissionMask.Modify >> 13);
+                    }
+    
+                    if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
+                        mask &= ~(uint)PermissionMask.Copy;
+                    if ((item.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
+                        mask &= ~(uint)PermissionMask.Transfer;
+                    if ((item.CurrentPermissions & (uint)PermissionMask.Modify) == 0)
+                        mask &= ~(uint)PermissionMask.Modify;
                 }
-
-                if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
-                    mask &= ~(uint)PermissionMask.Copy;
-                if ((item.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
-                    mask &= ~(uint)PermissionMask.Transfer;
-                if ((item.CurrentPermissions & (uint)PermissionMask.Modify) == 0)
-                    mask &= ~(uint)PermissionMask.Modify;
             }
+                
             return mask;
         }
 
         public void ApplyNextOwnerPermissions()
         {
-            foreach (TaskInventoryItem item in m_items.Values)
+            lock (m_items)
             {
-                if (item.InvType == (int)InventoryType.Object && (item.CurrentPermissions & 7) != 0)
+                foreach (TaskInventoryItem item in m_items.Values)
                 {
-                    if ((item.CurrentPermissions & ((uint)PermissionMask.Copy >> 13)) == 0)
-                        item.CurrentPermissions &= ~(uint)PermissionMask.Copy;
-                    if ((item.CurrentPermissions & ((uint)PermissionMask.Transfer >> 13)) == 0)
-                        item.CurrentPermissions &= ~(uint)PermissionMask.Transfer;
-                    if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
-                        item.CurrentPermissions &= ~(uint)PermissionMask.Modify;
-                    item.CurrentPermissions |= 8;
+                    if (item.InvType == (int)InventoryType.Object && (item.CurrentPermissions & 7) != 0)
+                    {
+                        if ((item.CurrentPermissions & ((uint)PermissionMask.Copy >> 13)) == 0)
+                            item.CurrentPermissions &= ~(uint)PermissionMask.Copy;
+                        if ((item.CurrentPermissions & ((uint)PermissionMask.Transfer >> 13)) == 0)
+                            item.CurrentPermissions &= ~(uint)PermissionMask.Transfer;
+                        if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
+                            item.CurrentPermissions &= ~(uint)PermissionMask.Modify;
+                        item.CurrentPermissions |= 8;
+                    }
+                    item.CurrentPermissions &= item.NextPermissions;
+                    item.BasePermissions &= item.NextPermissions;
+                    item.EveryonePermissions &= item.NextPermissions;
                 }
-                item.CurrentPermissions &= item.NextPermissions;
-                item.BasePermissions &= item.NextPermissions;
-                item.EveryonePermissions &= item.NextPermissions;
             }
 
             m_part.TriggerScriptChangedEvent(Changed.OWNER);
@@ -896,22 +963,29 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void ApplyGodPermissions(uint perms)
         {
-            foreach (TaskInventoryItem item in m_items.Values)
+            lock (m_items)
             {
-                item.CurrentPermissions = perms;
-                item.BasePermissions = perms;
+                foreach (TaskInventoryItem item in m_items.Values)
+                {
+                    item.CurrentPermissions = perms;
+                    item.BasePermissions = perms;
+                }
             }
         }
 
         public bool ContainsScripts()
         {
-            foreach (TaskInventoryItem item in m_items.Values)
+            lock (m_items)
             {
-                if (item.InvType == (int)InventoryType.LSL)
+                foreach (TaskInventoryItem item in m_items.Values)
                 {
-                    return true;
+                    if (item.InvType == (int)InventoryType.LSL)
+                    {
+                        return true;
+                    }
                 }
             }
+            
             return false;
         }
 
@@ -919,8 +993,11 @@ namespace OpenSim.Region.Framework.Scenes
         {
             List<UUID> ret = new List<UUID>();
 
-            foreach (TaskInventoryItem item in m_items.Values)
-                ret.Add(item.ItemID);
+            lock (m_items)
+            {
+                foreach (TaskInventoryItem item in m_items.Values)
+                    ret.Add(item.ItemID);
+            }
 
             return ret;
         }
@@ -933,26 +1010,30 @@ namespace OpenSim.Region.Framework.Scenes
             if (engines == null) // No engine at all
                 return ret;
 
-            foreach (TaskInventoryItem item in m_items.Values)
+            lock (m_items)
             {
-                if (item.InvType == (int)InventoryType.LSL)
+                foreach (TaskInventoryItem item in m_items.Values)
                 {
-                    foreach (IScriptModule e in engines)
+                    if (item.InvType == (int)InventoryType.LSL)
                     {
-                        if (e != null)
+                        foreach (IScriptModule e in engines)
                         {
-                            string n = e.GetXMLState(item.ItemID);
-                            if (n != String.Empty)
+                            if (e != null)
                             {
-                                if (!ret.ContainsKey(item.ItemID))
-                                    ret[item.ItemID] = n;
-                                break;
+                                string n = e.GetXMLState(item.ItemID);
+                                if (n != String.Empty)
+                                {
+                                    if (!ret.ContainsKey(item.ItemID))
+                                        ret[item.ItemID] = n;
+                                    break;
+                                }
                             }
                         }
                     }
                 }
             }
+            
             return ret;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index afb5b9a..29f607b 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -104,6 +104,8 @@ namespace OpenSim.Region.Framework.Scenes
         }
         protected ScenePresenceAnimator m_animator;
 
+        protected List<SceneObjectGroup> m_attachments = new List<SceneObjectGroup>();
+
         private Dictionary<UUID, ScriptControllers> scriptedcontrols = new Dictionary<UUID, ScriptControllers>();
         private ScriptControlled IgnoredControls = ScriptControlled.CONTROL_ZERO;
         private ScriptControlled LastCommands = ScriptControlled.CONTROL_ZERO;
@@ -217,7 +219,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         protected AvatarAppearance m_appearance;
 
-        protected List<SceneObjectGroup> m_attachments = new List<SceneObjectGroup>();
         public List<SceneObjectGroup> Attachments
         {
             get { return m_attachments; }
@@ -636,12 +637,16 @@ namespace OpenSim.Region.Framework.Scenes
         #endregion
 
         #region Constructor(s)
-
-        private ScenePresence(IClientAPI client, Scene world, RegionInfo reginfo)
-        {
-            m_animator = new ScenePresenceAnimator(this);
+        
+        public ScenePresence()
+        {            
             m_sendCourseLocationsMethod = SendCoarseLocationsDefault;
             CreateSceneViewer();
+            m_animator = new ScenePresenceAnimator(this);
+        }
+        
+        private ScenePresence(IClientAPI client, Scene world, RegionInfo reginfo) : this()
+        {
             m_rootRegionHandle = reginfo.RegionHandle;
             m_controllingClient = client;
             m_firstname = m_controllingClient.FirstName;
@@ -665,7 +670,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_reprioritization_timer.Elapsed += new ElapsedEventHandler(Reprioritize);
             m_reprioritization_timer.AutoReset = false;
 
-
             AdjustKnownSeeds();
 
             // TODO: I think, this won't send anything, as we are still a child here...
@@ -1294,6 +1298,12 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (m_allowMovement)
             {
+                if (agentData.UseClientAgentPosition)
+                {
+                    m_moveToPositionInProgress = (agentData.ClientAgentPosition - AbsolutePosition).Length() > 0.2f;
+                    m_moveToPositionTarget = agentData.ClientAgentPosition;
+                }
+
                 int i = 0;
                 
                 bool update_rotation = false;
@@ -1400,7 +1410,7 @@ namespace OpenSim.Region.Framework.Scenes
                     if (bAllowUpdateMoveToPosition && (m_moveToPositionInProgress && !m_autopilotMoving))
                     {
                         //Check the error term of the current position in relation to the target position
-                        if (Util.GetDistanceTo(AbsolutePosition, m_moveToPositionTarget) <= 1.5f)
+                        if (Util.GetDistanceTo(AbsolutePosition, m_moveToPositionTarget) <= 0.5f)
                         {
                             // we are close enough to the target
                             m_moveToPositionTarget = Vector3.Zero;
@@ -2795,7 +2805,14 @@ namespace OpenSim.Region.Framework.Scenes
         protected void CrossToNewRegion()
         {
             InTransit();
-            m_scene.CrossAgentToNewRegion(this, m_physicsActor.Flying);
+            try
+            {
+                m_scene.CrossAgentToNewRegion(this, m_physicsActor.Flying);
+            }
+            catch
+            {
+                m_scene.CrossAgentToNewRegion(this, false);
+            }
         }
 
         public void InTransit()
@@ -2873,7 +2890,6 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 RemoveNeighbourRegion(handle);
             }
-
         }
 
         #endregion
@@ -3037,7 +3053,7 @@ namespace OpenSim.Region.Framework.Scenes
             List<int> attPoints = m_appearance.GetAttachedPoints();
             if (attPoints != null)
             {
-                m_log.DebugFormat("[SCENE PRESENCE]: attachments {0}", attPoints.Count);
+                //m_log.DebugFormat("[SCENE PRESENCE]: attachments {0}", attPoints.Count);
                 int i = 0;
                 AttachmentData[] attachs = new AttachmentData[attPoints.Count];
                 foreach (int point in attPoints)
@@ -3261,17 +3277,15 @@ namespace OpenSim.Region.Framework.Scenes
             uint killerObj = 0;
             foreach (uint localid in coldata.Keys)
             {
-                if (coldata[localid].PenetrationDepth <= 0.10f || m_invulnerable)
-                    continue;
-                //if (localid == 0)
-                    //continue;
-
-                SceneObjectPart part = m_scene.GetSceneObjectPart(localid);
+                SceneObjectPart part = Scene.GetSceneObjectPart(localid);
 
                 if (part != null && part.ParentGroup.Damage != -1.0f)
                     Health -= part.ParentGroup.Damage;
                 else
-                    Health -= coldata[localid].PenetrationDepth * 5.0f;
+                {
+                    if (coldata[localid].PenetrationDepth >= 0.10f)
+                        Health -= coldata[localid].PenetrationDepth * 5.0f;
+                }
 
                 if (Health <= 0.0f)
                 {
@@ -3289,9 +3303,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 if (m_health <= 0)
                     m_scene.EventManager.TriggerAvatarKill(killerObj, this);
-            }
-
-            
+            }            
         }
 
         public void setHealthWithUpdate(float health)
@@ -3338,13 +3350,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_animator = null;
         }
 
-        public ScenePresence()
-        {
-            m_sendCourseLocationsMethod = SendCoarseLocationsDefault;
-            CreateSceneViewer();
-            m_animator = new ScenePresenceAnimator(this);
-        }
-
         public void AddAttachment(SceneObjectGroup gobj)
         {
             lock (m_attachments)
@@ -3843,4 +3848,4 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
     }
-}
\ No newline at end of file
+}