36 files changed, 2115 insertions, 1084 deletions

diff --git a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
index 90a13a7..d781eae 100644
--- a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
@@ -114,6 +114,15 @@ namespace OpenSim.Region.Framework.Interfaces
         void DetachSingleAttachmentToGround(IScenePresence sp, uint objectLocalID);
 
         /// <summary>
+        /// Detach the given item to the ground at the specified coordinates & rotation
+        /// </summary>
+        /// <param name="sp"></param>
+        /// <param name="objectLocalID"></param>
+        /// <param name="absolutePos"></param>
+        /// <param name="absoluteRot"></param>
+        void DetachSingleAttachmentToGround(IScenePresence sp, uint objectLocalID, Vector3 absolutePos, Quaternion absoluteRot);
+
+        /// <summary>
         /// Detach the given attachment so that it remains in the user's inventory.
         /// </summary>
         /// <param name="sp">/param>
diff --git a/OpenSim/Region/Framework/Interfaces/ICloudModule.cs b/OpenSim/Region/Framework/Interfaces/ICloudModule.cs
index 7296ac3..54172bd 100644
--- a/OpenSim/Region/Framework/Interfaces/ICloudModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/ICloudModule.cs
@@ -27,7 +27,7 @@
 
 namespace OpenSim.Region.Framework.Interfaces
 {
-    public interface ICloudModule : IRegionModule
+    public interface ICloudModule 
     {
         /// <summary>
         /// Retrieves the cloud density at the given region coordinates
diff --git a/OpenSim/Region/Framework/Interfaces/IDialogModule.cs b/OpenSim/Region/Framework/Interfaces/IDialogModule.cs
index be9764a..4d35c1c 100644
--- a/OpenSim/Region/Framework/Interfaces/IDialogModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IDialogModule.cs
@@ -33,95 +33,140 @@ namespace OpenSim.Region.Framework.Interfaces
     public interface IDialogModule
     {
         /// <summary>
-        /// Send a non-modal alert message to a particular user.  This can disappear from the user's view after a
-        /// small interval.
+        /// Send a non-modal alert message to a particular user. This can
+        /// disappear from the user's view after a small interval.
         /// </summary>
-        /// <param name="client"></param>
-        /// <param name="message"></param>
+        /// <param name="client">
+        /// IClientAPI object representing the user.
+        /// </param>
+        /// <param name="message">Message text to send to the user.</param>
         void SendAlertToUser(IClientAPI client, string message);
-        
+
         /// <summary>
         /// Send an alert message to a particular user.
         /// </summary>
-        /// <param name="client"></param>
-        /// <param name="message"></param>
-        /// <param name="modal"></param>
+        /// <param name="client">
+        /// IClientAPI object representing the user.
+        /// </param>
+        /// <param name="message">Message text to send to the user.</param>
+        /// <param name="modal">Flag to control modality.</param>
         void SendAlertToUser(IClientAPI client, string message, bool modal);
-        
+
         /// <summary>
         /// Send a non-modal alert message to a particular user.
         /// </summary>
-        /// <param name="agentID"></param>
-        /// <param name="message"></param>
+        /// <param name="agentID">UUID of agent representing the user.</param>
+        /// <param name="message">Message text to send to the user.</param>
         void SendAlertToUser(UUID agentID, string message);
-        
+
         /// <summary>
         /// Send an alert message to a particular user.
         /// </summary>
-        /// <param name="agentID"></param>
-        /// <param name="message"></param>
-        /// <param name="modal"></param>
+        /// <param name="agentID">UUID of agent representing the user.</param>
+        /// <param name="message">Message text to send to the user.</param>
+        /// <param name="modal">Flag to control modality.</param>
         void SendAlertToUser(UUID agentID, string message, bool modal);
-        
+
         /// <summary>
         /// Send an alert message to a particular user.
         /// </summary>
-        /// <param name="firstName"></param>
-        /// <param name="lastName"></param>
-        /// <param name="message"></param>
-        /// <param name="modal"></param>
-        void SendAlertToUser(string firstName, string lastName, string message, bool modal);
-        
+        /// <param name="firstName">Account first name</param>
+        /// <param name="lastName">Account last name</param>
+        /// <param name="message">Message text to send to the user.</param>
+        /// <param name="modal">Flag to control modality.</param>
+        void SendAlertToUser(string firstName, string lastName,
+                string message, bool modal);
+
         /// <summary>
         /// Send an alert message to all users in the scene.
         /// </summary>
-        /// <param name="message"></param>
+        /// <param name="message">Message text to send to all users.</param>
         void SendGeneralAlert(string message);
-        
+
         /// <summary>
         /// Send a dialog box to a particular user.
         /// </summary>
-        /// <param name="avatarID"></param>
-        /// <param name="objectName"></param>
-        /// <param name="objectID"></param>
-        /// <param name="ownerID"></param>
-        /// <param name="message"></param>
-        /// <param name="textureID"></param>
-        /// <param name="ch"></param>
-        /// <param name="buttonlabels"></param>
-        void SendDialogToUser(
-            UUID avatarID, string objectName, UUID objectID, UUID ownerID, 
-            string message, UUID textureID, int ch, string[] buttonlabels);
-        
+        /// <param name="avatarID">
+        /// UUID of the avatar representing the user.
+        /// </param>
+        /// <param name="objectName">
+        /// Name of the object sending the dialog.
+        /// </param>
+        /// <param name="objectID">
+        /// UUID of the object sending the dialog.
+        /// </param>
+        /// <param name="ownerID">
+        /// UUID of the user that owns the object.
+        /// </param>
+        /// <param name="message">Message text to send to the user.</param>
+        /// <param name="textureID">
+        /// Texture UUID to pass along with the dialog.
+        /// </param>
+        /// <param name="ch">
+        /// Channel on which the selected button text should be broadcast.
+        /// </param>
+        /// <param name="buttonlabels">Dialog button text.</param>
+        void SendDialogToUser(UUID avatarID, string objectName, UUID objectID,
+                UUID ownerID, string message, UUID textureID, int ch,
+                string[] buttonlabels);
+
         /// <summary>
         /// Send a url to a particular user.
         /// </summary>
-        /// <param name="avatarID"></param>
-        /// <param name="objectName"></param>
-        /// <param name="objectID"></param>
-        /// <param name="ownerID"></param>
-        /// <param name="groupOwned"></param>
-        /// <param name="message"></param>
-        /// <param name="url"></param>
-        void SendUrlToUser(
-            UUID avatarID, string objectName, UUID objectID, UUID ownerID, bool groupOwned, string message, string url);
-        
+        /// <param name="avatarID">
+        /// UUID of the avatar representing the user.
+        /// </param>
+        /// <param name="objectName">
+        /// Name of the object sending the dialog.
+        /// </param>
+        /// <param name="objectID">
+        /// UUID of the object sending the dialog.
+        /// </param>
+        /// <param name="ownerID">
+        /// UUID of the user that owns the object.
+        /// </param>
+        /// <param name="groupOwned">
+        /// Flag indicating whether or not the object is group-owned.
+        /// </param>
+        /// <param name="message">Message text to send to the user.</param>
+        /// <param name="url">Url to send to the user.</param>
+        void SendUrlToUser(UUID avatarID, string objectName, UUID objectID,
+                UUID ownerID, bool groupOwned, string message, string url);
+
         /// <summary>
-        /// Send a notification to all users in the scene.  This notification should remain around until the 
-        /// user explicitly dismisses it.
+        /// Send a notification to all users in the scene. This notification
+        /// should remain around until the user explicitly dismisses it.
         /// </summary>
-        /// 
-        /// On the Linden Labs Second Client (as of 1.21), this is a big blue box message on the upper right of the 
-        /// screen.
-        /// 
+        /// <remarks>
+        /// On the Linden Labs Second Client (as of 1.21), this is a big blue
+        /// box message on the upper right of the screen.
+        /// </remarks>
         /// <param name="fromAvatarID">The user sending the message</param>
-        /// <param name="fromAvatarName">The name of the user doing the sending</param>
+        /// <param name="fromAvatarName">
+        /// The name of the user doing the sending
+        /// </param>
         /// <param name="message">The message being sent to the user</param>
-        void SendNotificationToUsersInRegion(UUID fromAvatarID, string fromAvatarName, string message);
-        
+        void SendNotificationToUsersInRegion(UUID fromAvatarID,
+                string fromAvatarName, string message);
+
         /// <summary>
         /// Send a textbox entry for the client to respond to
         /// </summary>
-        void SendTextBoxToUser(UUID avatarid, string message, int chatChannel, string name, UUID objectid, UUID ownerid);
+        /// <param name="avatarID">
+        /// UUID of the avatar representing the user.
+        /// </param>
+        /// <param name="message">Message text to send to the user.</param>
+        /// <param name="chatChannel">
+        /// Chat channel that the user's input should be broadcast on.
+        /// </param>
+        /// <param name="name">Name of the object sending the dialog.</param>
+        /// <param name="objectid">
+        /// UUID of the object sending the dialog.
+        /// </param>
+        /// <param name="ownerid">
+        /// UUID of the user that owns the object.
+        /// </param>
+        void SendTextBoxToUser(UUID avatarid, string message, int chatChannel,
+                string name, UUID objectid, UUID ownerid);
     }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/IDynamicTextureManager.cs b/OpenSim/Region/Framework/Interfaces/IDynamicTextureManager.cs
index 8954513..6df5cc2 100644
--- a/OpenSim/Region/Framework/Interfaces/IDynamicTextureManager.cs
+++ b/OpenSim/Region/Framework/Interfaces/IDynamicTextureManager.cs
@@ -25,6 +25,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System;
+using System.Drawing;
 using System.IO;
 using OpenMetaverse;
 
@@ -33,7 +35,14 @@ namespace OpenSim.Region.Framework.Interfaces
     public interface IDynamicTextureManager
     {
         void RegisterRender(string handleType, IDynamicTextureRender render);
-        void ReturnData(UUID id, byte[] data);
+
+        /// <summary>
+        /// Used by IDynamicTextureRender implementations to return renders
+        /// </summary>
+        /// <param name='id'></param>
+        /// <param name='data'></param>
+        /// <param name='isReuseable'></param>
+        void ReturnData(UUID id, IDynamicTexture texture);
 
         UUID AddDynamicTextureURL(UUID simID, UUID primID, string contentType, string url, string extraParams,
                                     int updateTimer);
@@ -113,11 +122,65 @@ namespace OpenSim.Region.Framework.Interfaces
         string GetName();
         string GetContentType();
         bool SupportsAsynchronous();
-        byte[] ConvertUrl(string url, string extraParams);
-        byte[] ConvertStream(Stream data, string extraParams);
+
+//        /// <summary>
+//        /// Return true if converting the input body and extra params data will always result in the same byte[] array
+//        /// </summary>
+//        /// <remarks>
+//        /// This method allows the caller to use a previously generated asset if it has one.
+//        /// </remarks>
+//        /// <returns></returns>
+//        /// <param name='bodyData'></param>
+//        /// <param name='extraParams'></param>
+//        bool AlwaysIdenticalConversion(string bodyData, string extraParams);
+
+        IDynamicTexture ConvertUrl(string url, string extraParams);
+        IDynamicTexture ConvertData(string bodyData, string extraParams);
+
         bool AsyncConvertUrl(UUID id, string url, string extraParams);
         bool AsyncConvertData(UUID id, string bodyData, string extraParams);
+
         void GetDrawStringSize(string text, string fontName, int fontSize, 
                                out double xSize, out double ySize);
     }
+
+    public interface IDynamicTexture
+    {
+        /// <summary>
+        /// Input commands used to generate this data.
+        /// </summary>
+        /// <remarks>
+        /// Null if input commands were not used.
+        /// </remarks>
+        string InputCommands { get; }
+
+        /// <summary>
+        /// Uri used to generate this data.
+        /// </summary>
+        /// <remarks>
+        /// Null if a uri was not used.
+        /// </remarks>
+        Uri InputUri { get; }
+
+        /// <summary>
+        /// Extra input params used to generate this data.
+        /// </summary>
+        string InputParams { get; }
+
+        /// <summary>
+        /// Texture data.
+        /// </summary>
+        byte[] Data { get; }
+
+        /// <summary>
+        /// Size of texture.
+        /// </summary>
+        Size Size { get; }
+
+        /// <summary>
+        /// Signal whether the texture is reuseable (i.e. whether the same input data will always generate the same
+        /// texture).
+        /// </summary>
+        bool IsReuseable { get; }
+    }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
index 4274cbe..8028d87 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
@@ -152,6 +152,19 @@ namespace OpenSim.Region.Framework.Interfaces
         void StopScriptInstance(UUID itemId);
 
         /// <summary>
+        /// Try to get the script running status.
+        /// </summary>
+        /// <returns>
+        /// Returns true if a script for the item was found in one of the simulator's script engines.  In this case,
+        /// the running parameter will reflect the running status.
+        /// Returns false if the item could not be found, if the item is not a script or if a script instance for the
+        /// item was not found in any of the script engines.  In this case, running status is irrelevant.
+        /// </returns>
+        /// <param name='itemId'></param>
+        /// <param name='running'></param>
+        bool TryGetScriptInstanceRunning(UUID itemId, out bool running);
+
+        /// <summary>
         /// Add an item to this entity's inventory.  If an item with the same name already exists, then an alternative
         /// name is chosen.
         /// </summary>
@@ -270,17 +283,25 @@ namespace OpenSim.Region.Framework.Interfaces
         void ApplyGodPermissions(uint perms);
 
         /// <summary>
+        /// Number of items in this inventory.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
         /// Returns true if this inventory contains any scripts
         /// </summary></returns>
         bool ContainsScripts();
 
         /// <summary>
-        /// Returns the count of scripts contained
-        /// </summary></returns>
+        /// Number of scripts in this inventory.
+        /// </summary>
+        /// <remarks>
+        /// Includes both running and non running scripts.
+        /// </remarks>
         int ScriptCount();
 
         /// <summary>
-        /// Returns the count of running scripts contained
+        /// Number of running scripts in this inventory.
         /// </summary></returns>
         int RunningScriptCount();
 
diff --git a/OpenSim/Region/Framework/Interfaces/IEstateModule.cs b/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
index ca2ad94..292efa4 100644
--- a/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
@@ -46,6 +46,10 @@ namespace OpenSim.Region.Framework.Interfaces
         /// </summary>
         void sendRegionHandshakeToAll();
         void TriggerEstateInfoChange();
+
+        /// <summary>
+        /// Fires the OnRegionInfoChange event.
+        /// </summary>
         void TriggerRegionInfoChange();
 
         void setEstateTerrainBaseTexture(int level, UUID texture);
diff --git a/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs b/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
index baac6e8..da39e95 100644
--- a/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
@@ -35,7 +35,7 @@ namespace OpenSim.Region.Framework.Interfaces
 
     public interface IJsonStoreModule
     {
-        bool CreateStore(string value, out UUID result);
+        bool CreateStore(string value, ref UUID result);
         bool DestroyStore(UUID storeID);
         bool TestPath(UUID storeID, string path, bool useJson);
         bool SetValue(UUID storeID, string path, string value, bool useJson);
diff --git a/OpenSim/Region/Framework/Interfaces/IRegionModule.cs b/OpenSim/Region/Framework/Interfaces/ILightShareModule.cs
index 2bb0c75..b5fd24f 100644
--- a/OpenSim/Region/Framework/Interfaces/IRegionModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/ILightShareModule.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -25,29 +25,9 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-using Nini.Config;
-using OpenSim.Region.Framework.Scenes;
-
 namespace OpenSim.Region.Framework.Interfaces
 {
-    /// <summary>
-    /// DEPRECATED! Use INonSharedRegionModule or ISharedRegionModule instead
-    /// </summary>
-    public interface IRegionModule
+    public interface ILightShareModule
     {
-        /// <summary>
-        /// Initialize the module.
-        /// </summary>
-        /// <remarks>
-        /// For a shared module this can be called multiple times - once per scene.
-        /// </remarks>
-        /// <param name="scene"></param>
-        /// <param name="source">Configuration information.  For a shared module this will be identical on every scene call</param>
-        void Initialise(Scene scene, IConfigSource source);
-        
-        void PostInitialise();
-        void Close();
-        string Name { get; }
-        bool IsSharedModule { get; }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/INPCModule.cs b/OpenSim/Region/Framework/Interfaces/INPCModule.cs
index d582149..9817cf7 100644
--- a/OpenSim/Region/Framework/Interfaces/INPCModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/INPCModule.cs
@@ -32,14 +32,16 @@ using OpenSim.Region.Framework.Scenes;
 namespace OpenSim.Region.Framework.Interfaces
 {
     /// <summary>
-    /// Temporary interface.  More methods to come at some point to make NPCs more object oriented rather than
-    /// controlling purely through module level interface calls (e.g. sit/stand).
+    /// Temporary interface. More methods to come at some point to make NPCs
+    /// more object oriented rather than controlling purely through module
+    /// level interface calls (e.g. sit/stand).
     /// </summary>
     public interface INPC
     {
         /// <summary>
-        /// Should this NPC be sensed by LSL sensors as an 'agent' (interpreted here to mean a normal user)
-        /// rather than an OpenSim specific NPC extension?
+        /// Should this NPC be sensed by LSL sensors as an 'agent'
+        /// (interpreted here to mean a normal user) rather than an OpenSim
+        /// specific NPC extension?
         /// </summary>
         bool SenseAsAgent { get; }
     }
@@ -53,35 +55,42 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="lastname"></param>
         /// <param name="position"></param>
         /// <param name="senseAsAgent">
-        /// Make the NPC show up as an agent on LSL sensors.  The default is that they
-        /// show up as the NPC type instead, but this is currently an OpenSim-only extension.
+        /// Make the NPC show up as an agent on LSL sensors. The default is
+        /// that they show up as the NPC type instead, but this is currently
+        /// an OpenSim-only extension.
         /// </param>
         /// <param name="scene"></param>
-        /// <param name="appearance">The avatar appearance to use for the new NPC.</param>
-        /// <returns>The UUID of the ScenePresence created.  UUID.Zero if there was a failure.</returns>
-        UUID CreateNPC(
-            string firstname,
-            string lastname,
-            Vector3 position,
-            UUID owner,
-            bool senseAsAgent,
-            Scene scene,
-            AvatarAppearance appearance);
+        /// <param name="appearance">
+        /// The avatar appearance to use for the new NPC.
+        /// </param>
+        /// <returns>
+        /// The UUID of the ScenePresence created. UUID.Zero if there was a
+        /// failure.
+        /// </returns>
+        UUID CreateNPC(string firstname, string lastname, Vector3 position,
+                UUID owner, bool senseAsAgent, Scene scene,
+                AvatarAppearance appearance);
 
         /// <summary>
         /// Check if the agent is an NPC.
         /// </summary>
         /// <param name="agentID"></param>
         /// <param name="scene"></param>
-        /// <returns>True if the agent is an NPC in the given scene.  False otherwise.</returns>
+        /// <returns>
+        /// True if the agent is an NPC in the given scene. False otherwise.
+        /// </returns>
         bool IsNPC(UUID agentID, Scene scene);
 
         /// <summary>
-        /// Get the NPC.  This is not currently complete - manipulation of NPCs still occurs through the region interface
+        /// Get the NPC.
         /// </summary>
+        /// <remarks>
+        /// This is not currently complete - manipulation of NPCs still occurs
+        /// through the region interface.
+        /// </remarks>
         /// <param name="agentID"></param>
         /// <param name="scene"></param>
-        /// <returns>The NPC.  null if it does not exist.</returns>
+        /// <returns>The NPC. null if it does not exist.</returns>
         INPC GetNPC(UUID agentID, Scene scene);
 
         /// <summary>
@@ -89,7 +98,10 @@ namespace OpenSim.Region.Framework.Interfaces
         /// </summary>
         /// <param name="npcID"></param>
         /// <param name="callerID"></param>
-        /// <returns>true if they do, false if they don't or if there's no NPC with the given ID.</returns>
+        /// <returns>
+        /// true if they do, false if they don't or if there's no NPC with the
+        /// given ID.
+        /// </returns>
         bool CheckPermissions(UUID npcID, UUID callerID);
 
         /// <summary>
@@ -98,8 +110,12 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="agentID"></param>
         /// <param name="appearance"></param>
         /// <param name="scene"></param>
-        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
-        bool SetNPCAppearance(UUID agentID, AvatarAppearance appearance, Scene scene);
+        /// <returns>
+        /// True if the operation succeeded, false if there was no such agent
+        /// or the agent was not an NPC.
+        /// </returns>
+        bool SetNPCAppearance(UUID agentID, AvatarAppearance appearance,
+                Scene scene);
 
         /// <summary>
         /// Move an NPC to a target over time.
@@ -108,23 +124,29 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="scene"></param>
         /// <param name="pos"></param>
         /// <param name="noFly">
-        /// If true, then the avatar will attempt to walk to the location even if it's up in the air.
-        /// This is to allow walking on prims.
+        /// If true, then the avatar will attempt to walk to the location even
+        /// if it's up in the air. This is to allow walking on prims.
         /// </param>
         /// <param name="landAtTarget">
         /// If true and the avatar is flying when it reaches the target, land.
         /// </param> name="running">
         /// If true, NPC moves with running speed.
-        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
-        /// 
-        bool MoveToTarget(UUID agentID, Scene scene, Vector3 pos, bool noFly, bool landAtTarget, bool running);
+        /// <returns>
+        /// True if the operation succeeded, false if there was no such agent
+        /// or the agent was not an NPC.
+        /// </returns>
+        bool MoveToTarget(UUID agentID, Scene scene, Vector3 pos, bool noFly,
+                bool landAtTarget, bool running);
 
         /// <summary>
         /// Stop the NPC's current movement.
         /// </summary>
         /// <param name="agentID">The UUID of the NPC</param>
         /// <param name="scene"></param>
-        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        /// <returns>
+        /// True if the operation succeeded, false if there was no such agent
+        /// or the agent was not an NPC.
+        /// </returns>
         bool StopMoveToTarget(UUID agentID, Scene scene);
 
         /// <summary>
@@ -133,7 +155,10 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="agentID">The UUID of the NPC</param>
         /// <param name="scene"></param>
         /// <param name="text"></param>
-        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        /// <returns>
+        /// True if the operation succeeded, false if there was no such agent
+        /// or the agent was not an NPC.
+        /// </returns>
         bool Say(UUID agentID, Scene scene, string text);
 
         /// <summary>
@@ -143,7 +168,10 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="scene"></param>
         /// <param name="text"></param>
         /// <param name="channel"></param>
-        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        /// <returns>
+        /// True if the operation succeeded, false if there was no such agent
+        /// or the agent was not an NPC.
+        /// </returns>
         bool Say(UUID agentID, Scene scene, string text, int channel);
 
         /// <summary>
@@ -153,7 +181,10 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="scene"></param>
         /// <param name="text"></param>
         /// <param name="channel"></param>
-        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        /// <returns>
+        /// True if the operation succeeded, false if there was no such agent
+        /// or the agent was not an NPC.
+        /// </returns>
         bool Shout(UUID agentID, Scene scene, string text, int channel);
 
         /// <summary>
@@ -163,7 +194,10 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="scene"></param>
         /// <param name="text"></param>
         /// <param name="channel"></param>
-        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        /// <returns>
+        /// True if the operation succeeded, false if there was no such agent
+        /// or the agent was not an NPC.
+        /// </returns>
         bool Whisper(UUID agentID, Scene scene, string text, int channel);
 
         /// <summary>
@@ -188,7 +222,9 @@ namespace OpenSim.Region.Framework.Interfaces
         /// </summary>
         /// <param name="agentID"></param>
         /// <param name="partID"></param>
-        /// <returns>true if the touch is actually attempted, false if not</returns>
+        /// <returns>
+        /// true if the touch is actually attempted, false if not.
+        /// </returns>
         bool Touch(UUID agentID, UUID partID);
 
         /// <summary>
@@ -196,14 +232,20 @@ namespace OpenSim.Region.Framework.Interfaces
         /// </summary>
         /// <param name="agentID">The UUID of the NPC</param>
         /// <param name="scene"></param>
-        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        /// <returns>
+        /// True if the operation succeeded, false if there was no such agent
+        /// or the agent was not an NPC.
+        /// </returns>
         bool DeleteNPC(UUID agentID, Scene scene);
 
         /// <summary>
         /// Get the owner of a NPC
         /// </summary>
         /// <param name="agentID">The UUID of the NPC</param>
-        /// <returns>UUID of owner if the NPC exists, UUID.Zero  if there was no such agent, the agent is unowned  or the agent was not an NPC</returns>
+        /// <returns>
+        /// UUID of owner if the NPC exists, UUID.Zero  if there was no such
+        /// agent, the agent is unowned  or the agent was not an NPC.
+        /// </returns>
         UUID GetOwner(UUID agentID);
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Interfaces/IScriptModuleComms.cs b/OpenSim/Region/Framework/Interfaces/IScriptModuleComms.cs
index a76ffde..70ff954 100644
--- a/OpenSim/Region/Framework/Interfaces/IScriptModuleComms.cs
+++ b/OpenSim/Region/Framework/Interfaces/IScriptModuleComms.cs
@@ -47,9 +47,46 @@ namespace OpenSim.Region.Framework.Interfaces
         /// </summary>
         event ScriptCommand OnScriptCommand;
 
+        /// <summary>
+        /// Register an instance method as a script call by method name
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="method"></param>
         void RegisterScriptInvocation(object target, string method);
+
+        /// <summary>
+        /// Register a static or instance method as a script call by method info
+        /// </summary>
+        /// <param name="target">If target is a Type object, will assume method is static.</param>
+        /// <param name="method"></param>
         void RegisterScriptInvocation(object target, MethodInfo method);
+
+        /// <summary>
+        /// Register one or more instance methods as script calls by method name
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="methods"></param>
         void RegisterScriptInvocation(object target, string[] methods);
+
+        /// <summary>
+        /// Register one or more static methods as script calls by method name
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="methods"></param>
+        void RegisterScriptInvocation(Type target, string[] methods);
+
+        /// <summary>
+        /// Automatically register script invocations by checking for methods
+        /// with <see cref="ScriptInvocationAttribute"/>. Should only check
+        /// public methods.
+        /// </summary>
+        /// <param name="target"></param>
+        void RegisterScriptInvocations(IRegionModuleBase target);
+
+        /// <summary>
+        /// Returns an array of all registered script calls
+        /// </summary>
+        /// <returns></returns>
         Delegate[] GetScriptInvocationList();
 
         Delegate LookupScriptInvocation(string fname);
@@ -68,12 +105,44 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="key"></param>
         void DispatchReply(UUID scriptId, int code, string text, string key);
 
-        /// For constants
+        /// <summary>
+        /// Operation to for a region module to register a constant to be used
+        /// by the script engine
+        /// </summary>
+        /// <param name="cname">
+        /// The name of the constant. LSL convention is for constant names to
+        /// be uppercase.
+        /// </param>
+        /// <param name="value">
+        /// The value of the constant. Should be of a type that can be
+        /// converted to one of <see cref="OpenSim.Region.ScriptEngine.Shared.LSL_Types"/>
+        /// </param>
         void RegisterConstant(string cname, object value);
+
+        /// <summary>
+        /// Automatically register all constants on a region module by
+        /// checking for fields with <see cref="ScriptConstantAttribute"/>.
+        /// </summary>
+        /// <param name="target"></param>
+        void RegisterConstants(IRegionModuleBase target);
+
+        /// <summary>
+        /// Operation to check for a registered constant
+        /// </summary>
+        /// <param name="cname">Name of constant</param>
+        /// <returns>Value of constant or null if none found.</returns>
         object LookupModConstant(string cname);
         Dictionary<string, object> GetConstants();
 
         // For use ONLY by the script API
         void RaiseEvent(UUID script, string id, string module, string command, string key);
     }
+
+    [AttributeUsage(AttributeTargets.Method)]
+    public class ScriptInvocationAttribute : Attribute
+    { }
+
+    [AttributeUsage(AttributeTargets.Field)]
+    public class ScriptConstantAttribute : Attribute
+    { }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/ISoundModule.cs b/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
index 6117a80..68af492 100644
--- a/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
@@ -32,9 +32,96 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface ISoundModule
     {
-        void PlayAttachedSound(UUID soundID, UUID ownerID, UUID objectID, double gain, Vector3 position, byte flags, float radius);
-        
+        /// <summary>
+        /// Maximum distance between a sound source and a recipient.
+        /// </summary>
+        float MaxDistance { get; }
+
+        /// <summary>
+        /// Play a sound from an object.
+        /// </summary>
+        /// <param name="soundID">Sound asset ID</param>
+        /// <param name="ownerID">Sound source owner</param>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="gain">Sound volume</param>
+        /// <param name="position">Sound source position</param>
+        /// <param name="flags">Sound flags</param>
+        /// <param name="radius">
+        /// Radius used to affect gain over distance.
+        /// </param>
+        void PlayAttachedSound(UUID soundID, UUID ownerID, UUID objectID,
+                double gain, Vector3 position, byte flags, float radius);
+
+        /// <summary>
+        /// Trigger a sound in the scene.
+        /// </summary>
+        /// <param name="soundId">Sound asset ID</param>
+        /// <param name="ownerID">Sound source owner</param>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="parentID">Sound source parent.</param>
+        /// <param name="gain">Sound volume</param>
+        /// <param name="position">Sound source position</param>
+        /// <param name="handle"></param>
+        /// <param name="radius">
+        /// Radius used to affect gain over distance.
+        /// </param>
         void TriggerSound(
-            UUID soundId, UUID ownerID, UUID objectID, UUID parentID, double gain, Vector3 position, UInt64 handle, float radius);
+                UUID soundId, UUID ownerID, UUID objectID, UUID parentID,
+                double gain, Vector3 position, UInt64 handle, float radius);
+
+        /// <summary>
+        /// Stop sounds eminating from an object.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        void StopSound(UUID objectID);
+
+        /// <summary>
+        /// Preload sound to viewers within range.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="soundID">Sound asset ID</param>
+        /// <param name="radius">
+        /// Radius used to determine which viewers should preload the sound.
+        /// </param>
+        void PreloadSound(UUID objectID, UUID soundID, float radius);
+
+        /// <summary>
+        /// Loop specified sound at specified volume with specified radius,
+        /// optionally declaring object as new sync master.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="soundID">Sound asset ID</param>
+        /// <param name="gain">Sound volume</param>
+        /// <param name="radius">Sound radius</param>
+        /// <param name="isMaster">Set object to sync master if true</param>
+        void LoopSound(UUID objectID, UUID soundID, double gain,
+                double radius, bool isMaster);
+
+        /// <summary>
+        /// Trigger or play an attached sound in this part's inventory.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="sound">Sound asset ID</param>
+        /// <param name="volume">Sound volume</param>
+        /// <param name="triggered">Triggered or not.</param>
+        /// <param name="flags"></param>
+        /// <param name="radius">Sound radius</param>
+        /// <param name="useMaster">Play using sound master</param>
+        /// <param name="isMaster">Play as sound master</param>
+        void SendSound(UUID objectID, UUID sound, double volume,
+                bool triggered, byte flags, float radius, bool useMaster,
+                bool isMaster);
+
+        /// <summary>
+        /// Trigger a sound to be played to all agents within an axis-aligned
+        /// bounding box.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="sound">Sound asset ID</param>
+        /// <param name="volume">Sound volume</param>
+        /// <param name="min">AABB bottom south-west corner</param>
+        /// <param name="max">AABB top north-east corner</param>
+        void TriggerSoundLimited(UUID objectID, UUID sound, double volume,
+                Vector3 min, Vector3 max);
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/ISunModule.cs b/OpenSim/Region/Framework/Interfaces/ISunModule.cs
index 819ae11..8231716 100644
--- a/OpenSim/Region/Framework/Interfaces/ISunModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISunModule.cs
@@ -29,7 +29,7 @@ using OpenMetaverse;
 
 namespace OpenSim.Region.Framework.Interfaces
 {
-    public interface ISunModule : IRegionModule
+    public interface ISunModule : INonSharedRegionModule
     {
         double GetSunParameter(string param);
 
diff --git a/OpenSim/Region/Framework/Interfaces/IUrlModule.cs b/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
index 457444c..79e9f9d 100644
--- a/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
@@ -39,6 +39,8 @@ namespace OpenSim.Region.Framework.Interfaces
         UUID RequestSecureURL(IScriptModule engine, SceneObjectPart host, UUID itemID);
         void ReleaseURL(string url);
         void HttpResponse(UUID request, int status, string body);
+        void HttpContentType(UUID request, string type);
+        
         string GetHttpHeader(UUID request, string header);
         int GetFreeUrls();
 
diff --git a/OpenSim/Region/Framework/Interfaces/IUserManagement.cs b/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
index 24cd069..f8088c3 100644
--- a/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
+++ b/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
@@ -1,4 +1,31 @@
-using System;
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using OpenMetaverse;
diff --git a/OpenSim/Region/Framework/Interfaces/IWindModule.cs b/OpenSim/Region/Framework/Interfaces/IWindModule.cs
index 10ecc32..4a26a71 100644
--- a/OpenSim/Region/Framework/Interfaces/IWindModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IWindModule.cs
@@ -29,7 +29,7 @@ using OpenMetaverse;
 
 namespace OpenSim.Region.Framework.Interfaces
 {
-    public interface IWindModule : IRegionModule
+    public interface IWindModule : INonSharedRegionModule
     {
         
         /// <summary>
diff --git a/OpenSim/Region/Framework/Interfaces/IWorldComm.cs b/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
index e8e375e..20e0199 100644
--- a/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
+++ b/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
@@ -45,6 +45,13 @@ namespace OpenSim.Region.Framework.Interfaces
         void Deactivate();
         void Activate();
         UUID GetID();
+
+        /// <summary>
+        /// Bitfield indicating which strings should be processed as regex.
+        /// 1 corresponds to IWorldCommListenerInfo::GetName()
+        /// 2 corresponds to IWorldCommListenerInfo::GetMessage()
+        /// </summary>
+        int RegexBitfield { get; }
     }
 
     public interface IWorldComm
@@ -60,7 +67,7 @@ namespace OpenSim.Region.Framework.Interfaces
         /// 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="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>
@@ -70,6 +77,23 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <returns>number of the scripts handle</returns>
         int Listen(uint LocalID, UUID itemID, UUID hostID, int channel, string name, UUID id, string msg);
 
+         /// <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>
+        /// <param name="regexBitfield">Bitfield indicating which strings should be processed as regex.</param>
+        /// <returns>number of the scripts handle</returns>
+        int Listen(uint LocalID, UUID itemID, UUID hostID, int channel, string name, UUID id, string msg, int regexBitfield);
+
         /// <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
diff --git a/OpenSim/Region/Framework/ModuleLoader.cs b/OpenSim/Region/Framework/ModuleLoader.cs
deleted file mode 100644
index 32ee674..0000000
--- a/OpenSim/Region/Framework/ModuleLoader.cs
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Reflection;
-using log4net;
-using Nini.Config;
-using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.Framework.Scenes;
-
-namespace OpenSim.Region.Framework
-{
-    public class ModuleLoader
-    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-
-        public Dictionary<string, Assembly> LoadedAssemblys = new Dictionary<string, Assembly>();
-
-        private readonly List<IRegionModule> m_loadedModules = new List<IRegionModule>();
-        private readonly Dictionary<string, IRegionModule> m_loadedSharedModules = new Dictionary<string, IRegionModule>();
-        private readonly IConfigSource m_config;
-
-        public ModuleLoader(IConfigSource config)
-        {
-            m_config = config;
-        }
-
-        public IRegionModule[] GetLoadedSharedModules
-        {
-            get
-            {
-                IRegionModule[] regionModules = new IRegionModule[m_loadedSharedModules.Count];
-                m_loadedSharedModules.Values.CopyTo(regionModules, 0);
-                return regionModules;
-            }
-        }
-
-        public List<IRegionModule> PickupModules(Scene scene, string moduleDir)
-        {
-            DirectoryInfo dir = new DirectoryInfo(moduleDir);
-            List<IRegionModule> modules = new List<IRegionModule>();
-
-            foreach (FileInfo fileInfo in dir.GetFiles("*.dll"))
-            {
-                modules.AddRange(LoadRegionModules(fileInfo.FullName, scene));
-            }
-            return modules;
-        }
-
-        public void LoadDefaultSharedModule(IRegionModule module)
-        {
-            if (m_loadedSharedModules.ContainsKey(module.Name))
-            {
-                m_log.ErrorFormat("[MODULES]: Module name \"{0}\" already exists in module list. Module not added!", module.Name);
-            }
-            else
-            {
-                m_loadedSharedModules.Add(module.Name, module);
-            }
-        }
-
-
-        public void InitialiseSharedModules(Scene scene)
-        {
-            foreach (IRegionModule module in m_loadedSharedModules.Values)
-            {
-                module.Initialise(scene, m_config);
-                scene.AddModule(module.Name, module); //should be doing this?
-            }
-        }
-
-        public void InitializeModule(IRegionModule module, Scene scene)
-        {
-            module.Initialise(scene, m_config);
-            scene.AddModule(module.Name, module);
-            m_loadedModules.Add(module);
-        }
-
-        /// <summary>
-        ///  Loads/initialises a Module instance that can be used by multiple Regions
-        /// </summary>
-        /// <param name="dllName"></param>
-        /// <param name="moduleName"></param>
-        public void LoadSharedModule(string dllName, string moduleName)
-        {
-            IRegionModule module = LoadModule(dllName, moduleName);
-
-            if (module != null)
-                LoadSharedModule(module);
-        }
-
-        /// <summary>
-        ///  Loads/initialises a Module instance that can be used by multiple Regions
-        /// </summary>
-        /// <param name="module"></param>
-        public void LoadSharedModule(IRegionModule module)
-        {
-            if (!m_loadedSharedModules.ContainsKey(module.Name))
-            {
-                m_loadedSharedModules.Add(module.Name, module);
-            }
-        }
-
-        public List<IRegionModule> LoadRegionModules(string dllName, Scene scene)
-        {
-            IRegionModule[] modules = LoadModules(dllName);
-            List<IRegionModule> initializedModules = new List<IRegionModule>();
-
-            if (modules.Length > 0)
-            {
-                m_log.InfoFormat("[MODULES]: Found Module Library [{0}]", dllName);
-                foreach (IRegionModule module in modules)
-                {
-                    if (!module.IsSharedModule)
-                    {
-                        m_log.InfoFormat("[MODULES]:    [{0}]: Initializing.", module.Name);
-                        InitializeModule(module, scene);
-                        initializedModules.Add(module);
-                    }
-                    else
-                    {
-                        m_log.InfoFormat("[MODULES]:    [{0}]: Loading Shared Module.", module.Name);
-                        LoadSharedModule(module);
-                    }
-                }
-            }
-            return initializedModules;
-        }
-
-        public void LoadRegionModule(string dllName, string moduleName, Scene scene)
-        {
-            IRegionModule module = LoadModule(dllName, moduleName);
-            if (module != null)
-            {
-                InitializeModule(module, scene);
-            }
-        }
-
-        /// <summary>
-        /// Loads a external Module (if not already loaded) and creates a new instance of it.
-        /// </summary>
-        /// <param name="dllName"></param>
-        /// <param name="moduleName"></param>
-        public IRegionModule LoadModule(string dllName, string moduleName)
-        {
-            IRegionModule[] modules = LoadModules(dllName);
-
-            foreach (IRegionModule module in modules)
-            {
-                if ((module != null) && (module.Name == moduleName))
-                {
-                    return module;
-                }
-            }
-
-            return null;
-        }
-
-        public IRegionModule[] LoadModules(string dllName)
-        {
-            //m_log.DebugFormat("[MODULES]: Looking for modules in {0}", dllName);
-            
-            List<IRegionModule> modules = new List<IRegionModule>();
-
-            Assembly pluginAssembly;
-            if (!LoadedAssemblys.TryGetValue(dllName, out pluginAssembly))
-            {
-                try
-                {
-                    pluginAssembly = Assembly.LoadFrom(dllName);
-                    LoadedAssemblys.Add(dllName, pluginAssembly);
-                }
-                catch (BadImageFormatException)
-                {
-                    //m_log.InfoFormat("[MODULES]: The file [{0}] is not a module assembly.", e.FileName);
-                }
-            }
-
-            if (pluginAssembly != null)
-            {
-                try
-                {
-                    foreach (Type pluginType in pluginAssembly.GetTypes())
-                    {
-                        if (pluginType.IsPublic)
-                        {
-                            if (!pluginType.IsAbstract)
-                            {
-                                if (pluginType.GetInterface("IRegionModule") != null)
-                                {
-                                    modules.Add((IRegionModule)Activator.CreateInstance(pluginType));
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (Exception e)
-                {
-                    m_log.ErrorFormat(
-                        "[MODULES]: Could not load types for plugin DLL {0}.  Exception {1} {2}", 
-                        pluginAssembly.FullName, e.Message, e.StackTrace);
-                    
-                    // justincc: Right now this is fatal to really get the user's attention
-                    // TomMeta: WTF? No, how about we /don't/ throw a fatal exception when there's no need to?
-                    //throw e;
-                }
-            }
-
-            return modules.ToArray();
-        }
-
-        public void PostInitialise()
-        {
-            foreach (IRegionModule module in m_loadedSharedModules.Values)
-            {
-                module.PostInitialise();
-            }
-
-            foreach (IRegionModule module in m_loadedModules)
-            {
-                module.PostInitialise();
-            }
-        }
-
-        public void ClearCache()
-        {
-            LoadedAssemblys.Clear();
-        }
-
-        public void UnloadModule(IRegionModule rm)
-        {
-            rm.Close();
-
-            m_loadedModules.Remove(rm);
-        }
-    }
-}
diff --git a/OpenSim/Region/Framework/Properties/AssemblyInfo.cs b/OpenSim/Region/Framework/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..9b504c0
--- /dev/null
+++ b/OpenSim/Region/Framework/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Region.Framework")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("d25e7aed-7f55-4bb8-9970-0d7d978ea8a5")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs b/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
index ad421ee..65ae445 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
@@ -41,6 +41,7 @@ namespace OpenSim.Region.Framework.Scenes.Animation
     {
 //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        private OpenSim.Framework.Animation m_implicitDefaultAnimation = new OpenSim.Framework.Animation();
         private OpenSim.Framework.Animation m_defaultAnimation = new OpenSim.Framework.Animation();
         private List<OpenSim.Framework.Animation> m_animations = new List<OpenSim.Framework.Animation>();
 
@@ -49,6 +50,11 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             get { return m_defaultAnimation; } 
         }
         
+        public OpenSim.Framework.Animation ImplicitDefaultAnimation 
+        {
+            get { return m_implicitDefaultAnimation; } 
+        }
+        
         public AnimationSet()
         {
             ResetDefaultAnimation();
@@ -119,11 +125,18 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             if (m_defaultAnimation.AnimID != animID)
             {
                 m_defaultAnimation = new OpenSim.Framework.Animation(animID, sequenceNum, objectID);
+                m_implicitDefaultAnimation = m_defaultAnimation;
                 return true;
             }
             return false;
         }
 
+        // Called from serialization only
+        public void SetImplicitDefaultAnimation(UUID animID, int sequenceNum, UUID objectID)
+        {
+            m_implicitDefaultAnimation = new OpenSim.Framework.Animation(animID, sequenceNum, objectID);
+        }
+
         protected bool ResetDefaultAnimation()
         {
             return TrySetDefaultAnimation("STAND", 1, UUID.Zero);
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 4a19c3b..5b1c9f4 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -47,30 +47,75 @@ namespace OpenSim.Region.Framework.Scenes
         
         public delegate void OnFrameDelegate();
 
+        /// <summary>
+        /// Triggered on each sim frame.
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.Update"/>
+        /// Core uses it for things like Sun, Wind & Clouds
+        /// The MRM module also uses it.
+        /// </remarks>
         public event OnFrameDelegate OnFrame;
 
         public delegate void ClientMovement(ScenePresence client);
 
+        /// <summary>
+        /// Trigerred when an agent moves.
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.Framework.Scenes.ScenePresence.HandleAgentUpdate"/>
+        /// prior to <see cref="OpenSim.Region.Framework.Scenes.ScenePresence.TriggerScenePresenceUpdated"/>
+        /// </remarks>
         public event ClientMovement OnClientMovement;
 
         public delegate void OnTerrainTaintedDelegate();
 
+        /// <summary>
+        /// Triggered if the terrain has been edited
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.CoreModules.World.Terrain.CheckForTerrainUpdates"/>
+        /// after it determines that an update has been made.
+        /// </remarks>
         public event OnTerrainTaintedDelegate OnTerrainTainted;
 
         public delegate void OnTerrainTickDelegate();
 
-        public delegate void OnTerrainUpdateDelegate();
-
+        /// <summary>
+        /// Triggered if the terrain has been edited
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.UpdateTerrain"/>
+        /// but is used by core solely to update the physics engine.
+        /// </remarks>
         public event OnTerrainTickDelegate OnTerrainTick;
 
+        public delegate void OnTerrainUpdateDelegate();
+
         public event OnTerrainUpdateDelegate OnTerrainUpdate;
 
         public delegate void OnBackupDelegate(ISimulationDataService datastore, bool forceBackup);
 
+        /// <summary>
+        /// Triggered when a region is backed up/persisted to storage
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.Backup"/>
+        /// and is fired before the persistence occurs.
+        /// </remarks>
         public event OnBackupDelegate OnBackup;
 
         public delegate void OnClientConnectCoreDelegate(IClientCore client);
 
+        /// <summary>
+        /// Triggered when a new client connects to the scene.
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="TriggerOnNewClient"/>,
+        /// which checks if an instance of <see cref="OpenSim.Framework.IClientAPI"/>
+        /// also implements <see cref="OpenSim.Framework.Client.IClientCore"/> and as such,
+        /// is not triggered by <see cref="OpenSim.Region.OptionalModules.World.NPC">NPCs</see>.
+        /// </remarks>
         public event OnClientConnectCoreDelegate OnClientConnect;
 
         public delegate void OnNewClientDelegate(IClientAPI client);
@@ -80,33 +125,96 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// This is triggered for both child and root agent client connections.
+        ///
         /// Triggered before OnClientLogin.
+        ///
+        /// This is triggered under per-agent lock.  So if you want to perform any long-running operations, please
+        /// do this on a separate thread.
         /// </remarks>
         public event OnNewClientDelegate OnNewClient;
 
         /// <summary>
         /// Fired if the client entering this sim is doing so as a new login
         /// </summary>
+        /// <remarks>
+        /// This is triggered under per-agent lock.  So if you want to perform any long-running operations, please
+        /// do this on a separate thread.
+        /// </remarks>
         public event Action<IClientAPI> OnClientLogin;
 
         public delegate void OnNewPresenceDelegate(ScenePresence presence);
 
+        /// <summary>
+        /// Triggered when a new presence is added to the scene
+        /// </summary>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/> which is used by both
+        /// <see cref="OpenSim.Framework.PresenceType.User">users</see> and <see cref="OpenSim.Framework.PresenceType.Npc">NPCs</see>
+        /// </remarks>
         public event OnNewPresenceDelegate OnNewPresence;
 
         public delegate void OnRemovePresenceDelegate(UUID agentId);
 
+        /// <summary>
+        /// Triggered when a presence is removed from the scene
+        /// </summary>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/> which is used by both
+        /// <see cref="OpenSim.Framework.PresenceType.User">users</see> and <see cref="OpenSim.Framework.PresenceType.Npc">NPCs</see>
+        /// 
+        /// Triggered under per-agent lock.  So if you want to perform any long-running operations, please
+        /// do this on a separate thread.
+        /// </remarks>
         public event OnRemovePresenceDelegate OnRemovePresence;
 
         public delegate void OnParcelPrimCountUpdateDelegate();
 
+        /// <summary>
+        /// Triggered whenever the prim count may have been altered, or prior
+        /// to an action that requires the current prim count to be accurate.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerParcelPrimCountUpdate"/> in
+        /// <see cref="OpenSim.OpenSimBase.CreateRegion"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.EventManagerOnRequestParcelPrimCountUpdate"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.ClientOnParcelObjectOwnerRequest"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandObject.GetPrimsFree"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandObject.UpdateLandSold"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandObject.DeedToGroup"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandObject.SendLandUpdateToClient"/>
+        /// </remarks>
         public event OnParcelPrimCountUpdateDelegate OnParcelPrimCountUpdate;
 
         public delegate void OnParcelPrimCountAddDelegate(SceneObjectGroup obj);
 
+        /// <summary>
+        /// Triggered in response to <see cref="OnParcelPrimCountUpdate"/> for
+        /// objects that actually contribute to parcel prim count.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerParcelPrimCountAdd"/> in
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.EventManagerOnParcelPrimCountUpdate"/>
+        /// </remarks>
         public event OnParcelPrimCountAddDelegate OnParcelPrimCountAdd;
 
         public delegate void OnPluginConsoleDelegate(string[] args);
 
+        /// <summary>
+        /// Triggered after <see cref="OpenSim.IApplicationPlugin.PostInitialise"/>
+        /// has been called for all <see cref="OpenSim.IApplicationPlugin"/>
+        /// loaded via <see cref="OpenSim.OpenSimBase.LoadPlugins"/>.
+        /// Handlers for this event are typically used to parse the arguments
+        /// from <see cref="OnPluginConsoleDelegate"/> in order to process or
+        /// filter the arguments and pass them onto <see cref="OpenSim.Region.CoreModules.Framework.InterfaceCommander.Commander.ProcessConsoleCommand"/>
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerOnPluginConsole"/> in
+        /// <see cref="Scene.SendCommandToPlugins"/> via
+        /// <see cref="SceneManager.SendCommandToPluginModules"/> via
+        /// <see cref="OpenSim.OpenSimBase.HandleCommanderCommand"/> via
+        /// <see cref="OpenSim.OpenSimBase.AddPluginCommands"/> via
+        /// <see cref="OpenSim.OpenSimBase.StartupSpecific"/>
+        /// </remarks>
         public event OnPluginConsoleDelegate OnPluginConsole;
 
         /// <summary>
@@ -121,8 +229,28 @@ namespace OpenSim.Region.Framework.Scenes
 
         public delegate void OnSetRootAgentSceneDelegate(UUID agentID, Scene scene);
 
+        /// <summary>
+        /// Triggered before the grunt work for adding a root agent to a
+        /// scene has been performed (resuming attachment scripts, physics,
+        /// animations etc.)
+        /// </summary>
+        /// <remarks>
+        /// Triggered before <see cref="OnMakeRootAgent"/>
+        /// by <see cref="TriggerSetRootAgentScene"/>
+        /// in <see cref="ScenePresence.MakeRootAgent"/>
+        /// via <see cref="Scene.AgentCrossing"/>
+        /// and <see cref="ScenePresence.CompleteMovement"/>
+        /// </remarks>
         public event OnSetRootAgentSceneDelegate OnSetRootAgentScene;
 
+        /// <summary>
+        /// Triggered after parcel properties have been updated.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerOnParcelPropertiesUpdateRequest"/> in
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.ClientOnParcelPropertiesUpdateRequest"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.ProcessPropertiesUpdate"/>
+        /// </remarks>
         public event ParcelPropertiesUpdateRequest OnParcelPropertiesUpdateRequest;
 
         /// <summary>
@@ -137,13 +265,45 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Fired when an object is touched/grabbed.
         /// </summary>
+        /// <remarks>
         /// The originalID is the local ID of the part that was actually touched.  The localID itself is always that of
         /// the root part.
+        /// Triggerd in response to <see cref="OpenSim.Framework.IClientAPI.OnGrabObject"/>
+        /// via <see cref="TriggerObjectGrab"/>
+        /// in <see cref="Scene.ProcessObjectGrab"/>
+        /// </remarks>
         public event ObjectGrabDelegate OnObjectGrab;
         public delegate void ObjectGrabDelegate(uint localID, uint originalID, Vector3 offsetPos, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs);
         
+        /// <summary>
+        /// Triggered when an object is being touched/grabbed continuously.
+        /// </summary>
+        /// <remarks>
+        /// Triggered in response to <see cref="OpenSim.Framework.IClientAPI.OnGrabUpdate"/>
+        /// via <see cref="TriggerObjectGrabbing"/>
+        /// in <see cref="Scene.ProcessObjectGrabUpdate"/>
+        /// </remarks>
         public event ObjectGrabDelegate OnObjectGrabbing;
+
+        /// <summary>
+        /// Triggered when an object stops being touched/grabbed.
+        /// </summary>
+        /// <remarks>
+        /// Triggered in response to <see cref="OpenSim.Framework.IClientAPI.OnDeGrabObject"/>
+        /// via <see cref="TriggerObjectDeGrab"/>
+        /// in <see cref="Scene.ProcessObjectDeGrab"/>
+        /// </remarks>
         public event ObjectDeGrabDelegate OnObjectDeGrab;
+
+        /// <summary>
+        /// Triggered when a script resets.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptReset"/>
+        /// in <see cref="Scene.ProcessScriptReset"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnScriptReset"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleScriptReset"/>
+        /// </remarks>
         public event ScriptResetDelegate OnScriptReset;
 
         public event OnPermissionErrorDelegate OnPermissionError;
@@ -153,29 +313,105 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// Occurs after OnNewScript.
+        /// Triggered by <see cref="TriggerRezScript"/>
+        /// in <see cref="SceneObjectPartInventory.CreateScriptInstance"/>
         /// </remarks>
         public event NewRezScript OnRezScript;
         public delegate void NewRezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine, int stateSource);
 
         public delegate void RemoveScript(uint localID, UUID itemID);
+
+        /// <summary>
+        /// Triggered when a script is removed from an object.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerRemoveScript"/>
+        /// in <see cref="Scene.RemoveTaskInventory"/>,
+        /// <see cref="Scene.CreateAgentInventoryItemFromTask"/>,
+        /// <see cref="SceneObjectPartInventory.RemoveScriptInstance"/>,
+        /// <see cref="SceneObjectPartInventory.RemoveInventoryItem"/>
+        /// </remarks>
         public event RemoveScript OnRemoveScript;
 
         public delegate void StartScript(uint localID, UUID itemID);
+
+        /// <summary>
+        /// Triggered when a script starts.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerStartScript"/>
+        /// in <see cref="Scene.SetScriptRunning"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnSetScriptRunning"/>,
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.HandleSetScriptRunning"/>
+        /// </remarks>
         public event StartScript OnStartScript;
 
         public delegate void StopScript(uint localID, UUID itemID);
+
+        /// <summary>
+        /// Triggered when a script stops.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerStopScript"/>,
+        /// in <see cref="SceneObjectPartInventory.CreateScriptInstance"/>,
+        /// <see cref="SceneObjectPartInventory.StopScriptInstance"/>,
+        /// <see cref="Scene.SetScriptRunning"/>
+        /// </remarks>
         public event StopScript OnStopScript;
 
         public delegate bool SceneGroupMoved(UUID groupID, Vector3 delta);
+
+        /// <summary>
+        /// Triggered when an object is moved.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerGroupMove"/>
+        /// in <see cref="SceneObjectGroup.UpdateGroupPosition"/>,
+        /// <see cref="SceneObjectGroup.GrabMovement"/>
+        /// </remarks>
         public event SceneGroupMoved OnSceneGroupMove;
 
         public delegate void SceneGroupGrabed(UUID groupID, Vector3 offset, UUID userID);
+
+        /// <summary>
+        /// Triggered when an object is grabbed.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerGroupGrab"/>
+        /// in <see cref="SceneObjectGroup.OnGrabGroup"/>
+        /// via <see cref="SceneObjectGroup.ObjectGrabHandler"/>
+        /// via <see cref="Scene.ProcessObjectGrab"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnGrabObject"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleObjectGrab"/>
+        /// </remarks>
         public event SceneGroupGrabed OnSceneGroupGrab;
 
         public delegate bool SceneGroupSpinStarted(UUID groupID);
+
+        /// <summary>
+        /// Triggered when an object starts to spin.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerGroupSpinStart"/>
+        /// in <see cref="SceneObjectGroup.SpinStart"/>
+        /// via <see cref="SceneGraph.SpinStart"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnSpinStart"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleObjectSpinStart"/>
+        /// </remarks>
         public event SceneGroupSpinStarted OnSceneGroupSpinStart;
 
         public delegate bool SceneGroupSpun(UUID groupID, Quaternion rotation);
+
+        /// <summary>
+        /// Triggered when an object is being spun.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerGroupSpin"/>
+        /// in <see cref="SceneObjectGroup.SpinMovement"/>
+        /// via <see cref="SceneGraph.SpinObject"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnSpinUpdate"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleObjectSpinUpdate"/>
+        /// </remarks>
         public event SceneGroupSpun OnSceneGroupSpin;
 
         public delegate void LandObjectAdded(ILandObject newParcel);
@@ -204,6 +440,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// At the point of firing, the scene still contains the client's scene presence.
+        ///
+        /// This is triggered under per-agent lock.  So if you want to perform any long-running operations, please
+        /// do this on a separate thread.
         /// </remarks>
         public event ClientClosed OnClientClosed;
 
@@ -214,6 +453,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// Occurs before OnRezScript
+        /// Triggered by <see cref="TriggerNewScript"/>
+        /// in <see cref="Scene.RezScriptFromAgentInventory"/>,
+        /// <see cref="Scene.RezNewScript"/>
         /// </remarks>
         public event NewScript OnNewScript;
 
@@ -248,6 +490,12 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// Triggered after the scene receives a client's upload of an updated script and has stored it in an asset.
+        /// Triggered by <see cref="TriggerUpdateScript"/>
+        /// in <see cref="Scene.CapsUpdateTaskInventoryScriptAsset"/>
+        /// via <see cref="Scene.CapsUpdateTaskInventoryScriptAsset"/>
+        /// via <see cref="OpenSim.Region.ClientStack.Linden.BunchOfCaps.TaskScriptUpdated"/>
+        /// via <see cref="OpenSim.Region.ClientStack.Linden.TaskInventoryScriptUpdater.OnUpLoad"/>
+        /// via <see cref="OpenSim.Region.ClientStack.Linden.TaskInventoryScriptUpdater.uploaderCaps"/>
         /// </remarks>
         public event UpdateScript OnUpdateScript;
         
@@ -273,48 +521,203 @@ namespace OpenSim.Region.Framework.Scenes
         } 
 
         /// <summary>
+        /// Triggered when some scene object properties change.
+        /// </summary>
+        /// <remarks>
         /// ScriptChangedEvent is fired when a scene object property that a script might be interested 
         /// in (such as color, scale or inventory) changes.  Only enough information sent is for the LSL changed event.
         /// This is not an indication that the script has changed (see OnUpdateScript for that). 
         /// This event is sent to a script to tell it that some property changed on 
         /// the object the script is in. See http://lslwiki.net/lslwiki/wakka.php?wakka=changed .
-        /// </summary>
+        /// Triggered by <see cref="TriggerOnScriptChangedEvent"/>
+        /// in <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.TeleportAgentWithinRegion"/>,
+        /// <see cref="SceneObjectPart.TriggerScriptChangedEvent"/>
+        /// </remarks>
         public event ScriptChangedEvent OnScriptChangedEvent;
         public delegate void ScriptChangedEvent(uint localID, uint change);
 
         public delegate void ScriptControlEvent(UUID item, UUID avatarID, uint held, uint changed);
+
+        /// <summary>
+        /// Triggered when a script receives control input from an agent.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerControlEvent"/>
+        /// in <see cref="ScenePresence.SendControlsToScripts"/>
+        /// via <see cref="ScenePresence.HandleAgentUpdate"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnAgentUpdate"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleAgentUpdate"/>
+        /// </remarks>
         public event ScriptControlEvent OnScriptControlEvent;
 
         public delegate void ScriptAtTargetEvent(uint localID, uint handle, Vector3 targetpos, Vector3 atpos);
+
+        /// <summary>
+        /// Triggered when an object has arrived within a tolerance distance
+        /// of a motion target.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerAtTargetEvent"/>
+        /// in <see cref="SceneObjectGroup.checkAtTargets"/>
+        /// via <see cref="SceneObjectGroup.ScheduleGroupForFullUpdate"/>,
+        /// <see cref="Scene.CheckAtTargets"/> via <see cref="Scene.Update"/>
+        /// </remarks>
         public event ScriptAtTargetEvent OnScriptAtTargetEvent;
 
         public delegate void ScriptNotAtTargetEvent(uint localID);
+
+        /// <summary>
+        /// Triggered when an object has a motion target but has not arrived
+        /// within a tolerance distance.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerNotAtTargetEvent"/>
+        /// in <see cref="SceneObjectGroup.checkAtTargets"/>
+        /// via <see cref="SceneObjectGroup.ScheduleGroupForFullUpdate"/>,
+        /// <see cref="Scene.CheckAtTargets"/> via <see cref="Scene.Update"/>
+        /// </remarks>
         public event ScriptNotAtTargetEvent OnScriptNotAtTargetEvent;
 
         public delegate void ScriptAtRotTargetEvent(uint localID, uint handle, Quaternion targetrot, Quaternion atrot);
+
+        /// <summary>
+        /// Triggered when an object has arrived within a tolerance rotation
+        /// of a rotation target.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerAtRotTargetEvent"/>
+        /// in <see cref="SceneObjectGroup.checkAtTargets"/>
+        /// via <see cref="SceneObjectGroup.ScheduleGroupForFullUpdate"/>,
+        /// <see cref="Scene.CheckAtTargets"/> via <see cref="Scene.Update"/>
+        /// </remarks>
         public event ScriptAtRotTargetEvent OnScriptAtRotTargetEvent;
 
         public delegate void ScriptNotAtRotTargetEvent(uint localID);
+
+        /// <summary>
+        /// Triggered when an object has a rotation target but has not arrived
+        /// within a tolerance rotation.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerNotAtRotTargetEvent"/>
+        /// in <see cref="SceneObjectGroup.checkAtTargets"/>
+        /// via <see cref="SceneObjectGroup.ScheduleGroupForFullUpdate"/>,
+        /// <see cref="Scene.CheckAtTargets"/> via <see cref="Scene.Update"/>
+        /// </remarks>
         public event ScriptNotAtRotTargetEvent OnScriptNotAtRotTargetEvent;
 
         public delegate void ScriptColliding(uint localID, ColliderArgs colliders);
+
+        /// <summary>
+        /// Triggered when a physical collision has started between a prim
+        /// and something other than the region terrain.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptCollidingStart"/>
+        /// in <see cref="SceneObjectPart.SendCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptColliderStart;
+
+        /// <summary>
+        /// Triggered when something that previously collided with a prim has
+        /// not stopped colliding with it.
+        /// </summary>
+        /// <remarks>
+        /// <seealso cref="OnScriptColliderStart"/>
+        /// Triggered by <see cref="TriggerScriptColliding"/>
+        /// in <see cref="SceneObjectPart.SendCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptColliding;
+
+        /// <summary>
+        /// Triggered when something that previously collided with a prim has
+        /// stopped colliding with it.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptCollidingEnd"/>
+        /// in <see cref="SceneObjectPart.SendCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptCollidingEnd;
+
+        /// <summary>
+        /// Triggered when a physical collision has started between an object
+        /// and the region terrain.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptLandCollidingStart"/>
+        /// in <see cref="SceneObjectPart.SendLandCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptLandColliderStart;
+
+        /// <summary>
+        /// Triggered when an object that previously collided with the region
+        /// terrain has not yet stopped colliding with it.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptLandColliding"/>
+        /// in <see cref="SceneObjectPart.SendLandCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptLandColliding;
+
+        /// <summary>
+        /// Triggered when an object that previously collided with the region
+        /// terrain has stopped colliding with it.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptLandCollidingEnd"/>
+        /// in <see cref="SceneObjectPart.SendLandCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptLandColliderEnd;
 
         public delegate void OnMakeChildAgentDelegate(ScenePresence presence);
+
+        /// <summary>
+        /// Triggered when an agent has been made a child agent of a scene.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerOnMakeChildAgent"/>
+        /// in <see cref="ScenePresence.MakeChildAgent"/>
+        /// via <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.CrossAgentToNewRegionAsync"/>,
+        /// <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.DoTeleport"/>,
+        /// <see cref="OpenSim.Region.CoreModules.InterGrid.KillAUser.ShutdownNoLogout"/>
+        /// </remarks>
         public event OnMakeChildAgentDelegate OnMakeChildAgent;
 
         public delegate void OnSaveNewWindlightProfileDelegate();
         public delegate void OnSendNewWindlightProfileTargetedDelegate(RegionLightShareData wl, UUID user);
 
         /// <summary>
+        /// Triggered after the grunt work for adding a root agent to a
+        /// scene has been performed (resuming attachment scripts, physics,
+        /// animations etc.)
+        /// </summary>
+        /// <remarks>
         /// This event is on the critical path for transferring an avatar from one region to another.  Try and do
         /// as little work on this event as possible, or do work asynchronously.
-        /// </summary>
+        /// Triggered after <see cref="OnSetRootAgentScene"/>
+        /// by <see cref="TriggerOnMakeRootAgent"/>
+        /// in <see cref="ScenePresence.MakeRootAgent"/>
+        /// via <see cref="Scene.AgentCrossing"/>
+        /// and <see cref="ScenePresence.CompleteMovement"/>
+        /// </remarks>
         public event Action<ScenePresence> OnMakeRootAgent;
         
         public event OnSendNewWindlightProfileTargetedDelegate OnSendNewWindlightProfileTargeted;
@@ -340,9 +743,17 @@ namespace OpenSim.Region.Framework.Scenes
         public event AvatarKillData OnAvatarKilled;
         public delegate void AvatarKillData(uint KillerLocalID, ScenePresence avatar);
 
-//        public delegate void ScriptTimerEvent(uint localID, double timerinterval);
-
-//        public event ScriptTimerEvent OnScriptTimerEvent;
+        /*
+        public delegate void ScriptTimerEvent(uint localID, double timerinterval);
+        /// <summary>
+        /// Used to be triggered when the LSL timer event fires.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerTimerEvent"/>
+        /// via <see cref="SceneObjectPart.handleTimerAccounting"/>
+        /// </remarks>
+        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);
@@ -352,12 +763,27 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Triggered when an object is added to the scene.
         /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerObjectAddedToScene"/>
+        /// in <see cref="Scene.AddNewSceneObject"/>,
+        /// <see cref="Scene.DuplicateObject"/>,
+        /// <see cref="Scene.doObjectDuplicateOnRay"/>
+        /// </remarks>
         public event Action<SceneObjectGroup> OnObjectAddedToScene;
 
         /// <summary>
-        /// Triggered when an object is removed from the scene.
+        /// Delegate for <see cref="OnObjectBeingRemovedFromScene"/>
         /// </summary>
+        /// <param name="obj">The object being removed from the scene</param>
         public delegate void ObjectBeingRemovedFromScene(SceneObjectGroup obj);
+
+        /// <summary>
+        /// Triggered when an object is removed from the scene.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerObjectBeingRemovedFromScene"/>
+        /// in <see cref="Scene.DeleteSceneObject"/>
+        /// </remarks>
         public event ObjectBeingRemovedFromScene OnObjectBeingRemovedFromScene;
 
         public delegate void NoticeNoLandDataFromStorage();
@@ -373,6 +799,20 @@ namespace OpenSim.Region.Framework.Scenes
         public event RequestParcelPrimCountUpdate OnRequestParcelPrimCountUpdate;
 
         public delegate void ParcelPrimCountTainted();
+
+        /// <summary>
+        /// Triggered when the parcel prim count has been altered.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerParcelPrimCountTainted"/> in
+        /// <see cref="OpenSim.Region.CoreModules.Avatar.Attachments.AttachmentsModule.DetachSingleAttachmentToGround"/>,
+        /// <see cref="OpenSim.Region.CoreModules.Avatar.Attachments.AttachmentsModule.AttachToAgent"/>,
+        /// <see cref="Scene.DeleteSceneObject"/>,
+        /// <see cref="Scene.SelectPrim"/>,
+        /// <see cref="Scene.DeselectPrim"/>,
+        /// <see cref="SceneObjectGroup.UpdatePrimFlags"/>,
+        /// <see cref="SceneObjectGroup.AbsolutePosition"/>
+        /// </remarks>
         public event ParcelPrimCountTainted OnParcelPrimCountTainted;
         public event GetScriptRunning OnGetScriptRunning;
 
@@ -436,7 +876,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// the scripts may not have started yet
         /// Message is non empty string if there were problems loading the oar file
         /// </summary>
-        public delegate void OarFileLoaded(Guid guid, string message);
+        public delegate void OarFileLoaded(Guid guid, List<UUID> loadedScenes, string message);
         public event OarFileLoaded OnOarFileLoaded;
         
         /// <summary>
@@ -489,10 +929,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="copy"></param>
         /// <param name="original"></param>
         /// <param name="userExposed">True if the duplicate will immediately be in the scene, false otherwise</param>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.SceneObjectPart.Copy"/>
+        /// </remarks>
         public event SceneObjectPartCopyDelegate OnSceneObjectPartCopy;
         public delegate void SceneObjectPartCopyDelegate(SceneObjectPart copy, SceneObjectPart original, bool userExposed);
 
-        public delegate void SceneObjectPartUpdated(SceneObjectPart sop);
+        public delegate void SceneObjectPartUpdated(SceneObjectPart sop, bool full);
         public event SceneObjectPartUpdated OnSceneObjectPartUpdated;
 
         public delegate void ScenePresenceUpdated(ScenePresence sp);
@@ -530,9 +973,28 @@ namespace OpenSim.Region.Framework.Scenes
         public event PrimsLoaded OnPrimsLoaded;
 
         public delegate void TeleportStart(IClientAPI client, GridRegion destination, GridRegion finalDestination, uint teleportFlags, bool gridLogout);
+
+        /// <summary>
+        /// Triggered when a teleport starts
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerTeleportStart"/>
+        /// in <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.CreateAgent"/>
+        /// and <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.HGEntityTransferModule.CreateAgent"/>
+        /// via <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.DoTeleport"/>
+        /// </remarks>
         public event TeleportStart OnTeleportStart;
 
         public delegate void TeleportFail(IClientAPI client, bool gridLogout);
+
+        /// <summary>
+        /// Trigered when a teleport fails.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerTeleportFail"/>
+        /// in <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.Fail"/>
+        /// via <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.DoTeleport"/>
+        /// </remarks>
         public event TeleportFail OnTeleportFail;
 
         public class MoneyTransferArgs : EventArgs
@@ -540,7 +1002,9 @@ namespace OpenSim.Region.Framework.Scenes
             public UUID sender;
             public UUID receiver;
 
-            // Always false. The SL protocol sucks.
+            /// <summary>
+            /// Always false. The SL protocol sucks.
+            /// </summary>
             public bool authenticated = false;
 
             public int amount;
@@ -597,8 +1061,29 @@ namespace OpenSim.Region.Framework.Scenes
 
         public delegate void LandBuy(Object sender, LandBuyArgs e);
 
+        /// <summary>
+        /// Triggered when an attempt to transfer grid currency occurs
+        /// </summary>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.ProcessMoneyTransferRequest"/>
+        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.SubscribeToClientGridEvents"/>
+        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.SubscribeToClientEvents"/>
+        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/>
+        /// </remarks>
         public event MoneyTransferEvent OnMoneyTransfer;
+
+        /// <summary>
+        /// Triggered after after <see cref="OnValidateLandBuy"/>
+        /// </summary>
         public event LandBuy OnLandBuy;
+
+        /// <summary>
+        /// Triggered to allow or prevent a real estate transaction
+        /// </summary>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.ProcessParcelBuy"/>
+        /// <seealso cref="OpenSim.Region.OptionalModules.World.MoneyModule.SampleMoneyModule.ValidateLandBuy"/>
+        /// </remarks>
         public event LandBuy OnValidateLandBuy;
 
         public void TriggerOnAttach(uint localID, UUID itemID, UUID avatarID)
@@ -2035,7 +2520,11 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        // this lets us keep track of nasty script events like timer, etc.
+        /// <summary>
+        /// this lets us keep track of nasty script events like timer, etc.
+        /// </summary>
+        /// <param name="objLocalID"></param>
+        /// <param name="Interval"></param>
         public void TriggerTimerEvent(uint objLocalID, double Interval)
         {
             throw new NotImplementedException("TriggerTimerEvent was thought to be not used anymore and the registration for the event from scene object part has been commented out due to a memory leak");
@@ -2097,7 +2586,7 @@ namespace OpenSim.Region.Framework.Scenes
             return 6;
         }
 
-        public void TriggerOarFileLoaded(Guid requestId, string message)
+        public void TriggerOarFileLoaded(Guid requestId, List<UUID> loadedScenes, string message)
         {
             OarFileLoaded handlerOarFileLoaded = OnOarFileLoaded;
             if (handlerOarFileLoaded != null)
@@ -2106,7 +2595,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     try
                     {
-                        d(requestId, message);
+                        d(requestId, loadedScenes, message);
                     }
                     catch (Exception e)
                     {
@@ -2391,7 +2880,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void TriggerSceneObjectPartUpdated(SceneObjectPart sop)
+        public void TriggerSceneObjectPartUpdated(SceneObjectPart sop, bool full)
         {
             SceneObjectPartUpdated handler = OnSceneObjectPartUpdated;
             if (handler != null)
@@ -2400,7 +2889,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     try
                     {
-                        d(sop);
+                        d(sop, full);
                     }
                     catch (Exception e)
                     {
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 906c1ee..c9d1205 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -93,7 +93,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void StartScripts()
         {
-            m_log.InfoFormat("[SCENE]: Starting scripts in {0}, please wait.", RegionInfo.RegionName);
+//            m_log.InfoFormat("[SCENE]: Starting scripts in {0}, please wait.", RegionInfo.RegionName);
 
             IScriptModule[] engines = RequestModuleInterfaces<IScriptModule>();
 
@@ -1469,7 +1469,7 @@ namespace OpenSim.Region.Framework.Scenes
             return newFolderID;
         }
 
-        private void SendInventoryUpdate(IClientAPI client, InventoryFolderBase folder, bool fetchFolders, bool fetchItems)
+        public void SendInventoryUpdate(IClientAPI client, InventoryFolderBase folder, bool fetchFolders, bool fetchItems)
         {
             if (folder == null)
                 return;
@@ -1954,8 +1954,19 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public virtual void DeRezObjects(IClientAPI remoteClient, List<uint> localIDs,
-                UUID groupID, DeRezAction action, UUID destinationID)
+        /// <summary>
+        /// Derez one or more objects from the scene.
+        /// </summary>
+        /// <remarks>
+        /// Won't actually remove the scene object in the case where the object is being copied to a user inventory.
+        /// </remarks>
+        /// <param name='remoteClient'>Client requesting derez</param>
+        /// <param name='localIDs'>Local ids of root parts of objects to delete.</param>
+        /// <param name='groupID'>Not currently used.  Here because the client passes this to us.</param>
+        /// <param name='action'>DeRezAction</param>
+        /// <param name='destinationID'>User folder ID to place derezzed object</param>
+        public virtual void DeRezObjects(
+            IClientAPI remoteClient, List<uint> localIDs, UUID groupID, DeRezAction action, UUID destinationID)
         {
             // First, see of we can perform the requested action and
             // build a list of eligible objects
@@ -1997,6 +2008,9 @@ namespace OpenSim.Region.Framework.Scenes
                 // If child prims have invalid perms, fix them
                 grp.AdjustChildPrimPermissions();
 
+                // If child prims have invalid perms, fix them
+                grp.AdjustChildPrimPermissions();
+
                 if (remoteClient == null)
                 {
                     // Autoreturn has a null client. Nothing else does. So
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index e970543..ce6415a 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -38,8 +38,20 @@ namespace OpenSim.Region.Framework.Scenes
 {
     public partial class Scene
     {
+        /// <summary>
+        /// Send chat to listeners.
+        /// </summary>
+        /// <param name='message'></param>
+        /// <param name='type'>/param>
+        /// <param name='channel'></param>
+        /// <param name='fromPos'></param>
+        /// <param name='fromName'></param>
+        /// <param name='fromID'></param>
+        /// <param name='targetID'></param>
+        /// <param name='fromAgent'></param>
+        /// <param name='broadcast'></param>
         public void SimChat(byte[] message, ChatTypeEnum type, int channel, Vector3 fromPos, string fromName,
-                               UUID fromID, bool fromAgent, bool broadcast, UUID destination)
+                               UUID fromID, UUID targetID, bool fromAgent, bool broadcast)
         {
             OSChatMessage args = new OSChatMessage();
 
@@ -49,7 +61,7 @@ namespace OpenSim.Region.Framework.Scenes
             args.Position = fromPos;
             args.SenderUUID = fromID;
             args.Scene = this;
-            args.Destination = destination;
+            args.Destination = targetID;
 
             if (fromAgent)
             {
@@ -66,6 +78,10 @@ namespace OpenSim.Region.Framework.Scenes
             args.From = fromName;
             //args.
 
+//            m_log.DebugFormat(
+//                "[SCENE]: Sending message {0} on channel {1}, type {2} from {3}, broadcast {4}",
+//                args.Message.Replace("\n", "\\n"), args.Channel, args.Type, fromName, broadcast);
+
             if (broadcast)
                 EventManager.TriggerOnChatBroadcast(this, args);
             else
@@ -75,7 +91,7 @@ namespace OpenSim.Region.Framework.Scenes
         protected void SimChat(byte[] message, ChatTypeEnum type, int channel, Vector3 fromPos, string fromName,
                                UUID fromID, bool fromAgent, bool broadcast)
         {
-            SimChat(message, type, channel, fromPos, fromName, fromID, fromAgent, broadcast, UUID.Zero);
+            SimChat(message, type, channel, fromPos, fromName, fromID, UUID.Zero, fromAgent, broadcast);
         }
 
         /// <summary>
@@ -543,7 +559,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (!InventoryService.AddFolder(folder))
             {
                 m_log.WarnFormat(
-                     "[AGENT INVENTORY]: Failed to move create folder for user {0} {1}",
+                     "[AGENT INVENTORY]: Failed to create folder for user {0} {1}",
                      remoteClient.Name, remoteClient.AgentId);
             }
         }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 649d545..80d9f6e 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -80,6 +80,11 @@ namespace OpenSim.Region.Framework.Scenes
         public SynchronizeSceneHandler SynchronizeScene;
 
         /// <summary>
+        /// Used to prevent simultaneous calls to RemoveClient() for the same agent from interfering with each other.
+        /// </summary>
+        private object m_removeClientLock = new object();
+
+        /// <summary>
         /// Statistical information for this scene.
         /// </summary>
         public SimStatsReporter StatsReporter { get; private set; }
@@ -103,8 +108,31 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public bool CollidablePrims { get; private set; }
 
+        /// <summary>
+        /// Minimum value of the size of a non-physical prim in each axis
+        /// </summary>
+        public float m_minNonphys = 0.001f;
+
+        /// <summary>
+        /// Maximum value of the size of a non-physical prim in each axis
+        /// </summary>
         public float m_maxNonphys = 256;
+
+        /// <summary>
+        /// Minimum value of the size of a physical prim in each axis
+        /// </summary>
+        public float m_minPhys = 0.01f;
+
+        /// <summary>
+        /// Maximum value of the size of a physical prim in each axis
+        /// </summary>
         public float m_maxPhys = 10;
+
+        /// <summary>
+        /// Max prims an object will hold
+        /// </summary>
+        public int m_linksetCapacity = 0;
+
         public bool m_clampPrimSize;
         public bool m_trustBinaries;
         public bool m_allowScriptCrossings;
@@ -149,7 +177,6 @@ namespace OpenSim.Region.Framework.Scenes
         protected List<RegionInfo> m_regionRestartNotifyList = new List<RegionInfo>();
         protected List<RegionInfo> m_neighbours = new List<RegionInfo>();
         protected string m_simulatorVersion = "OpenSimulator Server";
-        protected ModuleLoader m_moduleLoader;
         protected AgentCircuitManager m_authenticateHandler;
         protected SceneCommunicationService m_sceneGridService;
         protected ISnmpModule m_snmpService = null;
@@ -285,6 +312,31 @@ namespace OpenSim.Region.Framework.Scenes
         }
         private volatile bool m_shuttingDown;
 
+        /// <summary>
+        /// Is the scene active?
+        /// </summary>
+        /// <remarks>
+        /// If false, maintenance and update loops are not being run.  Updates can still be triggered manually if
+        /// the scene is not active.
+        /// </remarks>
+        public bool Active
+        {
+            get { return m_active; }
+            set
+            {
+                if (value)
+                {
+                    if (!m_active)
+                        Start();
+                }
+                else
+                {
+                    m_active = false;
+                }
+            }
+        }
+        private volatile bool m_active;
+
 //        private int m_lastUpdate;
         private bool m_firstHeartbeat = true;
         
@@ -626,7 +678,7 @@ namespace OpenSim.Region.Framework.Scenes
         public Scene(RegionInfo regInfo, AgentCircuitManager authen,
                      SceneCommunicationService sceneGridService,
                      ISimulationDataService simDataService, IEstateDataService estateDataService,
-                     ModuleLoader moduleLoader, bool dumpAssetsToFile,
+                     bool dumpAssetsToFile,
                      IConfigSource config, string simulatorVersion)
             : this(regInfo)
         {
@@ -637,7 +689,6 @@ namespace OpenSim.Region.Framework.Scenes
             Random random = new Random();
 
             m_lastAllocatedLocalId = (uint)(random.NextDouble() * (double)(uint.MaxValue / 2)) + (uint)(uint.MaxValue / 4);
-            m_moduleLoader = moduleLoader;
             m_authenticateHandler = authen;
             m_sceneGridService = sceneGridService;
             m_SimulationDataService = simDataService;
@@ -746,12 +797,24 @@ namespace OpenSim.Region.Framework.Scenes
                     PhysicalPrims = startupConfig.GetBoolean("physical_prim", true);
                     CollidablePrims = startupConfig.GetBoolean("collidable_prim", true);
 
-                    m_maxNonphys = startupConfig.GetFloat("NonphysicalPrimMax", m_maxNonphys);
+                    m_minNonphys = startupConfig.GetFloat("NonPhysicalPrimMin", m_minNonphys);
+                    if (RegionInfo.NonphysPrimMin > 0)
+                    {
+                        m_minNonphys = RegionInfo.NonphysPrimMin;
+                    }
+
+                    m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", m_maxNonphys);
                     if (RegionInfo.NonphysPrimMax > 0)
                     {
                         m_maxNonphys = RegionInfo.NonphysPrimMax;
                     }
 
+                    m_minPhys = startupConfig.GetFloat("PhysicalPrimMin", m_minPhys);
+                    if (RegionInfo.PhysPrimMin > 0)
+                    {
+                        m_minPhys = RegionInfo.PhysPrimMin;
+                    }
+
                     m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", m_maxPhys);
 
                     if (RegionInfo.PhysPrimMax > 0)
@@ -759,6 +822,12 @@ namespace OpenSim.Region.Framework.Scenes
                         m_maxPhys = RegionInfo.PhysPrimMax;
                     }
 
+                    m_linksetCapacity = startupConfig.GetInt("LinksetPrims", m_linksetCapacity);
+                    if (RegionInfo.LinksetCapacity > 0)
+                    {
+                        m_linksetCapacity = RegionInfo.LinksetCapacity;
+                    }
+
                     SpawnPointRouting = startupConfig.GetString("SpawnPointRouting", "closest");
                     TelehubAllowLandmarks = startupConfig.GetBoolean("TelehubAllowLandmark", false);
 
@@ -784,13 +853,6 @@ namespace OpenSim.Region.Framework.Scenes
                     m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "XEngine");
                     m_log.InfoFormat("[SCENE]: Default script engine {0}", m_defaultScriptEngine);
 
-                    IConfig packetConfig = m_config.Configs["PacketPool"];
-                    if (packetConfig != null)
-                    {
-                        PacketPool.Instance.RecyclePackets = packetConfig.GetBoolean("RecyclePackets", true);
-                        PacketPool.Instance.RecycleDataBlocks = packetConfig.GetBoolean("RecycleDataBlocks", true);
-                    }
-
                     m_strictAccessControl = startupConfig.GetBoolean("StrictAccessControl", m_strictAccessControl);
                     m_seeIntoBannedRegion = startupConfig.GetBoolean("SeeIntoBannedRegion", m_seeIntoBannedRegion);
                     CombineRegions = startupConfig.GetBoolean("CombineContiguousRegions", false);
@@ -854,6 +916,8 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             // FIXME: Ultimately this should be in a module.
+            SendPeriodicAppearanceUpdates = true;
+            
             IConfig appearanceConfig = m_config.Configs["Appearance"];
             if (appearanceConfig != null)
             {
@@ -1151,6 +1215,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetSceneCoreDebug(Dictionary<string, string> options)
         {
+            if (options.ContainsKey("active"))
+            {
+                bool active;
+
+                if (bool.TryParse(options["active"], out active))
+                    Active = active;
+            }
+
             if (options.ContainsKey("scripting"))
             {
                 bool enableScripts = true;
@@ -1226,6 +1298,12 @@ namespace OpenSim.Region.Framework.Scenes
         // This is the method that shuts down the scene.
         public override void Close()
         {
+            if (m_shuttingDown)
+            {
+                m_log.WarnFormat("[SCENE]: Ignoring close request because already closing {0}", Name);
+                return;
+            }
+
             m_log.InfoFormat("[SCENE]: Closing down the single simulator: {0}", RegionInfo.RegionName);
 
             StatsReporter.Close();
@@ -1272,6 +1350,14 @@ namespace OpenSim.Region.Framework.Scenes
             m_log.Debug("[SCENE]: Graph close");
             m_sceneGraph.Close();
 
+            if (!GridService.DeregisterRegion(RegionInfo.RegionID))
+                m_log.WarnFormat("[SCENE]: Deregister from grid failed for region {0}", Name);
+
+            base.Close();
+
+            // XEngine currently listens to the EventManager.OnShutdown event to trigger script stop and persistence.
+            // Therefore. we must dispose of the PhysicsScene after this to prevent a window where script code can
+            // attempt to reference a null or disposed physics scene.
             if (PhysicsScene != null)
             {
                 m_log.Debug("[SCENE]: Dispose Physics");
@@ -1281,13 +1367,6 @@ namespace OpenSim.Region.Framework.Scenes
                 phys.Dispose();
                 phys = null;
             }
-
-            if (!GridService.DeregisterRegion(RegionInfo.RegionID))
-                m_log.WarnFormat("[SCENE]: Deregister from grid failed for region {0}", Name);
-
-            // call the base class Close method.
-            m_log.Debug("[SCENE]: Base close");
-            base.Close();
         }
 
         /// <summary>
@@ -1295,6 +1374,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void Start()
         {
+            m_active = true;
+
 //            m_log.DebugFormat("[SCENE]: Starting Heartbeat timer for {0}", RegionInfo.RegionName);
 
             //m_heartbeatTimer.Enabled = true;
@@ -1354,7 +1435,7 @@ namespace OpenSim.Region.Framework.Scenes
         #region Update Methods
 
         /// <summary>
-        /// Performs per-frame updates regularly
+        /// Activate the various loops necessary to continually update the scene.
         /// </summary>
         private void Heartbeat()
         {
@@ -1411,7 +1492,7 @@ namespace OpenSim.Region.Framework.Scenes
             List<Vector3> coarseLocations;
             List<UUID> avatarUUIDs;
 
-            while (!m_shuttingDown && (endRun == null || MaintenanceRun < endRun))
+            while (!m_shuttingDown && ((endRun == null && Active) || MaintenanceRun < endRun))
             {
                 runtc = Util.EnvironmentTickCount();
                 ++MaintenanceRun;
@@ -1473,7 +1554,7 @@ namespace OpenSim.Region.Framework.Scenes
             int sleepMS;
             int framestart;
 
-            while (!m_shuttingDown && (endFrame == null || Frame < endFrame))
+            while (!m_shuttingDown && ((endFrame == null && Active) || Frame < endFrame))
             {
                 framestart = Util.EnvironmentTickCount();
                 ++Frame;
@@ -1672,15 +1753,19 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void CheckAtTargets()
         {
-            List<SceneObjectGroup> objs = new List<SceneObjectGroup>();
+            List<SceneObjectGroup> objs = null;
+
             lock (m_groupsWithTargets)
             {
-                foreach (SceneObjectGroup grp in m_groupsWithTargets.Values)
-                    objs.Add(grp);
+                if (m_groupsWithTargets.Count != 0)
+                    objs = new List<SceneObjectGroup>(m_groupsWithTargets.Values);
             }
 
-            foreach (SceneObjectGroup entry in objs)
-                entry.checkAtTargets();
+            if (objs != null)
+            {
+                foreach (SceneObjectGroup entry in objs)
+                    entry.checkAtTargets();
+            }
         }
 
         /// <summary>
@@ -2193,10 +2278,14 @@ namespace OpenSim.Region.Framework.Scenes
         public bool AddRestoredSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates)
         {
-            bool result =  m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates);
-            if (result)
+            if (m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates))
+            {
                 sceneObject.IsDeleted = false;
-            return result;
+                EventManager.TriggerObjectAddedToScene(sceneObject);
+                return true;
+            }
+
+            return false;
         }
         
         /// <summary>
@@ -2837,77 +2926,89 @@ namespace OpenSim.Region.Framework.Scenes
 
         public override ISceneAgent AddNewClient(IClientAPI client, PresenceType type)
         {
+            ScenePresence sp;
+            bool vialogin;
+
             // Validation occurs in LLUDPServer
+            //
+            // XXX: A race condition exists here where two simultaneous calls to AddNewClient can interfere with
+            // each other.  In practice, this does not currently occur in the code.
             AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(client.CircuitCode);
 
-            bool vialogin
-                = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
-                    || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
-
-            CheckHeartbeat();
-
-            ScenePresence sp = GetScenePresence(client.AgentId);
-
-            // XXX: Not sure how good it is to add a new client if a scene presence already exists.  Possibly this
-            // could occur if a viewer crashes and relogs before the old client is kicked out.  But this could cause
-            // other problems, and possible the code calling AddNewClient() should ensure that no client is already
-            // connected.
-            if (sp == null)
-            {
-                m_log.DebugFormat(
-                    "[SCENE]: Adding new child scene presence {0} {1} to scene {2} at pos {3}",
-                    client.Name, client.AgentId, RegionInfo.RegionName, client.StartPos);
-
-                m_clientManager.Add(client);
-                SubscribeToClientEvents(client);
-
-                sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
-                m_eventManager.TriggerOnNewPresence(sp);
-
-                sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;
+            // We lock here on AgentCircuitData to prevent a race condition between the thread adding a new connection
+            // and a simultaneous one that removes it (as can happen if the client is closed at a particular point
+            // whilst connecting).
+            //
+            // It would be easier to lock across all NewUserConnection(), AddNewClient() and
+            // RemoveClient() calls for all agents, but this would allow a slow call (e.g. because of slow service
+            // response in some module listening to AddNewClient()) from holding up unrelated agent calls.
+            //
+            // In practice, the lock (this) in LLUDPServer.AddNewClient() currently lock across all
+            // AddNewClient() operations (though not other ops).
+            // In the future this can be relieved once locking per agent (not necessarily on AgentCircuitData) is improved.
+            lock (aCircuit)
+            {
+                vialogin
+                    = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
+                        || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
+    
+                CheckHeartbeat();
+    
+                sp = GetScenePresence(client.AgentId);
 
-                // The first agent upon login is a root agent by design.
-                // For this agent we will have to rez the attachments.
-                // All other AddNewClient calls find aCircuit.child to be true.
-                if (aCircuit.child == false)
+                // XXX: Not sure how good it is to add a new client if a scene presence already exists.  Possibly this
+                // could occur if a viewer crashes and relogs before the old client is kicked out.  But this could cause
+                // other problems, and possible the code calling AddNewClient() should ensure that no client is already
+                // connected.
+                if (sp == null)
                 {
-                    // We have to set SP to be a root agent here so that SP.MakeRootAgent() will later not try to
-                    // start the scripts again (since this is done in RezAttachments()).
-                    // XXX: This is convoluted.
-                    sp.IsChildAgent = false;
-
-                    if (AttachmentsModule != null)
-                        Util.FireAndForget(delegate(object o) { AttachmentsModule.RezAttachments(sp); });
+                    m_log.DebugFormat(
+                        "[SCENE]: Adding new child scene presence {0} {1} to scene {2} at pos {3}",
+                        client.Name, client.AgentId, RegionInfo.RegionName, client.StartPos);
+    
+                    m_clientManager.Add(client);
+                    SubscribeToClientEvents(client);
+    
+                    sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
+                    m_eventManager.TriggerOnNewPresence(sp);
+    
+                    sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;
+    
+                    // The first agent upon login is a root agent by design.
+                    // For this agent we will have to rez the attachments.
+                    // All other AddNewClient calls find aCircuit.child to be true.
+                    if (aCircuit.child == false)
+                    {
+                        // We have to set SP to be a root agent here so that SP.MakeRootAgent() will later not try to
+                        // start the scripts again (since this is done in RezAttachments()).
+                        // XXX: This is convoluted.
+                        sp.IsChildAgent = false;
+    
+                        if (AttachmentsModule != null)
+                            Util.FireAndForget(delegate(object o) { AttachmentsModule.RezAttachments(sp); });
+                    }
                 }
-            }
-            else
-            {
-                m_log.WarnFormat(
-                    "[SCENE]: Already found {0} scene presence for {1} in {2} when asked to add new scene presence",
-                    sp.IsChildAgent ? "child" : "root", sp.Name, RegionInfo.RegionName);
-            }
+                else
+                {
+                    m_log.WarnFormat(
+                        "[SCENE]: Already found {0} scene presence for {1} in {2} when asked to add new scene presence",
+                        sp.IsChildAgent ? "child" : "root", sp.Name, RegionInfo.RegionName);
+                }
+    
+                // We must set this here so that TriggerOnNewClient and TriggerOnClientLogin can determine whether the
+                // client is for a root or child agent.
+                client.SceneAgent = sp;
 
-            // We must set this here so that TriggerOnNewClient and TriggerOnClientLogin can determine whether the
-            // client is for a root or child agent.
-            client.SceneAgent = sp;
+                // Cache the user's name
+                CacheUserName(sp, aCircuit);
+    
+                EventManager.TriggerOnNewClient(client);
+                if (vialogin)
+                    EventManager.TriggerOnClientLogin(client);
+            }
 
             m_LastLogin = Util.EnvironmentTickCount();
 
-            // Cache the user's name
-            CacheUserName(sp, aCircuit);
-
-            EventManager.TriggerOnNewClient(client);
-            if (vialogin)
-            {
-                EventManager.TriggerOnClientLogin(client);
-                // Send initial parcel data
-/* this is done on TriggerOnNewClient by landmanegement respective event handler
-                Vector3 pos = sp.AbsolutePosition;
-                ILandObject land = LandChannel.GetLandObject(pos.X, pos.Y);
-                land.SendLandUpdateToClient(client);
-*/
-            }
-
             return sp;
         }
 
@@ -3447,110 +3548,132 @@ namespace OpenSim.Region.Framework.Scenes
         {
 //            CheckHeartbeat();
             bool isChildAgent = false;
-            ScenePresence avatar = GetScenePresence(agentID);
+            AgentCircuitData acd;
 
-            if (avatar == null)
+            lock (m_removeClientLock)
             {
-                m_log.WarnFormat(
-                    "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
-
-                return;
-            }
-
-            try
-            {
-                isChildAgent = avatar.IsChildAgent;
-
-                m_log.DebugFormat(
-                    "[SCENE]: Removing {0} agent {1} {2} from {3}",
-                    (isChildAgent ? "child" : "root"), avatar.Name, agentID, RegionInfo.RegionName);
+                acd = m_authenticateHandler.GetAgentCircuitData(agentID);
 
-                // Don't do this to root agents, it's not nice for the viewer
-                if (closeChildAgents && isChildAgent)
+                if (acd == null)
                 {
-                    // Tell a single agent to disconnect from the region.
-                    IEventQueue eq = RequestModuleInterface<IEventQueue>();
-                    if (eq != null)
-                    {
-                        eq.DisableSimulator(RegionInfo.RegionHandle, avatar.UUID);
-                    }
-                    else
-                    {
-                        avatar.ControllingClient.SendShutdownConnectionNotice();
-                    }
+                    m_log.ErrorFormat("[SCENE]: No agent circuit found for {0}, aborting Scene.RemoveClient", agentID);
+                    return;
                 }
-
-                // Only applies to root agents.
-                if (avatar.ParentID != 0)
+                else
                 {
-                    avatar.StandUp();
+                    // We remove the acd up here to avoid later race conditions if two RemoveClient() calls occurred
+                    // simultaneously.
+                    // We also need to remove by agent ID since NPCs will have no circuit code.
+                    m_authenticateHandler.RemoveCircuit(agentID);
                 }
+            }
 
-                m_sceneGraph.removeUserCount(!isChildAgent);
-
-                // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
-                // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
-                if (closeChildAgents && CapsModule != null)
-                    CapsModule.RemoveCaps(agentID);
-
-                // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
-                // this method is doing is HORRIBLE!!!
-                avatar.Scene.NeedSceneCacheClear(avatar.UUID);
-
-                if (closeChildAgents && !isChildAgent)
+            lock (acd)
+            {
+                ScenePresence avatar = GetScenePresence(agentID);
+    
+                if (avatar == null)
                 {
-                    List<ulong> regions = avatar.KnownRegionHandles;
-                    regions.Remove(RegionInfo.RegionHandle);
-                    m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
+                    m_log.WarnFormat(
+                        "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
+    
+                    return;
                 }
-
-                m_eventManager.TriggerClientClosed(agentID, this);
-                m_eventManager.TriggerOnRemovePresence(agentID);
-
-                if (!isChildAgent)
+    
+                try
                 {
-                    if (AttachmentsModule != null)
+                    isChildAgent = avatar.IsChildAgent;
+
+                    m_log.DebugFormat(
+                        "[SCENE]: Removing {0} agent {1} {2} from {3}",
+                        (isChildAgent ? "child" : "root"), avatar.Name, agentID, RegionInfo.RegionName);
+    
+                    // Don't do this to root agents, it's not nice for the viewer
+                    if (closeChildAgents && isChildAgent)
                     {
-                        AttachmentsModule.DeRezAttachments(avatar);
+                        // Tell a single agent to disconnect from the region.
+                        IEventQueue eq = RequestModuleInterface<IEventQueue>();
+                        if (eq != null)
+                        {
+                            eq.DisableSimulator(RegionInfo.RegionHandle, avatar.UUID);
+                        }
+                        else
+                        {
+                            avatar.ControllingClient.SendShutdownConnectionNotice();
+                        }
                     }
-
-                    ForEachClient(
-                        delegate(IClientAPI client)
+    
+                    // Only applies to root agents.
+                    if (avatar.ParentID != 0)
+                    {
+                        avatar.StandUp();
+                    }
+    
+                    m_sceneGraph.removeUserCount(!isChildAgent);
+    
+                    // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
+                    // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
+                    if (closeChildAgents && CapsModule != null)
+                        CapsModule.RemoveCaps(agentID);
+    
+//                    // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
+//                    // this method is doing is HORRIBLE!!!
+                    // Commented pending deletion since this method no longer appears to do anything at all
+//                    avatar.Scene.NeedSceneCacheClear(avatar.UUID);
+    
+                    if (closeChildAgents && !isChildAgent)
+                    {
+                        List<ulong> regions = avatar.KnownRegionHandles;
+                        regions.Remove(RegionInfo.RegionHandle);
+                        m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
+                    }
+    
+                    m_eventManager.TriggerClientClosed(agentID, this);
+                    m_eventManager.TriggerOnRemovePresence(agentID);
+    
+                    if (!isChildAgent)
+                    {
+                        if (AttachmentsModule != null)
                         {
-                            //We can safely ignore null reference exceptions.  It means the avatar is dead and cleaned up anyway
-                            try { client.SendKillObject(avatar.RegionHandle, new List<uint> { avatar.LocalId }); }
-                            catch (NullReferenceException) { }
-                        });
-                }
-
-                // It's possible for child agents to have transactions if changes are being made cross-border.
-                if (AgentTransactionsModule != null)
-                    AgentTransactionsModule.RemoveAgentAssetTransactions(agentID);
+                            AttachmentsModule.DeRezAttachments(avatar);
+                        }
 
-                m_authenticateHandler.RemoveCircuit(avatar.ControllingClient.CircuitCode);
-                m_log.Debug("[Scene] The avatar has left the building");
-            }
-            catch (Exception e)
-            {
-                m_log.Error(
-                    string.Format("[SCENE]: Exception removing {0} from {1}.  Cleaning up.  Exception ", avatar.Name, Name), e);
-            }
-            finally
-            {
-                try
-                {
-                    // Always clean these structures up so that any failure above doesn't cause them to remain in the
-                    // scene with possibly bad effects (e.g. continually timing out on unacked packets and triggering
-                    // the same cleanup exception continually.
-                    m_sceneGraph.RemoveScenePresence(agentID);
-                    m_clientManager.Remove(agentID);
+                        ForEachClient(
+                            delegate(IClientAPI client)
+                            {
+                                //We can safely ignore null reference exceptions.  It means the avatar is dead and cleaned up anyway
+                                try { client.SendKillObject(avatar.RegionHandle, new List<uint> { avatar.LocalId }); }
+                                catch (NullReferenceException) { }
+                            });
+                    }
     
-                    avatar.Close();
+                    // It's possible for child agents to have transactions if changes are being made cross-border.
+                    if (AgentTransactionsModule != null)
+                        AgentTransactionsModule.RemoveAgentAssetTransactions(agentID);
+                    m_log.Debug("[Scene] The avatar has left the building");
                 }
                 catch (Exception e)
                 {
                     m_log.Error(
-                        string.Format("[SCENE]: Exception in final clean up of {0} in {1}.  Exception ", avatar.Name, Name), e);
+                        string.Format("[SCENE]: Exception removing {0} from {1}.  Cleaning up.  Exception ", avatar.Name, Name), e);
+                }
+                finally
+                {
+                    try
+                    {
+                        // Always clean these structures up so that any failure above doesn't cause them to remain in the
+                        // scene with possibly bad effects (e.g. continually timing out on unacked packets and triggering
+                        // the same cleanup exception continually.
+                        m_sceneGraph.RemoveScenePresence(agentID);
+                        m_clientManager.Remove(agentID);
+        
+                        avatar.Close();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Error(
+                            string.Format("[SCENE]: Exception in final clean up of {0} in {1}.  Exception ", avatar.Name, Name), e);
+                    }
                 }
             }
 
@@ -3609,11 +3732,9 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Do the work necessary to initiate a new user connection for a particular scene.
-        /// At the moment, this consists of setting up the caps infrastructure
-        /// The return bool should allow for connections to be refused, but as not all calling paths
-        /// take proper notice of it let, we allowed banned users in still.
         /// </summary>
         /// <param name="agent">CircuitData of the agent who is connecting</param>
+        /// <param name="teleportFlags"></param>
         /// <param name="reason">Outputs the reason for the false response on this string</param>
         /// <returns>True if the region accepts this agent.  False if it does not.  False will 
         /// also return a reason.</returns>
@@ -3624,10 +3745,20 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Do the work necessary to initiate a new user connection for a particular scene.
-        /// At the moment, this consists of setting up the caps infrastructure
+        /// </summary>
+        /// <remarks>
+        /// The return bool should allow for connections to be refused, but as not all calling paths
+        /// take proper notice of it yet, we still allowed banned users in.
+        ///
+        /// At the moment this method consists of setting up the caps infrastructure
         /// The return bool should allow for connections to be refused, but as not all calling paths
         /// take proper notice of it let, we allowed banned users in still.
-        /// </summary>
+        ///
+        /// This method is called by the login service (in the case of login) or another simulator (in the case of region
+        /// cross or teleport) to initiate the connection.  It is not triggered by the viewer itself - the connection
+        /// is activated later when the viewer sends the initial UseCircuitCodePacket UDP packet (in the case of
+        /// the LLUDP stack).
+        /// </remarks>
         /// <param name="agent">CircuitData of the agent who is connecting</param>
         /// <param name="reason">Outputs the reason for the false response on this string</param>
         /// <param name="requirePresenceLookup">True for normal presence. False for NPC
@@ -3726,83 +3857,86 @@ namespace OpenSim.Region.Framework.Scenes
                     "[SCENE]: Existing root scene presence detected for {0} {1} in {2} when connecting.  Removing existing presence.",
                     sp.Name, sp.UUID, RegionInfo.RegionName);
 
-                sp.ControllingClient.Close();
+                sp.ControllingClient.Close(true, true);
                 sp = null;
             }
 
-
-            //On login test land permisions
-            if (vialogin)
+            lock (agent)
             {
-                IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
-                if (cache != null)
-                    cache.Remove(agent.firstname + " " + agent.lastname);
-                if (!TestLandRestrictions(agent.AgentID, out reason, ref agent.startpos.X, ref agent.startpos.Y))
+                //On login test land permisions
+                if (vialogin)
                 {
-                    m_log.DebugFormat("[CONNECTION BEGIN]: Denying access to {0} due to no land access", agent.AgentID.ToString());
-                    return false;
+                    IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
+                    if (cache != null)
+                        cache.Remove(agent.firstname + " " + agent.lastname);
+                    if (!TestLandRestrictions(agent.AgentID, out reason, ref agent.startpos.X, ref agent.startpos.Y))
+                    {
+                        m_log.DebugFormat("[CONNECTION BEGIN]: Denying access to {0} due to no land access", agent.AgentID.ToString());
+                        return false;
+                    }
                 }
-            }
 
-            if (sp == null) // We don't have an [child] agent here already
-            {
-                if (requirePresenceLookup)
+                if (sp == null) // We don't have an [child] agent here already
                 {
-                    try
+                    if (requirePresenceLookup)
                     {
-                        if (!VerifyUserPresence(agent, out reason))
+                        try
+                        {
+                            if (!VerifyUserPresence(agent, out reason))
+                                return false;
+                        } catch (Exception e)
+                        {
+                            m_log.ErrorFormat(
+                                "[SCENE]: Exception verifying presence {0}{1}", e.Message, e.StackTrace);
                             return false;
-                    } catch (Exception e)
+                        }
+                    }
+
+                    try
+                    {
+                        // Always check estate if this is a login. Always
+                        // check if banned regions are to be blacked out.
+                        if (vialogin || (!m_seeIntoBannedRegion))
+                        {
+                            if (!AuthorizeUser(agent, out reason))
+                                return false;
+                        }
+                    }
+                    catch (Exception e)
                     {
                         m_log.ErrorFormat(
-                            "[SCENE]: Exception verifying presence {0}{1}", e.Message, e.StackTrace);
+                            "[SCENE]: Exception authorizing user {0}{1}", e.Message, e.StackTrace);
                         return false;
                     }
-                }
 
-                try
-                {
-                    // Always check estate if this is a login. Always
-                    // check if banned regions are to be blacked out.
-                    if (vialogin || (!m_seeIntoBannedRegion))
+                    m_log.InfoFormat(
+                        "[SCENE]: Region {0} authenticated and authorized incoming {1} agent {2} {3} {4} (circuit code {5})",
+                        RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
+                        agent.AgentID, agent.circuitcode);
+
+                    if (CapsModule != null)
                     {
-                        if (!AuthorizeUser(agent, out reason))
-                            return false;
+                        CapsModule.SetAgentCapsSeeds(agent);
+                        CapsModule.CreateCaps(agent.AgentID);
                     }
                 }
-                catch (Exception e)
+                else
                 {
-                    m_log.ErrorFormat(
-                        "[SCENE]: Exception authorizing user {0}{1}", e.Message, e.StackTrace);
-                    return false;
-                }
-
-                m_log.InfoFormat(
-                    "[SCENE]: Region {0} authenticated and authorized incoming {1} agent {2} {3} {4} (circuit code {5})",
-                    RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
-                    agent.AgentID, agent.circuitcode);
+                    // Let the SP know how we got here. This has a lot of interesting
+                    // uses down the line.
+                    sp.TeleportFlags = (TPFlags)teleportFlags;
 
-                if (CapsModule != null)
-                {
-                    CapsModule.SetAgentCapsSeeds(agent);
-                    CapsModule.CreateCaps(agent.AgentID);
-                }
-            } else
-            {
-                // Let the SP know how we got here. This has a lot of interesting
-                // uses down the line.
-                sp.TeleportFlags = (TPFlags)teleportFlags;
+                    if (sp.IsChildAgent)
+                    {
+                        m_log.DebugFormat(
+                            "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
+                            agent.AgentID, RegionInfo.RegionName);
 
-                if (sp.IsChildAgent)
-                {
-                    m_log.DebugFormat(
-                        "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
-                        agent.AgentID, RegionInfo.RegionName);
+                        sp.AdjustKnownSeeds();
 
-                    sp.AdjustKnownSeeds();
-                    
-                    if (CapsModule != null)
-                        CapsModule.SetAgentCapsSeeds(agent);
+                        if (CapsModule != null)
+                            CapsModule.SetAgentCapsSeeds(agent);
+                    }
                 }
             }
 
@@ -4233,8 +4367,9 @@ namespace OpenSim.Region.Framework.Scenes
                 return false;
             }
 
-            // We have to wait until the viewer contacts this region after receiving EAC.
-            // That calls AddNewClient, which finally creates the ScenePresence
+            // We have to wait until the viewer contacts this region
+            // after receiving the EnableSimulator HTTP Event Queue message.  This triggers the viewer to send
+            // a UseCircuitCode packet which in turn calls AddNewClient which finally creates the ScenePresence.
             ScenePresence childAgentUpdate = WaitGetScenePresence(cAgentData.AgentID);
 
             if (childAgentUpdate != null)
@@ -4329,15 +4464,18 @@ namespace OpenSim.Region.Framework.Scenes
         /// Tell a single agent to disconnect from the region.
         /// </summary>
         /// <param name="agentID"></param>
-        /// <param name="childOnly"></param>
-        public bool IncomingCloseAgent(UUID agentID, bool childOnly)
+        /// <param name="force">
+        /// Force the agent to close even if it might be in the middle of some other operation.  You do not want to
+        /// force unless you are absolutely sure that the agent is dead and a normal close is not working.
+        /// </param>
+        public bool IncomingCloseAgent(UUID agentID, bool force)
         {
             //m_log.DebugFormat("[SCENE]: Processing incoming close agent for {0}", agentID);
 
             ScenePresence presence = m_sceneGraph.GetScenePresence(agentID);
             if (presence != null)
             {
-                presence.ControllingClient.Close(false);
+                presence.ControllingClient.Close(force, force);
                 return true;
             }
 
@@ -4543,6 +4681,16 @@ namespace OpenSim.Region.Framework.Scenes
             return LandChannel.GetLandObject(x, y).LandData;
         }
 
+        /// <summary>
+        /// Get LandData by position.
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <returns></returns>
+        public LandData GetLandData(Vector3 pos)
+        {
+            return GetLandData(pos.X, pos.Y);
+        }
+
         public LandData GetLandData(uint x, uint y)
         {
             m_log.DebugFormat("[SCENE]: returning land for {0},{1}", x, y);
@@ -4773,13 +4921,24 @@ namespace OpenSim.Region.Framework.Scenes
         /// Get a group via its UUID
         /// </summary>
         /// <param name="fullID"></param>
-        /// <returns>null if no group with that name exists</returns>
+        /// <returns>null if no group with that id exists</returns>
         public SceneObjectGroup GetSceneObjectGroup(UUID fullID)
         {
             return m_sceneGraph.GetSceneObjectGroup(fullID);
         }
 
         /// <summary>
+        /// Get a group via its local ID
+        /// </summary>
+        /// <remarks>This will only return a group if the local ID matches a root part</remarks>
+        /// <param name="localID"></param>
+        /// <returns>null if no group with that id exists</returns>
+        public SceneObjectGroup GetSceneObjectGroup(uint localID)
+        {
+            return m_sceneGraph.GetSceneObjectGroup(localID);
+        }
+
+        /// <summary>
         /// Get a group by name from the scene (will return the first
         /// found, if there are more than one prim with the same name)
         /// </summary>
@@ -4791,6 +4950,18 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Attempt to get the SOG via its UUID
+        /// </summary>
+        /// <param name="fullID"></param>
+        /// <param name="sog"></param>
+        /// <returns></returns>
+        public bool TryGetSceneObjectGroup(UUID fullID, out SceneObjectGroup sog)
+        {
+            sog = GetSceneObjectGroup(fullID);
+            return sog != null;
+        }
+
+        /// <summary>
         /// Get a prim by name from the scene (will return the first
         /// found, if there are more than one prim with the same name)
         /// </summary>
@@ -4822,6 +4993,18 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Attempt to get a prim via its UUID
+        /// </summary>
+        /// <param name="fullID"></param>
+        /// <param name="sop"></param>
+        /// <returns></returns>
+        public bool TryGetSceneObjectPart(UUID fullID, out SceneObjectPart sop)
+        {
+            sop = GetSceneObjectPart(fullID);
+            return sop != null;
+        }
+
+        /// <summary>
         /// Get a scene object group that contains the prim with the given local id
         /// </summary>
         /// <param name="localID"></param>
@@ -4915,14 +5098,15 @@ namespace OpenSim.Region.Framework.Scenes
                 client.SendRegionHandle(regionID, handle);
         }
 
-        public bool NeedSceneCacheClear(UUID agentID)
-        {
-            IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
-            if (inv == null)
-                return true;
-
-            return inv.NeedSceneCacheClear(agentID, this);
-        }
+// Commented pending deletion since this method no longer appears to do anything at all
+//        public bool NeedSceneCacheClear(UUID agentID)
+//        {
+//            IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
+//            if (inv == null)
+//                return true;
+//
+//            return inv.NeedSceneCacheClear(agentID, this);
+//        }
 
         public void CleanTempObjects()
         {
@@ -5876,6 +6060,9 @@ Environment.Exit(1);
 
         public string GetExtraSetting(string name)
         {
+            if (m_extraSettings == null)
+                return String.Empty;
+
             string val;
 
             if (!m_extraSettings.TryGetValue(name, out val))
@@ -5886,6 +6073,9 @@ Environment.Exit(1);
 
         public void StoreExtraSetting(string name, string val)
         {
+            if (m_extraSettings == null)
+                return;
+
             string oldVal;
 
             if (m_extraSettings.TryGetValue(name, out oldVal))
@@ -5903,6 +6093,9 @@ Environment.Exit(1);
 
         public void RemoveExtraSetting(string name)
         {
+            if (m_extraSettings == null)
+                return;
+
             if (!m_extraSettings.ContainsKey(name))
                 return;
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index 7c8bd88..74c9582 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -67,12 +67,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <value>
         /// All the region modules attached to this scene.
         /// </value>
-        public Dictionary<string, IRegionModule> Modules
-        {
-            get { return m_modules; }
-        }
-        protected Dictionary<string, IRegionModule> m_modules = new Dictionary<string, IRegionModule>();
-
         public Dictionary<string, IRegionModuleBase> RegionModules
         {
             get { return m_regionModules; }
@@ -273,16 +267,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public virtual void Close()
         {
-            // Shut down all non shared modules.
-            foreach (IRegionModule module in Modules.Values)
-            {
-                if (!module.IsSharedModule)
-                {
-                    module.Close();
-                }
-            }
-            Modules.Clear();
-
             try
             {
                 EventManager.TriggerShutdown();
@@ -313,19 +297,6 @@ namespace OpenSim.Region.Framework.Scenes
         #region Module Methods
 
         /// <summary>
-        /// Add a module to this scene.
-        /// </summary>
-        /// <param name="name"></param>
-        /// <param name="module"></param>
-        public void AddModule(string name, IRegionModule module)
-        {
-            if (!Modules.ContainsKey(name))
-            {
-                Modules.Add(name, module);
-            }
-        }
-
-        /// <summary>
         /// Add a region-module to this scene. TODO: This will replace AddModule in the future.
         /// </summary>
         /// <param name="name"></param>
@@ -509,9 +480,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="shorthelp"></param>
         /// <param name="longhelp"></param>
         /// <param name="callback"></param>
-        public void AddCommand(object mod, string command, string shorthelp, string longhelp, CommandDelegate callback)
+        public void AddCommand(IRegionModuleBase module, string command, string shorthelp, string longhelp, CommandDelegate callback)
         {
-            AddCommand(mod, command, shorthelp, longhelp, string.Empty, callback);
+            AddCommand(module, command, shorthelp, longhelp, string.Empty, callback);
         }
 
         /// <summary>
@@ -529,9 +500,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="longhelp"></param>
         /// <param name="callback"></param>
         public void AddCommand(
-            string category, object mod, string command, string shorthelp, string longhelp, CommandDelegate callback)
+            string category, IRegionModuleBase module, string command, string shorthelp, string longhelp, CommandDelegate callback)
         {
-            AddCommand(category, mod, command, shorthelp, longhelp, string.Empty, callback);
+            AddCommand(category, module, command, shorthelp, longhelp, string.Empty, callback);
         }
 
         /// <summary>
@@ -543,29 +514,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="longhelp"></param>
         /// <param name="descriptivehelp"></param>
         /// <param name="callback"></param>
-        public void AddCommand(object mod, string command, string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
+        public void AddCommand(IRegionModuleBase module, string command, string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
         {
             string moduleName = "";
 
-            if (mod != null)
-            {
-                if (mod is IRegionModule)
-                {
-                    IRegionModule module = (IRegionModule)mod;
-                    moduleName = module.Name;
-                }
-                else if (mod is IRegionModuleBase)
-                {
-                    IRegionModuleBase module = (IRegionModuleBase)mod;
-                    moduleName = module.Name;
-                }
-                else
-                {
-                    throw new Exception("AddCommand module parameter must be IRegionModule or IRegionModuleBase");
-                }
-            }
+            if (module != null)
+                moduleName = module.Name;
 
-            AddCommand(moduleName, mod, command, shorthelp, longhelp, descriptivehelp, callback);
+            AddCommand(moduleName, module, command, shorthelp, longhelp, descriptivehelp, callback);
         }
 
         /// <summary>
@@ -581,7 +537,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="descriptivehelp"></param>
         /// <param name="callback"></param>
         public void AddCommand(
-            string category, object mod, string command,
+            string category, IRegionModuleBase module, string command,
             string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
         {
             if (MainConsole.Instance == null)
@@ -589,22 +545,8 @@ namespace OpenSim.Region.Framework.Scenes
 
             bool shared = false;
 
-            if (mod != null)
-            {
-                if (mod is IRegionModule)
-                {
-                    IRegionModule module = (IRegionModule)mod;
-                    shared = module.IsSharedModule;
-                }
-                else if (mod is IRegionModuleBase)
-                {
-                    shared = mod is ISharedRegionModule;
-                }
-                else
-                {
-                    throw new Exception("AddCommand module parameter must be IRegionModule or IRegionModuleBase");
-                }
-            }
+            if (module != null)
+                shared = module is ISharedRegionModule;
 
             MainConsole.Instance.Commands.AddCommand(
                 category, shared, command, shorthelp, longhelp, descriptivehelp, callback);
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index af13b46..e599e90 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -342,7 +342,7 @@ namespace OpenSim.Region.Framework.Scenes
         public bool AddNewSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, Vector3? pos, Quaternion? rot, Vector3 vel)
         {
-            AddNewSceneObject(sceneObject, true, false);
+            AddNewSceneObject(sceneObject, attachToBackup, false);
 
             if (pos != null)
                 sceneObject.AbsolutePosition = (Vector3)pos;
@@ -421,12 +421,9 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     Vector3 scale = part.Shape.Scale;
 
-                    if (scale.X > m_parentScene.m_maxNonphys)
-                        scale.X = m_parentScene.m_maxNonphys;
-                    if (scale.Y > m_parentScene.m_maxNonphys)
-                        scale.Y = m_parentScene.m_maxNonphys;
-                    if (scale.Z > m_parentScene.m_maxNonphys)
-                        scale.Z = m_parentScene.m_maxNonphys;
+                    scale.X = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.X));
+                    scale.Y = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.Y));
+                    scale.Z = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.Z));
 
                     part.Shape.Scale = scale;
                 }
@@ -1066,6 +1063,30 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Get a group in the scene
+        /// </summary>
+        /// <remarks>
+        /// This will only return a group if the local ID matches the root part, not other parts.
+        /// </remarks>
+        /// <param name="localID">Local id of the root part of the group</param>
+        /// <returns>null if no such group was found</returns>
+        protected internal SceneObjectGroup GetSceneObjectGroup(uint localID)
+        {
+            lock (SceneObjectGroupsByLocalPartID)
+            {
+                if (SceneObjectGroupsByLocalPartID.ContainsKey(localID))
+                {
+                    SceneObjectGroup so = SceneObjectGroupsByLocalPartID[localID];
+
+                    if (so.LocalId == localID)
+                        return so;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
         /// Get a group by name from the scene (will return the first
         /// found, if there are more than one prim with the same name)
         /// </summary>
diff --git a/OpenSim/Region/Framework/Scenes/SceneManager.cs b/OpenSim/Region/Framework/Scenes/SceneManager.cs
index f1b09ca..89e3ac5 100644
--- a/OpenSim/Region/Framework/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneManager.cs
@@ -92,7 +92,11 @@ namespace OpenSim.Region.Framework.Scenes
         private static SceneManager m_instance = null;
         public static SceneManager Instance
         { 
-            get { return m_instance; } 
+            get {
+                if (m_instance == null)
+                    m_instance = new SceneManager();
+                return m_instance;
+            } 
         }
 
         private readonly DoubleDictionary<UUID, string, Scene> m_localScenes = new DoubleDictionary<UUID, string, Scene>();
@@ -134,31 +138,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void Close()
         {
-            // collect known shared modules in sharedModules
-            Dictionary<string, IRegionModule> sharedModules = new Dictionary<string, IRegionModule>();
-
-            List<Scene> sceneList = Scenes;
-            for (int i = 0; i < sceneList.Count; i++)
-            {
-                // extract known shared modules from scene
-                foreach (string k in sceneList[i].Modules.Keys)
-                {
-                    if (sceneList[i].Modules[k].IsSharedModule &&
-                        !sharedModules.ContainsKey(k))
-                        sharedModules[k] = sceneList[i].Modules[k];
-                }
-                // close scene/region
-                sceneList[i].Close();
-            }
-
-            // all regions/scenes are now closed, we can now safely
-            // close all shared modules
-            foreach (IRegionModule mod in sharedModules.Values)
-            {
-                mod.Close();
-            }
-
-            m_localScenes.Clear();
         }
 
         public void Close(Scene cscene)
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index ee61de6..b9f9c86 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -112,7 +112,7 @@ namespace OpenSim.Region.Framework.Scenes
         private long timeLastChanged = 0;
         private long m_maxPersistTime = 0;
         private long m_minPersistTime = 0;
-        private Random m_rand;
+//        private Random m_rand;
         private List<ScenePresence> m_linkedAvatars = new List<ScenePresence>();
 
         /// <summary>
@@ -130,6 +130,7 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (value)
                 {
+                    
                     if (m_isBackedUp)
                     {
                         m_scene.SceneGraph.FireChangeBackup(this);
@@ -139,19 +140,21 @@ namespace OpenSim.Region.Framework.Scenes
                         timeFirstChanged = DateTime.Now.Ticks;
                     if (m_rootPart != null && m_rootPart.UUID != null && m_scene != null)
                     {
+/*
                         if (m_rand == null)
                         {
                             byte[] val = new byte[16];
                             m_rootPart.UUID.ToBytes(val, 0);
                             m_rand = new Random(BitConverter.ToInt32(val, 0));
                         }
-                       
+ */
                         if (m_scene.GetRootAgentCount() == 0)
                         {
                             //If the region is empty, this change has been made by an automated process
                             //and thus we delay the persist time by a random amount between 1.5 and 2.5.
 
-                            float factor = 1.5f + (float)(m_rand.NextDouble());
+//                            float factor = 1.5f + (float)(m_rand.NextDouble());
+                            float factor = 2.0f;
                             m_maxPersistTime = (long)((float)m_scene.m_persistAfter * factor);
                             m_minPersistTime = (long)((float)m_scene.m_dontPersistBefore * factor);
                         }
@@ -159,8 +162,10 @@ namespace OpenSim.Region.Framework.Scenes
                         {
                             //If the region is not empty, we want to obey the minimum and maximum persist times
                             //but add a random factor so we stagger the object persistance a little
-                            m_maxPersistTime = (long)((float)m_scene.m_persistAfter * (1.0d - (m_rand.NextDouble() / 5.0d))); //Multiply by 1.0-1.5
-                            m_minPersistTime = (long)((float)m_scene.m_dontPersistBefore * (1.0d + (m_rand.NextDouble() / 2.0d))); //Multiply by 0.8-1.0
+//                            m_maxPersistTime = (long)((float)m_scene.m_persistAfter * (1.0d - (m_rand.NextDouble() / 5.0d))); //Multiply by 1.0-1.5
+//                            m_minPersistTime = (long)((float)m_scene.m_dontPersistBefore * (1.0d + (m_rand.NextDouble() / 2.0d))); //Multiply by 0.8-1.0
+                            m_maxPersistTime = m_scene.m_persistAfter;
+                            m_minPersistTime = m_scene.m_dontPersistBefore;
                         }
                     }
                 }
@@ -2747,6 +2752,25 @@ namespace OpenSim.Region.Framework.Scenes
             if (objectGroup == this)
                 return;
 
+            // If the configured linkset capacity is greater than zero,
+            // and the new linkset would have a prim count higher than this
+            // value, do not link it.
+            if (m_scene.m_linksetCapacity > 0 &&
+                    (PrimCount + objectGroup.PrimCount) >
+                    m_scene.m_linksetCapacity)
+            {
+                m_log.DebugFormat(
+                    "[SCENE OBJECT GROUP]: Cannot link group with root" +
+                    " part {0}, {1} ({2} prims) to group with root part" +
+                    " {3}, {4} ({5} prims) because the new linkset" +
+                    " would exceed the configured maximum of {6}",
+                    objectGroup.RootPart.Name, objectGroup.RootPart.UUID,
+                    objectGroup.PrimCount, RootPart.Name, RootPart.UUID,
+                    PrimCount, m_scene.m_linksetCapacity);
+
+                return;
+            }
+
             // 'linkPart' == the root of the group being linked into this group
             SceneObjectPart linkPart = objectGroup.m_rootPart;
 
@@ -3492,27 +3516,33 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="scale"></param>
         public void GroupResize(Vector3 scale)
         {
-            scale.X = Math.Min(scale.X, Scene.m_maxNonphys);
-            scale.Y = Math.Min(scale.Y, Scene.m_maxNonphys);
-            scale.Z = Math.Min(scale.Z, Scene.m_maxNonphys);
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Group resizing {0} {1} from {2} to {3}", Name, LocalId, RootPart.Scale, scale);
 
             PhysicsActor pa = m_rootPart.PhysActor;
 
-            if (pa != null && pa.IsPhysical)
+            if (Scene != null)
             {
-                scale.X = Math.Min(scale.X, Scene.m_maxPhys);
-                scale.Y = Math.Min(scale.Y, Scene.m_maxPhys);
-                scale.Z = Math.Min(scale.Z, Scene.m_maxPhys);
+                scale.X = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.X));
+                scale.Y = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.Y));
+                scale.Z = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.Z));
+    
+                if (pa != null && pa.IsPhysical)
+                {
+                    scale.X = Math.Max(Scene.m_minPhys, Math.Min(Scene.m_maxPhys, scale.X));
+                    scale.Y = Math.Max(Scene.m_minPhys, Math.Min(Scene.m_maxPhys, scale.Y));
+                    scale.Z = Math.Max(Scene.m_minPhys, Math.Min(Scene.m_maxPhys, scale.Z));
+                }
             }
 
             float x = (scale.X / RootPart.Scale.X);
             float y = (scale.Y / RootPart.Scale.Y);
             float z = (scale.Z / RootPart.Scale.Z);
 
-            SceneObjectPart[] parts;
-            if (x > 1.0f || y > 1.0f || z > 1.0f)
+            SceneObjectPart[] parts = m_parts.GetArray();
+
+            if (Scene != null & (x > 1.0f || y > 1.0f || z > 1.0f))
             {
-                parts = m_parts.GetArray();
                 for (int i = 0; i < parts.Length; i++)
                 {
                     SceneObjectPart obPart = parts[i];
@@ -3525,7 +3555,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                         if (pa != null && pa.IsPhysical)
                         {
-                            if (oldSize.X * x > m_scene.m_maxPhys)
+                            if (oldSize.X * x > Scene.m_maxPhys)
                             {
                                 f = m_scene.m_maxPhys / oldSize.X;
                                 a = f / x;
@@ -3533,8 +3563,16 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.X * x < Scene.m_minPhys)
+                            {
+                                f = m_scene.m_minPhys / oldSize.X;
+                                a = f / x;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (oldSize.Y * y > m_scene.m_maxPhys)
+                            if (oldSize.Y * y > Scene.m_maxPhys)
                             {
                                 f = m_scene.m_maxPhys / oldSize.Y;
                                 a = f / y;
@@ -3542,8 +3580,16 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.Y * y < Scene.m_minPhys)
+                            {
+                                f = m_scene.m_minPhys / oldSize.Y;
+                                a = f / y;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (oldSize.Z * z > m_scene.m_maxPhys)
+                            if (oldSize.Z * z > Scene.m_maxPhys)
                             {
                                 f = m_scene.m_maxPhys / oldSize.Z;
                                 a = f / z;
@@ -3551,10 +3597,18 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.Z * z < Scene.m_minPhys)
+                            {
+                                f = m_scene.m_minPhys / oldSize.Z;
+                                a = f / z;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
                         }
                         else
                         {
-                            if (oldSize.X * x > m_scene.m_maxNonphys)
+                            if (oldSize.X * x > Scene.m_maxNonphys)
                             {
                                 f = m_scene.m_maxNonphys / oldSize.X;
                                 a = f / x;
@@ -3562,8 +3616,16 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.X * x < Scene.m_minNonphys)
+                            {
+                                f = m_scene.m_minNonphys / oldSize.X;
+                                a = f / x;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (oldSize.Y * y > m_scene.m_maxNonphys)
+                            if (oldSize.Y * y > Scene.m_maxNonphys)
                             {
                                 f = m_scene.m_maxNonphys / oldSize.Y;
                                 a = f / y;
@@ -3571,8 +3633,16 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.Y * y < Scene.m_minNonphys)
+                            {
+                                f = m_scene.m_minNonphys / oldSize.Y;
+                                a = f / y;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (oldSize.Z * z > m_scene.m_maxNonphys)
+                            if (oldSize.Z * z > Scene.m_maxNonphys)
                             {
                                 f = m_scene.m_maxNonphys / oldSize.Z;
                                 a = f / z;
@@ -3580,6 +3650,14 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.Z * z < Scene.m_minNonphys)
+                            {
+                                f = m_scene.m_minNonphys / oldSize.Z;
+                                a = f / z;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
                         }
                     }
                 }
@@ -3592,7 +3670,6 @@ namespace OpenSim.Region.Framework.Scenes
 
             RootPart.Resize(prevScale);
 
-            parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
             {
                 SceneObjectPart obPart = parts[i];
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 165dd85..2191cfa 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -790,7 +790,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     catch (Exception e)
                     {
-                        m_log.Error("[SCENEOBJECTPART]: GROUP POSITION. " + e.Message);
+                        m_log.ErrorFormat("[SCENEOBJECTPART]: GROUP POSITION. {0}", e);
                     }
                 }
             }
@@ -2864,6 +2864,35 @@ namespace OpenSim.Region.Framework.Scenes
                 SendLandCollisionEvent(scriptEvents.land_collision_end, ParentGroup.Scene.EventManager.TriggerScriptLandCollidingEnd);
         }
 
+        // The Collision sounds code calls this
+        public void SendCollisionSound(UUID soundID, double volume, Vector3 position)
+        {
+            if (soundID == UUID.Zero)
+                return;
+
+            ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
+            if (soundModule == null)
+                return;
+
+            if (volume > 1)
+                volume = 1;
+            if (volume < 0)
+                volume = 0;
+
+            int now = Util.EnvironmentTickCount();
+            if(Util.EnvironmentTickCountSubtract(now,LastColSoundSentTime) <200)
+                return;
+
+            LastColSoundSentTime = now;
+
+            UUID ownerID = OwnerID;
+            UUID objectID = ParentGroup.RootPart.UUID;
+            UUID parentID = ParentGroup.UUID;
+            ulong regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
+
+            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, 0 );
+        }
+
         public void PhysicsOutOfBounds(Vector3 pos)
         {
             m_log.Error("[PHYSICS]: Physical Object went out of bounds.");
@@ -2895,38 +2924,6 @@ namespace OpenSim.Region.Framework.Scenes
             ScheduleTerseUpdate();
         }
 
-        public void PreloadSound(string sound)
-        {
-            // UUID ownerID = OwnerID;
-            UUID objectID = ParentGroup.RootPart.UUID;
-            UUID soundID = UUID.Zero;
-
-            if (!UUID.TryParse(sound, out soundID))
-            {
-                //Trys to fetch sound id from prim's inventory.
-                //Prim's inventory doesn't support non script items yet
-                
-                TaskInventory.LockItemsForRead(true);
-
-                foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
-                {
-                    if (item.Value.Name == sound)
-                    {
-                        soundID = item.Value.ItemID;
-                        break;
-                    }
-                }
-
-                TaskInventory.LockItemsForRead(false);
-            }
-
-            ParentGroup.Scene.ForEachRootScenePresence(delegate(ScenePresence sp)
-            {
-                if (!(Util.GetDistanceTo(sp.AbsolutePosition, AbsolutePosition) >= 100))
-                    sp.ControllingClient.SendPreLoadSound(objectID, objectID, soundID);
-            });
-        }
-
         public void RemFlag(PrimFlags flag)
         {
             // PrimFlags prevflag = Flags;
@@ -2979,17 +2976,20 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="scale"></param>
         public void Resize(Vector3 scale)
         {
-            scale.X = Math.Min(scale.X, ParentGroup.Scene.m_maxNonphys);
-            scale.Y = Math.Min(scale.Y, ParentGroup.Scene.m_maxNonphys);
-            scale.Z = Math.Min(scale.Z, ParentGroup.Scene.m_maxNonphys);
-
             PhysicsActor pa = PhysActor;
 
-            if (pa != null && pa.IsPhysical)
+            if (ParentGroup.Scene != null)
             {
-                scale.X = Math.Min(scale.X, ParentGroup.Scene.m_maxPhys);
-                scale.Y = Math.Min(scale.Y, ParentGroup.Scene.m_maxPhys);
-                scale.Z = Math.Min(scale.Z, ParentGroup.Scene.m_maxPhys);
+                scale.X = Math.Max(ParentGroup.Scene.m_minNonphys, Math.Min(ParentGroup.Scene.m_maxNonphys, scale.X));
+                scale.Y = Math.Max(ParentGroup.Scene.m_minNonphys, Math.Min(ParentGroup.Scene.m_maxNonphys, scale.Y));
+                scale.Z = Math.Max(ParentGroup.Scene.m_minNonphys, Math.Min(ParentGroup.Scene.m_maxNonphys, scale.Z));
+    
+                if (pa != null && pa.IsPhysical)
+                {
+                    scale.X = Math.Max(ParentGroup.Scene.m_minPhys, Math.Min(ParentGroup.Scene.m_maxPhys, scale.X));
+                    scale.Y = Math.Max(ParentGroup.Scene.m_minPhys, Math.Min(ParentGroup.Scene.m_maxPhys, scale.Y));
+                    scale.Z = Math.Max(ParentGroup.Scene.m_minPhys, Math.Min(ParentGroup.Scene.m_maxPhys, scale.Z));
+                }
             }
 
 //            m_log.DebugFormat("[SCENE OBJECT PART]: Resizing {0} {1} to {2}", Name, LocalId, scale);
@@ -3086,7 +3086,7 @@ namespace OpenSim.Region.Framework.Scenes
             //                UUID, Name, TimeStampFull);
 
             if (ParentGroup.Scene != null)
-                ParentGroup.Scene.EventManager.TriggerSceneObjectPartUpdated(this);
+                ParentGroup.Scene.EventManager.TriggerSceneObjectPartUpdated(this, true);
         }
 
         /// <summary>
@@ -3120,7 +3120,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             if (ParentGroup.Scene != null)
-                ParentGroup.Scene.EventManager.TriggerSceneObjectPartUpdated(this);
+                ParentGroup.Scene.EventManager.TriggerSceneObjectPartUpdated(this, false);
         }
 
         public void ScriptSetPhysicsStatus(bool UsePhysics)
@@ -3295,126 +3295,6 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Trigger or play an attached sound in this part's inventory.
-        /// </summary>
-        /// <param name="sound"></param>
-        /// <param name="volume"></param>
-        /// <param name="triggered"></param>
-        /// <param name="flags"></param>
-        public void SendSound(string sound, double volume, bool triggered, byte flags, float radius, bool useMaster, bool isMaster)
-        {
-            if (volume > 1)
-                volume = 1;
-            if (volume < 0)
-                volume = 0;
-
-            UUID ownerID = OwnerID;
-            UUID objectID = ParentGroup.RootPart.UUID;
-            UUID parentID = ParentGroup.UUID;
-
-            UUID soundID = UUID.Zero;
-            Vector3 position = AbsolutePosition; // region local
-            ulong regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
-
-            if (!UUID.TryParse(sound, out soundID))
-            {
-                // search sound file from inventory
-                TaskInventory.LockItemsForRead(true);
-                foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
-                {
-                    if (item.Value.Name == sound && item.Value.Type == (int)AssetType.Sound)
-                    {
-                        soundID = item.Value.ItemID;
-                        break;
-                    }
-                }
-                TaskInventory.LockItemsForRead(false);
-            }
-
-            if (soundID == UUID.Zero)
-                return;
-
-            ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
-            if (soundModule != null)
-            {
-                if (useMaster)
-                {
-                    if (isMaster)
-                    {
-                        if (triggered)
-                            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, radius);
-                        else
-                            soundModule.PlayAttachedSound(soundID, ownerID, objectID, volume, position, flags, radius);
-                        ParentGroup.PlaySoundMasterPrim = this;
-                        ownerID = OwnerID;
-                        objectID = ParentGroup.RootPart.UUID;
-                        parentID = ParentGroup.UUID;
-                        position = AbsolutePosition; // region local
-                        regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
-                        if (triggered)
-                            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, radius);
-                        else
-                            soundModule.PlayAttachedSound(soundID, ownerID, objectID, volume, position, flags, radius);
-                        foreach (SceneObjectPart prim in ParentGroup.PlaySoundSlavePrims)
-                        {
-                            ownerID = prim.OwnerID;
-                            objectID = prim.ParentGroup.RootPart.UUID;
-                            parentID = prim.ParentGroup.UUID;
-                            position = prim.AbsolutePosition; // region local
-                            regionHandle = prim.ParentGroup.Scene.RegionInfo.RegionHandle;
-                            if (triggered)
-                                soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, radius);
-                            else
-                                soundModule.PlayAttachedSound(soundID, ownerID, objectID, volume, position, flags, radius);
-                        }
-                        ParentGroup.PlaySoundSlavePrims.Clear();
-                        ParentGroup.PlaySoundMasterPrim = null;
-                    }
-                    else
-                    {
-                        ParentGroup.PlaySoundSlavePrims.Add(this);
-                    }
-                }
-                else
-                {
-                    if (triggered)
-                        soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, radius);
-                    else
-                        soundModule.PlayAttachedSound(soundID, ownerID, objectID, volume, position, flags, radius);
-                }
-            }
-        }
-
-        public void SendCollisionSound(UUID soundID, double volume, Vector3 position)
-        {
-            if (soundID == UUID.Zero)
-                return;
-
-            ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
-            if (soundModule == null)
-                return;
-
-            if (volume > 1)
-                volume = 1;
-            if (volume < 0)
-                volume = 0;
-
-            int now = Util.EnvironmentTickCount();
-            if(Util.EnvironmentTickCountSubtract(now,LastColSoundSentTime) <200)
-                return;
-
-            LastColSoundSentTime = now;
-
-            UUID ownerID = OwnerID;
-            UUID objectID = ParentGroup.RootPart.UUID;
-            UUID parentID = ParentGroup.UUID;
-            ulong regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
-
-            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, 0 );
-        }
-
-
-        /// <summary>
         /// Send a terse update to all clients
         /// </summary>
         public void SendTerseUpdateToAllClients()
@@ -3575,23 +3455,32 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Set the color of prim faces
+        /// Set the color & alpha of prim faces
         /// </summary>
-        /// <param name="color"></param>
         /// <param name="face"></param>
-        public void SetFaceColor(Vector3 color, int face)
+        /// <param name="color"></param>
+        /// <param name="alpha"></param>
+        public void SetFaceColorAlpha(int face, Vector3 color, double ?alpha)
         {
+            Vector3 clippedColor = Util.Clip(color, 0.0f, 1.0f);
+            float clippedAlpha = alpha.HasValue ?
+                Util.Clip((float)alpha.Value, 0.0f, 1.0f) : 0;
+
             // The only way to get a deep copy/ If we don't do this, we can
-            // mever detect color changes further down.
+            // never detect color changes further down.
             Byte[] buf = Shape.Textures.GetBytes();
             Primitive.TextureEntry tex = new Primitive.TextureEntry(buf, 0, buf.Length);
             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);
+                texcolor.R = clippedColor.X;
+                texcolor.G = clippedColor.Y;
+                texcolor.B = clippedColor.Z;
+                if (alpha.HasValue)
+                {
+                    texcolor.A = clippedAlpha;
+                }
                 tex.FaceTextures[face].RGBA = texcolor;
                 UpdateTextureEntry(tex.GetBytes());
                 return;
@@ -3603,15 +3492,23 @@ namespace OpenSim.Region.Framework.Scenes
                     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);
+                        texcolor.R = clippedColor.X;
+                        texcolor.G = clippedColor.Y;
+                        texcolor.B = clippedColor.Z;
+                        if (alpha.HasValue)
+                        {
+                            texcolor.A = clippedAlpha;
+                        }
                         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);
+                    texcolor.R = clippedColor.X;
+                    texcolor.G = clippedColor.Y;
+                    texcolor.B = clippedColor.Z;
+                    if (alpha.HasValue)
+                    {
+                        texcolor.A = clippedAlpha;
+                    }
                     tex.DefaultTexture.RGBA = texcolor;
                 }
                 UpdateTextureEntry(tex.GetBytes());
@@ -4899,6 +4796,57 @@ namespace OpenSim.Region.Framework.Scenes
             ScheduleFullUpdate();
         }
 
+        public void UpdateSlice(float begin, float end)
+        {
+            if (end < begin)
+            {
+                float temp = begin;
+                begin = end;
+                end = temp;
+            }
+            end = Math.Min(1f, Math.Max(0f, end));
+            begin = Math.Min(Math.Min(1f, Math.Max(0f, begin)), end - 0.02f);
+            if (begin < 0.02f && end < 0.02f)
+            {
+                begin = 0f;
+                end = 0.02f;
+            }
+
+            ushort uBegin = (ushort)(50000.0 * begin);
+            ushort uEnd = (ushort)(50000.0 * (1f - end));
+            bool updatePossiblyNeeded = false;
+            PrimType primType = GetPrimType();
+            if (primType == PrimType.SPHERE || primType == PrimType.TORUS || primType == PrimType.TUBE || primType == PrimType.RING)
+            {
+                if (m_shape.ProfileBegin != uBegin || m_shape.ProfileEnd != uEnd)
+                {
+                    m_shape.ProfileBegin = uBegin;
+                    m_shape.ProfileEnd = uEnd;
+                    updatePossiblyNeeded = true;
+                }
+            }
+            else if (m_shape.PathBegin != uBegin || m_shape.PathEnd != uEnd)
+            {
+                m_shape.PathBegin = uBegin;
+                m_shape.PathEnd = uEnd;
+                updatePossiblyNeeded = true;
+            }
+
+            if (updatePossiblyNeeded && ParentGroup != null)
+            {
+                ParentGroup.HasGroupChanged = true;
+            }
+            if (updatePossiblyNeeded && PhysActor != null)
+            {
+                PhysActor.Shape = m_shape;
+                ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+            }
+            if (updatePossiblyNeeded)
+            {
+                ScheduleFullUpdate();
+            }
+        }
+
         /// <summary>
         /// If the part is a sculpt/mesh, retrieve the mesh data and reinsert it into the shape so that the physics
         /// engine can use it.
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index e010864..3a9a146 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -97,6 +97,15 @@ namespace OpenSim.Region.Framework.Scenes
                 QueryScriptStates();
             }
         }
+
+        public int Count
+        {
+            get
+            {
+                lock (m_items)
+                    return m_items.Count;
+            }
+        }
         
         /// <summary>
         /// Constructor
@@ -235,31 +244,52 @@ namespace OpenSim.Region.Framework.Scenes
             if (m_part == null || m_part.ParentGroup == null || m_part.ParentGroup.Scene == null)
                 return;
 
-            IScriptModule[] engines = m_part.ParentGroup.Scene.RequestModuleInterfaces<IScriptModule>();
-            if (engines == null) // No engine at all
-                return;
-
             Items.LockItemsForRead(true);
             foreach (TaskInventoryItem item in Items.Values)
             {
                 if (item.InvType == (int)InventoryType.LSL)
                 {
-                    foreach (IScriptModule e in engines)
-                    {
-                        bool running;
-
-                        if (e.HasScript(item.ItemID, out running))
-                        {
-                            item.ScriptRunning = running;
-                            break;
-                        }
-                    }
+                    bool running;
+                    if (TryGetScriptInstanceRunning(m_part.ParentGroup.Scene, item, out running))
+                        item.ScriptRunning = running;
                 }
             }
 
             Items.LockItemsForRead(false);
         }
 
+        public bool TryGetScriptInstanceRunning(UUID itemId, out bool running)
+        {
+            running = false;
+
+            TaskInventoryItem item = GetInventoryItem(itemId);
+
+            if (item == null)
+                return false;
+
+            return TryGetScriptInstanceRunning(m_part.ParentGroup.Scene, item, out running);
+        }
+
+        public static bool TryGetScriptInstanceRunning(Scene scene, TaskInventoryItem item, out bool running)
+        {
+            running = false;
+
+            if (item.InvType != (int)InventoryType.LSL)
+                return false;
+
+            IScriptModule[] engines = scene.RequestModuleInterfaces<IScriptModule>();
+            if (engines == null) // No engine at all
+                return false;
+
+            foreach (IScriptModule e in engines)
+            {
+                if (e.HasScript(item.ItemID, out running))
+                    return true;
+            }
+
+            return false;
+        }
+
         public int CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
         {
             int scriptsValidForStarting = 0;
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 2b9665c..25a53b4 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -69,14 +69,15 @@ namespace OpenSim.Region.Framework.Scenes
         public ScriptControlled eventControls;
     }
 
-    public delegate void SendCourseLocationsMethod(UUID scene, ScenePresence presence, List<Vector3> coarseLocations, List<UUID> avatarUUIDs);
+    public delegate void SendCoarseLocationsMethod(UUID scene, ScenePresence presence, List<Vector3> coarseLocations, List<UUID> avatarUUIDs);
 
     public class ScenePresence : EntityBase, IScenePresence
     {
 //        ~ScenePresence()
 //        {
-//            m_log.Debug("[SCENE PRESENCE] Destructor called");
+//            m_log.DebugFormat("[SCENE PRESENCE]: Destructor called on {0}", Name);
 //        }
+
         private void TriggerScenePresenceUpdated()
         {
             if (m_scene != null)
@@ -188,7 +189,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public bool SitGround { get; private set; }
 
-        private SendCourseLocationsMethod m_sendCourseLocationsMethod;
+        private SendCoarseLocationsMethod m_sendCoarseLocationsMethod;
 
         //private Vector3 m_requestedSitOffset = new Vector3();
 
@@ -546,7 +547,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     try
                     {
-                        PhysicsActor.Velocity = value;
+                        PhysicsActor.TargetVelocity = value;
                     }
                     catch (Exception e)
                     {
@@ -711,7 +712,7 @@ namespace OpenSim.Region.Framework.Scenes
             AttachmentsSyncLock = new Object();
             AllowMovement = true;
             IsChildAgent = true;
-            m_sendCourseLocationsMethod = SendCoarseLocationsDefault;
+            m_sendCoarseLocationsMethod = SendCoarseLocationsDefault;
             Animator = new ScenePresenceAnimator(this);
             PresenceType = type;
             DrawDistance = world.DefaultDrawDistance;
@@ -975,7 +976,9 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (wasChild && HasAttachments())
                 {
-                    m_log.DebugFormat("[SCENE PRESENCE]: Restarting scripts in attachments...");
+                    m_log.DebugFormat(
+                        "[SCENE PRESENCE]: Restarting scripts in attachments for {0} in {1}", Name, Scene.Name);
+                    
                     // Resume scripts
                     Util.FireAndForget(delegate(object x) {
                         foreach (SceneObjectGroup sog in m_attachments)
@@ -1531,17 +1534,22 @@ namespace OpenSim.Region.Framework.Scenes
                 bool DCFlagKeyPressed = false;
                 Vector3 agent_control_v3 = Vector3.Zero;
 
-                bool oldflying = Flying;
+                bool newFlying = actor.Flying;
 
                 if (ForceFly)
-                    actor.Flying = true;
+                    newFlying = true;
                 else if (FlyDisabled)
-                    actor.Flying = false;
+                    newFlying = false;
                 else
-                    actor.Flying = ((flags & AgentManager.ControlFlags.AGENT_CONTROL_FLY) != 0);
+                    newFlying = ((flags & AgentManager.ControlFlags.AGENT_CONTROL_FLY) != 0);
 
-                if (actor.Flying != oldflying)
+                if (actor.Flying != newFlying)
+                {
+                    // Note: ScenePresence.Flying is actually fetched from the physical actor
+                    //     so setting PhysActor.Flying here also sets the ScenePresence's value.
+                    actor.Flying = newFlying;
                     update_movementflag = true;
+                }
 
                 if (ParentID == 0)
                 {
@@ -2623,17 +2631,17 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SendCoarseLocations(List<Vector3> coarseLocations, List<UUID> avatarUUIDs)
         {
-            SendCourseLocationsMethod d = m_sendCourseLocationsMethod;
+            SendCoarseLocationsMethod d = m_sendCoarseLocationsMethod;
             if (d != null)
             {
                 d.Invoke(m_scene.RegionInfo.originRegionID, this, coarseLocations, avatarUUIDs);
             }
         }
 
-        public void SetSendCourseLocationMethod(SendCourseLocationsMethod d)
+        public void SetSendCoarseLocationMethod(SendCoarseLocationsMethod d)
         {
             if (d != null)
-                m_sendCourseLocationsMethod = d;
+                m_sendCoarseLocationsMethod = d;
         }
 
         public void SendCoarseLocationsDefault(UUID sceneId, ScenePresence p, List<Vector3> coarseLocations, List<UUID> avatarUUIDs)
@@ -2837,7 +2845,7 @@ namespace OpenSim.Region.Framework.Scenes
         #region Significant Movement Method
 
         /// <summary>
-        /// This checks for a significant movement and sends a courselocationchange update
+        /// This checks for a significant movement and sends a coarselocationchange update
         /// </summary>
         protected void CheckForSignificantMovement()
         {
@@ -3274,6 +3282,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
             catch { }
             cAgent.DefaultAnim = Animator.Animations.DefaultAnimation;
+            cAgent.AnimState = Animator.Animations.ImplicitDefaultAnimation;
 
             if (Scene.AttachmentsModule != null)
                 Scene.AttachmentsModule.CopyAttachments(this, cAgent);
@@ -3350,6 +3359,8 @@ namespace OpenSim.Region.Framework.Scenes
                 Animator.Animations.FromArray(cAgent.Anims);
             if (cAgent.DefaultAnim != null)
                 Animator.Animations.SetDefaultAnimation(cAgent.DefaultAnim.AnimID, cAgent.DefaultAnim.SequenceNum, UUID.Zero);
+            if (cAgent.AnimState != null)
+                Animator.Animations.SetImplicitDefaultAnimation(cAgent.AnimState.AnimID, cAgent.AnimState.SequenceNum, UUID.Zero);
 
             if (Scene.AttachmentsModule != null)
                 Scene.AttachmentsModule.CopyAttachments(cAgent, this);
@@ -3632,13 +3643,16 @@ namespace OpenSim.Region.Framework.Scenes
         public List<SceneObjectGroup> GetAttachments(uint attachmentPoint)
         {
             List<SceneObjectGroup> attachments = new List<SceneObjectGroup>();
-            
-            lock (m_attachments)
+
+            if (attachmentPoint >= 0)
             {
-                foreach (SceneObjectGroup so in m_attachments)
+                lock (m_attachments)
                 {
-                    if (attachmentPoint == so.AttachmentPoint)
-                        attachments.Add(so);
+                    foreach (SceneObjectGroup so in m_attachments)
+                    {
+                        if (attachmentPoint == so.AttachmentPoint)
+                            attachments.Add(so);
+                    }
                 }
             }
             
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index 756b1f4..5398ab9 100644
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -47,6 +47,7 @@ namespace OpenSim.Region.Framework.Scenes
             = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
 
         public const string LastReportedObjectUpdateStatName = "LastReportedObjectUpdates";
+        public const string SlowFramesStatName = "SlowFrames";
 
         public delegate void SendStatResult(SimStats stats);
 
@@ -129,6 +130,16 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Number of frames that have taken longer to process than Scene.MIN_FRAME_TIME
+        /// </summary>
+        public Stat SlowFramesStat { get; private set; }
+
+        /// <summary>
+        /// The threshold at which we log a slow frame.
+        /// </summary>
+        public int SlowFramesStatReportThreshold { get; private set; }
+
+        /// <summary>
         /// Extra sim statistics that are used by monitors but not sent to the client.
         /// </summary>
         /// <value>
@@ -226,6 +237,24 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (StatsManager.SimExtraStats != null)
                 OnSendStatsResult += StatsManager.SimExtraStats.ReceiveClassicSimStatsPacket;
+
+            /// At the moment, we'll only report if a frame is over 120% of target, since commonly frames are a bit
+            /// longer than ideal (which in itself is a concern).
+            SlowFramesStatReportThreshold = (int)Math.Ceiling(m_scene.MinFrameTime * 1000 * 1.2);
+
+            SlowFramesStat
+                = new Stat(
+                    "SlowFrames",
+                    "Slow Frames",
+                    "Number of frames where frame time has been significantly longer than the desired frame time.",
+                    " frames",
+                    "scene",
+                    m_scene.Name,
+                    StatType.Push,
+                    null,
+                    StatVerbosity.Info);
+
+            StatsManager.RegisterStat(SlowFramesStat);
         }
 
         public void Close()
@@ -443,6 +472,7 @@ namespace OpenSim.Region.Framework.Scenes
                     lock (m_lastReportedExtraSimStats)
                     {
                         m_lastReportedExtraSimStats[LastReportedObjectUpdateStatName] = m_objectUpdates / m_statsUpdateFactor;
+                        m_lastReportedExtraSimStats[SlowFramesStat.ShortName] = (float)SlowFramesStat.Value;
 
                         Dictionary<string, float> physicsStats = m_scene.PhysicsScene.GetStats();
         
@@ -563,6 +593,11 @@ namespace OpenSim.Region.Framework.Scenes
         public void addFrameMS(int ms)
         {
             m_frameMS += ms;
+
+            // At the moment, we'll only report if a frame is over 120% of target, since commonly frames are a bit
+            // longer than ideal due to the inaccuracy of the Sleep in Scene.Update() (which in itself is a concern).
+            if (ms > SlowFramesStatReportThreshold)
+                SlowFramesStat.Value++;
         }
 
         public void addNetMS(int ms)
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
index 3398a53..5b334c6 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
@@ -26,6 +26,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Reflection;
 using System.Threading;
 using NUnit.Framework;
@@ -33,6 +34,7 @@ using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
 
@@ -42,7 +44,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
     /// Basic scene object tests (create, read and delete but not update).
     /// </summary>
     [TestFixture]
-    public class SceneObjectBasicTests
+    public class SceneObjectBasicTests : OpenSimTestCase
     {
 //        [TearDown]
 //        public void TearDown()
@@ -237,38 +239,60 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         /// <summary>
         /// Test deleting an object asynchronously to user inventory.
         /// </summary>
-        //[Test]
-        //public void TestDeleteSceneObjectAsyncToUserInventory()
-        //{
-        //    TestHelper.InMethod();
-        //    //log4net.Config.XmlConfigurator.Configure();
-            
-        //    UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000001");
-        //    string myObjectName = "Fred";
-            
-        //    TestScene scene = SceneSetupHelpers.SetupScene();
-        //    SceneObjectPart part = SceneSetupHelpers.AddSceneObject(scene, myObjectName);
-            
-        //    Assert.That(
-        //        scene.CommsManager.UserAdminService.AddUser(
-        //            "Bob", "Hoskins", "test", "test@test.com", 1000, 1000, agentId),
-        //        Is.EqualTo(agentId));
-            
-        //    IClientAPI client = SceneSetupHelpers.AddRootAgent(scene, agentId);
-                                                
-        //    CachedUserInfo userInfo = scene.CommsManager.UserProfileCacheService.GetUserDetails(agentId);
-        //    Assert.That(userInfo, Is.Not.Null);
-        //    Assert.That(userInfo.RootFolder, Is.Not.Null);
-            
-        //    SceneSetupHelpers.DeleteSceneObjectAsync(scene, part, DeRezAction.Take, userInfo.RootFolder.ID, client);
-            
-        //    // Check that we now have the taken part in our inventory
-        //    Assert.That(myObjectName, Is.EqualTo(userInfo.RootFolder.FindItemByPath(myObjectName).Name));
-            
-        //    // Check that the taken part has actually disappeared
-        //    SceneObjectPart retrievedPart = scene.GetSceneObjectPart(part.LocalId);
-        //    Assert.That(retrievedPart, Is.Null);
-        //}
+//        [Test]
+        public void TestDeleteSceneObjectAsyncToUserInventory()
+        {
+            TestHelpers.InMethod();
+            TestHelpers.EnableLogging();
+
+            UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000001");
+            string myObjectName = "Fred";
+
+            TestScene scene = new SceneHelpers().SetupScene();
+
+            // Turn off the timer on the async sog deleter - we'll crank it by hand for this test.
+            AsyncSceneObjectGroupDeleter sogd = scene.SceneObjectGroupDeleter;
+            sogd.Enabled = false;
+
+            SceneObjectGroup so = SceneHelpers.AddSceneObject(scene, myObjectName, agentId);
+
+//            Assert.That(
+//                scene.CommsManager.UserAdminService.AddUser(
+//                    "Bob", "Hoskins", "test", "test@test.com", 1000, 1000, agentId),
+//                Is.EqualTo(agentId));
+
+            UserAccount ua = UserAccountHelpers.CreateUserWithInventory(scene, agentId);
+            InventoryFolderBase folder1
+                = UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, ua.PrincipalID, "folder1");
+
+            IClientAPI client = SceneHelpers.AddScenePresence(scene, agentId).ControllingClient;
+            scene.DeRezObjects(client, new List<uint>() { so.LocalId }, UUID.Zero, DeRezAction.Take, folder1.ID);
+
+            SceneObjectPart retrievedPart = scene.GetSceneObjectPart(so.LocalId);
+
+            Assert.That(retrievedPart, Is.Not.Null);
+            Assert.That(so.IsDeleted, Is.False);
+
+            sogd.InventoryDeQueueAndDelete();
+
+            Assert.That(so.IsDeleted, Is.True);
+
+            SceneObjectPart retrievedPart2 = scene.GetSceneObjectPart(so.LocalId);
+            Assert.That(retrievedPart2, Is.Null);
+
+//            SceneSetupHelpers.DeleteSceneObjectAsync(scene, part, DeRezAction.Take, userInfo.RootFolder.ID, client);
+
+            InventoryItemBase retrievedItem
+                = UserInventoryHelpers.GetInventoryItem(
+                    scene.InventoryService, ua.PrincipalID, "folder1/" + myObjectName);
+
+            // Check that we now have the taken part in our inventory
+            Assert.That(retrievedItem, Is.Not.Null);
+
+            // Check that the taken part has actually disappeared
+//            SceneObjectPart retrievedPart = scene.GetSceneObjectPart(part.LocalId);
+//            Assert.That(retrievedPart, Is.Null);
+        }
         
         /// <summary>
         /// Changing a scene object uuid changes the root part uuid.  This is a valid operation if the object is not
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
index 5758869..5faf131 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
@@ -141,7 +141,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             TestScene scene = new SceneHelpers().SetupScene();
             ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
 
-            scene.IncomingCloseAgent(sp.UUID);
+            scene.IncomingCloseAgent(sp.UUID, false);
 
             Assert.That(scene.GetScenePresence(sp.UUID), Is.Null);
             Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(sp.UUID), Is.Null);
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
index d722a09..ac3da1e 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
@@ -65,5 +65,22 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             
             Assert.That(scene.Frame, Is.EqualTo(1));
         }
+
+        [Test]
+        public void TestShutdownScene()
+        {
+            TestHelpers.InMethod();
+
+            Scene scene = new SceneHelpers().SetupScene();
+            scene.Close();
+
+            Assert.That(scene.ShuttingDown, Is.True);
+            Assert.That(scene.Active, Is.False);
+
+            // Trying to update a shutdown scene should result in no update
+            scene.Update(1);
+
+            Assert.That(scene.Frame, Is.EqualTo(0));
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs b/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
index 44d2d45..9457ebb 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
@@ -50,9 +50,41 @@ using OpenSim.Tests.Common.Mock;
 namespace OpenSim.Region.Framework.Tests
 {
     [TestFixture]
-    public class UserInventoryTests
+    public class UserInventoryTests : OpenSimTestCase
     {
         [Test]
+        public void TestCreateInventoryFolders()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            // For this test both folders will have the same name which is legal in SL user inventories.
+            string foldersName = "f1";
+
+            Scene scene = new SceneHelpers().SetupScene();
+            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1001));
+
+            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, user1.PrincipalID, foldersName);
+
+            List<InventoryFolderBase> oneFolder
+                = UserInventoryHelpers.GetInventoryFolders(scene.InventoryService, user1.PrincipalID, foldersName);
+
+            Assert.That(oneFolder.Count, Is.EqualTo(1));
+            InventoryFolderBase firstRetrievedFolder = oneFolder[0];
+            Assert.That(firstRetrievedFolder.Name, Is.EqualTo(foldersName));
+
+            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, user1.PrincipalID, foldersName);
+
+            List<InventoryFolderBase> twoFolders
+                = UserInventoryHelpers.GetInventoryFolders(scene.InventoryService, user1.PrincipalID, foldersName);
+
+            Assert.That(twoFolders.Count, Is.EqualTo(2));
+            Assert.That(twoFolders[0].Name, Is.EqualTo(foldersName));
+            Assert.That(twoFolders[1].Name, Is.EqualTo(foldersName));
+            Assert.That(twoFolders[0].ID, Is.Not.EqualTo(twoFolders[1].ID));
+        }
+
+        [Test]
         public void TestGiveInventoryItem()
         {
             TestHelpers.InMethod();
@@ -83,7 +115,7 @@ namespace OpenSim.Region.Framework.Tests
         public void TestGiveInventoryFolder()
         {
             TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
+//            TestHelpers.EnableLogging();
             
             Scene scene = new SceneHelpers().SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1001));
diff --git a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
index 411e421..2279e62 100644
--- a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
+++ b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
@@ -52,26 +52,23 @@ namespace OpenSim.Region.Framework.Scenes
     public class UuidGatherer
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
-        /// <summary>
-        /// Asset cache used for gathering assets
-        /// </summary>
-        protected IAssetService m_assetCache;
-        
-        /// <summary>
-        /// Used as a temporary store of an asset which represents an object.  This can be a null if no appropriate
-        /// asset was found by the asset service.
-        /// </summary>
-        private AssetBase m_requestedObjectAsset;
 
-        /// <summary>
-        /// Signal whether we are currently waiting for the asset service to deliver an asset.
-        /// </summary>
-        private bool m_waitingForObjectAsset;
+        protected IAssetService m_assetService;
+
+//        /// <summary>
+//        /// Used as a temporary store of an asset which represents an object.  This can be a null if no appropriate
+//        /// asset was found by the asset service.
+//        /// </summary>
+//        private AssetBase m_requestedObjectAsset;
+//
+//        /// <summary>
+//        /// Signal whether we are currently waiting for the asset service to deliver an asset.
+//        /// </summary>
+//        private bool m_waitingForObjectAsset;
                 
-        public UuidGatherer(IAssetService assetCache)
+        public UuidGatherer(IAssetService assetService)
         {
-            m_assetCache = assetCache;
+            m_assetService = assetService;
         }
                 
         /// <summary>
@@ -191,18 +188,18 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
         
-        /// <summary>
-        /// The callback made when we request the asset for an object from the asset service.
-        /// </summary>
-        private void AssetReceived(string id, Object sender, AssetBase asset)
-        {
-            lock (this)
-            {
-                m_requestedObjectAsset = asset;
-                m_waitingForObjectAsset = false;
-                Monitor.Pulse(this);
-            }
-        }
+//        /// <summary>
+//        /// The callback made when we request the asset for an object from the asset service.
+//        /// </summary>
+//        private void AssetReceived(string id, Object sender, AssetBase asset)
+//        {
+//            lock (this)
+//            {
+//                m_requestedObjectAsset = asset;
+//                m_waitingForObjectAsset = false;
+//                Monitor.Pulse(this);
+//            }
+//        }
 
         /// <summary>
         /// Get an asset synchronously, potentially using an asynchronous callback.  If the
@@ -212,25 +209,29 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         protected virtual AssetBase GetAsset(UUID uuid)
         {
-            m_waitingForObjectAsset = true;
-            m_assetCache.Get(uuid.ToString(), this, AssetReceived);
-
-            // The asset cache callback can either
-            //
-            // 1. Complete on the same thread (if the asset is already in the cache) or
-            // 2. Come in via a different thread (if we need to go fetch it).
-            //
-            // The code below handles both these alternatives.
-            lock (this)
-            {
-                if (m_waitingForObjectAsset)
-                {
-                    Monitor.Wait(this);
-                    m_waitingForObjectAsset = false;
-                }
-            }
+            return m_assetService.Get(uuid.ToString());
 
-            return m_requestedObjectAsset;
+            // XXX: Switching to do this synchronously where the call was async before but we always waited for it
+            // to complete anyway!
+//            m_waitingForObjectAsset = true;
+//            m_assetCache.Get(uuid.ToString(), this, AssetReceived);
+//
+//            // The asset cache callback can either
+//            //
+//            // 1. Complete on the same thread (if the asset is already in the cache) or
+//            // 2. Come in via a different thread (if we need to go fetch it).
+//            //
+//            // The code below handles both these alternatives.
+//            lock (this)
+//            {
+//                if (m_waitingForObjectAsset)
+//                {
+//                    Monitor.Wait(this);
+//                    m_waitingForObjectAsset = false;
+//                }
+//            }
+//
+//            return m_requestedObjectAsset;
         }
 
         /// <summary>
@@ -361,4 +362,47 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
     }
+
+    public class HGUuidGatherer : UuidGatherer
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected string m_assetServerURL;
+
+        public HGUuidGatherer(IAssetService assetService, string assetServerURL)
+            : base(assetService)
+        {
+            m_assetServerURL = assetServerURL;
+            if (!m_assetServerURL.EndsWith("/") && !m_assetServerURL.EndsWith("="))
+                m_assetServerURL = m_assetServerURL + "/";
+        }
+
+        protected override AssetBase GetAsset(UUID uuid)
+        {
+            if (string.Empty == m_assetServerURL)
+                return base.GetAsset(uuid);
+            else
+                return FetchAsset(uuid);
+        }
+
+        public AssetBase FetchAsset(UUID assetID)
+        {
+
+            // Test if it's already here
+            AssetBase asset = m_assetService.Get(assetID.ToString());
+            if (asset == null)
+            {
+                // It's not, so fetch it from abroad
+                asset = m_assetService.Get(m_assetServerURL + assetID.ToString());
+                if (asset != null)
+                    m_log.DebugFormat("[HGUUIDGatherer]: Copied asset {0} from {1} to local asset server", assetID, m_assetServerURL);
+                else
+                    m_log.DebugFormat("[HGUUIDGatherer]: Failed to fetch asset {0} from {1}", assetID, m_assetServerURL);
+            }
+            //else
+            //    m_log.DebugFormat("[HGUUIDGatherer]: Asset {0} from {1} was already here", assetID, m_assetServerURL);
+
+            return asset;
+        }
+    }
 }