53 files changed, 2393 insertions, 1082 deletions

diff --git a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
index 0516cb1..7446530 100644
--- a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
@@ -37,6 +37,20 @@ namespace OpenSim.Region.Framework.Interfaces
     public interface IAttachmentsModule
     {
         /// <summary>
+        /// Copy attachment data from a ScenePresence into the AgentData structure for transmission to another simulator
+        /// </summary>
+        /// <param name='sp'></param>
+        /// <param name='ad'></param>
+        void CopyAttachments(IScenePresence sp, AgentData ad);
+
+        /// <summary>
+        /// Copy attachment data from an AgentData structure into a ScenePresence.
+        /// </summary>
+        /// <param name='ad'></param>
+        /// <param name='sp'></param>
+        void CopyAttachments(AgentData ad, IScenePresence sp);
+
+        /// <summary>
         /// RezAttachments. This should only be called upon login on the first region.
         /// Attachment rezzings on crossings and TPs are done in a different way.
         /// </summary>
@@ -44,10 +58,15 @@ namespace OpenSim.Region.Framework.Interfaces
         void RezAttachments(IScenePresence sp);
 
         /// <summary>
-        /// Save the attachments that have change on this presence.
+        /// Derez the attachements for a scene presence that is closing.
         /// </summary>
-        /// <param name="sp"></param>
-        void SaveChangedAttachments(IScenePresence sp, bool saveAllScripted);
+        /// <remarks>
+        /// Attachment changes are saved.
+        /// </remarks>
+        /// <param name="sp">The presence closing</param>
+        /// <param name="saveChanged">Save changed attachments.</param>
+        /// <param name="saveAllScripted">Save attachments with scripts even if they haven't changed.</para>
+        void DeRezAttachments(IScenePresence sp, bool saveChanged, bool saveAllScripted);
 
         /// <summary>
         /// Delete all the presence's attachments from the scene
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
index 32f4eea..4f0e100 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
@@ -81,7 +81,12 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <summary>
         /// Start all the scripts contained in this entity's inventory
         /// </summary>
-        void CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource);
+        /// <param name="startParam"></param>
+        /// <param name="postOnRez"></param>
+        /// <param name="engine"></param>
+        /// <param name="stateSource"></param>
+        /// <returns>Number of scripts started.</returns>
+        int CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource);
         
         ArrayList GetScriptErrors(UUID itemID);
         void ResumeScripts();
@@ -102,7 +107,11 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="postOnRez"></param>
         /// <param name="engine"></param>
         /// <param name="stateSource"></param>
-        void CreateScriptInstance(
+        /// <returns>
+        /// true if the script instance was valid for starting, false otherwise.  This does not guarantee
+        /// that the script was actually started, just that the script was valid (i.e. its asset data could be found, etc.)
+        /// </returns>
+        bool CreateScriptInstance(
             TaskInventoryItem item, int startParam, bool postOnRez, string engine, int stateSource);
 
         /// <summary>
@@ -113,7 +122,11 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="postOnRez"></param>
         /// <param name="engine"></param>
         /// <param name="stateSource"></param>
-        void CreateScriptInstance(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource);
+        /// <returns>
+        /// true if the script instance was valid for starting, false otherwise.  This does not guarantee
+        /// that the script was actually started, just that the script was valid (i.e. its asset data could be found, etc.)
+        /// </returns>
+        bool CreateScriptInstance(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource);
 
         ArrayList CreateScriptInstanceEr(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource);
 
@@ -166,6 +179,19 @@ namespace OpenSim.Region.Framework.Interfaces
         List<TaskInventoryItem> GetInventoryItems();
 
         /// <summary>
+        /// Gets an inventory item by name
+        /// </summary>
+        /// <remarks>
+        /// This method returns the first inventory item that matches the given name.  In SL this is all you need
+        /// since each item in a prim inventory must have a unique name.
+        /// </remarks>
+        /// <param name='name'></param>
+        /// <returns>
+        /// The inventory item.  Null if no such item was found.
+        /// </returns>
+        TaskInventoryItem GetInventoryItem(string name);
+
+        /// <summary>
         /// Get inventory items by name.
         /// </summary>
         /// <param name="name"></param>
@@ -174,7 +200,17 @@ namespace OpenSim.Region.Framework.Interfaces
         /// If no inventory item has that name then an empty list is returned.
         /// </returns>
         List<TaskInventoryItem> GetInventoryItems(string name);
-        
+
+        /// <summary>
+        /// Get inventory items by type.
+        /// </summary>
+        /// <param type="name"></param>
+        /// <returns>
+        /// A list of inventory items of that type.
+        /// If no inventory items of that type then an empty list is returned.
+        /// </returns>
+        List<TaskInventoryItem> GetInventoryItems(InventoryType type);
+
         /// <summary>
         /// Get the scene object referenced by an inventory item.
         /// </summary>
@@ -228,6 +264,16 @@ namespace OpenSim.Region.Framework.Interfaces
         bool ContainsScripts();
 
         /// <summary>
+        /// Returns the count of scripts contained
+        /// </summary></returns>
+        int ScriptCount();
+
+        /// <summary>
+        /// Returns the count of running scripts contained
+        /// </summary></returns>
+        int RunningScriptCount();
+
+        /// <summary>
         /// Get the uuids of all items in this inventory
         /// </summary>
         /// <returns></returns>
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs b/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
index 76f1641..5bc8e51 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
@@ -39,13 +39,30 @@ namespace OpenSim.Region.Framework.Interfaces
 
     public interface IEntityTransferModule
     {
-        void Teleport(ScenePresence agent, ulong regionHandle, Vector3 position,
-                                                      Vector3 lookAt, uint teleportFlags);
+        /// <summary>
+        /// Teleport an agent within the same or to a different region.
+        /// </summary>
+        /// <param name='agent'></param>
+        /// <param name='regionHandle'>
+        /// The handle of the destination region.  If it's the same as the region currently
+        /// occupied by the agent then the teleport will be within that region.
+        /// </param>
+        /// <param name='position'></param>
+        /// <param name='lookAt'></param>
+        /// <param name='teleportFlags'></param>
+        void Teleport(ScenePresence agent, ulong regionHandle, Vector3 position, Vector3 lookAt, uint teleportFlags);
 
         bool TeleportHome(UUID id, IClientAPI client);
 
         void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination,
-            Vector3 position, Vector3 lookAt, uint teleportFlags, IEventQueue eq);
+            Vector3 position, Vector3 lookAt, uint teleportFlags);
+
+        /// <summary>
+        /// Show whether the given agent is being teleported.
+        /// </summary>
+        /// <param name='id'>The agent ID</para></param>
+        /// <returns>true if the agent is in the process of being teleported, false otherwise.</returns>
+        bool IsInTransit(UUID id);        
 
         bool Cross(ScenePresence agent, bool isFlying);
 
diff --git a/OpenSim/Region/Framework/Interfaces/IEnvironmentModule.cs b/OpenSim/Region/Framework/Interfaces/IEnvironmentModule.cs
new file mode 100644
index 0000000..7a7b782
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/IEnvironmentModule.cs
@@ -0,0 +1,36 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Region.Framework.Interfaces
+{
+    public interface IEnvironmentModule
+    {
+        void ResetEnvironmentSettings(UUID regionUUID);
+    }
+}
diff --git a/OpenSim/Region/Framework/Interfaces/IEstateModule.cs b/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
index 72e79ed..ca2ad94 100644
--- a/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
@@ -47,5 +47,8 @@ namespace OpenSim.Region.Framework.Interfaces
         void sendRegionHandshakeToAll();
         void TriggerEstateInfoChange();
         void TriggerRegionInfoChange();
+
+        void setEstateTerrainBaseTexture(int level, UUID texture);
+        void setEstateTerrainTextureHeights(int corner, float lowValue, float highValue);
     }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/IInventoryAccessModule.cs b/OpenSim/Region/Framework/Interfaces/IInventoryAccessModule.cs
index 1904011..3576e35 100644
--- a/OpenSim/Region/Framework/Interfaces/IInventoryAccessModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IInventoryAccessModule.cs
@@ -49,11 +49,15 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="folderID"></param>
         /// <param name="objectGroups"></param>
         /// <param name="remoteClient"></param>
+        /// <param name="asAttachment">
+        /// Should be true if the object(s) are begin taken as attachments.  False otherwise.
+        /// </param>
         /// <returns>
-        /// Returns the UUID of the newly created item asset (not the item itself).
-        /// FIXME: This is not very useful.  It would be far more useful to return a list of items instead.
+        /// A list of the items created.  If there was more than one object and objects are not being coaleseced in
+        /// inventory, then the order of items is in the same order as the input objects.
         /// </returns>
-        UUID CopyToInventory(DeRezAction action, UUID folderID, List<SceneObjectGroup> objectGroups, IClientAPI remoteClient);
+        List<InventoryItemBase> CopyToInventory(
+            DeRezAction action, UUID folderID, List<SceneObjectGroup> objectGroups, IClientAPI remoteClient, bool asAttachment);
 
         /// <summary>
         /// Rez an object into the scene from the user's inventory
diff --git a/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs b/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
new file mode 100644
index 0000000..baac6e8
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Contributors 
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Reflection;
+using OpenMetaverse;
+
+namespace OpenSim.Region.Framework.Interfaces
+{
+    public delegate void TakeValueCallback(string s);
+
+    public interface IJsonStoreModule
+    {
+        bool CreateStore(string value, out UUID result);
+        bool DestroyStore(UUID storeID);
+        bool TestPath(UUID storeID, string path, bool useJson);
+        bool SetValue(UUID storeID, string path, string value, bool useJson);
+        bool RemoveValue(UUID storeID, string path);
+        bool GetValue(UUID storeID, string path, bool useJson, out string value);
+
+        void TakeValue(UUID storeID, string path, bool useJson, TakeValueCallback cback);
+        void ReadValue(UUID storeID, string path, bool useJson, TakeValueCallback cback);
+    }
+}
diff --git a/OpenSim/Region/Framework/Interfaces/INPCModule.cs b/OpenSim/Region/Framework/Interfaces/INPCModule.cs
index dc3ff89..860483d 100644
--- a/OpenSim/Region/Framework/Interfaces/INPCModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/INPCModule.cs
@@ -113,9 +113,11 @@ namespace OpenSim.Region.Framework.Interfaces
         /// </param>
         /// <param name="landAtTarget">
         /// If true and the avatar is flying when it reaches the target, land.
-        /// </param>
+        /// </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 MoveToTarget(UUID agentID, Scene scene, Vector3 pos, bool noFly, bool landAtTarget, bool running);
 
         /// <summary>
         /// Stop the NPC's current movement.
@@ -135,6 +137,36 @@ namespace OpenSim.Region.Framework.Interfaces
         bool Say(UUID agentID, Scene scene, string text);
 
         /// <summary>
+        /// Get the NPC to say something.
+        /// </summary>
+        /// <param name="agentID">The UUID of the NPC</param>
+        /// <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>
+        bool Say(UUID agentID, Scene scene, string text, int channel);
+
+        /// <summary>
+        /// Get the NPC to shout something.
+        /// </summary>
+        /// <param name="agentID">The UUID of the NPC</param>
+        /// <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>
+        bool Shout(UUID agentID, Scene scene, string text, int channel);
+
+        /// <summary>
+        /// Get the NPC to whisper something.
+        /// </summary>
+        /// <param name="agentID">The UUID of the NPC</param>
+        /// <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>
+        bool Whisper(UUID agentID, Scene scene, string text, int channel);
+
+        /// <summary>
         /// Sit the NPC.
         /// </summary>
         /// <param name="agentID"></param>
diff --git a/OpenSim/Region/Framework/Interfaces/IRegionCombinerModule.cs b/OpenSim/Region/Framework/Interfaces/IRegionCombinerModule.cs
new file mode 100644
index 0000000..e03ac5a
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/IRegionCombinerModule.cs
@@ -0,0 +1,59 @@
+/*
+ * 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.Linq;
+using System.Text;
+using OpenSim.Region.Framework.Scenes;
+using System.IO;
+using OpenMetaverse;
+
+namespace OpenSim.Region.Framework.Interfaces
+{
+    public interface IRegionCombinerModule
+    {
+        /// <summary>
+        /// Does the given id belong to the root region of a megaregion?
+        /// </summary>
+        bool IsRootForMegaregion(UUID regionId);
+
+        /// <summary>
+        /// Gets the size of megaregion.
+        /// </summary>
+        /// <remarks>
+        /// Returns size in meters.
+        /// Do not rely on this method remaining the same - this area is actively under development.
+        /// </remarks>
+        /// <param name="sceneId">
+        /// The id of the root region for a megaregion.
+        /// This may change in the future to allow any region id that makes up a megaregion.
+        /// Currently, will throw an exception if this does not match a root region.
+        /// </param>
+        Vector2 GetSizeOfMegaregion(UUID regionId);
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IScenePresence.cs b/OpenSim/Region/Framework/Interfaces/IScenePresence.cs
index 5e43843..19a8236 100644
--- a/OpenSim/Region/Framework/Interfaces/IScenePresence.cs
+++ b/OpenSim/Region/Framework/Interfaces/IScenePresence.cs
@@ -41,6 +41,12 @@ namespace OpenSim.Region.Framework.Interfaces
     public interface IScenePresence : ISceneAgent
     {
         /// <summary>
+        /// Copy of the script states while the agent is in transit. This state may
+        /// need to be placed back in case of transfer fail.
+        /// </summary>
+        List<string> InTransitScriptStates { get; }
+
+        /// <summary>
         /// The AttachmentsModule synchronizes on this to avoid race conditions between commands to add and remove attachments.
         /// </summary>
         /// <remarks>
diff --git a/OpenSim/Region/Framework/Interfaces/IScriptModule.cs b/OpenSim/Region/Framework/Interfaces/IScriptModule.cs
index ce66100..42dbedc 100644
--- a/OpenSim/Region/Framework/Interfaces/IScriptModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IScriptModule.cs
@@ -71,6 +71,14 @@ namespace OpenSim.Region.Framework.Interfaces
 
         bool HasScript(UUID itemID, out bool running);
 
+        /// <summary>
+        /// Returns true if a script is running.
+        /// </summary>
+        /// <param name="itemID">The item ID of the script.</param>
+        bool GetScriptState(UUID itemID);
+
+        void SetRunEnable(UUID instanceID, bool enable);
+
         void SaveAllState();
 
         /// <summary>
@@ -79,6 +87,14 @@ namespace OpenSim.Region.Framework.Interfaces
         void StartProcessing();
 
         /// <summary>
+        /// Get the execution times of all scripts in the given array if they are currently running.
+        /// </summary>
+        /// <returns>
+        /// A float the value is a representative execution time in milliseconds of all scripts in that Array.
+        /// </returns>
+        float GetScriptExecutionTime(List<UUID> itemIDs);
+
+        /// <summary>
         /// Get the execution times of all scripts in each object.
         /// </summary>
         /// <returns>
@@ -87,4 +103,4 @@ namespace OpenSim.Region.Framework.Interfaces
         /// </returns>
         Dictionary<uint, float> GetObjectScriptsExecutionTimes();
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Interfaces/ISimulationDataService.cs b/OpenSim/Region/Framework/Interfaces/ISimulationDataService.cs
index 5b69616..ccb583d 100644
--- a/OpenSim/Region/Framework/Interfaces/ISimulationDataService.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISimulationDataService.cs
@@ -96,6 +96,26 @@ namespace OpenSim.Region.Framework.Interfaces
         void StoreRegionWindlightSettings(RegionLightShareData wl);
         void RemoveRegionWindlightSettings(UUID regionID);
 
+        /// <summary>
+        /// Load Environment settings from region storage
+        /// </summary>
+        /// <param name="regionUUID">the region UUID</param>
+        /// <returns>LLSD string for viewer</returns>
+        string LoadRegionEnvironmentSettings(UUID regionUUID);
+
+        /// <summary>
+        /// Store Environment settings into region storage
+        /// </summary>
+        /// <param name="regionUUID">the region UUID</param>
+        /// <param name="settings">LLSD string from viewer</param>
+        void StoreRegionEnvironmentSettings(UUID regionUUID, string settings);
+
+        /// <summary>
+        /// Delete Environment settings from region storage
+        /// </summary>
+        /// <param name="regionUUID">the region UUID</param>
+        void RemoveRegionEnvironmentSettings(UUID regionUUID);
+
         UUID[] GetObjectIDs(UUID regionID);
     }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs b/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
index b7d9cfa..d7c80f7 100644
--- a/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
@@ -108,6 +108,26 @@ namespace OpenSim.Region.Framework.Interfaces
         void RemoveRegionWindlightSettings(UUID regionID);
         UUID[] GetObjectIDs(UUID regionID);
 
+        /// <summary>
+        /// Load Environment settings from region storage
+        /// </summary>
+        /// <param name="regionUUID">the region UUID</param>
+        /// <returns>LLSD string for viewer</returns>
+        string LoadRegionEnvironmentSettings(UUID regionUUID);
+
+        /// <summary>
+        /// Store Environment settings into region storage
+        /// </summary>
+        /// <param name="regionUUID">the region UUID</param>
+        /// <param name="settings">LLSD string from viewer</param>
+        void StoreRegionEnvironmentSettings(UUID regionUUID, string settings);
+
+        /// <summary>
+        /// Delete Environment settings from region storage
+        /// </summary>
+        /// <param name="regionUUID">the region UUID</param>
+        void RemoveRegionEnvironmentSettings(UUID regionUUID);
+
         void Shutdown();
     }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/IUrlModule.cs b/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
index 1b91166..457444c 100644
--- a/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
@@ -34,6 +34,7 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface IUrlModule
     {
+        string ExternalHostNameForLSL { get; }
         UUID RequestURL(IScriptModule engine, SceneObjectPart host, UUID itemID);
         UUID RequestSecureURL(IScriptModule engine, SceneObjectPart host, UUID itemID);
         void ReleaseURL(string url);
diff --git a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
index e577958..9ddac19 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -294,6 +294,10 @@ namespace OpenSim.Region.Framework.Scenes.Animation
                     return "FALLDOWN";
                 }
 
+                // Check if the user has stopped walking just now
+                if (CurrentMovementAnimation == "WALK" && (move == Vector3.Zero))
+                    return "STAND";
+
                 return CurrentMovementAnimation;
             }
 
@@ -418,13 +422,16 @@ namespace OpenSim.Region.Framework.Scenes.Animation
         /// </summary>
         public void UpdateMovementAnimations()
         {
-            CurrentMovementAnimation = DetermineMovementAnimation();
+            lock (m_animations)
+            {
+                CurrentMovementAnimation = DetermineMovementAnimation();
 
-//            m_log.DebugFormat(
-//                "[SCENE PRESENCE ANIMATOR]: Determined animation {0} for {1} in UpdateMovementAnimations()",
-//                CurrentMovementAnimation, m_scenePresence.Name);
+//                m_log.DebugFormat(
+//                    "[SCENE PRESENCE ANIMATOR]: Determined animation {0} for {1} in UpdateMovementAnimations()",
+//                    CurrentMovementAnimation, m_scenePresence.Name);
 
-            TrySetMovementAnimation(CurrentMovementAnimation);
+                TrySetMovementAnimation(CurrentMovementAnimation);
+            }
         }
 
         public UUID[] GetAnimationArray()
diff --git a/OpenSim/Region/Framework/Scenes/AsyncInventorySender.cs b/OpenSim/Region/Framework/Scenes/AsyncInventorySender.cs
index 9cb5674..d9d2e64 100644
--- a/OpenSim/Region/Framework/Scenes/AsyncInventorySender.cs
+++ b/OpenSim/Region/Framework/Scenes/AsyncInventorySender.cs
@@ -137,7 +137,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
 
-                if (fh.Client.IsLoggingOut)
+                if (!fh.Client.IsActive)
                     continue;
 
 //                m_log.DebugFormat(
diff --git a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
index f678d07..f555b49 100644
--- a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
+++ b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
@@ -117,7 +117,7 @@ namespace OpenSim.Region.Framework.Scenes
         
         private void InventoryRunDeleteTimer(object sender, ElapsedEventArgs e)
         {
-            m_log.Debug("[ASYNC DELETER]: Starting send to inventory loop");
+//            m_log.Debug("[ASYNC DELETER]: Starting send to inventory loop");
 
             // We must set appearance parameters in the en_US culture in order to avoid issues where values are saved
             // in a culture where decimal points are commas and then reloaded in a culture which just treats them as
@@ -147,15 +147,15 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         x = m_inventoryDeletes.Dequeue();
 
-                        m_log.DebugFormat(
-                            "[ASYNC DELETER]: Sending object to user's inventory, action {1}, count {2}, {0} item(s) remaining.",
-                            left, x.action, x.objectGroups.Count);
+//                        m_log.DebugFormat(
+//                            "[ASYNC DELETER]: Sending object to user's inventory, action {1}, count {2}, {0} item(s) remaining.",
+//                            left, x.action, x.objectGroups.Count);
                         
                         try
                         {
                             IInventoryAccessModule invAccess = m_scene.RequestModuleInterface<IInventoryAccessModule>();
                             if (invAccess != null)
-                                invAccess.CopyToInventory(x.action, x.folderID, x.objectGroups, x.remoteClient);
+                                invAccess.CopyToInventory(x.action, x.folderID, x.objectGroups, x.remoteClient, false);
                             
                             if (x.permissionToDelete)
                             {
@@ -185,7 +185,7 @@ namespace OpenSim.Region.Framework.Scenes
                     e.StackTrace);
             }
 
-            m_log.Debug("[ASYNC DELETER]: No objects left in inventory send queue.");
+//            m_log.Debug("[ASYNC DELETER]: No objects left in inventory send queue.");
             
             return false;
         }
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 2365cfe..76a952b 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -53,6 +53,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         public event ClientMovement OnClientMovement;
 
+        public delegate void OnTerrainTaintedDelegate();
+
+        public event OnTerrainTaintedDelegate OnTerrainTainted;
+
         public delegate void OnTerrainTickDelegate();
 
         public delegate void OnTerrainUpdateDelegate();
@@ -484,6 +488,9 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void SceneObjectPartUpdated(SceneObjectPart sop);
         public event SceneObjectPartUpdated OnSceneObjectPartUpdated;
 
+        public delegate void ScenePresenceUpdated(ScenePresence sp);
+        public event ScenePresenceUpdated OnScenePresenceUpdated;
+
         public delegate void RegionUp(GridRegion region);
         public event RegionUp OnRegionUp;
 
@@ -935,6 +942,27 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public void TriggerTerrainTainted()
+        {
+            OnTerrainTaintedDelegate handlerTerrainTainted = OnTerrainTainted;
+            if (handlerTerrainTainted != null)
+            {
+                foreach (OnTerrainTaintedDelegate d in handlerTerrainTainted.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerTerrainTainted failed - continuing.  {0} {1}",
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }
+
         public void TriggerParcelPrimCountAdd(SceneObjectGroup obj)
         {
             OnParcelPrimCountAddDelegate handlerParcelPrimCountAdd = OnParcelPrimCountAdd;
@@ -2367,6 +2395,27 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public void TriggerScenePresenceUpdated(ScenePresence sp)
+        {
+            ScenePresenceUpdated handler = OnScenePresenceUpdated;
+            if (handler != null)
+            {
+                foreach (ScenePresenceUpdated d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(sp);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerScenePresenceUpdated failed - continuing.  {0} {1}",
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }
+
         public void TriggerOnParcelPropertiesUpdateRequest(LandUpdateArgs args,
                         int local_id, IClientAPI remote_client)
         {
diff --git a/OpenSim/Region/Framework/Scenes/RegionStatsHandler.cs b/OpenSim/Region/Framework/Scenes/RegionStatsHandler.cs
index 6c5685c..1365831 100644
--- a/OpenSim/Region/Framework/Scenes/RegionStatsHandler.cs
+++ b/OpenSim/Region/Framework/Scenes/RegionStatsHandler.cs
@@ -48,16 +48,19 @@ namespace OpenSim.Region.Framework.Scenes
 {
     public class RegionStatsHandler : IStreamedRequestHandler
     {
+        //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         private string osRXStatsURI = String.Empty;
         private string osXStatsURI = String.Empty;
         //private string osSecret = String.Empty;
         private OpenSim.Framework.RegionInfo regionInfo;
         public string localZone = TimeZone.CurrentTimeZone.StandardName;
         public TimeSpan utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now);
-        
-        //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        public RegionStatsHandler(OpenSim.Framework.RegionInfo region_info)
+        public string Name { get { return "RegionStats"; } }
+        public string Description { get { return "Region Statistics"; } }
+
+        public RegionStatsHandler(RegionInfo region_info)
         {
             regionInfo = region_info;
             osRXStatsURI = Util.SHA1Hash(regionInfo.regionSecret);
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 29465c0..9776a82 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -60,19 +60,32 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Creates all the scripts in the scene which should be started.
         /// </summary>
-        public void CreateScriptInstances()
+        /// <returns>
+        /// Number of scripts that were valid for starting.  This does not guarantee that all these scripts
+        /// were actually started, but just that the start could be attempt (e.g. the asset data for the script could be found)
+        /// </returns>
+        public int CreateScriptInstances()
         {
-            m_log.Info("[PRIM INVENTORY]: Creating scripts in scene");
+            m_log.InfoFormat("[SCENE]: Initializing script instances in {0}", RegionInfo.RegionName);
+
+            int scriptsValidForStarting = 0;
 
             EntityBase[] entities = Entities.GetEntities();
             foreach (EntityBase group in entities)
             {
                 if (group is SceneObjectGroup)
                 {
-                    ((SceneObjectGroup) group).CreateScriptInstances(0, false, DefaultScriptEngine, 0);
+                    scriptsValidForStarting
+                        += ((SceneObjectGroup) group).CreateScriptInstances(0, false, DefaultScriptEngine, 0);
                     ((SceneObjectGroup) group).ResumeScripts();
                 }
             }
+
+            m_log.InfoFormat(
+                "[SCENE]: Initialized {0} script instances in {1}",
+                scriptsValidForStarting, RegionInfo.RegionName);
+
+            return scriptsValidForStarting;
         }
 
         /// <summary>
@@ -80,7 +93,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void StartScripts()
         {
-            m_log.Info("[PRIM INVENTORY]: Starting scripts in scene");
+            m_log.InfoFormat("[SCENE]: Starting scripts in {0}, please wait.", RegionInfo.RegionName);
 
             IScriptModule[] engines = RequestModuleInterfaces<IScriptModule>();
 
@@ -300,6 +313,10 @@ namespace OpenSim.Region.Framework.Scenes
             AssetBase asset = CreateAsset(item.Name, item.Description, (sbyte)AssetType.LSLText, data, remoteClient.AgentId);
             AssetService.Store(asset);
 
+//            m_log.DebugFormat(
+//                "[PRIM INVENTORY]: Stored asset {0} when updating item {1} in prim {2} for {3}",
+//                asset.ID, item.Name, part.Name, remoteClient.Name);
+
             if (isScriptRunning)
             {
                 part.Inventory.RemoveScriptInstance(item.ItemID, false);
@@ -431,10 +448,9 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 else
                 {
-                    IAgentAssetTransactions agentTransactions = this.RequestModuleInterface<IAgentAssetTransactions>();
-                    if (agentTransactions != null)
+                    if (AgentTransactionsModule != null)
                     {
-                        agentTransactions.HandleItemUpdateFromTransaction(remoteClient, transactionID, item);
+                        AgentTransactionsModule.HandleItemUpdateFromTransaction(remoteClient, transactionID, item);
                     }
                 }
             }
@@ -950,8 +966,8 @@ namespace OpenSim.Region.Framework.Scenes
                                              sbyte invType, sbyte type, UUID olditemID)
         {
 //            m_log.DebugFormat(
-//                "[AGENT INVENTORY]: Received request from {0} to create inventory item link {1} in folder {2} pointing to {3}",
-//                remoteClient.Name, name, folderID, olditemID);
+//                "[AGENT INVENTORY]: Received request from {0} to create inventory item link {1} in folder {2} pointing to {3}, assetType {4}, inventoryType {5}",
+//                remoteClient.Name, name, folderID, olditemID, (AssetType)type, (InventoryType)invType);
 
             if (!Permissions.CanCreateUserInventory(invType, remoteClient.AgentId))
                 return;
@@ -984,10 +1000,10 @@ namespace OpenSim.Region.Framework.Scenes
                 asset.Type = type;
                 asset.Name = name;
                 asset.Description = description;
-                
+
                 CreateNewInventoryItem(
-                    remoteClient, remoteClient.AgentId.ToString(), string.Empty, folderID, name, 0, callbackID, asset, invType, 
-                    (uint)PermissionMask.All, (uint)PermissionMask.All, (uint)PermissionMask.All, 
+                    remoteClient, remoteClient.AgentId.ToString(), string.Empty, folderID, name, 0, callbackID, asset, invType,
+                    (uint)PermissionMask.All, (uint)PermissionMask.All, (uint)PermissionMask.All,
                     (uint)PermissionMask.All, (uint)PermissionMask.All, Util.UnixTimeSinceEpoch());
             }
             else
@@ -1562,21 +1578,17 @@ namespace OpenSim.Region.Framework.Scenes
                     // Only look for an uploaded updated asset if we are passed a transaction ID.  This is only the
                     // case for updates uploded through UDP.  Updates uploaded via a capability (e.g. a script update)
                     // will not pass in a transaction ID in the update message.
-                    if (transactionID != UUID.Zero)
+                    if (transactionID != UUID.Zero && AgentTransactionsModule != null)
                     {
-                        IAgentAssetTransactions agentTransactions = this.RequestModuleInterface<IAgentAssetTransactions>();
-                        if (agentTransactions != null)
-                        {
-                            agentTransactions.HandleTaskItemUpdateFromTransaction(
-                                remoteClient, part, transactionID, currentItem);
-    
-//                            if ((InventoryType)itemInfo.InvType == InventoryType.Notecard)
-//                                remoteClient.SendAgentAlertMessage("Notecard saved", false);
-//                            else if ((InventoryType)itemInfo.InvType == InventoryType.LSL)
-//                                remoteClient.SendAgentAlertMessage("Script saved", false);
-//                            else
-//                                remoteClient.SendAgentAlertMessage("Item saved", false);
-                        }
+                        AgentTransactionsModule.HandleTaskItemUpdateFromTransaction(
+                            remoteClient, part, transactionID, currentItem);
+
+//                        if ((InventoryType)itemInfo.InvType == InventoryType.Notecard)
+//                            remoteClient.SendAgentAlertMessage("Notecard saved", false);
+//                        else if ((InventoryType)itemInfo.InvType == InventoryType.LSL)
+//                            remoteClient.SendAgentAlertMessage("Script saved", false);
+//                        else
+//                            remoteClient.SendAgentAlertMessage("Item saved", false);
                     }
 
                     // Base ALWAYS has move
@@ -2286,10 +2298,24 @@ namespace OpenSim.Region.Framework.Scenes
             if (part == null)
                 return;
 
+            IScriptModule[] engines = RequestModuleInterfaces<IScriptModule>();
+
             if (running)
+            {
+                foreach (IScriptModule engine in engines)
+                {
+                    engine.SetRunEnable(itemID, true);
+                }
                 EventManager.TriggerStartScript(part.LocalId, itemID);
+            }
             else
+            {
+                foreach (IScriptModule engine in engines)
+                {
+                    engine.SetRunEnable(itemID, false);
+                }
                 EventManager.TriggerStopScript(part.LocalId, itemID);
+            }
         }
 
         public void GetScriptRunning(IClientAPI controllingClient, UUID objectID, UUID itemID)
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs b/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
index e1fedf4..535d87a 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
@@ -67,6 +67,7 @@ namespace OpenSim.Region.Framework.Scenes
     public delegate bool RunConsoleCommandHandler(UUID user, Scene requestFromScene);
     public delegate bool IssueEstateCommandHandler(UUID user, Scene requestFromScene, bool ownerCommand);
     public delegate bool IsGodHandler(UUID user, Scene requestFromScene);
+    public delegate bool IsGridGodHandler(UUID user, Scene requestFromScene);
     public delegate bool IsAdministratorHandler(UUID user);
     public delegate bool EditParcelHandler(UUID user, ILandObject parcel, Scene scene);
     public delegate bool EditParcelPropertiesHandler(UUID user, ILandObject parcel, GroupPowers p, Scene scene);
@@ -134,6 +135,7 @@ namespace OpenSim.Region.Framework.Scenes
         public event RunConsoleCommandHandler OnRunConsoleCommand;
         public event IssueEstateCommandHandler OnIssueEstateCommand;
         public event IsGodHandler OnIsGod;
+        public event IsGridGodHandler OnIsGridGod;
         public event IsAdministratorHandler OnIsAdministrator;
 //        public event EditParcelHandler OnEditParcel;
         public event EditParcelPropertiesHandler OnEditParcelProperties;
@@ -728,6 +730,21 @@ namespace OpenSim.Region.Framework.Scenes
             return true;
         }
 
+        public bool IsGridGod(UUID user)
+        {
+            IsGridGodHandler handler = OnIsGridGod;
+            if (handler != null)
+            {
+                Delegate[] list = handler.GetInvocationList();
+                foreach (IsGridGodHandler h in list)
+                {
+                    if (h(user, m_scene) == false)
+                        return false;
+                }
+            }
+            return true;
+        }
+
         public bool IsAdministrator(UUID user)
         {
             IsAdministratorHandler handler = OnIsAdministrator;
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 6a120c1..8591b09 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -77,7 +77,12 @@ namespace OpenSim.Region.Framework.Scenes
         public bool DebugUpdates { get; private set; }
 
         public SynchronizeSceneHandler SynchronizeScene;
-        public SimStatsReporter StatsReporter;
+
+        /// <summary>
+        /// Statistical information for this scene.
+        /// </summary>
+        public SimStatsReporter StatsReporter { get; private set; }
+
         public List<Border> NorthBorders = new List<Border>();
         public List<Border> EastBorders = new List<Border>();
         public List<Border> SouthBorders = new List<Border>();
@@ -103,6 +108,7 @@ namespace OpenSim.Region.Framework.Scenes
         public bool m_trustBinaries;
         public bool m_allowScriptCrossings;
         public bool m_useFlySlow;
+        public bool m_useTrashOnDelete = true;
 
         /// <summary>
         /// Temporarily setting to trigger appearance resends at 60 second intervals.
@@ -163,7 +169,6 @@ namespace OpenSim.Region.Framework.Scenes
         protected IConfigSource m_config;
         protected IRegionSerialiserModule m_serialiser;
         protected IDialogModule m_dialogModule;
-        protected IEntityTransferModule m_teleportModule;
         protected ICapabilitiesModule m_capsModule;
         protected IGroupsModule m_groupsModule;
 
@@ -217,6 +222,7 @@ namespace OpenSim.Region.Framework.Scenes
         private int backupMS;
         private int terrainMS;
         private int landMS;
+        private int spareMS;
 
         /// <summary>
         /// Tick at which the last frame was processed.
@@ -458,6 +464,7 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_simulationService == null)
                     m_simulationService = RequestModuleInterface<ISimulationService>();
+
                 return m_simulationService;
             }
         }
@@ -513,6 +520,9 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         public IAttachmentsModule AttachmentsModule { get; set; }
+        public IEntityTransferModule EntityTransferModule { get; private set; }
+        public IAgentAssetTransactions AgentTransactionsModule { get; private set; }
+        public IUserManagement UserManagementModule { get; private set; }
 
         public IAvatarFactoryModule AvatarFactory
         {
@@ -589,6 +599,20 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_sceneGraph.Entities; }
         }
 
+        
+        // used in sequence see: SpawnPoint()
+        private int m_SpawnPoint;
+        // can be closest/random/sequence
+        public string SpawnPointRouting
+        {
+            get; private set;
+        }
+        // allow landmarks to pass
+        public bool TelehubAllowLandmarks
+        {
+            get; private set;
+        }
+
         #endregion Properties
 
         #region Constructors
@@ -606,7 +630,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             Random random = new Random();
 
-            m_lastAllocatedLocalId = (uint)(random.NextDouble() * (double)(uint.MaxValue/2))+(uint)(uint.MaxValue/4);
+            m_lastAllocatedLocalId = (uint)(random.NextDouble() * (double)(uint.MaxValue / 2)) + (uint)(uint.MaxValue / 4);
             m_moduleLoader = moduleLoader;
             m_authenticateHandler = authen;
             m_sceneGridService = sceneGridService;
@@ -726,6 +750,9 @@ namespace OpenSim.Region.Framework.Scenes
                         m_maxPhys = RegionInfo.PhysPrimMax;
                     }
 
+                    SpawnPointRouting = startupConfig.GetString("SpawnPointRouting", "closest");
+                    TelehubAllowLandmarks = startupConfig.GetBoolean("TelehubAllowLandmark", false);
+
                     // Here, if clamping is requested in either global or
                     // local config, it will be used
                     //
@@ -735,6 +762,7 @@ namespace OpenSim.Region.Framework.Scenes
                         m_clampPrimSize = true;
                     }
 
+                    m_useTrashOnDelete = startupConfig.GetBoolean("UseTrashOnDelete",m_useTrashOnDelete);
                     m_trustBinaries = startupConfig.GetBoolean("TrustBinaries", m_trustBinaries);
                     m_allowScriptCrossings = startupConfig.GetBoolean("AllowScriptCrossing", m_allowScriptCrossings);
                     m_dontPersistBefore =
@@ -833,13 +861,11 @@ namespace OpenSim.Region.Framework.Scenes
             StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats;
         }
 
-        /// <summary>
-        /// Mock constructor for scene group persistency unit tests.
-        /// SceneObjectGroup RegionId property is delegated to Scene.
-        /// </summary>
-        /// <param name="regInfo"></param>
         public Scene(RegionInfo regInfo)
         {
+            PhysicalPrims = true;
+            CollidablePrims = true;
+
             BordersLocked = true;
             Border northBorder = new Border();
             northBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, (int)Constants.RegionSize);  //<---
@@ -866,8 +892,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_eventManager = new EventManager();
 
             m_permissions = new ScenePermissions(this);
-
-//            m_lastUpdate = Util.EnvironmentTickCount();
         }
 
         #endregion
@@ -936,8 +960,8 @@ namespace OpenSim.Region.Framework.Scenes
                             List<ulong> old = new List<ulong>();
                             old.Add(otherRegion.RegionHandle);
                             agent.DropOldNeighbours(old);
-                            if (m_teleportModule != null && agent.PresenceType != PresenceType.Npc)
-                                m_teleportModule.EnableChildAgent(agent, otherRegion);
+                            if (EntityTransferModule != null && agent.PresenceType != PresenceType.Npc)
+                                EntityTransferModule.EnableChildAgent(agent, otherRegion);
                         });
                     }
                     catch (NullReferenceException)
@@ -950,7 +974,7 @@ namespace OpenSim.Region.Framework.Scenes
                 else
                 {
                     m_log.InfoFormat(
-                        "[INTERGRID]: Got notice about far away Region: {0} at ({1}, {2})",
+                        "[SCENE]: Got notice about far away Region: {0} at ({1}, {2})",
                         otherRegion.RegionName, otherRegion.RegionLocX, otherRegion.RegionLocY);
                 }
             }
@@ -1044,13 +1068,13 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
 
+            m_log.Error("[REGION]: Closing");
+            Close();
+
             if (PhysicsScene != null)
             {
                 PhysicsScene.Dispose();
-            }
-
-            m_log.Error("[REGION]: Closing");
-            Close();
+            }            
 
             m_log.Error("[REGION]: Firing Region Restart Message");
 
@@ -1074,8 +1098,8 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         ForEachRootScenePresence(delegate(ScenePresence agent)
                         {
-                            if (m_teleportModule != null && agent.PresenceType != PresenceType.Npc)
-                                m_teleportModule.EnableChildAgent(agent, r);
+                            if (EntityTransferModule != null && agent.PresenceType != PresenceType.Npc)
+                                EntityTransferModule.EnableChildAgent(agent, r);
                         });
                     }
                     catch (NullReferenceException)
@@ -1265,8 +1289,10 @@ namespace OpenSim.Region.Framework.Scenes
             m_serialiser = RequestModuleInterface<IRegionSerialiserModule>();
             m_dialogModule = RequestModuleInterface<IDialogModule>();
             m_capsModule = RequestModuleInterface<ICapabilitiesModule>();
-            m_teleportModule = RequestModuleInterface<IEntityTransferModule>();
+            EntityTransferModule = RequestModuleInterface<IEntityTransferModule>();
             m_groupsModule = RequestModuleInterface<IGroupsModule>();
+            AgentTransactionsModule = RequestModuleInterface<IAgentAssetTransactions>();
+            UserManagementModule = RequestModuleInterface<IUserManagement>();
         }
 
         #endregion
@@ -1387,37 +1413,41 @@ namespace OpenSim.Region.Framework.Scenes
                 endFrame = Frame + frames;
 
             float physicsFPS = 0f;
-            int tmpPhysicsMS, tmpPhysicsMS2, tmpAgentMS, tmpTempOnRezMS, evMS, backMS, terMS;
-            int previousFrameTick;
-            int maintc;
-            int sleepMS;
-            int framestart;
+            int previousFrameTick, tmpMS;
+            int maintc = Util.EnvironmentTickCount();
 
             while (!m_shuttingDown && (endFrame == null || Frame < endFrame))
             {
-                framestart = Util.EnvironmentTickCount();
                 ++Frame;
 
 //            m_log.DebugFormat("[SCENE]: Processing frame {0} in {1}", Frame, RegionInfo.RegionName);
 
-                agentMS = tempOnRezMS = eventMS = backupMS = terrainMS = landMS = 0;
+                agentMS = tempOnRezMS = eventMS = backupMS = terrainMS = landMS = spareMS = 0;
 
                 try
                 {
-                    tmpPhysicsMS2 = Util.EnvironmentTickCount();
+                    // Apply taints in terrain module to terrain in physics scene
+                    if (Frame % m_update_terrain == 0)
+                    {
+                        tmpMS = Util.EnvironmentTickCount();
+                        UpdateTerrain();
+                        terrainMS = Util.EnvironmentTickCountSubtract(tmpMS);
+                    }
+
+                    tmpMS = Util.EnvironmentTickCount();
                     if ((Frame % m_update_physics == 0) && m_physics_enabled)
                         m_sceneGraph.UpdatePreparePhysics();
-                    physicsMS2 = Util.EnvironmentTickCountSubtract(tmpPhysicsMS2);
+                    physicsMS2 = Util.EnvironmentTickCountSubtract(tmpMS);
     
                     // Apply any pending avatar force input to the avatar's velocity
-                    tmpAgentMS = Util.EnvironmentTickCount();
+                    tmpMS = Util.EnvironmentTickCount();
                     if (Frame % m_update_entitymovement == 0)
                         m_sceneGraph.UpdateScenePresenceMovement();
-                    agentMS = Util.EnvironmentTickCountSubtract(tmpAgentMS);
+                    agentMS = Util.EnvironmentTickCountSubtract(tmpMS);
     
                     // Perform the main physics update.  This will do the actual work of moving objects and avatars according to their
                     // velocity
-                    tmpPhysicsMS = Util.EnvironmentTickCount();
+                    tmpMS = Util.EnvironmentTickCount();
                     if (Frame % m_update_physics == 0)
                     {
                         if (m_physics_enabled)
@@ -1426,9 +1456,9 @@ namespace OpenSim.Region.Framework.Scenes
                         if (SynchronizeScene != null)
                             SynchronizeScene(this);
                     }
-                    physicsMS = Util.EnvironmentTickCountSubtract(tmpPhysicsMS);
+                    physicsMS = Util.EnvironmentTickCountSubtract(tmpMS);
 
-                    tmpAgentMS = Util.EnvironmentTickCount();
+                    tmpMS = Util.EnvironmentTickCount();
     
                     // Check if any objects have reached their targets
                     CheckAtTargets();
@@ -1443,36 +1473,29 @@ namespace OpenSim.Region.Framework.Scenes
                     if (Frame % m_update_presences == 0)
                         m_sceneGraph.UpdatePresences();
     
-                    agentMS += Util.EnvironmentTickCountSubtract(tmpAgentMS);
+                    agentMS += Util.EnvironmentTickCountSubtract(tmpMS);
     
                     // Delete temp-on-rez stuff
                     if (Frame % m_update_temp_cleaning == 0 && !m_cleaningTemps)
                     {
-                        tmpTempOnRezMS = Util.EnvironmentTickCount();
+                        tmpMS = Util.EnvironmentTickCount();
                         m_cleaningTemps = true;
                         Util.FireAndForget(delegate { CleanTempObjects(); m_cleaningTemps = false;  });
-                        tempOnRezMS = Util.EnvironmentTickCountSubtract(tmpTempOnRezMS);
+                        tempOnRezMS = Util.EnvironmentTickCountSubtract(tmpMS);
                     }
     
                     if (Frame % m_update_events == 0)
                     {
-                        evMS = Util.EnvironmentTickCount();
+                        tmpMS = Util.EnvironmentTickCount();
                         UpdateEvents();
-                        eventMS = Util.EnvironmentTickCountSubtract(evMS);
+                        eventMS = Util.EnvironmentTickCountSubtract(tmpMS);
                     }
     
                     if (Frame % m_update_backup == 0)
                     {
-                        backMS = Util.EnvironmentTickCount();
+                        tmpMS = Util.EnvironmentTickCount();
                         UpdateStorageBackup();
-                        backupMS = Util.EnvironmentTickCountSubtract(backMS);
-                    }
-    
-                    if (Frame % m_update_terrain == 0)
-                    {
-                        terMS = Util.EnvironmentTickCount();
-                        UpdateTerrain();
-                        terrainMS = Util.EnvironmentTickCountSubtract(terMS);
+                        backupMS = Util.EnvironmentTickCountSubtract(tmpMS);
                     }
     
                     //if (Frame % m_update_land == 0)
@@ -1481,29 +1504,6 @@ namespace OpenSim.Region.Framework.Scenes
                     //    UpdateLand();
                     //    landMS = Util.EnvironmentTickCountSubtract(ldMS);
                     //}
-
-                    //                    frameMS = Util.EnvironmentTickCountSubtract(maintc);
-                    otherMS = tempOnRezMS + eventMS + backupMS + terrainMS + landMS;
-
-                    // if (Frame%m_update_avatars == 0)
-                    //   UpdateInWorldTime();
-                    StatsReporter.AddPhysicsFPS(physicsFPS);
-                    StatsReporter.AddTimeDilation(TimeDilation);
-                    StatsReporter.AddFPS(1);
-                    StatsReporter.SetRootAgents(m_sceneGraph.GetRootAgentCount());
-                    StatsReporter.SetChildAgents(m_sceneGraph.GetChildAgentCount());
-                    StatsReporter.SetObjects(m_sceneGraph.GetTotalObjectsCount());
-                    StatsReporter.SetActiveObjects(m_sceneGraph.GetActiveObjectsCount());
-
-                    // frameMS currently records work frame times, not total frame times (work + any required sleep to
-                    // reach min frame time.
-                    //                    StatsReporter.addFrameMS(frameMS);
-
-                    StatsReporter.addAgentMS(agentMS);
-                    StatsReporter.addPhysicsMS(physicsMS + physicsMS2);
-                    StatsReporter.addOtherMS(otherMS);
-                    StatsReporter.SetActiveScripts(m_sceneGraph.GetActiveScriptsCount());
-                    StatsReporter.addScriptLines(m_sceneGraph.GetScriptLPS());
     
                     if (LoginsDisabled && Frame == 20)
                     {
@@ -1524,11 +1524,11 @@ namespace OpenSim.Region.Framework.Scenes
                                 LoginLock = false;
                                 EventManager.TriggerLoginsEnabled(RegionInfo.RegionName);
                             }
-                            m_log.DebugFormat("[REGION]: Enabling logins for {0}", RegionInfo.RegionName);
     
                             // For RegionReady lockouts
-                            if(LoginLock == false)
+                            if (!LoginLock)
                             {
+                                m_log.InfoFormat("[REGION]: Enabling logins for {0}", RegionInfo.RegionName);
                                 LoginsDisabled = false;
                             }
     
@@ -1554,23 +1554,36 @@ namespace OpenSim.Region.Framework.Scenes
 
                 previousFrameTick = m_lastFrameTick;
                 m_lastFrameTick = Util.EnvironmentTickCount();
-                maintc = Util.EnvironmentTickCountSubtract(m_lastFrameTick, framestart);
-                maintc = (int)(MinFrameTime * 1000) - maintc;
+                tmpMS = Util.EnvironmentTickCountSubtract(m_lastFrameTick, maintc);
+                tmpMS = (int)(MinFrameTime * 1000) - tmpMS;
 
                 m_firstHeartbeat = false;
 
+                if (tmpMS > 0)
+                {
+                    Thread.Sleep(tmpMS);
+                    spareMS += tmpMS;
+                }
+
+                frameMS = Util.EnvironmentTickCountSubtract(maintc);
+                maintc = Util.EnvironmentTickCount();
 
-                sleepMS = Util.EnvironmentTickCount();
+                otherMS = tempOnRezMS + eventMS + backupMS + terrainMS + landMS;
 
-                if (maintc > 0)
-                    Thread.Sleep(maintc);
+                // if (Frame%m_update_avatars == 0)
+                //   UpdateInWorldTime();
+                StatsReporter.AddPhysicsFPS(physicsFPS);
+                StatsReporter.AddTimeDilation(TimeDilation);
+                StatsReporter.AddFPS(1);
 
-                sleepMS = Util.EnvironmentTickCountSubtract(sleepMS);
-                frameMS = Util.EnvironmentTickCountSubtract(framestart);
-                StatsReporter.addSleepMS(sleepMS);
                 StatsReporter.addFrameMS(frameMS);
-                
-                // Optionally warn if a frame takes double the amount of time that it should.
+                StatsReporter.addAgentMS(agentMS);
+                StatsReporter.addPhysicsMS(physicsMS + physicsMS2);
+                StatsReporter.addOtherMS(otherMS);
+                StatsReporter.AddSpareMS(spareMS);
+                StatsReporter.addScriptLines(m_sceneGraph.GetScriptLPS());
+
+               // Optionally warn if a frame takes double the amount of time that it should.
                 if (DebugUpdates
                     && Util.EnvironmentTickCountSubtract(
                         m_lastFrameTick, previousFrameTick) > (int)(MinFrameTime * 1000 * 2))
@@ -2083,9 +2096,8 @@ namespace OpenSim.Region.Framework.Scenes
                 sceneObject.SetGroup(groupID, null);
             }
 
-            IUserManagement uman = RequestModuleInterface<IUserManagement>();
-            if (uman != null)
-                sceneObject.RootPart.CreatorIdentification = uman.GetUserUUI(ownerID);
+            if (UserManagementModule != null)
+                sceneObject.RootPart.CreatorIdentification = UserManagementModule.GetUserUUI(ownerID);
 
             sceneObject.ScheduleGroupForFullUpdate();
 
@@ -2363,8 +2375,8 @@ namespace OpenSim.Region.Framework.Scenes
                 return;
             }
 
-            if (m_teleportModule != null)
-                m_teleportModule.Cross(grp, attemptedPosition, silent);
+            if (EntityTransferModule != null)
+                EntityTransferModule.Cross(grp, attemptedPosition, silent);
         }
 
         public Border GetCrossedBorder(Vector3 position, Cardinals gridline)
@@ -2684,10 +2696,10 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     SceneObjectGroup grp = sceneObject;
 
-                    m_log.DebugFormat(
-                        "[ATTACHMENT]: Received attachment {0}, inworld asset id {1}", grp.FromItemID, grp.UUID);
-                    m_log.DebugFormat(
-                        "[ATTACHMENT]: Attach to avatar {0} at position {1}", sp.UUID, grp.AbsolutePosition);
+//                    m_log.DebugFormat(
+//                        "[ATTACHMENT]: Received attachment {0}, inworld asset id {1}", grp.FromItemID, grp.UUID);
+//                    m_log.DebugFormat(
+//                        "[ATTACHMENT]: Attach to avatar {0} at position {1}", sp.UUID, grp.AbsolutePosition);
 
                     RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
                     
@@ -2783,7 +2795,8 @@ namespace OpenSim.Region.Framework.Scenes
             if (sp == null)
             {
                 m_log.DebugFormat(
-                    "[SCENE]: Adding new child scene presence {0} to scene {1} at pos {2}", client.Name, RegionInfo.RegionName, client.StartPos);
+                    "[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);
@@ -2843,14 +2856,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="aCircuit"></param>
         private void CacheUserName(ScenePresence sp, AgentCircuitData aCircuit)
         {
-            IUserManagement uMan = RequestModuleInterface<IUserManagement>();
-            if (uMan != null)
+            if (UserManagementModule != null)
             {
                 string first = aCircuit.firstname, last = aCircuit.lastname;
 
                 if (sp.PresenceType == PresenceType.Npc)
                 {
-                    uMan.AddUser(aCircuit.AgentID, first, last);
+                    UserManagementModule.AddUser(aCircuit.AgentID, first, last);
                 }
                 else
                 {
@@ -2869,7 +2881,7 @@ namespace OpenSim.Region.Framework.Scenes
                         }
                     }
 
-                    uMan.AddUser(aCircuit.AgentID, first, last, homeURL);
+                    UserManagementModule.AddUser(aCircuit.AgentID, first, last, homeURL);
                 }
             }
         }
@@ -3207,8 +3219,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="client">The IClientAPI for the client</param>
         public virtual bool TeleportClientHome(UUID agentId, IClientAPI client)
         {
-            if (m_teleportModule != null)
-                return m_teleportModule.TeleportHome(agentId, client);
+            if (EntityTransferModule != null)
+            {
+                EntityTransferModule.TeleportHome(agentId, client);
+            }
             else
             {
                 m_log.DebugFormat("[SCENE]: Unable to teleport user home: no AgentTransferModule is active");
@@ -3370,65 +3384,82 @@ namespace OpenSim.Region.Framework.Scenes
 //            CheckHeartbeat();
             bool isChildAgent = false;
             ScenePresence avatar = GetScenePresence(agentID);
-            if (avatar != null)
+
+            if (avatar == null)
+            {
+                m_log.WarnFormat(
+                    "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
+
+                return;
+            }
+
+            try
             {
                 isChildAgent = avatar.IsChildAgent;
 
-                if (avatar.ParentID != 0)
+                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)
                 {
-                    avatar.StandUp();
+                    // 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();
+                    }
                 }
 
-                try
+                // Only applies to root agents.
+                if (avatar.ParentID != 0)
                 {
-                    m_log.DebugFormat(
-                        "[SCENE]: Removing {0} agent {1} from region {2}",
-                        (isChildAgent ? "child" : "root"), agentID, RegionInfo.RegionName);
+                    avatar.StandUp();
+                }
 
-                    m_sceneGraph.removeUserCount(!isChildAgent);
+                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);
+                // 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);
+                // 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 && !avatar.IsChildAgent)
-                    {
-                        List<ulong> regions = avatar.KnownRegionHandles;
-                        regions.Remove(RegionInfo.RegionHandle);
-                        m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
-                    }
-                    m_log.Debug("[Scene] Beginning ClientClosed");
-                    m_eventManager.TriggerClientClosed(agentID, this);
-                    m_log.Debug("[Scene] Finished ClientClosed");
-                }
-                catch (NullReferenceException)
+                if (closeChildAgents && !isChildAgent)
                 {
-                    // We don't know which count to remove it from
-                    // Avatar is already disposed :/
+                    List<ulong> regions = avatar.KnownRegionHandles;
+                    regions.Remove(RegionInfo.RegionHandle);
+                    m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
                 }
 
-                try
+                m_eventManager.TriggerClientClosed(agentID, this);
+                m_eventManager.TriggerOnRemovePresence(agentID);
+
+                if (!isChildAgent)
                 {
-                    m_eventManager.TriggerOnRemovePresence(agentID);
-    
-                    if (AttachmentsModule != null && !isChildAgent && avatar.PresenceType != PresenceType.Npc)
+                    if (AttachmentsModule != null)
                     {
-                        IUserManagement uMan = RequestModuleInterface<IUserManagement>(); 
                         // Don't save attachments for HG visitors, it
                         // messes up their inventory. When a HG visitor logs
                         // out on a foreign grid, their attachments will be
                         // reloaded in the state they were in when they left
                         // the home grid. This is best anyway as the visited
                         // grid may use an incompatible script engine.
-                        if (uMan == null || uMan.IsLocalGridUser(avatar.UUID))
-                            AttachmentsModule.SaveChangedAttachments(avatar, false);
+                        bool saveChanged
+                            = avatar.PresenceType != PresenceType.Npc
+                                && (UserManagementModule == null || UserManagementModule.IsLocalGridUser(avatar.UUID));
+
+                        AttachmentsModule.DeRezAttachments(avatar, saveChanged, false);
                     }
-    
+
                     ForEachClient(
                         delegate(IClientAPI client)
                         {
@@ -3436,43 +3467,35 @@ namespace OpenSim.Region.Framework.Scenes
                             try { client.SendKillObject(avatar.RegionHandle, new List<uint> { avatar.LocalId }); }
                             catch (NullReferenceException) { }
                         });
-    
-                    IAgentAssetTransactions agentTransactions = this.RequestModuleInterface<IAgentAssetTransactions>();
-                    if (agentTransactions != null)
-                    {
-                        agentTransactions.RemoveAgentAssetTransactions(agentID);
-                    }
-                }
-                finally
-                {
-                    // 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.
-                    // TODO: This should probably extend to the whole method, but we don't want to also catch the NRE
-                    // since this would hide the underlying failure and other associated problems.
-                    m_sceneGraph.RemoveScenePresence(agentID);
-                    m_clientManager.Remove(agentID);
                 }
 
-                try
-                {
-                    avatar.Close();
-                }
-                catch (NullReferenceException)
-                {
-                    //We can safely ignore null reference exceptions.  It means the avatar are dead and cleaned up anyway.
-                }
-                catch (Exception e)
-                {
-                    m_log.ErrorFormat("[SCENE] Scene.cs:RemoveClient exception {0}{1}", e.Message, e.StackTrace);
-                }
-                m_log.Debug("[Scene] Done. Firing RemoveCircuit");
+                // It's possible for child agents to have transactions if changes are being made cross-border.
+                if (AgentTransactionsModule != null)
+                    AgentTransactionsModule.RemoveAgentAssetTransactions(agentID);
+
+                avatar.Close();
+
                 m_authenticateHandler.RemoveCircuit(avatar.ControllingClient.CircuitCode);
-//                CleanDroppedAttachments();
                 m_log.Debug("[Scene] The avatar has left the building");
-                //m_log.InfoFormat("[SCENE] Memory pre  GC {0}", System.GC.GetTotalMemory(false));
-                //m_log.InfoFormat("[SCENE] Memory post GC {0}", System.GC.GetTotalMemory(true));
             }
+            catch (Exception e)
+            {
+                m_log.Error(
+                    string.Format("[SCENE]: Exception removing {0} from {1}, ", avatar.Name, RegionInfo.RegionName), e);
+            }
+            finally
+            {
+                // 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.
+                // TODO: This should probably extend to the whole method, but we don't want to also catch the NRE
+                // since this would hide the underlying failure and other associated problems.
+                m_sceneGraph.RemoveScenePresence(agentID);
+                m_clientManager.Remove(agentID);
+            }
+
+            //m_log.InfoFormat("[SCENE] Memory pre  GC {0}", System.GC.GetTotalMemory(false));
+            //m_log.InfoFormat("[SCENE] Memory post GC {0}", System.GC.GetTotalMemory(true));
         }
 
         /// <summary>
@@ -3554,7 +3577,7 @@ namespace OpenSim.Region.Framework.Scenes
         public bool NewUserConnection(AgentCircuitData agent, uint teleportFlags, out string reason, bool requirePresenceLookup)
         {
             bool vialogin = ((teleportFlags & (uint)TPFlags.ViaLogin) != 0 ||
-                             (teleportFlags & (uint)TPFlags.ViaHGLogin) != 0);
+                (teleportFlags & (uint)TPFlags.ViaHGLogin) != 0);
             bool viahome = ((teleportFlags & (uint)TPFlags.ViaHome) != 0);
             bool godlike = ((teleportFlags & (uint)TPFlags.Godlike) != 0);
 
@@ -3570,8 +3593,17 @@ namespace OpenSim.Region.Framework.Scenes
             // Don't disable this log message - it's too helpful
             m_log.DebugFormat(
                 "[SCENE]: Region {0} told of incoming {1} agent {2} {3} {4} (circuit code {5}, IP {6}, viewer {7}, teleportflags ({8}), position {9})",
-                RegionInfo.RegionName, (agent.child ? "child" : "root"),agent.firstname, agent.lastname,
-                agent.AgentID, agent.circuitcode, agent.IPAddress, agent.Viewer, ((TPFlags)teleportFlags).ToString(), agent.startpos);
+                RegionInfo.RegionName,
+                (agent.child ? "child" : "root"),
+                agent.firstname,
+                agent.lastname,
+                agent.AgentID,
+                agent.circuitcode,
+                agent.IPAddress,
+                agent.Viewer,
+                ((TPFlags)teleportFlags).ToString(),
+                agent.startpos
+            );
 
             if (LoginsDisabled)
             {
@@ -3586,7 +3618,10 @@ namespace OpenSim.Region.Framework.Scenes
                 // We have a zombie from a crashed session. 
                 // Or the same user is trying to be root twice here, won't work.
                 // Kill it.
-                m_log.DebugFormat("[SCENE]: Zombie scene presence detected for {0} in {1}", agent.AgentID, RegionInfo.RegionName);
+                m_log.DebugFormat(
+                    "[SCENE]: Zombie scene presence detected for {0} {1} in {2}",
+                    sp.Name, sp.UUID, RegionInfo.RegionName);
+
                 sp.ControllingClient.Close();
                 sp = null;
             }
@@ -3613,8 +3648,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if (!VerifyUserPresence(agent, out reason))
                             return false;
-                    }
-                    catch (Exception e)
+                    } catch (Exception e)
                     {
                         m_log.ErrorFormat(
                             "[SCENE]: Exception verifying presence {0}{1}", e.Message, e.StackTrace);
@@ -3649,8 +3683,7 @@ namespace OpenSim.Region.Framework.Scenes
                     CapsModule.SetAgentCapsSeeds(agent);
                     CapsModule.CreateCaps(agent.AgentID);
                 }
-            }
-            else
+            } else
             {
                 // Let the SP know how we got here. This has a lot of interesting
                 // uses down the line.
@@ -3673,7 +3706,7 @@ namespace OpenSim.Region.Framework.Scenes
             agent.teleportFlags = teleportFlags;
             m_authenticateHandler.AddNewCircuit(agent.circuitcode, agent);
 
-            if (vialogin) 
+            if (vialogin)
             {
 //                CleanDroppedAttachments();
 
@@ -3714,8 +3747,7 @@ namespace OpenSim.Region.Framework.Scenes
                                 agent.startpos.Z = 720;
                         }
                     }
-                }
-                else
+                } else
                 {
                     if (agent.startpos.X > EastBorders[0].BorderLine.Z)
                     {
@@ -3741,10 +3773,19 @@ namespace OpenSim.Region.Framework.Scenes
                     SceneObjectGroup telehub = GetSceneObjectGroup(RegionInfo.RegionSettings.TelehubObject);
                     // Can have multiple SpawnPoints
                     List<SpawnPoint> spawnpoints = RegionInfo.RegionSettings.SpawnPoints();
-                    if ( spawnpoints.Count  > 1)
+                    if (spawnpoints.Count > 1)
                     {
-                        // We have multiple SpawnPoints, Route the agent to a random one
-                        agent.startpos =  spawnpoints[Util.RandomClass.Next(spawnpoints.Count)].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
+                        // We have multiple SpawnPoints, Route the agent to a random or sequential one
+                        if (SpawnPointRouting == "random")
+                            agent.startpos = spawnpoints[Util.RandomClass.Next(spawnpoints.Count) - 1].GetLocation(
+                                telehub.AbsolutePosition,
+                                telehub.GroupRotation
+                            );
+                        else
+                            agent.startpos = spawnpoints[SpawnPoint()].GetLocation(
+                                telehub.AbsolutePosition,
+                                telehub.GroupRotation
+                            );
                     }
                     else
                     {
@@ -3981,41 +4022,41 @@ namespace OpenSim.Region.Framework.Scenes
             return m_authenticateHandler.TryChangeCiruitCode(oldcc, newcc);
         }
 
-        /// <summary>
-        /// The Grid has requested that we log-off a user.  Log them off.
-        /// </summary>
-        /// <param name="AvatarID">Unique ID of the avatar to log-off</param>
-        /// <param name="RegionSecret">SecureSessionID of the user, or the RegionSecret text when logging on to the grid</param>
-        /// <param name="message">message to display to the user.  Reason for being logged off</param>
-        public void HandleLogOffUserFromGrid(UUID AvatarID, UUID RegionSecret, string message)
-        {
-            ScenePresence loggingOffUser = GetScenePresence(AvatarID);
-            if (loggingOffUser != null)
-            {
-                UUID localRegionSecret = UUID.Zero;
-                bool parsedsecret = UUID.TryParse(m_regInfo.regionSecret, out localRegionSecret);
-
-                // Region Secret is used here in case a new sessionid overwrites an old one on the user server.
-                // Will update the user server in a few revisions to use it.
-
-                if (RegionSecret == loggingOffUser.ControllingClient.SecureSessionId || (parsedsecret && RegionSecret == localRegionSecret))
-                {
-                    m_sceneGridService.SendCloseChildAgentConnections(loggingOffUser.UUID, loggingOffUser.KnownRegionHandles);
-                    loggingOffUser.ControllingClient.Kick(message);
-                    // Give them a second to receive the message!
-                    Thread.Sleep(1000);
-                    loggingOffUser.ControllingClient.Close();
-                }
-                else
-                {
-                    m_log.Info("[USERLOGOFF]: System sending the LogOff user message failed to sucessfully authenticate");
-                }
-            }
-            else
-            {
-                m_log.InfoFormat("[USERLOGOFF]: Got a logoff request for {0} but the user isn't here.  The user might already have been logged out", AvatarID.ToString());
-            }
-        }
+//        /// <summary>
+//        /// The Grid has requested that we log-off a user.  Log them off.
+//        /// </summary>
+//        /// <param name="AvatarID">Unique ID of the avatar to log-off</param>
+//        /// <param name="RegionSecret">SecureSessionID of the user, or the RegionSecret text when logging on to the grid</param>
+//        /// <param name="message">message to display to the user.  Reason for being logged off</param>
+//        public void HandleLogOffUserFromGrid(UUID AvatarID, UUID RegionSecret, string message)
+//        {
+//            ScenePresence loggingOffUser = GetScenePresence(AvatarID);
+//            if (loggingOffUser != null)
+//            {
+//                UUID localRegionSecret = UUID.Zero;
+//                bool parsedsecret = UUID.TryParse(m_regInfo.regionSecret, out localRegionSecret);
+//
+//                // Region Secret is used here in case a new sessionid overwrites an old one on the user server.
+//                // Will update the user server in a few revisions to use it.
+//
+//                if (RegionSecret == loggingOffUser.ControllingClient.SecureSessionId || (parsedsecret && RegionSecret == localRegionSecret))
+//                {
+//                    m_sceneGridService.SendCloseChildAgentConnections(loggingOffUser.UUID, loggingOffUser.KnownRegionHandles);
+//                    loggingOffUser.ControllingClient.Kick(message);
+//                    // Give them a second to receive the message!
+//                    Thread.Sleep(1000);
+//                    loggingOffUser.ControllingClient.Close();
+//                }
+//                else
+//                {
+//                    m_log.Info("[USERLOGOFF]: System sending the LogOff user message failed to sucessfully authenticate");
+//                }
+//            }
+//            else
+//            {
+//                m_log.InfoFormat("[USERLOGOFF]: Got a logoff request for {0} but the user isn't here.  The user might already have been logged out", AvatarID.ToString());
+//            }
+//        }
 
         /// <summary>
         /// Triggered when an agent crosses into this sim.  Also happens on initial login.
@@ -4068,21 +4109,19 @@ namespace OpenSim.Region.Framework.Scenes
                 return false;
             }
 
+            // TODO: This check should probably be in QueryAccess().
             ILandObject nearestParcel = GetNearestAllowedParcel(cAgentData.AgentID, Constants.RegionSize / 2, Constants.RegionSize / 2);
             if (nearestParcel == null)
             {
-                m_log.DebugFormat("[SCENE]: Denying root agent entry to {0}: no allowed parcel", cAgentData.AgentID);
-                return false;
-            }
-
-            int num = m_sceneGraph.GetNumberOfScenePresences();
+                m_log.DebugFormat(
+                    "[SCENE]: Denying root agent entry to {0} in {1}: no allowed parcel",
+                    cAgentData.AgentID, RegionInfo.RegionName);
 
-            if (num >= RegionInfo.RegionSettings.AgentLimit)
-            {
-                if (!Permissions.IsAdministrator(cAgentData.AgentID))
-                    return false;
+                return false;
             }
 
+            // We have to wait until the viewer contacts this region after receiving EAC.
+            // That calls AddNewClient, which finally creates the ScenePresence
             ScenePresence childAgentUpdate = WaitGetScenePresence(cAgentData.AgentID);
 
             if (childAgentUpdate != null)
@@ -4126,14 +4165,28 @@ namespace OpenSim.Region.Framework.Scenes
             return false;
         }
 
+        /// <summary>
+        /// Poll until the requested ScenePresence appears or we timeout.
+        /// </summary>
+        /// <returns>The scene presence is found, else null.</returns>
+        /// <param name='agentID'></param>
         protected virtual ScenePresence WaitGetScenePresence(UUID agentID)
         {
             int ntimes = 10;
-            ScenePresence childAgentUpdate = null;
-            while ((childAgentUpdate = GetScenePresence(agentID)) == null && (ntimes-- > 0))
+            ScenePresence sp = null;
+            while ((sp = GetScenePresence(agentID)) == null && (ntimes-- > 0))
                 Thread.Sleep(1000);
-            return childAgentUpdate;
 
+            if (sp == null)
+                m_log.WarnFormat(
+                    "[SCENE PRESENCE]: Did not find presence with id {0} in {1} before timeout",
+                    agentID, RegionInfo.RegionName);
+//            else
+//                m_log.DebugFormat(
+//                    "[SCENE PRESENCE]: Found presence {0} {1} {2} in {3} after {4} waits",
+//                    sp.Name, sp.UUID, sp.IsChildAgent ? "child" : "root", RegionInfo.RegionName, 10 - ntimes);
+
+            return sp;
         }
 
         public virtual bool IncomingRetrieveRootAgent(UUID id, out IAgentData agent)
@@ -4171,33 +4224,7 @@ namespace OpenSim.Region.Framework.Scenes
             ScenePresence presence = m_sceneGraph.GetScenePresence(agentID);
             if (presence != null)
             {
-                // Nothing is removed here, so down count it as such
-                if (presence.IsChildAgent)
-                {
-                   m_sceneGraph.removeUserCount(false);
-                }
-                else if (!childOnly)
-                {
-                   m_sceneGraph.removeUserCount(true);
-                }
-
-                // Don't do this to root agents on logout, it's not nice for the viewer
-                if (presence.IsChildAgent)
-                {
-                    // Tell a single agent to disconnect from the region.
-                    IEventQueue eq = RequestModuleInterface<IEventQueue>();
-                    if (eq != null)
-                    {
-                        eq.DisableSimulator(RegionInfo.RegionHandle, agentID);
-                    }
-                    else
-                        presence.ControllingClient.SendShutdownConnectionNotice();
-                    presence.ControllingClient.Close(false);
-                }
-                else if (!childOnly)
-                {
-                    presence.ControllingClient.Close(true);
-                }
+                presence.ControllingClient.Close();
                 return true;
             }
 
@@ -4283,8 +4310,10 @@ namespace OpenSim.Region.Framework.Scenes
                     position.Y -= shifty;
                 }
 
-                if (m_teleportModule != null)
-                    m_teleportModule.Teleport(sp, regionHandle, position, lookAt, teleportFlags);
+                if (EntityTransferModule != null)
+                {
+                    EntityTransferModule.Teleport(sp, regionHandle, position, lookAt, teleportFlags);
+                }
                 else
                 {
                     m_log.DebugFormat("[SCENE]: Unable to perform teleports: no AgentTransferModule is active");
@@ -4295,8 +4324,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool CrossAgentToNewRegion(ScenePresence agent, bool isFlying)
         {
-            if (m_teleportModule != null)
-                return m_teleportModule.Cross(agent, isFlying);
+            if (EntityTransferModule != null)
+            {
+                return EntityTransferModule.Cross(agent, isFlying);
+            }
             else
             {
                 m_log.DebugFormat("[SCENE]: Unable to cross agent to neighbouring region, because there is no AgentTransferModule");
@@ -5444,29 +5475,58 @@ Environment.Exit(1);
                 throw new Exception(error);
         }
 
-        // This method is called across the simulation connector to
-        // determine if a given agent is allowed in this region
-        // AS A ROOT AGENT. Returning false here will prevent them
-        // from logging into the region, teleporting into the region
-        // or corssing the broder walking, but will NOT prevent
-        // child agent creation, thereby emulating the SL behavior.
+        /// <summary>
+        /// This method is called across the simulation connector to
+        /// determine if a given agent is allowed in this region
+        /// AS A ROOT AGENT
+        /// </summary>
+        /// <remarks>
+        /// Returning false here will prevent them
+        /// from logging into the region, teleporting into the region
+        /// or corssing the broder walking, but will NOT prevent
+        /// child agent creation, thereby emulating the SL behavior.
+        /// </remarks>
+        /// <param name='agentID'></param>
+        /// <param name='position'></param>
+        /// <param name='reason'></param>
+        /// <returns></returns>
         public bool QueryAccess(UUID agentID, Vector3 position, out string reason)
         {
             reason = "You are banned from the region";
 
+            if (EntityTransferModule.IsInTransit(agentID))
+            {
+                reason = "Agent is still in transit from this region";
+
+                m_log.WarnFormat(
+                    "[SCENE]: Denying agent {0} entry into {1} since region still has them registered as in transit",
+                    agentID, RegionInfo.RegionName);
+
+                return false;
+            }
+
             if (Permissions.IsGod(agentID))
             {
                 reason = String.Empty;
                 return true;
             }
 
-            int num = m_sceneGraph.GetNumberOfScenePresences();
+            // FIXME: Root agent count is currently known to be inaccurate.  This forces a recount before we check.
+            // However, the long term fix is to make sure root agent count is always accurate.
+            m_sceneGraph.RecalculateStats();
+
+            int num = m_sceneGraph.GetRootAgentCount();
 
             if (num >= RegionInfo.RegionSettings.AgentLimit)
             {
                 if (!Permissions.IsAdministrator(agentID))
                 {
                     reason = "The region is full";
+
+                    m_log.DebugFormat(
+                        "[SCENE]: Denying presence with id {0} entry into {1} since region is at agent limit of {2}",
+                        agentID, RegionInfo.RegionName, RegionInfo.RegionSettings.AgentLimit);
+
                     return false;
                 }
             }
@@ -5637,5 +5697,19 @@ Environment.Exit(1);
                 }
             }
         }
+
+        // manage and select spawn points in sequence
+        public int SpawnPoint()
+        {
+            int spawnpoints = RegionInfo.RegionSettings.SpawnPoints().Count;
+
+            if (spawnpoints == 0)
+                return 0;
+
+            m_SpawnPoint++;
+            if (m_SpawnPoint > spawnpoints)
+                m_SpawnPoint = 1;
+            return m_SpawnPoint - 1;
+        }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
index b806d91..c1414ee 100644
--- a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
@@ -84,16 +84,16 @@ namespace OpenSim.Region.Framework.Scenes
             if (neighbourService != null)
                 neighbour = neighbourService.HelloNeighbour(regionhandle, region);
             else
-                m_log.DebugFormat("[SCS]: No neighbour service provided for informing neigbhours of this region");
+                m_log.DebugFormat("[SCENE COMMUNICATION SERVICE]: No neighbour service provided for informing neigbhours of this region");
 
             if (neighbour != null)
             {
-              //  m_log.DebugFormat("[INTERGRID]: Successfully informed neighbour {0}-{1} that I'm here", x / Constants.RegionSize, y / Constants.RegionSize);
+                m_log.DebugFormat("[SCENE COMMUNICATION SERVICE]: Successfully informed neighbour {0}-{1} that I'm here", x / Constants.RegionSize, y / Constants.RegionSize);
                 m_scene.EventManager.TriggerOnRegionUp(neighbour);
             }
             else
             {
-                m_log.InfoFormat("[INTERGRID]: Failed to inform neighbour {0}-{1} that I'm here.", x / Constants.RegionSize, y / Constants.RegionSize);
+                m_log.InfoFormat("[SCENE COMMUNICATION SERVICE]: Failed to inform neighbour {0}-{1} that I'm here.", x / Constants.RegionSize, y / Constants.RegionSize);
             }
         }
 
@@ -102,7 +102,7 @@ namespace OpenSim.Region.Framework.Scenes
             //m_log.Info("[INTER]: " + debugRegionName + ": SceneCommunicationService: Sending InterRegion Notification that region is up " + region.RegionName);
 
             List<GridRegion> neighbours = m_scene.GridService.GetNeighbours(m_scene.RegionInfo.ScopeID, m_scene.RegionInfo.RegionID);
-            //m_log.DebugFormat("[INTERGRID]: Informing {0} neighbours that this region is up", neighbours.Count);
+            m_log.DebugFormat("[SCENE COMMUNICATION SERVICE]: Informing {0} neighbours that this region is up", neighbours.Count);
             foreach (GridRegion n in neighbours)
             {
                 InformNeighbourThatRegionUpDelegate d = InformNeighboursThatRegionIsUpAsync;
@@ -156,7 +156,9 @@ namespace OpenSim.Region.Framework.Scenes
                         // that the region position is cached or performance will degrade
                         Utils.LongToUInts(regionHandle, out x, out y);
                         GridRegion dest = m_scene.GridService.GetRegionByPosition(UUID.Zero, (int)x, (int)y);
-//                        bool v = true;
+                        if (dest == null)
+                            continue;
+
                         if (!simulatorList.Contains(dest.ServerURI))
                         {
                             // we havent seen this simulator before, add it to the list
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index b7466be..4c12496 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -101,6 +101,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         protected internal Dictionary<uint, SceneObjectGroup> SceneObjectGroupsByLocalPartID = new Dictionary<uint, SceneObjectGroup>();        
 
+        /// <summary>
+        /// Lock to prevent object group update, linking, delinking and duplication operations from running concurrently.
+        /// </summary>
+        /// <remarks>
+        /// These operations rely on the parts composition of the object.  If allowed to run concurrently then race
+        /// conditions can occur.
+        /// </remarks>
         private Object m_updateLock = new Object();
 
         #endregion
@@ -775,12 +782,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public int GetChildAgentCount()
         {
-            // some network situations come in where child agents get closed twice.
-            if (m_numChildAgents < 0)
-            {
-                m_numChildAgents = 0;
-            }
-
             return m_numChildAgents;
         }
 
@@ -852,11 +853,6 @@ namespace OpenSim.Region.Framework.Scenes
             return m_scenePresenceArray;
         }
 
-        public int GetNumberOfScenePresences()
-        {
-            return m_scenePresenceArray.Count;
-        }
-
         /// <summary>
         /// Request a scene presence by UUID. Fast, indexed lookup.
         /// </summary>
@@ -2063,12 +2059,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="AgentID"></param>
         /// <param name="GroupID"></param>
         /// <param name="rot"></param>
+        /// <returns>null if duplication fails, otherwise the duplicated object</returns>
+        /// <summary>
         public SceneObjectGroup DuplicateObject(uint originalPrimID, Vector3 offset, uint flags, UUID AgentID, UUID GroupID, Quaternion rot)
         {
 //            m_log.DebugFormat(
 //                "[SCENE]: Duplication of object {0} at offset {1} requested by agent {2}", 
 //                originalPrimID, offset, AgentID);
-            
+
             SceneObjectGroup original = GetGroupByPrim(originalPrimID);
             if (original != null)
             {
@@ -2098,25 +2096,25 @@ namespace OpenSim.Region.Framework.Scenes
 
                     // FIXME: This section needs to be refactored so that it just calls AddSceneObject()
                     Entities.Add(copy);
-                    
+
                     lock (SceneObjectGroupsByFullID)
                         SceneObjectGroupsByFullID[copy.UUID] = copy;
-                    
+
                     SceneObjectPart[] children = copy.Parts;
-                    
+
                     lock (SceneObjectGroupsByFullPartID)
                     {
                         SceneObjectGroupsByFullPartID[copy.UUID] = copy;
                         foreach (SceneObjectPart part in children)
                             SceneObjectGroupsByFullPartID[part.UUID] = copy;
                     }
-        
+
                     lock (SceneObjectGroupsByLocalPartID)
                     {
                         SceneObjectGroupsByLocalPartID[copy.LocalId] = copy;
                         foreach (SceneObjectPart part in children)
                             SceneObjectGroupsByLocalPartID[part.LocalId] = copy;
-                    }   
+                    }
                     // PROBABLE END OF FIXME
 
                     // Since we copy from a source group that is in selected
@@ -2148,11 +2146,10 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 m_log.WarnFormat("[SCENE]: Attempted to duplicate nonexistant prim id {0}", GroupID);
             }
-            
+
             return null;
         }
-        
-        /// <summary>
+
         /// Calculates the distance between two Vector3s
         /// </summary>
         /// <param name="v1"></param>
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
index 2effa25..1038111 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
@@ -54,16 +54,28 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Start the scripts contained in all the prims in this group.
         /// </summary>
-        public void CreateScriptInstances(int startParam, bool postOnRez,
-                string engine, int stateSource)
+        /// <param name="startParam"></param>
+        /// <param name="postOnRez"></param>
+        /// <param name="engine"></param>
+        /// <param name="stateSource"></param>
+        /// <returns>
+        /// Number of scripts that were valid for starting.  This does not guarantee that all these scripts
+        /// were actually started, but just that the start could be attempt (e.g. the asset data for the script could be found)
+        /// </returns>
+        public int CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
         {
+            int scriptsStarted = 0;
+
             // Don't start scripts if they're turned off in the region!
             if (!m_scene.RegionInfo.RegionSettings.DisableScripts)
             {
                 SceneObjectPart[] parts = m_parts.GetArray();
                 for (int i = 0; i < parts.Length; i++)
-                    parts[i].Inventory.CreateScriptInstances(startParam, postOnRez, engine, stateSource);
+                    scriptsStarted
+                        += parts[i].Inventory.CreateScriptInstances(startParam, postOnRez, engine, stateSource);
             }
+
+            return scriptsStarted;
         }
 
         /// <summary>
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index aab6a49..11d703a 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -244,6 +244,22 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// If this scene object has an attachment point then indicate whether there is a point where
+        /// attachments are perceivable by avatars other than the avatar to which this object is attached.
+        /// </summary>
+        /// <remarks>
+        /// HUDs are not perceivable by other avatars.
+        /// </remarks>
+        public bool HasPrivateAttachmentPoint
+        {
+            get
+            {
+                return AttachmentPoint >= (uint)OpenMetaverse.AttachmentPoint.HUDCenter2
+                    && AttachmentPoint <= (uint)OpenMetaverse.AttachmentPoint.HUDBottomRight;
+            }
+        }
+
         public void ClearPartAttachmentData()
         {
             AttachmentPoint = 0;
@@ -1808,8 +1824,9 @@ namespace OpenSim.Region.Framework.Scenes
                         part.ClearUpdateSchedule();
                         if (part == m_rootPart)
                         {
-                            if (!IsAttachment || (AttachedAvatar == avatar.ControllingClient.AgentId) ||
-                                (AttachmentPoint < 31) || (AttachmentPoint > 38))
+                            if (!IsAttachment
+                                || AttachedAvatar == avatar.ControllingClient.AgentId
+                                || !HasPrivateAttachmentPoint)
                                 avatar.ControllingClient.SendKillObject(m_regionHandle, new List<uint> { part.LocalId });
                         }
                     }
@@ -2670,6 +2687,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Link the prims in a given group to this group
         /// </summary>
+        /// <remarks>
+        /// Do not call this method directly - use Scene.LinkObjects() instead to avoid races between threads.
+        /// FIXME: There are places where scripts call these methods directly without locking.  This is a potential race condition.
+        /// </remarks>
         /// <param name="objectGroup">The group of prims which should be linked to this group</param>
         public void LinkToGroup(SceneObjectGroup objectGroup)
         {
@@ -2751,6 +2772,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
                 linkPart.LinkNum = linkNum++;
+                linkPart.UpdatePrimFlags(UsesPhysics, IsTemporary, IsPhantom, IsVolumeDetect, false);
 
                 SceneObjectPart[] ogParts = objectGroup.Parts;
                 Array.Sort(ogParts, delegate(SceneObjectPart a, SceneObjectPart b)
@@ -2802,6 +2824,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// Delink the given prim from this group.  The delinked prim is established as
         /// an independent SceneObjectGroup.
         /// </summary>
+        /// <remarks>
+        /// FIXME: This method should not be called directly since it bypasses update locking, allowing a potential race
+        /// condition.  But currently there is no
+        /// alternative method that does take a lonk to delink a single prim.
+        /// </remarks>
         /// <param name="partID"></param>
         /// <returns>The object group of the newly delinked prim.  Null if part could not be found</returns>
         public SceneObjectGroup DelinkFromGroup(uint partID)
@@ -2813,6 +2840,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// Delink the given prim from this group.  The delinked prim is established as
         /// an independent SceneObjectGroup.
         /// </summary>
+        /// <remarks>
+        /// FIXME: This method should not be called directly since it bypasses update locking, allowing a potential race
+        /// condition.  But currently there is no
+        /// alternative method that does take a lonk to delink a single prim.
+        /// </remarks>
         /// <param name="partID"></param>
         /// <param name="sendEvents"></param>
         /// <returns>The object group of the newly delinked prim.  Null if part could not be found</returns>
@@ -2838,6 +2870,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// Delink the given prim from this group.  The delinked prim is established as
         /// an independent SceneObjectGroup.
         /// </summary>
+        /// <remarks>
+        /// FIXME: This method should not be called directly since it bypasses update locking, allowing a potential race
+        /// condition.  But currently there is no
+        /// alternative method that does take a lonk to delink a single prim.
+        /// </remarks>
         /// <param name="partID"></param>
         /// <param name="sendEvents"></param>
         /// <returns>The object group of the newly delinked prim.</returns>
@@ -2971,6 +3008,8 @@ namespace OpenSim.Region.Framework.Scenes
             oldRot = part.RotationOffset;
             Quaternion newRot = Quaternion.Conjugate(parentRot) * worldRot;
             part.RotationOffset = newRot;
+
+            part.UpdatePrimFlags(UsesPhysics, IsTemporary, IsPhantom, IsVolumeDetect, false);
         }
 
         /// <summary>
@@ -3486,7 +3525,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             //we need to do a terse update even if the move wasn't allowed
             // so that the position is reset in the client (the object snaps back)
-            ScheduleGroupForTerseUpdate();
+            RootPart.ScheduleTerseUpdate();
         }
 
         /// <summary>
@@ -3601,6 +3640,11 @@ namespace OpenSim.Region.Framework.Scenes
                 m_scene.PhysicsScene.AddPhysicsActorTaint(actor);
             }
 
+            if (IsAttachment)
+            {
+                m_rootPart.AttachedPos = pos;
+            }
+
             AbsolutePosition = pos;
 
             HasGroupChanged = true;
@@ -4187,7 +4231,72 @@ namespace OpenSim.Region.Framework.Scenes
             for (int i = 0; i < parts.Length; i++)
                 parts[i].TriggerScriptChangedEvent(val);
         }
-        
+
+        /// <summary>
+        /// Returns a count of the number of scripts in this groups parts.
+        /// </summary>
+        public int ScriptCount()
+        {
+            int count = 0;
+            SceneObjectPart[] parts = m_parts.GetArray();
+            for (int i = 0; i < parts.Length; i++)
+                count += parts[i].Inventory.ScriptCount();
+
+            return count;
+        }
+
+        /// <summary>
+        /// A float the value is a representative execution time in milliseconds of all scripts in the link set.
+        /// </summary>
+        public float ScriptExecutionTime()
+        {
+            IScriptModule[] engines = Scene.RequestModuleInterfaces<IScriptModule>();
+
+            if (engines.Length == 0) // No engine at all
+                return 0.0f;
+
+            float time = 0.0f;
+
+            // get all the scripts in all parts
+            SceneObjectPart[] parts = m_parts.GetArray();
+            List<TaskInventoryItem> scripts = new List<TaskInventoryItem>();
+            for (int i = 0; i < parts.Length; i++)
+            {
+                scripts.AddRange(parts[i].Inventory.GetInventoryItems(InventoryType.LSL));
+            }
+            // extract the UUIDs
+            List<UUID> ids = new List<UUID>(scripts.Count);
+            foreach (TaskInventoryItem script in scripts)
+            {
+                if (!ids.Contains(script.ItemID))
+                {
+                    ids.Add(script.ItemID);
+                }
+            }
+            // Offer the list of script UUIDs to each engine found and accumulate the time
+            foreach (IScriptModule e in engines)
+            {
+                if (e != null)
+                {
+                    time += e.GetScriptExecutionTime(ids);
+                }
+            }
+            return time;
+        }
+
+        /// <summary>
+        /// Returns a count of the number of running scripts in this groups parts.
+        /// </summary>
+        public int RunningScriptCount()
+        {
+            int count = 0;
+            SceneObjectPart[] parts = m_parts.GetArray();
+            for (int i = 0; i < parts.Length; i++)
+                count += parts[i].Inventory.RunningScriptCount();
+
+            return count;
+        }
+
         public override string ToString()
         {
             return String.Format("{0} {1} ({2})", Name, UUID, AbsolutePosition);
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 8e74dc8..f1e781c 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -1016,7 +1016,18 @@ namespace OpenSim.Region.Framework.Scenes
         public int LinkNum
         {
             get { return m_linkNum; }
-            set { m_linkNum = value; }
+            set
+            {
+//                if (ParentGroup != null)
+//                {
+//                    m_log.DebugFormat(
+//                        "[SCENE OBJECT PART]: Setting linknum of {0}@{1} to {2} from {3}",
+//                        Name, AbsolutePosition, value, m_linkNum);
+//                    Util.PrintCallStack();
+//                }
+
+                m_linkNum = value;
+            }
         }
 
         public byte ClickAction
@@ -2048,7 +2059,7 @@ namespace OpenSim.Region.Framework.Scenes
             else
                 m_log.WarnFormat(
                     "[SCENE OBJECT PART]: Part {0} {1} requested mesh/sculpt data for asset id {2} from asset service but received no data",
-                    Name, LocalId, id);
+                    Name, UUID, id);
         }
 
         /// <summary>
@@ -2153,6 +2164,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="isNew"></param>
         public void DoPhysicsPropertyUpdate(bool UsePhysics, bool isNew)
         {
+            if (ParentGroup.Scene == null)
+                return;
+
             if (!ParentGroup.Scene.PhysicalPrims && UsePhysics)
                 return;
 
@@ -3111,8 +3125,9 @@ namespace OpenSim.Region.Framework.Scenes
             if (ParentGroup.IsDeleted)
                 return;
 
-            if (ParentGroup.IsAttachment && (ParentGroup.AttachedAvatar != remoteClient.AgentId) &&
-                (ParentGroup.AttachmentPoint >= 31) && (ParentGroup.AttachmentPoint <= 38))
+            if (ParentGroup.IsAttachment
+                && ParentGroup.AttachedAvatar != remoteClient.AgentId
+                && ParentGroup.HasPrivateAttachmentPoint)
                 return;
 
             if (remoteClient.AgentId == OwnerID)
@@ -3631,7 +3646,6 @@ namespace OpenSim.Region.Framework.Scenes
             hasProfileCut = hasDimple; // is it the same thing?
         }
         
-
         public void SetGroup(UUID groupID, IClientAPI client)
         {
             // Scene.AddNewPrims() calls with client == null so can't use this.
@@ -3661,10 +3675,12 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetPhysicsAxisRotation()
         {
-            if (PhysActor != null)
+            PhysicsActor pa = PhysActor;
+
+            if (pa != null)
             {
-                PhysActor.LockAngularMotion(RotationAxis);
-                ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+                pa.LockAngularMotion(RotationAxis);
+                ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(pa);
             }
         }
 
@@ -4381,7 +4397,7 @@ namespace OpenSim.Region.Framework.Scenes
             // For now, we use the NINJA naming scheme for identifying joints.
             // In the future, we can support other joint specification schemes such as a 
             // custom checkbox in the viewer GUI.
-            if (ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
+            if (ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
             {
                 string hingeString = "hingejoint";
                 return (Name.Length >= hingeString.Length && Name.Substring(0, hingeString.Length) == hingeString);
@@ -4397,7 +4413,7 @@ namespace OpenSim.Region.Framework.Scenes
             // For now, we use the NINJA naming scheme for identifying joints.
             // In the future, we can support other joint specification schemes such as a 
             // custom checkbox in the viewer GUI.
-            if (ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
+            if (ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
             {
                 string ballString = "balljoint";
                 return (Name.Length >= ballString.Length && Name.Substring(0, ballString.Length) == ballString);
@@ -4413,7 +4429,7 @@ namespace OpenSim.Region.Framework.Scenes
             // For now, we use the NINJA naming scheme for identifying joints.
             // In the future, we can support other joint specification schemes such as a 
             // custom checkbox in the viewer GUI.
-            if (ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
+            if (ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
             {
                 return IsHingeJoint() || IsBallJoint();
             }
@@ -4534,7 +4550,6 @@ namespace OpenSim.Region.Framework.Scenes
                                                 }
                          */
                     }
-
                     else // it already has a physical representation
                     {
                         DoPhysicsPropertyUpdate(UsePhysics, false); // Update physical status.
@@ -5011,8 +5026,9 @@ namespace OpenSim.Region.Framework.Scenes
             if (ParentGroup.IsDeleted)
                 return;
 
-            if (ParentGroup.IsAttachment && ((ParentGroup.RootPart != this) ||
-                ((ParentGroup.AttachedAvatar != remoteClient.AgentId) && (ParentGroup.AttachmentPoint >= 31) && (ParentGroup.AttachmentPoint <= 38))))
+            if (ParentGroup.IsAttachment
+                && (ParentGroup.RootPart != this
+                    || ParentGroup.AttachedAvatar != remoteClient.AgentId && ParentGroup.HasPrivateAttachmentPoint))
                 return;
             
             // Causes this thread to dig into the Client Thread Data.
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index 959046a..14ef0fb 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -176,16 +176,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="ownerId"></param>
         public void ChangeInventoryOwner(UUID ownerId)
         {
-            m_items.LockItemsForWrite(true);
-            if (0 == Items.Count)
-            {
-                m_items.LockItemsForWrite(false);
+            List<TaskInventoryItem> items = GetInventoryItems();
+
+            if (items.Count == 0)
                 return;
-            }
 
+            m_items.LockItemsForWrite(true);
             HasInventoryChanged = true;
             m_part.ParentGroup.HasGroupChanged = true;
-            List<TaskInventoryItem> items = GetInventoryItems();
             foreach (TaskInventoryItem item in items)
             {
                 if (ownerId != item.OwnerID)
@@ -262,19 +260,16 @@ namespace OpenSim.Region.Framework.Scenes
             Items.LockItemsForRead(false);
         }
 
-        /// <summary>
-        /// Start all the scripts contained in this prim's inventory
-        /// </summary>
-        public void CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
+        public int CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
         {
-            Items.LockItemsForRead(true);
-            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
-            Items.LockItemsForRead(false);
-            foreach (TaskInventoryItem item in items)
-            {
-                if ((int)InventoryType.LSL == item.InvType)
-                    CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
-            }
+            int scriptsValidForStarting = 0;
+
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
+            foreach (TaskInventoryItem item in scripts)
+                if (CreateScriptInstance(item, startParam, postOnRez, engine, stateSource))
+                    scriptsValidForStarting++;
+
+            return scriptsValidForStarting;
         }
 
         public ArrayList GetScriptErrors(UUID itemID)
@@ -305,17 +300,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// </param>
         public void RemoveScriptInstances(bool sceneObjectBeingDeleted)
         {
-            Items.LockItemsForRead(true);
-            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
-            Items.LockItemsForRead(false);
-
-            foreach (TaskInventoryItem item in items)
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
+            foreach (TaskInventoryItem item in scripts)
             {
-                if ((int)InventoryType.LSL == item.InvType)
-                {
-                    RemoveScriptInstance(item.ItemID, sceneObjectBeingDeleted);
-                    m_part.RemoveScriptEvents(item.ItemID);
-                }
+                RemoveScriptInstance(item.ItemID, sceneObjectBeingDeleted);
+                m_part.RemoveScriptEvents(item.ItemID);
             }
         }
 
@@ -323,8 +312,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// Start a script which is in this prim's inventory.
         /// </summary>
         /// <param name="item"></param>
-        /// <returns></returns>
-        public void CreateScriptInstance(TaskInventoryItem item, int startParam, bool postOnRez, string engine, int stateSource)
+        /// <returns>true if the script instance was created, false otherwise</returns>
+        public bool CreateScriptInstance(TaskInventoryItem item, int startParam, bool postOnRez, string engine, int stateSource)
         {
 //             m_log.DebugFormat("[PRIM INVENTORY]: Starting script {0} {1} in prim {2} {3} in {4}",
 //                 item.Name, item.ItemID, m_part.Name, m_part.UUID, m_part.ParentGroup.Scene.RegionInfo.RegionName);
@@ -332,61 +321,70 @@ namespace OpenSim.Region.Framework.Scenes
             if (!m_part.ParentGroup.Scene.Permissions.CanRunScript(item.ItemID, m_part.UUID, item.OwnerID))
             {
                 StoreScriptError(item.ItemID, "no permission");
-                return;
+                return false;
             }
 
             m_part.AddFlag(PrimFlags.Scripted);
 
-            if (!m_part.ParentGroup.Scene.RegionInfo.RegionSettings.DisableScripts)
+            if (m_part.ParentGroup.Scene.RegionInfo.RegionSettings.DisableScripts)
+                return false;
+
+            if (stateSource == 2 && // Prim crossing
+                    m_part.ParentGroup.Scene.m_trustBinaries)
             {
-                if (stateSource == 2 && // Prim crossing
-                        m_part.ParentGroup.Scene.m_trustBinaries)
-                {
-                    m_items.LockItemsForWrite(true);
-                    m_items[item.ItemID].PermsMask = 0;
-                    m_items[item.ItemID].PermsGranter = UUID.Zero;
-                    m_items.LockItemsForWrite(false);
-                    m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
-                        m_part.LocalId, item.ItemID, String.Empty, startParam, postOnRez, engine, stateSource);
-                    StoreScriptErrors(item.ItemID, null);
-                    m_part.ParentGroup.AddActiveScriptCount(1);
-                    m_part.ScheduleFullUpdate();
-                    return;
-                }
+                m_items.LockItemsForWrite(true);
+                m_items[item.ItemID].PermsMask = 0;
+                m_items[item.ItemID].PermsGranter = UUID.Zero;
+                m_items.LockItemsForWrite(false);
+                m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
+                    m_part.LocalId, item.ItemID, String.Empty, startParam, postOnRez, engine, stateSource);
+                StoreScriptErrors(item.ItemID, null);
+                m_part.ParentGroup.AddActiveScriptCount(1);
+                m_part.ScheduleFullUpdate();
+                return true;
+            }
 
-                AssetBase asset = m_part.ParentGroup.Scene.AssetService.Get(item.AssetID.ToString());
-                if (null == asset)
-                {
-                    string msg = String.Format("asset ID {0} could not be found", item.AssetID);
-                    StoreScriptError(item.ItemID, msg);
-                    m_log.ErrorFormat(
+            AssetBase asset = m_part.ParentGroup.Scene.AssetService.Get(item.AssetID.ToString());
+            if (null == asset)
+            {
+                m_log.ErrorFormat(
+                    "[PRIM INVENTORY]: Couldn't start script {0}, {1} at {2} in {3} since asset ID {4} could not be found",
+                    item.Name, item.ItemID, m_part.AbsolutePosition, 
+                    m_part.ParentGroup.Scene.RegionInfo.RegionName, item.AssetID);
+
+                return false;
+            }
+            else
+            {
+                if (m_part.ParentGroup.m_savedScriptState != null)
+                    item.OldItemID = RestoreSavedScriptState(item.LoadedItemID, item.OldItemID, item.ItemID);
+
+                string msg = String.Format("asset ID {0} could not be found", item.AssetID);
+                StoreScriptError(item.ItemID, msg);
+                m_log.ErrorFormat(
                         "[PRIM INVENTORY]: Couldn't start script {0}, {1} at {2} in {3} since asset ID {4} could not be found",
                         item.Name, item.ItemID, m_part.AbsolutePosition, 
                         m_part.ParentGroup.Scene.RegionInfo.RegionName, item.AssetID);
-                }
-                else
-                {
-                    if (m_part.ParentGroup.m_savedScriptState != null)
-                        item.OldItemID = RestoreSavedScriptState(item.LoadedItemID, item.OldItemID, item.ItemID);
 
-                    m_items.LockItemsForWrite(true);
+                m_items.LockItemsForWrite(true);
 
-                    m_items[item.ItemID].OldItemID = item.OldItemID;
-                    m_items[item.ItemID].PermsMask = 0;
-                    m_items[item.ItemID].PermsGranter = UUID.Zero;
+                m_items[item.ItemID].OldItemID = item.OldItemID;
+                m_items[item.ItemID].PermsMask = 0;
+                m_items[item.ItemID].PermsGranter = UUID.Zero;
 
-                    m_items.LockItemsForWrite(false);
+                m_items.LockItemsForWrite(false);
                 
-                    string script = Utils.BytesToString(asset.Data);
-                    m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
-                        m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
-                    StoreScriptErrors(item.ItemID, null);
-                    if (!item.ScriptRunning)
-                        m_part.ParentGroup.Scene.EventManager.TriggerStopScript(
-                            m_part.LocalId, item.ItemID);
-                    m_part.ParentGroup.AddActiveScriptCount(1);
-                    m_part.ScheduleFullUpdate();
-                }
+                string script = Utils.BytesToString(asset.Data);
+                m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
+                    m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
+                StoreScriptErrors(item.ItemID, null);
+                if (!item.ScriptRunning)
+                    m_part.ParentGroup.Scene.EventManager.TriggerStopScript(
+                        m_part.LocalId, item.ItemID);
+                m_part.ParentGroup.AddActiveScriptCount(1);
+                m_part.ScheduleFullUpdate();
+
+                return true;
             }
         }
 
@@ -459,7 +457,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="itemId">
         /// A <see cref="UUID"/>
         /// </param>
-        public void CreateScriptInstance(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
+        public bool CreateScriptInstance(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
         {
             lock (m_scriptErrors)
             {
@@ -467,6 +465,7 @@ namespace OpenSim.Region.Framework.Scenes
                 m_scriptErrors.Remove(itemId);
             }
             CreateScriptInstanceInternal(itemId, startParam, postOnRez, engine, stateSource);
+            return true;
         }
 
         private void CreateScriptInstanceInternal(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
@@ -770,14 +769,22 @@ namespace OpenSim.Region.Framework.Scenes
             return item;
         }
 
-        /// <summary>
-        /// Get inventory items by name.
-        /// </summary>
-        /// <param name="name"></param>
-        /// <returns>
-        /// A list of inventory items with that name.
-        /// If no inventory item has that name then an empty list is returned.
-        /// </returns>
+        public TaskInventoryItem GetInventoryItem(string name)
+        {
+            m_items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in m_items.Values)
+            {
+                if (item.Name == name)
+                {
+                    m_items.LockItemsForRead(false);
+                    return item;
+                }
+            }
+            m_items.LockItemsForRead(false);
+
+            return null;
+        }
+
         public List<TaskInventoryItem> GetInventoryItems(string name)
         {
             List<TaskInventoryItem> items = new List<TaskInventoryItem>();
@@ -1247,10 +1254,10 @@ namespace OpenSim.Region.Framework.Scenes
                     if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
                         item.CurrentPermissions &= ~(uint)PermissionMask.Modify;
                 }
-                item.OwnerChanged = true;
                 item.CurrentPermissions &= item.NextPermissions;
                 item.BasePermissions &= item.NextPermissions;
                 item.EveryonePermissions &= item.NextPermissions;
+                item.OwnerChanged = true;
                 item.PermsMask = 0;
                 item.PermsGranter = UUID.Zero;
             }
@@ -1281,9 +1288,57 @@ namespace OpenSim.Region.Framework.Scenes
                     return true;
                 }
             }
+
             return false;
         }
 
+        /// <summary>
+        /// Returns the count of scripts in this parts inventory.
+        /// </summary>
+        /// <returns></returns>
+        public int ScriptCount()
+        {
+            int count = 0;
+            Items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in m_items.Values)
+            {
+                if (item.InvType == (int)InventoryType.LSL)
+                {
+                    count++;
+                }
+            }
+            Items.LockItemsForRead(false);
+            return count;
+        }
+        /// <summary>
+        /// Returns the count of running scripts in this parts inventory.
+        /// </summary>
+        /// <returns></returns>
+        public int RunningScriptCount()
+        {
+            IScriptModule[] engines = m_part.ParentGroup.Scene.RequestModuleInterfaces<IScriptModule>();
+            if (engines.Length == 0)
+                return 0;
+
+            int count = 0;
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
+
+            foreach (TaskInventoryItem item in scripts)
+            {
+                foreach (IScriptModule engine in engines)
+                {
+                    if (engine != null)
+                    {
+                        if (engine.GetScriptState(item.ItemID))
+                        {
+                            count++;
+                        }
+                    }
+                }
+            }
+            return count;
+        }
+
         public List<UUID> GetInventoryList()
         {
             List<UUID> ret = new List<UUID>();
@@ -1298,22 +1353,24 @@ namespace OpenSim.Region.Framework.Scenes
         {
             List<TaskInventoryItem> ret = new List<TaskInventoryItem>();
 
-            lock (m_items)
-                ret = new List<TaskInventoryItem>(m_items.Values);
+            Items.LockItemsForRead(true);
+            ret = new List<TaskInventoryItem>(m_items.Values);
+            Items.LockItemsForRead(false);
 
             return ret;
         }
 
-        public List<TaskInventoryItem> GetInventoryScripts()
+        public List<TaskInventoryItem> GetInventoryItems(InventoryType type)
         {
             List<TaskInventoryItem> ret = new List<TaskInventoryItem>();
 
-            lock (m_items)
-            {
-                foreach (TaskInventoryItem item in m_items.Values)
-                    if (item.InvType == (int)InventoryType.LSL)
-                        ret.Add(item);
-            }
+            Items.LockItemsForRead(true);
+
+            foreach (TaskInventoryItem item in m_items.Values)
+                if (item.InvType == (int)type)
+                    ret.Add(item);
+
+            Items.LockItemsForRead(false);
 
             return ret;
         }
@@ -1335,35 +1392,32 @@ namespace OpenSim.Region.Framework.Scenes
             if (engines.Length == 0) // No engine at all
                 return ret;
 
-            Items.LockItemsForRead(true);
-            foreach (TaskInventoryItem item in m_items.Values)
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
+
+            foreach (TaskInventoryItem item in scripts)
             {
-                if (item.InvType == (int)InventoryType.LSL)
+                foreach (IScriptModule e in engines)
                 {
-                    foreach (IScriptModule e in engines)
+                    if (e != null)
                     {
-                        if (e != null)
+                        string n = e.GetXMLState(item.ItemID);
+                        if (n != String.Empty)
                         {
-                            string n = e.GetXMLState(item.ItemID);
-                            if (n != String.Empty)
+                            if (oldIDs)
                             {
-                                if (oldIDs)
-                                {
-                                    if (!ret.ContainsKey(item.OldItemID))
-                                        ret[item.OldItemID] = n;
-                                }
-                                else
-                                {
-                                    if (!ret.ContainsKey(item.ItemID))
-                                        ret[item.ItemID] = n;
-                                }
-                                break;
+                                if (!ret.ContainsKey(item.OldItemID))
+                                    ret[item.OldItemID] = n;
                             }
+                            else
+                            {
+                                if (!ret.ContainsKey(item.ItemID))
+                                    ret[item.ItemID] = n;
+                            }
+                            break;
                         }
                     }
                 }
             }
-            Items.LockItemsForRead(false);
             return ret;
         }
         
@@ -1373,27 +1427,27 @@ namespace OpenSim.Region.Framework.Scenes
             if (engines.Length == 0)
                 return;
 
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
 
-            Items.LockItemsForRead(true);
-
-            foreach (TaskInventoryItem item in m_items.Values)
+            foreach (TaskInventoryItem item in scripts)
             {
-                if (item.InvType == (int)InventoryType.LSL)
+                foreach (IScriptModule engine in engines)
                 {
-                    foreach (IScriptModule engine in engines)
+                    if (engine != null)
                     {
-                        if (engine != null)
-                        {
-                            if (item.OwnerChanged)
-                                engine.PostScriptEvent(item.ItemID, "changed", new Object[] { (int)Changed.OWNER });
-                            item.OwnerChanged = false;
-                            engine.ResumeScript(item.ItemID);
-                        }
+//                        m_log.DebugFormat(
+//                            "[PRIM INVENTORY]: Resuming script {0} {1} for {2}, OwnerChanged {3}",
+//                            item.Name, item.ItemID, item.OwnerID, item.OwnerChanged);
+
+                        engine.ResumeScript(item.ItemID);
+
+                        if (item.OwnerChanged)
+                            engine.PostScriptEvent(item.ItemID, "changed", new Object[] { (int)Changed.OWNER });
+
+                        item.OwnerChanged = false;
                     }
                 }
             }
-
-            Items.LockItemsForRead(false);
         }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 87b4d9f..159a92a 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.
  *
@@ -45,6 +45,7 @@ using TeleportFlags = OpenSim.Framework.Constants.TeleportFlags;
 
 namespace OpenSim.Region.Framework.Scenes
 {
+    [Flags]
     enum ScriptControlled : uint
     {
         CONTROL_ZERO = 0,
@@ -76,6 +77,11 @@ namespace OpenSim.Region.Framework.Scenes
 //        {
 //            m_log.Debug("[SCENE PRESENCE] Destructor called");
 //        }
+        private void TriggerScenePresenceUpdated()
+        {
+            if (m_scene != null)
+                m_scene.EventManager.TriggerScenePresenceUpdated(this);
+        }
 
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
@@ -497,6 +503,7 @@ namespace OpenSim.Region.Framework.Scenes
                 //m_log.DebugFormat(
                 //    "[ENTITY BASE]: In {0} set AbsolutePosition of {1} to {2}",
                 //    Scene.RegionInfo.RegionName, Name, m_pos);
+                TriggerScenePresenceUpdated();
             }
         }
 
@@ -516,6 +523,7 @@ namespace OpenSim.Region.Framework.Scenes
                     return;
 
                 m_pos = value;
+                TriggerScenePresenceUpdated();
             }
         }
 
@@ -1086,23 +1094,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="pos"></param>
         public void Teleport(Vector3 pos)
         {
-            bool isFlying = Flying;
-            RemoveFromPhysicalScene();
-            Velocity = Vector3.Zero;
-            CheckLandingPoint(ref pos);
-            AbsolutePosition = pos;
-            AddToPhysicalScene(isFlying);
-
-            SendTerseUpdateToAllClients();
-        }
-
-        public void TeleportWithMomentum(Vector3 pos)
-        {
-            TeleportWithMomentum(pos, null);
+            TeleportWithMomentum(pos, Vector3.Zero);
         }
 
         public void TeleportWithMomentum(Vector3 pos, Vector3? v)
         {
+            if (ParentID != (uint)0)
+                StandUp();
             bool isFlying = Flying;
             Vector3 vel = Velocity;
             RemoveFromPhysicalScene();
@@ -1282,17 +1280,33 @@ namespace OpenSim.Region.Framework.Scenes
 
             bool flying = ((m_AgentControlFlags & AgentManager.ControlFlags.AGENT_CONTROL_FLY) != 0);
             MakeRootAgent(AbsolutePosition, flying);
+            ControllingClient.MoveAgentIntoRegion(m_scene.RegionInfo, AbsolutePosition, look);
+
+//            m_log.DebugFormat("[SCENE PRESENCE] Completed movement");
 
             if ((m_callbackURI != null) && !m_callbackURI.Equals(""))
             {
-                m_log.DebugFormat("[SCENE PRESENCE]: Releasing agent in URI {0}", m_callbackURI);
+                // We cannot sleep here since this would hold up the inbound packet processing thread, as
+                // CompleteMovement() is executed synchronously.  However, it might be better to delay the release
+                // here until we know for sure that the agent is active in this region.  Sending AgentMovementComplete
+                // is not enough for Imprudence clients - there appears to be a small delay (<200ms, <500ms) until they regard this
+                // region as the current region, meaning that a close sent before then will fail the teleport.
+//                System.Threading.Thread.Sleep(2000);
+
+                m_log.DebugFormat(
+                    "[SCENE PRESENCE]: Releasing {0} {1} with callback to {2}",
+                    client.Name, client.AgentId, m_callbackURI);
+
                 Scene.SimulationService.ReleaseAgent(m_originRegionID, UUID, m_callbackURI);
                 m_callbackURI = null;
             }
+//            else
+//            {
+//                m_log.DebugFormat(
+//                    "[SCENE PRESENCE]: No callback provided on CompleteMovement of {0} {1} to {2}",
+//                    client.Name, client.AgentId, m_scene.RegionInfo.RegionName);
+//            }
 
-//            m_log.DebugFormat("[SCENE PRESENCE] Completed movement");
-
-            ControllingClient.MoveAgentIntoRegion(m_scene.RegionInfo, AbsolutePosition, look);
             ValidateAndSendAppearanceAndAgentData();
 
             // Create child agents in neighbouring regions
@@ -1307,7 +1321,6 @@ namespace OpenSim.Region.Framework.Scenes
                     friendsModule.SendFriendsOnlineIfNeeded(ControllingClient);
             }
 
-
 //            m_log.DebugFormat(
 //                "[SCENE PRESENCE]: Completing movement of {0} into region {1} took {2}ms", 
 //                client.Name, Scene.RegionInfo.RegionName, (DateTime.Now - startTime).Milliseconds);
@@ -1360,7 +1373,7 @@ namespace OpenSim.Region.Framework.Scenes
         {
 //            m_log.DebugFormat(
 //                "[SCENE PRESENCE]: In {0} received agent update from {1}, flags {2}",
-//                Scene.RegionInfo.RegionName, remoteClient.Name, agentData.ControlFlags);
+//                Scene.RegionInfo.RegionName, remoteClient.Name, (AgentManager.ControlFlags)agentData.ControlFlags);
 
             if (IsChildAgent)
             {
@@ -1470,14 +1483,8 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
 
-            lock (scriptedcontrols)
-            {
-                if (scriptedcontrols.Count > 0)
-                {
-                    SendControlToScripts((uint)flags);
-                    flags = RemoveIgnoredControls(flags, IgnoredControls);
-                }
-            }
+            uint flagsForScripts = (uint)flags;
+            flags = RemoveIgnoredControls(flags, IgnoredControls);
 
             if ((flags & AgentManager.ControlFlags.AGENT_CONTROL_SIT_ON_GROUND) != 0)
                 HandleAgentSitOnGround();
@@ -1491,6 +1498,7 @@ namespace OpenSim.Region.Framework.Scenes
             PhysicsActor actor = PhysicsActor;
             if (actor == null)
             {
+                SendControlsToScripts(flagsForScripts);
                 return;
             }
 
@@ -1570,7 +1578,7 @@ namespace OpenSim.Region.Framework.Scenes
                                     MovementFlag |= (byte)nudgehack;
                                 }
 
-//                                m_log.DebugFormat("[SCENE PRESENCE]: Updating MovementFlag for {0} with {1}", Name, DCF);
+                                //m_log.DebugFormat("[SCENE PRESENCE]: Updating MovementFlag for {0} with {1}", Name, DCF);
                                 MovementFlag += (byte)(uint)DCF;
                                 update_movementflag = true;
                             }
@@ -1583,7 +1591,7 @@ namespace OpenSim.Region.Framework.Scenes
                                 && ((MovementFlag & (byte)nudgehack) == nudgehack))
                                 ) // This or is for Nudge forward
                             {
-//                                m_log.DebugFormat("[SCENE PRESENCE]: Updating MovementFlag for {0} with lack of {1}", Name, DCF);
+                                //m_log.DebugFormat("[SCENE PRESENCE]: Updating MovementFlag for {0} with lack of {1}", Name, DCF);
                                 MovementFlag -= ((byte)(uint)DCF);
                                 update_movementflag = true;
 
@@ -1664,11 +1672,14 @@ namespace OpenSim.Region.Framework.Scenes
 //                    }
 //                }
 
-//                if (update_movementflag && ParentID == 0)
-//                    Animator.UpdateMovementAnimations();
+                if (update_movementflag && ParentID == 0)
+                    Animator.UpdateMovementAnimations();
+
+                SendControlsToScripts(flagsForScripts);
             }
 
             m_scene.EventManager.TriggerOnClientMovement(this);
+            TriggerScenePresenceUpdated();
         }
 
         /// <summary>
@@ -2042,9 +2053,9 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (SitTargetUnOccupied)
                 {
-                    m_log.DebugFormat(
-                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is set and unoccupied",
-                        Name, part.Name, part.LocalId);
+//                    m_log.DebugFormat(
+//                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is set and unoccupied",
+//                        Name, part.Name, part.LocalId);
 
                     part.SitTargetAvatar = UUID;
                     offset = new Vector3(avSitOffSet.X, avSitOffSet.Y, avSitOffSet.Z);
@@ -2056,9 +2067,9 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (Util.GetDistanceTo(AbsolutePosition, pos) <= 10)
                 {
-                    m_log.DebugFormat(
-                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is unset and within 10m",
-                        Name, part.Name, part.LocalId);
+//                    m_log.DebugFormat(
+//                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is unset and within 10m",
+//                        Name, part.Name, part.LocalId);
 
                     AbsolutePosition = pos + new Vector3(0.0f, 0.0f, m_sitAvatarHeight);
                     canSit = true;
@@ -2614,6 +2625,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                 m_scene.ForEachClient(SendTerseUpdateToClient);
             }
+            TriggerScenePresenceUpdated();
         }
 
         public void SendCoarseLocations(List<Vector3> coarseLocations, List<UUID> avatarUUIDs)
@@ -2692,7 +2704,7 @@ namespace OpenSim.Region.Framework.Scenes
             // If we are using the the cached appearance then send it out to everyone
             if (cachedappearance)
             {
-                m_log.DebugFormat("[SCENEPRESENCE]: baked textures are in the cache for {0}", Name);
+                m_log.DebugFormat("[SCENE PRESENCE]: baked textures are in the cache for {0}", Name);
 
                 // If the avatars baked textures are all in the cache, then we have a 
                 // complete appearance... send it out, if not, then we'll send it when
@@ -3097,8 +3109,8 @@ namespace OpenSim.Region.Framework.Scenes
                     x = x / Constants.RegionSize;
                     y = y / Constants.RegionSize;
 
-                    //m_log.Debug("---> x: " + x + "; newx:" + newRegionX + "; Abs:" + (int)Math.Abs((int)(x - newRegionX)));
-                    //m_log.Debug("---> y: " + y + "; newy:" + newRegionY + "; Abs:" + (int)Math.Abs((int)(y - newRegionY)));
+//                    m_log.Debug("---> x: " + x + "; newx:" + newRegionX + "; Abs:" + (int)Math.Abs((int)(x - newRegionX)));
+//                    m_log.Debug("---> y: " + y + "; newy:" + newRegionY + "; Abs:" + (int)Math.Abs((int)(y - newRegionY)));
                     if (Util.IsOutsideView(DrawDistance, x, newRegionX, y, newRegionY))
                     {
                         byebyeRegions.Add(handle);
@@ -3155,7 +3167,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void ChildAgentDataUpdate(AgentData cAgentData)
         {
-            //m_log.Debug("   >>> ChildAgentDataUpdate <<< " + Scene.RegionInfo.RegionName);
+//            m_log.Debug("   >>> ChildAgentDataUpdate <<< " + Scene.RegionInfo.RegionName);
             if (!IsChildAgent)
                 return;
 
@@ -3267,31 +3279,8 @@ namespace OpenSim.Region.Framework.Scenes
             catch { }
             cAgent.DefaultAnim = Animator.Animations.DefaultAnimation;
 
-            // Attachment objects
-            List<SceneObjectGroup> attachments = GetAttachments();
-            if (attachments.Count > 0)
-            {
-                cAgent.AttachmentObjects = new List<ISceneObject>();
-                cAgent.AttachmentObjectStates = new List<string>();
-//                IScriptModule se = m_scene.RequestModuleInterface<IScriptModule>();
-                InTransitScriptStates.Clear();
-
-                foreach (SceneObjectGroup sog in attachments)
-                {
-                    // We need to make a copy and pass that copy
-                    // because of transfers withn the same sim
-                    ISceneObject clone = sog.CloneForNewScene();
-                    // Attachment module assumes that GroupPosition holds the offsets...!
-                    ((SceneObjectGroup)clone).RootPart.GroupPosition = sog.RootPart.AttachedPos;
-                    ((SceneObjectGroup)clone).IsAttachment = false;
-                    cAgent.AttachmentObjects.Add(clone);
-                    string state = sog.GetStateSnapshot();
-                    cAgent.AttachmentObjectStates.Add(state);
-                    InTransitScriptStates.Add(state);
-                    // Let's remove the scripts of the original object here
-                    sog.RemoveScriptInstances(true);
-                }
-            }
+            if (Scene.AttachmentsModule != null)
+                Scene.AttachmentsModule.CopyAttachments(this, cAgent);
         }
 
         private void CopyFrom(AgentData cAgent)
@@ -3299,6 +3288,9 @@ namespace OpenSim.Region.Framework.Scenes
             m_originRegionID = cAgent.RegionID;
 
             m_callbackURI = cAgent.CallbackURI;
+//            m_log.DebugFormat(
+//                "[SCENE PRESENCE]: Set callback for {0} in {1} to {2} in CopyFrom()",
+//                Name, m_scene.RegionInfo.RegionName, m_callbackURI);
 
             m_pos = cAgent.Position;
             m_velocity = cAgent.Velocity;
@@ -3363,18 +3355,8 @@ namespace OpenSim.Region.Framework.Scenes
             if (cAgent.DefaultAnim != null)
                 Animator.Animations.SetDefaultAnimation(cAgent.DefaultAnim.AnimID, cAgent.DefaultAnim.SequenceNum, UUID.Zero);
 
-            if (cAgent.AttachmentObjects != null && cAgent.AttachmentObjects.Count > 0)
-            {
-                m_attachments = new List<SceneObjectGroup>();
-                int i = 0;
-                foreach (ISceneObject so in cAgent.AttachmentObjects)
-                {
-                    ((SceneObjectGroup)so).LocalId = 0;
-                    ((SceneObjectGroup)so).RootPart.ClearUpdateSchedule();
-                    so.SetState(cAgent.AttachmentObjectStates[i++], m_scene);
-                    m_scene.IncomingCreateObject(Vector3.Zero, so);
-                }
-            }
+            if (Scene.AttachmentsModule != null)
+                Scene.AttachmentsModule.CopyAttachments(cAgent, this);
         }
 
         public bool CopyAgent(out IAgentData agent)
@@ -3400,6 +3382,7 @@ namespace OpenSim.Region.Framework.Scenes
                 Velocity = force;
 
                 m_forceToApply = null;
+                TriggerScenePresenceUpdated();
             }
         }
 
@@ -3507,23 +3490,53 @@ namespace OpenSim.Region.Framework.Scenes
 
             RaiseCollisionScriptEvents(coldata);
 
-            if (Invulnerable || GodLevel >= 200)
+            // Gods do not take damage and Invulnerable is set depending on parcel/region flags
+            if (Invulnerable || GodLevel > 0)
                 return;
-            
+
+            // The following may be better in the ICombatModule
+            // probably tweaking of the values for ground and normal prim collisions will be needed
             float starthealth = Health;
             uint killerObj = 0;
+            SceneObjectPart part = null;
             foreach (uint localid in coldata.Keys)
             {
-                SceneObjectPart part = Scene.GetSceneObjectPart(localid);
-
-                if (part != null && part.ParentGroup.Damage != -1.0f)
-                    Health -= part.ParentGroup.Damage;
+                if (localid == 0)
+                {
+                    part = null;
+                }
+                else
+                {
+                    part = Scene.GetSceneObjectPart(localid);
+                }
+                if (part != null)
+                {
+                    // Ignore if it has been deleted or volume detect
+                    if (!part.ParentGroup.IsDeleted && !part.ParentGroup.IsVolumeDetect)
+                    {
+                        if (part.ParentGroup.Damage > 0.0f)
+                        {
+                            // Something with damage...
+                            Health -= part.ParentGroup.Damage;
+                            part.ParentGroup.Scene.DeleteSceneObject(part.ParentGroup, false);
+                        }
+                        else
+                        {
+                            // An ordinary prim
+                            if (coldata[localid].PenetrationDepth >= 0.10f)
+                                Health -= coldata[localid].PenetrationDepth * 5.0f;
+                        }
+                    }
+                }
                 else
                 {
-                    if (coldata[localid].PenetrationDepth >= 0.10f)
+                    // 0 is the ground
+                    // what about collisions with other avatars?
+                    if (localid == 0 && coldata[localid].PenetrationDepth >= 0.10f)
                         Health -= coldata[localid].PenetrationDepth * 5.0f;
                 }
 
+
                 if (Health <= 0.0f)
                 {
                     if (localid != 0)
@@ -3539,7 +3552,16 @@ namespace OpenSim.Region.Framework.Scenes
                     ControllingClient.SendHealth(Health);
                 }
                 if (Health <= 0)
+                {
                     m_scene.EventManager.TriggerAvatarKill(killerObj, this);
+                }
+                if (starthealth == Health && Health < 100.0f)
+                {
+                    Health += 0.03f;
+                    if (Health > 100.0f)
+                        Health = 100.0f;
+                    ControllingClient.SendHealth(Health);
+                }
             }
         }
 
@@ -3551,9 +3573,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void Close()
         {
-            if (!IsChildAgent)
-                m_scene.AttachmentsModule.DeleteAttachmentsFromScene(this, false);
-
             // Clear known regions
             KnownRegions = new Dictionary<ulong, string>();
 
@@ -3621,6 +3640,63 @@ namespace OpenSim.Region.Framework.Scenes
                 return m_attachments.Count > 0;
         }
 
+        /// <summary>
+        /// Returns the total count of scripts in all parts inventories.
+        /// </summary>
+        public int ScriptCount()
+        {
+            int count = 0;
+            lock (m_attachments)
+            {
+                foreach (SceneObjectGroup gobj in m_attachments)
+                {
+                    if (gobj != null)
+                    {
+                        count += gobj.ScriptCount();
+                    }
+                }
+            }
+            return count;
+        }
+
+        /// <summary>
+        /// A float the value is a representative execution time in milliseconds of all scripts in all attachments.
+        /// </summary>
+        public float ScriptExecutionTime()
+        {
+            float time = 0.0f;
+            lock (m_attachments)
+            {
+                foreach (SceneObjectGroup gobj in m_attachments)
+                {
+                    if (gobj != null)
+                    {
+                        time += gobj.ScriptExecutionTime();
+                    }
+                }
+            }
+            return time;
+        }
+
+        /// <summary>
+        /// Returns the total count of running scripts in all parts.
+        /// </summary>
+        public int RunningScriptCount()
+        {
+            int count = 0;
+            lock (m_attachments)
+            {
+                foreach (SceneObjectGroup gobj in m_attachments)
+                {
+                    if (gobj != null)
+                    {
+                        count += gobj.RunningScriptCount();
+                    }
+                }
+            }
+            return count;
+        }
+
         public bool HasScriptedAttachments()
         {
             lock (m_attachments)
@@ -3838,77 +3914,92 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        internal void SendControlToScripts(uint flags)
+        private void SendControlsToScripts(uint flags)
         {
-            ScriptControlled allflags = ScriptControlled.CONTROL_ZERO;
-
-            if (MouseDown)
+            // Notify the scripts only after calling UpdateMovementAnimations(), so that if a script
+            // (e.g., a walking script) checks which animation is active it will be the correct animation.
+            lock (scriptedcontrols)
             {
-                allflags = LastCommands & (ScriptControlled.CONTROL_ML_LBUTTON | ScriptControlled.CONTROL_LBUTTON);
-                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LBUTTON_UP) != 0 || (flags & unchecked((uint)AgentManager.ControlFlags.AGENT_CONTROL_ML_LBUTTON_UP)) != 0)
+                if (scriptedcontrols.Count <= 0)
+                    return;
+
+                ScriptControlled allflags = ScriptControlled.CONTROL_ZERO;
+    
+                if (MouseDown)
+                {
+                    allflags = LastCommands & (ScriptControlled.CONTROL_ML_LBUTTON | ScriptControlled.CONTROL_LBUTTON);
+                    if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LBUTTON_UP) != 0 || (flags & unchecked((uint)AgentManager.ControlFlags.AGENT_CONTROL_ML_LBUTTON_UP)) != 0)
+                    {
+                        allflags = ScriptControlled.CONTROL_ZERO;
+                        MouseDown = true;
+                    }
+                }
+    
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_ML_LBUTTON_DOWN) != 0)
                 {
-                    allflags = ScriptControlled.CONTROL_ZERO;
+                    allflags |= ScriptControlled.CONTROL_ML_LBUTTON;
                     MouseDown = true;
                 }
-            }
+    
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LBUTTON_DOWN) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_LBUTTON;
+                    MouseDown = true;
+                }
+    
+                // find all activated controls, whether the scripts are interested in them or not
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_AT_POS) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_POS) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_FWD;
+                }
+    
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_AT_NEG) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_NEG) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_BACK;
+                }
+    
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_UP_POS) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_UP;
+                }
+    
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_UP_NEG) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_DOWN;
+                }
 
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_ML_LBUTTON_DOWN) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_ML_LBUTTON;
-                MouseDown = true;
-            }
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LBUTTON_DOWN) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_LBUTTON;
-                MouseDown = true;
-            }
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LEFT_POS) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_POS) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_LEFT;
+                }
+    
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LEFT_NEG) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_NEG) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_RIGHT;
+                }
+    
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_YAW_NEG) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_ROT_RIGHT;
+                }
+    
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_YAW_POS) != 0)
+                {
+                    allflags |= ScriptControlled.CONTROL_ROT_LEFT;
+                }
 
-            // find all activated controls, whether the scripts are interested in them or not
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_AT_POS) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_POS) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_FWD;
-            }
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_AT_NEG) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_NEG) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_BACK;
-            }
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_UP_POS) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_UP;
-            }
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_UP_NEG) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_DOWN;
-            }
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LEFT_POS) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_POS) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_LEFT;
-            }
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LEFT_NEG) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_NEG) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_RIGHT;
-            }
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_YAW_NEG) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_ROT_RIGHT;
-            }
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_YAW_POS) != 0)
-            {
-                allflags |= ScriptControlled.CONTROL_ROT_LEFT;
-            }
-            // optimization; we have to check per script, but if nothing is pressed and nothing changed, we can skip that
-            if (allflags != ScriptControlled.CONTROL_ZERO || allflags != LastCommands)
-            {
-                lock (scriptedcontrols)
+                // optimization; we have to check per script, but if nothing is pressed and nothing changed, we can skip that
+                if (allflags != ScriptControlled.CONTROL_ZERO || allflags != LastCommands)
                 {
                     foreach (KeyValuePair<UUID, ScriptControllers> kvp in scriptedcontrols)
                     {
                         UUID scriptUUID = kvp.Key;
                         ScriptControllers scriptControlData = kvp.Value;
-
+    
                         ScriptControlled localHeld = allflags & scriptControlData.eventControls;     // the flags interesting for us
                         ScriptControlled localLast = LastCommands & scriptControlData.eventControls; // the activated controls in the last cycle
                         ScriptControlled localChange = localHeld ^ localLast;                        // the changed bits
+
                         if (localHeld != ScriptControlled.CONTROL_ZERO || localChange != ScriptControlled.CONTROL_ZERO)
                         {
                             // only send if still pressed or just changed
@@ -3916,9 +4007,9 @@ namespace OpenSim.Region.Framework.Scenes
                         }
                     }
                 }
+    
+                LastCommands = allflags;
             }
-
-            LastCommands = allflags;
         }
 
         internal static AgentManager.ControlFlags RemoveIgnoredControls(AgentManager.ControlFlags flags, ScriptControlled ignored)
@@ -3998,7 +4089,7 @@ namespace OpenSim.Region.Framework.Scenes
                 land.LandData.UserLocation != Vector3.Zero &&
                 land.LandData.OwnerID != m_uuid &&
                 (!m_scene.Permissions.IsGod(m_uuid)) &&
-                (!m_scene.RegionInfo.EstateSettings.IsEstateManager(m_uuid)))
+                (!m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(m_uuid)))
             {
                 float curr = Vector3.Distance(AbsolutePosition, pos);
                 if (Vector3.Distance(land.LandData.UserLocation, pos) < curr)
@@ -4012,13 +4103,13 @@ namespace OpenSim.Region.Framework.Scenes
         {
             if ((m_teleportFlags & (TeleportFlags.ViaLogin | TeleportFlags.ViaRegionID)) ==
                 (TeleportFlags.ViaLogin | TeleportFlags.ViaRegionID) ||
-                (m_teleportFlags & TeleportFlags.ViaLandmark) != 0 ||
+                (m_scene.TelehubAllowLandmarks == true ? false : ((m_teleportFlags & TeleportFlags.ViaLandmark) != 0 )) ||
                 (m_teleportFlags & TeleportFlags.ViaLocation) != 0 ||
                 (m_teleportFlags & Constants.TeleportFlags.ViaHGLogin) != 0)
             {
                 if (GodLevel < 200 &&
                     ((!m_scene.Permissions.IsGod(m_uuid) &&
-                    !m_scene.RegionInfo.EstateSettings.IsEstateManager(m_uuid)) || 
+                    !m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(m_uuid)) || 
                     (m_teleportFlags & TeleportFlags.ViaLocation) != 0 ||
                     (m_teleportFlags & Constants.TeleportFlags.ViaHGLogin) != 0))
                 {
@@ -4026,28 +4117,92 @@ namespace OpenSim.Region.Framework.Scenes
                     if (spawnPoints.Length == 0)
                         return;
 
-                    float distance = 9999;
-                    int closest = -1;
+                    int index;
+                    bool selected = false;
 
-                    for (int i = 0 ; i < spawnPoints.Length ; i++)
+                    switch (m_scene.SpawnPointRouting)
                     {
-                        Vector3 spawnPosition = spawnPoints[i].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
-                        Vector3 offset = spawnPosition - pos;
-                        float d = Vector3.Mag(offset);
-                        if (d >= distance)
-                            continue;
-                        ILandObject land = m_scene.LandChannel.GetLandObject(spawnPosition.X, spawnPosition.Y);
-                        if (land == null)
-                            continue;
-                        if (land.IsEitherBannedOrRestricted(UUID))
-                            continue;
-                        distance = d;
-                        closest = i;
-                    }
-                    if (closest == -1)
-                        return;
+                        case "random":
 
-                    pos = spawnPoints[closest].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
+                            do
+                            {
+                                index = Util.RandomClass.Next(spawnPoints.Length - 1);
+                                
+                                Vector3 spawnPosition = spawnPoints[index].GetLocation(
+                                    telehub.AbsolutePosition,
+                                    telehub.GroupRotation
+                                );
+                                // SpawnPoint sp = spawnPoints[index];
+
+                                ILandObject land = m_scene.LandChannel.GetLandObject(spawnPosition.X, spawnPosition.Y);
+                                if (land == null || land.IsEitherBannedOrRestricted(UUID))
+                                    selected = false;
+                                else
+                                    selected = true;
+
+                            } while ( selected == false);
+
+                            pos = spawnPoints[index].GetLocation(
+                                telehub.AbsolutePosition,
+                                telehub.GroupRotation
+                            );
+                            return;
+
+                        case "sequence":
+
+                            do
+                            {
+                                index = m_scene.SpawnPoint();
+                                
+                                Vector3 spawnPosition = spawnPoints[index].GetLocation(
+                                    telehub.AbsolutePosition,
+                                    telehub.GroupRotation
+                                );
+                                // SpawnPoint sp = spawnPoints[index];
+
+                                ILandObject land = m_scene.LandChannel.GetLandObject(spawnPosition.X, spawnPosition.Y);
+                                if (land == null || land.IsEitherBannedOrRestricted(UUID))
+                                    selected = false;
+                                else
+                                    selected = true;
+
+                            } while (selected == false);
+
+                            pos = spawnPoints[index].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
+                            ;
+                            return;
+
+                        default:
+                        case "closest":
+
+                            float distance = 9999;
+                            int closest = -1;
+        
+                            for (int i = 0; i < spawnPoints.Length; i++)
+                            {
+                                Vector3 spawnPosition = spawnPoints[i].GetLocation(
+                                    telehub.AbsolutePosition,
+                                    telehub.GroupRotation
+                                );
+                                Vector3 offset = spawnPosition - pos;
+                                float d = Vector3.Mag(offset);
+                                if (d >= distance)
+                                    continue;
+                                ILandObject land = m_scene.LandChannel.GetLandObject(spawnPosition.X, spawnPosition.Y);
+                                if (land == null)
+                                    continue;
+                                if (land.IsEitherBannedOrRestricted(UUID))
+                                    continue;
+                                distance = d;
+                                closest = i;
+                            }
+                            if (closest == -1)
+                                return;
+                            
+                            pos = spawnPoints[closest].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
+                            return;
+
+                    }
                 }
             }
         }
@@ -4092,7 +4247,7 @@ namespace OpenSim.Region.Framework.Scenes
                         GodLevel < 200 &&
                         ((land.LandData.OwnerID != m_uuid && 
                           !m_scene.Permissions.IsGod(m_uuid) &&
-                          !m_scene.RegionInfo.EstateSettings.IsEstateManager(m_uuid)) || 
+                          !m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(m_uuid)) || 
                          (m_teleportFlags & TeleportFlags.ViaLocation) != 0 ||
                          (m_teleportFlags & Constants.TeleportFlags.ViaHGLogin) != 0))
                     {
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/CoalescedSceneObjectsSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/CoalescedSceneObjectsSerializer.cs
index 55455cc..a4f730d 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/CoalescedSceneObjectsSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/CoalescedSceneObjectsSerializer.cs
@@ -47,14 +47,30 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
     /// </remarks>
     public class CoalescedSceneObjectsSerializer
     {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);        
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         /// <summary>
         /// Serialize coalesced objects to Xml
         /// </summary>
         /// <param name="coa"></param>
+        /// <param name="doScriptStates">
+        /// If true then serialize script states.  This will halt any running scripts
+        /// </param>
         /// <returns></returns>
         public static string ToXml(CoalescedSceneObjects coa)
+        {
+            return ToXml(coa, true);
+        }
+
+        /// <summary>
+        /// Serialize coalesced objects to Xml
+        /// </summary>
+        /// <param name="coa"></param>
+        /// <param name="doScriptStates">
+        /// If true then serialize script states.  This will halt any running scripts
+        /// </param>
+        /// <returns></returns>
+        public static string ToXml(CoalescedSceneObjects coa, bool doScriptStates)
         {            
             using (StringWriter sw = new StringWriter())
             {
@@ -91,7 +107,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                         writer.WriteAttributeString("offsety", offsets[i].Y.ToString());
                         writer.WriteAttributeString("offsetz", offsets[i].Z.ToString());
                         
-                        SceneObjectSerializer.ToOriginalXmlFormat(obj, writer, true);
+                        SceneObjectSerializer.ToOriginalXmlFormat(obj, writer, doScriptStates);
                         
                         writer.WriteEndElement(); // SceneObjectGroup
                     }  
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index 151eba2..e223f47 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -1538,51 +1538,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             }
         }
 
-        //////// Read /////////
-        public static bool Xml2ToSOG(XmlTextReader reader, SceneObjectGroup sog)
-        {
-            reader.Read();
-            reader.ReadStartElement("SceneObjectGroup");
-            SceneObjectPart root = Xml2ToSOP(reader);
-            if (root != null)
-                sog.SetRootPart(root);
-            else
-            {
-                return false;
-            }
-
-            if (sog.UUID == UUID.Zero)
-                sog.UUID = sog.RootPart.UUID;
-
-            reader.Read(); // OtherParts
-
-            while (!reader.EOF)
-            {
-                switch (reader.NodeType)
-                {
-                    case XmlNodeType.Element:
-                        if (reader.Name == "SceneObjectPart")
-                        {
-                            SceneObjectPart child = Xml2ToSOP(reader);
-                            if (child != null)
-                                sog.AddPart(child);
-                        }
-                        else
-                        {
-                            //Logger.Log("Found unexpected prim XML element " + reader.Name, Helpers.LogLevel.Debug);
-                            reader.Read();
-                        }
-                        break;
-                    case XmlNodeType.EndElement:
-                    default:
-                        reader.Read();
-                        break;
-                }
-
-            }
-            return true;
-        }
-
         public static SceneObjectPart Xml2ToSOP(XmlTextReader reader)
         {
             SceneObjectPart obj = new SceneObjectPart();
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneXmlLoader.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneXmlLoader.cs
index d214eba..a3485d2 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneXmlLoader.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneXmlLoader.cs
@@ -223,50 +223,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
         public static SceneObjectGroup DeserializeGroupFromXml2(string xmlString)
         {
-            XmlDocument doc = new XmlDocument();
-            XmlNode rootNode;
-
-            XmlTextReader reader = new XmlTextReader(new StringReader(xmlString));
-            reader.WhitespaceHandling = WhitespaceHandling.None;
-            doc.Load(reader);
-            reader.Close();
-            rootNode = doc.FirstChild;
-
-            // This is to deal with neighbouring regions that are still surrounding the group xml with the <scene>
-            // tag.  It should be possible to remove the first part of this if statement once we go past 0.5.9 (or
-            // when some other changes forces all regions to upgrade).
-            // This might seem rather pointless since prim crossing from this revision to an earlier revision remains
-            // broken.  But it isn't much work to accomodate the old format here.
-            if (rootNode.LocalName.Equals("scene"))
-            {
-                foreach (XmlNode aPrimNode in rootNode.ChildNodes)
-                {
-                    // There is only ever one prim.  This oddity should be removeable post 0.5.9
-                    //return SceneObjectSerializer.FromXml2Format(aPrimNode.OuterXml);
-                    using (reader = new XmlTextReader(new StringReader(aPrimNode.OuterXml)))
-                    {
-                        SceneObjectGroup obj = new SceneObjectGroup();
-                        if (SceneObjectSerializer.Xml2ToSOG(reader, obj))
-                            return obj;
-
-                        return null;
-                    }
-                }
-
-                return null;
-            }
-            else
-            {
-                //return SceneObjectSerializer.FromXml2Format(rootNode.OuterXml);
-                using (reader = new XmlTextReader(new StringReader(rootNode.OuterXml)))
-                {
-                    SceneObjectGroup obj = new SceneObjectGroup();
-                    if (SceneObjectSerializer.Xml2ToSOG(reader, obj))
-                        return obj;
-
-                    return null;
-                }
-            }
+            return SceneObjectSerializer.FromXml2Format(xmlString);
         }
 
         /// <summary>
@@ -307,8 +264,8 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             ICollection<SceneObjectGroup> sceneObjects = new List<SceneObjectGroup>();
             foreach (XmlNode aPrimNode in rootNode.ChildNodes)
             {
-                SceneObjectGroup obj = CreatePrimFromXml2(scene, aPrimNode.OuterXml);
-                if (obj != null && startScripts)
+                SceneObjectGroup obj = DeserializeGroupFromXml2(aPrimNode.OuterXml);
+                if (startScripts)
                     sceneObjects.Add(obj);
             }
 
@@ -319,27 +276,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             }
         }
 
-        /// <summary>
-        /// Create a prim from the xml2 representation.
-        /// </summary>
-        /// <param name="scene"></param>
-        /// <param name="xmlData"></param>
-        /// <returns>The scene object created.  null if the scene object already existed</returns>
-        protected static SceneObjectGroup CreatePrimFromXml2(Scene scene, string xmlData)
-        {
-            //SceneObjectGroup obj = SceneObjectSerializer.FromXml2Format(xmlData);
-            using (XmlTextReader reader = new XmlTextReader(new StringReader(xmlData)))
-            {
-                SceneObjectGroup obj = new SceneObjectGroup();
-                SceneObjectSerializer.Xml2ToSOG(reader, obj);
-
-                if (scene.AddRestoredSceneObject(obj, true, false))
-                    return obj;
-                else
-                    return null;
-            }
-        }
-
         #endregion
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index a4afd47..18e6ece 100644
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -26,7 +26,7 @@
  */
 
 using System;
-//using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Timers;
 using OpenMetaverse.Packets;
 using OpenSim.Framework;
@@ -35,10 +35,18 @@ using OpenSim.Region.Framework.Interfaces;
 
 namespace OpenSim.Region.Framework.Scenes
 {
+    /// <summary>
+    /// Collect statistics from the scene to send to the client and for access by other monitoring tools.
+    /// </summary>
+    /// <remarks>
+    /// FIXME: This should be a monitoring region module
+    /// </remarks>
     public class SimStatsReporter
     {
-//        private static readonly log4net.ILog m_log
-//            = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly log4net.ILog m_log
+            = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        public const string LastReportedObjectUpdateStatName = "LastReportedObjectUpdates";
 
         public delegate void SendStatResult(SimStats stats);
 
@@ -48,10 +56,17 @@ namespace OpenSim.Region.Framework.Scenes
 
         public event YourStatsAreWrong OnStatsIncorrect;
 
-        private SendStatResult handlerSendStatResult = null;
+        private SendStatResult handlerSendStatResult;
 
-        private YourStatsAreWrong handlerStatsIncorrect = null;
+        private YourStatsAreWrong handlerStatsIncorrect;
 
+        /// <summary>
+        /// These are the IDs of stats sent in the StatsPacket to the viewer.
+        /// </summary>
+        /// <remarks>
+        /// Some of these are not relevant to OpenSimulator since it is architected differently to other simulators
+        /// (e.g. script instructions aren't executed as part of the frame loop so 'script time' is tricky).
+        /// </remarks>
         public enum Stats : uint
         {
             TimeDilation = 0,
@@ -75,20 +90,20 @@ namespace OpenSim.Region.Framework.Scenes
             OutPacketsPerSecond = 18,
             PendingDownloads = 19,
             PendingUploads = 20,
-            VirtualSizeKB = 21,
-            ResidentSizeKB = 22,
+            VirtualSizeKb = 21,
+            ResidentSizeKb = 22,
             PendingLocalUploads = 23,
             UnAckedBytes = 24,
             PhysicsPinnedTasks = 25,
-            PhysicsLODTasks = 26,
-            PhysicsStepMS = 27,
-            PhysicsShapeMS = 28,
-            PhysicsOtherMS = 29,
-            PhysicsMemory = 30,
-            ScriptEPS = 31,
-            SimSpareTime = 32,
-            SimSleepTime = 33,
-            IOPumpTime = 34
+            PhysicsLodTasks = 26,
+            SimPhysicsStepMs = 27,
+            SimPhysicsShapeMs = 28,
+            SimPhysicsOtherMs = 29,
+            SimPhysicsMemory = 30,
+            ScriptEps = 31,
+            SimSpareMs = 32,
+            SimSleepMs = 33,
+            SimIoPumpTime = 34
         }
 
         /// <summary>
@@ -113,11 +128,24 @@ namespace OpenSim.Region.Framework.Scenes
             get { return lastReportedSimStats; }
         }
 
+        /// <summary>
+        /// Extra sim statistics that are used by monitors but not sent to the client.
+        /// </summary>
+        /// <value>
+        /// The keys are the stat names.
+        /// </value>
+        private Dictionary<string, float> m_lastReportedExtraSimStats = new Dictionary<string, float>();
+
         // Sending a stats update every 3 seconds-
-        private int statsUpdatesEveryMS = 3000;
-        private float statsUpdateFactor = 0;
-        private float m_timeDilation = 0;
-        private int m_fps = 0;
+        private int m_statsUpdatesEveryMS = 3000;
+        private float m_statsUpdateFactor;
+        private float m_timeDilation;
+        private int m_fps;
+
+        /// <summary>
+        /// Number of the last frame on which we processed a stats udpate.
+        /// </summary>
+        private uint m_lastUpdateFrame;
 
         /// <summary>
         /// Our nominal fps target, as expected in fps stats when a sim is running normally.
@@ -135,43 +163,42 @@ namespace OpenSim.Region.Framework.Scenes
         private float m_reportedFpsCorrectionFactor = 5;
 
         // saved last reported value so there is something available for llGetRegionFPS 
-        private float lastReportedSimFPS = 0;
-        private float[] lastReportedSimStats = new float[23];
-        private float m_pfps = 0;
+        private float lastReportedSimFPS;
+        private float[] lastReportedSimStats = new float[22];
+        private float m_pfps;
 
         /// <summary>
         /// Number of agent updates requested in this stats cycle
         /// </summary>
-        private int m_agentUpdates = 0;
+        private int m_agentUpdates;
 
         /// <summary>
         /// Number of object updates requested in this stats cycle
         /// </summary>
         private int m_objectUpdates;
 
-        private int m_frameMS = 0;
-        private int m_netMS = 0;
-        private int m_agentMS = 0;
-        private int m_physicsMS = 0;
-        private int m_imageMS = 0;
-        private int m_otherMS = 0;
-        private int m_sleeptimeMS = 0;
-
+        private int m_frameMS;
+        private int m_spareMS;
+        private int m_netMS;
+        private int m_agentMS;
+        private int m_physicsMS;
+        private int m_imageMS;
+        private int m_otherMS;
 
 //Ckrinke: (3-21-08) Comment out to remove a compiler warning. Bring back into play when needed.
 //Ckrinke        private int m_scriptMS = 0;
 
-        private int m_rootAgents = 0;
-        private int m_childAgents = 0;
-        private int m_numPrim = 0;
-        private int m_inPacketsPerSecond = 0;
-        private int m_outPacketsPerSecond = 0;
-        private int m_activePrim = 0;
-        private int m_unAckedBytes = 0;
-        private int m_pendingDownloads = 0;
-        private int m_pendingUploads = 0;
-        private int m_activeScripts = 0;
-        private int m_scriptLinesPerSecond = 0;
+        private int m_rootAgents;
+        private int m_childAgents;
+        private int m_numPrim;
+        private int m_inPacketsPerSecond;
+        private int m_outPacketsPerSecond;
+        private int m_activePrim;
+        private int m_unAckedBytes;
+        private int m_pendingDownloads;
+        private int m_pendingUploads = 0;  // FIXME: Not currently filled in
+        private int m_activeScripts;
+        private int m_scriptLinesPerSecond;
 
         private int m_objectCapacity = 45000;
 
@@ -187,13 +214,13 @@ namespace OpenSim.Region.Framework.Scenes
         {
             m_scene = scene;
             m_reportedFpsCorrectionFactor = scene.MinFrameTime * m_nominalReportedFps;
-            statsUpdateFactor = (float)(statsUpdatesEveryMS / 1000);
+            m_statsUpdateFactor = (float)(m_statsUpdatesEveryMS / 1000);
             ReportingRegion = scene.RegionInfo;
 
             m_objectCapacity = scene.RegionInfo.ObjectCapacity;
             m_report.AutoReset = true;
-            m_report.Interval = statsUpdatesEveryMS;
-            m_report.Elapsed += statsHeartBeat;
+            m_report.Interval = m_statsUpdatesEveryMS;
+            m_report.Elapsed += TriggerStatsHeartbeat;
             m_report.Enabled = true;
 
             if (StatsManager.SimExtraStats != null)
@@ -202,20 +229,38 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void Close()
         {
-            m_report.Elapsed -= statsHeartBeat;
+            m_report.Elapsed -= TriggerStatsHeartbeat;
             m_report.Close();
         }
 
+        /// <summary>
+        /// Sets the number of milliseconds between stat updates.
+        /// </summary>
+        /// <param name='ms'></param>
         public void SetUpdateMS(int ms)
         {
-            statsUpdatesEveryMS = ms;
-            statsUpdateFactor = (float)(statsUpdatesEveryMS / 1000);
-            m_report.Interval = statsUpdatesEveryMS;
+            m_statsUpdatesEveryMS = ms;
+            m_statsUpdateFactor = (float)(m_statsUpdatesEveryMS / 1000);
+            m_report.Interval = m_statsUpdatesEveryMS;
+        }
+
+        private void TriggerStatsHeartbeat(object sender, EventArgs args)
+        {
+            try
+            {
+                statsHeartBeat(sender, args);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn(string.Format(
+                    "[SIM STATS REPORTER] Update for {0} failed with exception ",
+                    m_scene.RegionInfo.RegionName), e);
+            }
         }
 
         private void statsHeartBeat(object sender, EventArgs e)
         {
-            SimStatsPacket.StatBlock[] sb = new SimStatsPacket.StatBlock[23];
+            SimStatsPacket.StatBlock[] sb = new SimStatsPacket.StatBlock[22];
             SimStatsPacket.RegionBlock rb = new SimStatsPacket.RegionBlock();
             
             // Know what's not thread safe in Mono... modifying timers.
@@ -242,7 +287,7 @@ namespace OpenSim.Region.Framework.Scenes
                 int reportedFPS = (int)(m_fps * m_reportedFpsCorrectionFactor);
 
                 // save the reported value so there is something available for llGetRegionFPS 
-                lastReportedSimFPS = reportedFPS / statsUpdateFactor;
+                lastReportedSimFPS = reportedFPS / m_statsUpdateFactor;
 
                 float physfps = ((m_pfps / 1000));
 
@@ -253,7 +298,6 @@ namespace OpenSim.Region.Framework.Scenes
                     physfps = 0;
 
 #endregion
-                float factor = 1 / statsUpdateFactor;
                 if (reportedFPS <= 0)
                     reportedFPS = 1;
 
@@ -264,32 +308,38 @@ namespace OpenSim.Region.Framework.Scenes
                 float targetframetime = 1100.0f / (float)m_nominalReportedFps;
 
                 float sparetime;
-                float sleeptime;
                 if (TotalFrameTime > targetframetime)
                 {
                     sparetime = 0;
-                    sleeptime = 0;
-                }
-                else
-                {
-                    sparetime = m_frameMS - m_physicsMS - m_agentMS;
-                    sparetime *= perframe;
-                    if (sparetime < 0)
-                        sparetime = 0;
-                    else if (sparetime > TotalFrameTime)
-                        sparetime = TotalFrameTime;
-                    sleeptime = m_sleeptimeMS * perframe;
                 }
+
+                m_rootAgents = m_scene.SceneGraph.GetRootAgentCount();
+                m_childAgents = m_scene.SceneGraph.GetChildAgentCount();
+                m_numPrim = m_scene.SceneGraph.GetTotalObjectsCount();
+                m_activePrim = m_scene.SceneGraph.GetActiveObjectsCount();
+                m_activeScripts = m_scene.SceneGraph.GetActiveScriptsCount();
+
+                // FIXME: Checking for stat sanity is a complex approach.  What we really need to do is fix the code
+                // so that stat numbers are always consistent.
+                CheckStatSanity();
                 
                 // other MS is actually simulation time
                 //                m_otherMS = m_frameMS - m_physicsMS - m_imageMS - m_netMS - m_agentMS;
                 // m_imageMS  m_netMS are not included in m_frameMS
 
-                m_otherMS = m_frameMS - m_physicsMS -  m_agentMS - m_sleeptimeMS;
+                m_otherMS = m_frameMS - m_physicsMS -  m_agentMS;
                 if (m_otherMS < 0)
                     m_otherMS = 0;
 
-                for (int i = 0; i < 23; i++)
+                uint thisFrame = m_scene.Frame;
+                float framesUpdated = (float)(thisFrame - m_lastUpdateFrame) * m_reportedFpsCorrectionFactor;
+                m_lastUpdateFrame = thisFrame;
+
+                // Avoid div-by-zero if somehow we've not updated any frames.
+                if (framesUpdated == 0)
+                    framesUpdated = 1;
+
+                for (int i = 0; i < 22; i++)
                 {
                     sb[i] = new SimStatsPacket.StatBlock();
                 }
@@ -298,13 +348,13 @@ namespace OpenSim.Region.Framework.Scenes
                 sb[0].StatValue = (Single.IsNaN(m_timeDilation)) ? 0.1f : m_timeDilation ; //((((m_timeDilation + (0.10f * statsUpdateFactor)) /10)  / statsUpdateFactor));
 
                 sb[1].StatID = (uint) Stats.SimFPS;
-                sb[1].StatValue = reportedFPS / statsUpdateFactor;
+                sb[1].StatValue = reportedFPS / m_statsUpdateFactor;
 
                 sb[2].StatID = (uint) Stats.PhysicsFPS;
-                sb[2].StatValue = physfps / statsUpdateFactor;
+                sb[2].StatValue = physfps / m_statsUpdateFactor;
 
                 sb[3].StatID = (uint) Stats.AgentUpdates;
-                sb[3].StatValue = (m_agentUpdates / statsUpdateFactor);
+                sb[3].StatValue = (m_agentUpdates / m_statsUpdateFactor);
 
                 sb[4].StatID = (uint) Stats.Agents;
                 sb[4].StatValue = m_rootAgents;
@@ -319,38 +369,31 @@ namespace OpenSim.Region.Framework.Scenes
                 sb[7].StatValue = m_activePrim;
 
                 sb[8].StatID = (uint)Stats.FrameMS;
-                //                sb[8].StatValue = m_frameMS / statsUpdateFactor;
-                sb[8].StatValue = TotalFrameTime;
+                sb[8].StatValue = m_frameMS / framesUpdated;
 
                 sb[9].StatID = (uint)Stats.NetMS;
-                //                sb[9].StatValue = m_netMS / statsUpdateFactor;
-                sb[9].StatValue = m_netMS * perframe;
+                sb[9].StatValue = m_netMS / framesUpdated;
 
                 sb[10].StatID = (uint)Stats.PhysicsMS;
-                //                sb[10].StatValue = m_physicsMS / statsUpdateFactor;
-                sb[10].StatValue = m_physicsMS * perframe;
+                sb[10].StatValue = m_physicsMS / framesUpdated;
 
                 sb[11].StatID = (uint)Stats.ImageMS ;
-                //                sb[11].StatValue = m_imageMS / statsUpdateFactor;
-                sb[11].StatValue = m_imageMS * perframe;
+                sb[11].StatValue = m_imageMS / framesUpdated;
 
                 sb[12].StatID = (uint)Stats.OtherMS;
-                //                sb[12].StatValue = m_otherMS / statsUpdateFactor;
-                sb[12].StatValue = m_otherMS * perframe;
-
+                sb[12].StatValue = m_otherMS / framesUpdated;
 
                 sb[13].StatID = (uint)Stats.InPacketsPerSecond;
-                sb[13].StatValue = (m_inPacketsPerSecond / statsUpdateFactor);
+                sb[13].StatValue = (m_inPacketsPerSecond / m_statsUpdateFactor);
 
                 sb[14].StatID = (uint)Stats.OutPacketsPerSecond;
-                sb[14].StatValue = (m_outPacketsPerSecond / statsUpdateFactor);
+                sb[14].StatValue = (m_outPacketsPerSecond / m_statsUpdateFactor);
 
                 sb[15].StatID = (uint)Stats.UnAckedBytes;
                 sb[15].StatValue = m_unAckedBytes;
 
                 sb[16].StatID = (uint)Stats.AgentMS;
-//                sb[16].StatValue = m_agentMS / statsUpdateFactor;
-                sb[16].StatValue = m_agentMS * perframe;
+                sb[16].StatValue = m_agentMS / framesUpdated;
 
                 sb[17].StatID = (uint)Stats.PendingDownloads;
                 sb[17].StatValue = m_pendingDownloads;
@@ -362,15 +405,12 @@ namespace OpenSim.Region.Framework.Scenes
                 sb[19].StatValue = m_activeScripts;
 
                 sb[20].StatID = (uint)Stats.ScriptLinesPerSecond;
-                sb[20].StatValue = m_scriptLinesPerSecond / statsUpdateFactor;
+                sb[20].StatValue = m_scriptLinesPerSecond / m_statsUpdateFactor;
 
-                sb[21].StatID = (uint)Stats.SimSpareTime;
-                sb[21].StatValue = sparetime;
+                sb[21].StatID = (uint)Stats.SimSpareMs;
+                sb[21].StatValue = m_spareMS / framesUpdated;
 
-                sb[22].StatID = (uint)Stats.SimSleepTime;
-                sb[22].StatValue = sleeptime;
-               
-                for (int i = 0; i < 23; i++)
+                for (int i = 0; i < 22; i++)
                 {
                     lastReportedSimStats[i] = sb[i].StatValue;
                 }
@@ -387,13 +427,32 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
                 // Extra statistics that aren't currently sent to clients
-                LastReportedObjectUpdates = m_objectUpdates / statsUpdateFactor;
+                lock (m_lastReportedExtraSimStats)
+                {
+                    m_lastReportedExtraSimStats[LastReportedObjectUpdateStatName] = m_objectUpdates / m_statsUpdateFactor;
+
+                    Dictionary<string, float> physicsStats = m_scene.PhysicsScene.GetStats();
+    
+                    if (physicsStats != null)
+                    {
+                        foreach (KeyValuePair<string, float> tuple in physicsStats)
+                        {
+                            // FIXME: An extremely dirty hack to divide MS stats per frame rather than per second
+                            // Need to change things so that stats source can indicate whether they are per second or
+                            // per frame.
+                            if (tuple.Key.EndsWith("MS"))
+                                m_lastReportedExtraSimStats[tuple.Key] = tuple.Value / framesUpdated;
+                            else
+                                m_lastReportedExtraSimStats[tuple.Key] = tuple.Value / m_statsUpdateFactor;
+                        }
+                    }
+                }
 
-                resetvalues();
+                ResetValues();
             }
         }
 
-        private void resetvalues()
+        private void ResetValues()
         {
             m_timeDilation = 0;
             m_fps = 0;
@@ -411,7 +470,7 @@ namespace OpenSim.Region.Framework.Scenes
             m_physicsMS = 0;
             m_imageMS = 0;
             m_otherMS = 0;
-            m_sleeptimeMS = 0;
+            m_spareMS = 0;
 
 //Ckrinke This variable is not used, so comment to remove compiler warning until it is used.
 //Ckrinke            m_scriptMS = 0;
@@ -433,13 +492,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_timeDilation = td;
         }
 
-        public void SetRootAgents(int rootAgents)
-        {
-            m_rootAgents = rootAgents;
-            CheckStatSanity();
-
-        }
-
         internal void CheckStatSanity()
         {
             if (m_rootAgents < 0 || m_childAgents < 0)
@@ -456,22 +508,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void SetChildAgents(int childAgents)
-        {
-            m_childAgents = childAgents;
-            CheckStatSanity();
-        }
-
-        public void SetObjects(int objects)
-        {
-            m_numPrim = objects;
-        }
-
-        public void SetActiveObjects(int objects)
-        {
-            m_activePrim = objects;
-        }
-
         public void AddFPS(int frames)
         {
             m_fps += frames;
@@ -513,6 +549,11 @@ namespace OpenSim.Region.Framework.Scenes
             m_frameMS += ms;
         }
 
+        public void AddSpareMS(int ms)
+        {
+            m_spareMS += ms;
+        }
+
         public void addNetMS(int ms)
         {
             m_netMS += ms;
@@ -538,15 +579,13 @@ namespace OpenSim.Region.Framework.Scenes
             m_otherMS += ms;
         }
 
-        public void addSleepMS(int ms)
-        {
-            m_sleeptimeMS += ms;
-        }
-
         public void AddPendingDownloads(int count)
         {
             m_pendingDownloads += count;
-            if (m_pendingDownloads < 0) m_pendingDownloads = 0;
+
+            if (m_pendingDownloads < 0)
+                m_pendingDownloads = 0;
+
             //m_log.InfoFormat("[stats]: Adding {0} to pending downloads to make {1}", count, m_pendingDownloads);
         }
 
@@ -555,11 +594,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_scriptLinesPerSecond += count;
         }
 
-        public void SetActiveScripts(int count)
-        {
-            m_activeScripts = count;
-        }
-
         public void AddPacketsStats(int inPackets, int outPackets, int unAckedBytes)
         {
             AddInPackets(inPackets);
@@ -568,5 +602,11 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         #endregion
+
+        public Dictionary<string, float> GetExtraSimStats()
+        {
+            lock (m_lastReportedExtraSimStats)
+                return new Dictionary<string, float>(m_lastReportedExtraSimStats);
+        }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Tests/BorderTests.cs b/OpenSim/Region/Framework/Scenes/Tests/BorderTests.cs
index ab6311b..4a21dc9 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/BorderTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/BorderTests.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Text;
 using NUnit.Framework;
 using OpenMetaverse;
@@ -68,11 +69,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             Vector3 position = new Vector3(200,200,21);
             
             foreach (Border b in testborders)
-            {
                 Assert.That(!b.TestCross(position));
 
-            }
-
             position = new Vector3(200,280,21);
             Assert.That(NorthBorder.TestCross(position));
 
diff --git a/OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs b/OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs
index a5d2b23..ea9fc93 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs
@@ -45,7 +45,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
     {
         static public Random random;
         SceneObjectGroup found;
-        Scene scene = SceneHelpers.SetupScene();
+        Scene scene = new SceneHelpers().SetupScene();
 
         [Test]
         public void T010_AddObjects()
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs
index 9a60e50..d23c965 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs
@@ -26,7 +26,9 @@
  */
 
 using System;
+using System.IO;
 using System.Reflection;
+using System.Text;
 using NUnit.Framework;
 using OpenMetaverse;
 using OpenSim.Framework;
@@ -44,7 +46,9 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         public void TestDuplicateObject()
         {
             TestHelpers.InMethod();
-            Scene scene = SceneHelpers.SetupScene();
+//            TestHelpers.EnableLogging();
+
+            Scene scene = new SceneHelpers().SetupScene();
 
             UUID ownerId = new UUID("00000000-0000-0000-0000-000000000010");
             string part1Name = "part1";
@@ -82,6 +86,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             Assert.That(dupePart1.PhysActor, Is.Not.Null);
             Assert.That(dupePart2.PhysActor, Is.Not.Null);
             */
+
+//            TestHelpers.DisableLogging();
         }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
index 7737d8e..81add43 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
@@ -88,7 +88,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         {
             TestHelpers.InMethod();
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             int partsToTestCount = 3;
 
             SceneObjectGroup so
@@ -118,7 +118,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         {
             TestHelpers.InMethod();
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
 
             string obj1Name = "Alfred";
             string obj2Name = "Betty";
@@ -152,7 +152,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         {
             TestHelpers.InMethod();
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             int partsToTestCount = 3;
 
             SceneObjectGroup so
@@ -185,10 +185,15 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         {
             TestHelpers.InMethod();
 
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             SceneObjectPart part = SceneHelpers.AddSceneObject(scene);
+
+            Assert.That(part.ParentGroup.IsDeleted, Is.False);
+
             scene.DeleteSceneObject(part.ParentGroup, false);
 
+            Assert.That(part.ParentGroup.IsDeleted, Is.True);
+
             SceneObjectPart retrievedPart = scene.GetSceneObjectPart(part.LocalId);
             Assert.That(retrievedPart, Is.Null);
         }
@@ -204,7 +209,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 
             UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000001");
 
-            TestScene scene = SceneHelpers.SetupScene();
+            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;
@@ -219,8 +224,12 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 
             Assert.That(retrievedPart, Is.Not.Null);
 
+            Assert.That(part.ParentGroup.IsDeleted, Is.False);
+
             sogd.InventoryDeQueueAndDelete();
 
+            Assert.That(part.ParentGroup.IsDeleted, Is.True);            
+
             SceneObjectPart retrievedPart2 = scene.GetSceneObjectPart(part.LocalId);
             Assert.That(retrievedPart2, Is.Null);
         }
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
index 654b1a2..0076f41 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
@@ -61,7 +61,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
                         
             UUID userId = UUID.Parse("10000000-0000-0000-0000-000000000001");
             
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             IConfigSource configSource = new IniConfigSource();
             IConfig config = configSource.AddConfig("Startup");
             config.Set("serverside_object_permissions", true);
@@ -100,7 +100,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             UUID userId = UUID.Parse("10000000-0000-0000-0000-000000000001");
             UUID objectOwnerId = UUID.Parse("20000000-0000-0000-0000-000000000001");
             
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             IConfigSource configSource = new IniConfigSource();
             IConfig config = configSource.AddConfig("Startup");
             config.Set("serverside_object_permissions", true);
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs
index be5b4a8..1add3dd 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs
@@ -55,7 +55,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             UUID ownerId = TestHelpers.ParseTail(0x1);
             int nParts = 3;
 
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             SceneObjectGroup sog1 = SceneHelpers.CreateSceneObject(nParts, ownerId, "TestLinkToSelf_", 0x10);
             scene.AddSceneObject(sog1);
             scene.LinkObjects(ownerId, sog1.LocalId, new List<uint>() { sog1.Parts[1].LocalId });
@@ -71,7 +71,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             
             bool debugtest = false; 
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             SceneObjectPart part1 = SceneHelpers.AddSceneObject(scene);
             SceneObjectGroup grp1 = part1.ParentGroup;
             SceneObjectPart part2 = SceneHelpers.AddSceneObject(scene);
@@ -153,7 +153,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             
             bool debugtest = false;
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             SceneObjectPart part1 = SceneHelpers.AddSceneObject(scene);
             SceneObjectGroup grp1 = part1.ParentGroup;
             SceneObjectPart part2 = SceneHelpers.AddSceneObject(scene);
@@ -286,7 +286,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             TestHelpers.InMethod();
             //log4net.Config.XmlConfigurator.Configure();
             
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             
             string rootPartName = "rootpart";
             UUID rootPartUuid = new UUID("00000000-0000-0000-0000-000000000001");
@@ -325,7 +325,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             TestHelpers.InMethod();
             //log4net.Config.XmlConfigurator.Configure();
             
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             
             string rootPartName = "rootpart";
             UUID rootPartUuid = new UUID("00000000-0000-0000-0000-000000000001");
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
index b49c6e7..0a94c19 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
@@ -52,7 +52,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             SceneObjectGroup g1 = SceneHelpers.AddSceneObject(scene).ParentGroup;
 
             g1.GroupResize(new Vector3(2, 3, 4));
@@ -75,7 +75,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             TestHelpers.InMethod();
             //log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
 
             SceneObjectGroup g1 = SceneHelpers.CreateSceneObject(2, UUID.Zero);
             g1.RootPart.Scale = new Vector3(2, 3, 4);
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectScriptTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectScriptTests.cs
index c582cf6..d2361f8 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectScriptTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectScriptTests.cs
@@ -52,7 +52,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 //            UUID itemId = TestHelpers.ParseTail(0x2);
             string itemName = "Test Script Item";
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             SceneObjectGroup so = SceneHelpers.CreateSceneObject(1, userId);
             scene.AddNewSceneObject(so, true);
 
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectSpatialTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectSpatialTests.cs
new file mode 100644
index 0000000..6d255aa
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectSpatialTests.cs
@@ -0,0 +1,154 @@
+/*
+ * 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.Reflection;
+using System.Threading;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+
+namespace OpenSim.Region.Framework.Scenes.Tests
+{
+    /// <summary>
+    /// Spatial scene object tests (will eventually cover root and child part position, rotation properties, etc.)
+    /// </summary>
+    [TestFixture]
+    public class SceneObjectSpatialTests
+    {
+        TestScene m_scene;
+        UUID m_ownerId = TestHelpers.ParseTail(0x1);
+
+        [SetUp]
+        public void SetUp()
+        {
+            m_scene = new SceneHelpers().SetupScene();
+        }
+
+        [Test]
+        public void TestGetSceneObjectGroupPosition()
+        {
+            TestHelpers.InMethod();
+
+            Vector3 position = new Vector3(10, 20, 30);
+
+            SceneObjectGroup so
+                = SceneHelpers.CreateSceneObject(1, m_ownerId, "obj1", 0x10);
+            so.AbsolutePosition = position;
+            m_scene.AddNewSceneObject(so, false);
+
+            Assert.That(so.AbsolutePosition, Is.EqualTo(position));
+        }
+
+        [Test]
+        public void TestGetRootPartPosition()
+        {
+            TestHelpers.InMethod();
+
+            Vector3 partPosition = new Vector3(10, 20, 30);
+
+            SceneObjectGroup so
+                = SceneHelpers.CreateSceneObject(1, m_ownerId, "obj1", 0x10);
+            so.AbsolutePosition = partPosition;
+            m_scene.AddNewSceneObject(so, false);
+
+            Assert.That(so.RootPart.AbsolutePosition, Is.EqualTo(partPosition));
+            Assert.That(so.RootPart.GroupPosition, Is.EqualTo(partPosition));
+            Assert.That(so.RootPart.GetWorldPosition(), Is.EqualTo(partPosition));
+            Assert.That(so.RootPart.RelativePosition, Is.EqualTo(partPosition));
+            Assert.That(so.RootPart.OffsetPosition, Is.EqualTo(Vector3.Zero));
+        }
+
+        [Test]
+        public void TestGetChildPartPosition()
+        {
+            TestHelpers.InMethod();
+
+            Vector3 rootPartPosition = new Vector3(10, 20, 30);
+            Vector3 childOffsetPosition = new Vector3(2, 3, 4);
+
+            SceneObjectGroup so
+                = SceneHelpers.CreateSceneObject(2, m_ownerId, "obj1", 0x10);
+            so.AbsolutePosition = rootPartPosition;
+            so.Parts[1].OffsetPosition = childOffsetPosition;
+
+            m_scene.AddNewSceneObject(so, false);
+
+            // Calculate child absolute position.
+            Vector3 childPosition = new Vector3(rootPartPosition + childOffsetPosition);
+
+            SceneObjectPart childPart = so.Parts[1];
+            Assert.That(childPart.AbsolutePosition, Is.EqualTo(childPosition));
+            Assert.That(childPart.GroupPosition, Is.EqualTo(rootPartPosition));
+            Assert.That(childPart.GetWorldPosition(), Is.EqualTo(childPosition));
+            Assert.That(childPart.RelativePosition, Is.EqualTo(childOffsetPosition));
+            Assert.That(childPart.OffsetPosition, Is.EqualTo(childOffsetPosition));
+        }
+
+        [Test]
+        public void TestGetChildPartPositionAfterObjectRotation()
+        {
+            TestHelpers.InMethod();
+
+            Vector3 rootPartPosition = new Vector3(10, 20, 30);
+            Vector3 childOffsetPosition = new Vector3(2, 3, 4);
+
+            SceneObjectGroup so
+                = SceneHelpers.CreateSceneObject(2, m_ownerId, "obj1", 0x10);
+            so.AbsolutePosition = rootPartPosition;
+            so.Parts[1].OffsetPosition = childOffsetPosition;
+
+            m_scene.AddNewSceneObject(so, false);
+
+            so.UpdateGroupRotationR(Quaternion.CreateFromEulers(0, 0, -90 * Utils.DEG_TO_RAD));
+
+            // Calculate child absolute position.
+            Vector3 rotatedChildOffsetPosition
+                = new Vector3(childOffsetPosition.Y, -childOffsetPosition.X, childOffsetPosition.Z);
+
+            Vector3 childPosition = new Vector3(rootPartPosition + rotatedChildOffsetPosition);
+
+            SceneObjectPart childPart = so.Parts[1];
+
+            // FIXME: Should be childPosition after rotation?
+            Assert.That(childPart.AbsolutePosition, Is.EqualTo(rootPartPosition + childOffsetPosition));
+
+            Assert.That(childPart.GroupPosition, Is.EqualTo(rootPartPosition));
+            Assert.That(childPart.GetWorldPosition(), Is.EqualTo(childPosition));
+
+            // Relative to root part as (0, 0, 0)
+            Assert.That(childPart.RelativePosition, Is.EqualTo(childOffsetPosition));
+
+            // Relative to root part as (0, 0, 0)
+            Assert.That(childPart.OffsetPosition, Is.EqualTo(childOffsetPosition));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectStatusTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectStatusTests.cs
index 2a342d5..742c769 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectStatusTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectStatusTests.cs
@@ -26,6 +26,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Reflection;
 using NUnit.Framework;
 using OpenMetaverse;
@@ -43,24 +44,141 @@ namespace OpenSim.Region.Framework.Scenes.Tests
     [TestFixture]
     public class SceneObjectStatusTests
     {
+        private TestScene m_scene;
+        private UUID m_ownerId = TestHelpers.ParseTail(0x1);
+        private SceneObjectGroup m_so1;
+        private SceneObjectGroup m_so2;
+
+        [SetUp]
+        public void Init()
+        {
+            m_scene = new SceneHelpers().SetupScene();
+            m_so1 = SceneHelpers.CreateSceneObject(1, m_ownerId, "so1", 0x10);
+            m_so2 = SceneHelpers.CreateSceneObject(1, m_ownerId, "so2", 0x20);
+        }
+
         [Test]
-        public void TestSetPhantom()
+        public void TestSetPhantomSinglePrim()
         {
             TestHelpers.InMethod();
 
-//            Scene scene = SceneSetupHelpers.SetupScene();
-            SceneObjectGroup so = SceneHelpers.CreateSceneObject(1, UUID.Zero);
-            SceneObjectPart rootPart = so.RootPart;
+            m_scene.AddSceneObject(m_so1);
+
+            SceneObjectPart rootPart = m_so1.RootPart;
             Assert.That(rootPart.Flags, Is.EqualTo(PrimFlags.None));
 
-            so.ScriptSetPhantomStatus(true);
+            m_so1.ScriptSetPhantomStatus(true);
 
 //            Console.WriteLine("so.RootPart.Flags [{0}]", so.RootPart.Flags);
             Assert.That(rootPart.Flags, Is.EqualTo(PrimFlags.Phantom));
 
-            so.ScriptSetPhantomStatus(false);
+            m_so1.ScriptSetPhantomStatus(false);
 
             Assert.That(rootPart.Flags, Is.EqualTo(PrimFlags.None));            
         }
+
+        [Test]
+        public void TestSetPhysicsSinglePrim()
+        {
+            TestHelpers.InMethod();
+
+            m_scene.AddSceneObject(m_so1);
+
+            SceneObjectPart rootPart = m_so1.RootPart;
+            Assert.That(rootPart.Flags, Is.EqualTo(PrimFlags.None));
+
+            m_so1.ScriptSetPhysicsStatus(true);
+
+//            Console.WriteLine("so.RootPart.Flags [{0}]", so.RootPart.Flags);
+            Assert.That(rootPart.Flags, Is.EqualTo(PrimFlags.Physics));
+
+            m_so1.ScriptSetPhysicsStatus(false);
+
+            Assert.That(rootPart.Flags, Is.EqualTo(PrimFlags.None));
+        }
+        
+        [Test]
+        public void TestSetPhysicsLinkset()
+        {
+            TestHelpers.InMethod();
+
+            m_scene.AddSceneObject(m_so1);
+            m_scene.AddSceneObject(m_so2);
+
+            m_scene.LinkObjects(m_ownerId, m_so1.LocalId, new List<uint>() { m_so2.LocalId });
+
+            m_so1.ScriptSetPhysicsStatus(true);
+
+            Assert.That(m_so1.RootPart.Flags, Is.EqualTo(PrimFlags.Physics));
+            Assert.That(m_so1.Parts[1].Flags, Is.EqualTo(PrimFlags.Physics));
+
+            m_so1.ScriptSetPhysicsStatus(false);
+
+            Assert.That(m_so1.RootPart.Flags, Is.EqualTo(PrimFlags.None));
+            Assert.That(m_so1.Parts[1].Flags, Is.EqualTo(PrimFlags.None));
+
+            m_so1.ScriptSetPhysicsStatus(true);
+
+            Assert.That(m_so1.RootPart.Flags, Is.EqualTo(PrimFlags.Physics));
+            Assert.That(m_so1.Parts[1].Flags, Is.EqualTo(PrimFlags.Physics));
+        }
+
+        /// <summary>
+        /// Test that linking results in the correct physical status for all linkees.
+        /// </summary>
+        [Test]
+        public void TestLinkPhysicsBothPhysical()
+        {
+            TestHelpers.InMethod();
+
+            m_scene.AddSceneObject(m_so1);
+            m_scene.AddSceneObject(m_so2);
+
+            m_so1.ScriptSetPhysicsStatus(true);
+            m_so2.ScriptSetPhysicsStatus(true);
+
+            m_scene.LinkObjects(m_ownerId, m_so1.LocalId, new List<uint>() { m_so2.LocalId });
+
+            Assert.That(m_so1.RootPart.Flags, Is.EqualTo(PrimFlags.Physics));
+            Assert.That(m_so1.Parts[1].Flags, Is.EqualTo(PrimFlags.Physics));
+        }
+
+        /// <summary>
+        /// Test that linking results in the correct physical status for all linkees.
+        /// </summary>
+        [Test]
+        public void TestLinkPhysicsRootPhysicalOnly()
+        {
+            TestHelpers.InMethod();
+
+            m_scene.AddSceneObject(m_so1);
+            m_scene.AddSceneObject(m_so2);
+
+            m_so1.ScriptSetPhysicsStatus(true);
+
+            m_scene.LinkObjects(m_ownerId, m_so1.LocalId, new List<uint>() { m_so2.LocalId });
+
+            Assert.That(m_so1.RootPart.Flags, Is.EqualTo(PrimFlags.Physics));
+            Assert.That(m_so1.Parts[1].Flags, Is.EqualTo(PrimFlags.Physics));
+        }
+
+        /// <summary>
+        /// Test that linking results in the correct physical status for all linkees.
+        /// </summary>
+        [Test]
+        public void TestLinkPhysicsChildPhysicalOnly()
+        {
+            TestHelpers.InMethod();
+
+            m_scene.AddSceneObject(m_so1);
+            m_scene.AddSceneObject(m_so2);
+
+            m_so2.ScriptSetPhysicsStatus(true);
+
+            m_scene.LinkObjects(m_ownerId, m_so1.LocalId, new List<uint>() { m_so2.LocalId });
+
+            Assert.That(m_so1.RootPart.Flags, Is.EqualTo(PrimFlags.None));
+            Assert.That(m_so1.Parts[1].Flags, Is.EqualTo(PrimFlags.None));
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
index c13d82e..c7eaff9 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
@@ -58,7 +58,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
                         
             UUID userId = UUID.Parse("10000000-0000-0000-0000-000000000001");
             
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             IConfigSource configSource = new IniConfigSource();
             
             IConfig startupConfig = configSource.AddConfig("Startup");
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
index ed9b179..02c45ef 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
@@ -67,10 +67,12 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         public void Init()
         {
             TestHelpers.InMethod();
-            
-            scene = SceneHelpers.SetupScene("Neighbour x", UUID.Random(), 1000, 1000);
-            scene2 = SceneHelpers.SetupScene("Neighbour x+1", UUID.Random(), 1001, 1000);
-            scene3 = SceneHelpers.SetupScene("Neighbour x-1", UUID.Random(), 999, 1000);
+
+            SceneHelpers sh = new SceneHelpers();
+
+            scene = sh.SetupScene("Neighbour x", UUID.Random(), 1000, 1000);
+            scene2 = sh.SetupScene("Neighbour x+1", UUID.Random(), 1001, 1000);
+            scene3 = sh.SetupScene("Neighbour x-1", UUID.Random(), 999, 1000);
 
             ISharedRegionModule interregionComms = new LocalSimulationConnectorModule();
             interregionComms.Initialise(new IniConfigSource());
@@ -99,9 +101,9 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         public void TestCloseAgent()
         {
             TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
+//            TestHelpers.EnableLogging();
 
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
 
             Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(sp.UUID), Is.Not.Null);
@@ -112,6 +114,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             Assert.That(scene.GetScenePresence(sp.UUID), Is.Null);
             Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(sp.UUID), Is.Null);
             Assert.That(scene.AuthenticateHandler.GetAgentCircuits().Count, Is.EqualTo(0));
+
+//            TestHelpers.DisableLogging();
         }
 
         [Test]
@@ -126,7 +130,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             IConfig config = configSource.AddConfig("Modules");
             config.Set("SimulationServices", "LocalSimulationConnectorModule");
 
-            TestScene scene = SceneHelpers.SetupScene();
+            SceneHelpers sceneHelpers = new SceneHelpers();
+            TestScene scene = sceneHelpers.SetupScene();
             SceneHelpers.SetupSceneModules(scene, configSource, lsc);
 
             UUID agentId = TestHelpers.ParseTail(0x01);
@@ -176,8 +181,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             
 //            UUID agent1Id = UUID.Parse("00000000-0000-0000-0000-000000000001");
             
-            TestScene myScene1 = SceneHelpers.SetupScene("Neighbour y", UUID.Random(), 1000, 1000);
-            TestScene myScene2 = SceneHelpers.SetupScene("Neighbour y + 1", UUID.Random(), 1001, 1000);
+            TestScene myScene1 = new SceneHelpers().SetupScene("Neighbour y", UUID.Random(), 1000, 1000);
+            TestScene myScene2 = new SceneHelpers().SetupScene("Neighbour y + 1", UUID.Random(), 1001, 1000);
 
             IConfigSource configSource = new IniConfigSource();
             IConfig config = configSource.AddConfig("Startup");
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAnimationTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAnimationTests.cs
index 89f8007..646e5fa 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAnimationTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAnimationTests.cs
@@ -59,7 +59,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
             ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
             sp.Flying = true;
             sp.PhysicsCollisionUpdate(new CollisionEventUpdate());
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAutopilotTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAutopilotTests.cs
index cfea10d..1d1ff88 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAutopilotTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAutopilotTests.cs
@@ -64,7 +64,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [SetUp]
         public void Init()
         {
-            m_scene = SceneHelpers.SetupScene();
+            m_scene = new SceneHelpers().SetupScene();
         }
 
         [Test]
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs
index b7b8db4..313e350 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs
@@ -50,7 +50,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [SetUp]
         public void Init()
         {
-            m_scene = SceneHelpers.SetupScene();
+            m_scene = new SceneHelpers().SetupScene();
             m_sp = SceneHelpers.AddScenePresence(m_scene, TestHelpers.ParseTail(0x1));
         }
 
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
index bebc10c..a407f01 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
@@ -34,10 +34,14 @@ using OpenSim.Framework;
 using OpenSim.Framework.Communications;
 using OpenSim.Framework.Servers;
 using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.CoreModules.Framework;
+using OpenSim.Region.CoreModules.Framework.EntityTransfer;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
+using OpenSim.Region.CoreModules.World.Permissions;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using System.Threading;
+using System.IO;
+using System.Text;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {
@@ -47,145 +51,367 @@ namespace OpenSim.Region.Framework.Scenes.Tests
     [TestFixture]
     public class ScenePresenceTeleportTests
     {
-        /// <summary>
-        /// Test a teleport between two regions that are not neighbours and do not share any neighbours in common.
-        /// </summary>
-        /// Does not yet do what is says on the tin.
-        /// Commenting for now
-        //[Test, LongRunning]
-        public void TestSimpleNotNeighboursTeleport()
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten so none of them require async stuff (which regression
+            // tests really shouldn't).
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+        [Test]
+        public void TestSameRegionTeleport()
         {
             TestHelpers.InMethod();
-            ThreadRunResults results = new ThreadRunResults();
-            results.Result = false;
-            results.Message = "Test did not run";
-            TestRunning testClass = new TestRunning(results);
+//            log4net.Config.XmlConfigurator.Configure();
+
+            EntityTransferModule etm = new EntityTransferModule();
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Modules");
+            // Not strictly necessary since FriendsModule assumes it is the default (!)
+            config.Configs["Modules"].Set("EntityTransferModule", etm.Name);
+
+            TestScene scene = new SceneHelpers().SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            SceneHelpers.SetupSceneModules(scene, config, etm);
+
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
+
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
+            sp.AbsolutePosition = new Vector3(30, 31, 32);
+            scene.RequestTeleportLocation(
+                sp.ControllingClient,
+                scene.RegionInfo.RegionHandle,
+                teleportPosition,
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
 
-            Thread testThread = new Thread(testClass.run);
+            Assert.That(sp.AbsolutePosition, Is.EqualTo(teleportPosition));
 
-            // Seems kind of redundant to start a thread and then join it, however..   We need to protect against
-            // A thread abort exception in the simulator code.
-            testThread.Start();
-            testThread.Join();
+            Assert.That(scene.GetRootAgentCount(), Is.EqualTo(1));
+            Assert.That(scene.GetChildAgentCount(), Is.EqualTo(0));
 
-            Assert.That(testClass.results.Result, Is.EqualTo(true), testClass.results.Message);
-            // Console.WriteLine("Beginning test {0}", MethodBase.GetCurrentMethod());
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
+            // position instead).
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
         }
 
-        [TearDown]
-        public void TearDown()
+        [Test]
+        public void TestSameSimulatorSeparatedRegionsTeleport()
         {
-            try
-            {
-                if (MainServer.Instance != null) MainServer.Instance.Stop();
-            }
-            catch (NullReferenceException)
-            { }
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            UUID userId = TestHelpers.ParseTail(0x1);
+
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+
+            IConfigSource config = new IniConfigSource();
+            IConfig modulesConfig = config.AddConfig("Modules");
+            modulesConfig.Set("EntityTransferModule", etmA.Name);
+            modulesConfig.Set("SimulationServices", lscm.Name);
+            IConfig entityTransferConfig = config.AddConfig("EntityTransfer");
+
+            // In order to run a single threaded regression test we do not want the entity transfer module waiting
+            // for a callback from the destination scene before removing its avatar data.
+            entityTransferConfig.Set("wait_for_callback", false);
+
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1002, 1000);
+
+            SceneHelpers.SetupSceneModules(sceneA, config, etmA);
+            SceneHelpers.SetupSceneModules(sceneB, config, etmB);
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
+
+            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            sp.AbsolutePosition = new Vector3(30, 31, 32);
+
+            // XXX: A very nasty hack to tell the client about the destination scene without having to crank the whole
+            // UDP stack (?)
+//            ((TestClient)sp.ControllingClient).TeleportTargetScene = sceneB;
+
+            sceneA.RequestTeleportLocation(
+                sp.ControllingClient,
+                sceneB.RegionInfo.RegionHandle,
+                teleportPosition,
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
+
+            ((TestClient)sp.ControllingClient).CompleteTeleportClientSide();
+
+            Assert.That(sceneA.GetScenePresence(userId), Is.Null);
+
+            ScenePresence sceneBSp = sceneB.GetScenePresence(userId);
+            Assert.That(sceneBSp, Is.Not.Null);
+            Assert.That(sceneBSp.Scene.RegionInfo.RegionName, Is.EqualTo(sceneB.RegionInfo.RegionName));
+            Assert.That(sceneBSp.AbsolutePosition, Is.EqualTo(teleportPosition));
+
+            Assert.That(sceneA.GetRootAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneA.GetChildAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneB.GetRootAgentCount(), Is.EqualTo(1));
+            Assert.That(sceneB.GetChildAgentCount(), Is.EqualTo(0));
+
+            // TODO: Add assertions to check correct circuit details in both scenes.
+
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
+            // position instead).
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
         }
 
-    }
+        /// <summary>
+        /// Test teleport procedures when the target simulator returns false when queried about access.
+        /// </summary>
+        [Test]
+        public void TestSameSimulatorSeparatedRegionsQueryAccessFails()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
 
-    public class ThreadRunResults
-    {
-        public bool Result = false;
-        public string Message = string.Empty;
-    }
+            UUID userId = TestHelpers.ParseTail(0x1);
+            Vector3 preTeleportPosition = new Vector3(30, 31, 32);
 
-    public class TestRunning
-    {
-        public ThreadRunResults results;
-        public TestRunning(ThreadRunResults t)
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Modules");
+            config.Configs["Modules"].Set("EntityTransferModule", etmA.Name);
+            config.Configs["Modules"].Set("SimulationServices", lscm.Name);
+
+            config.AddConfig("EntityTransfer");
+
+            // In order to run a single threaded regression test we do not want the entity transfer module waiting
+            // for a callback from the destination scene before removing its avatar data.
+            config.Configs["EntityTransfer"].Set("wait_for_callback", false);
+
+            config.AddConfig("Startup");
+            config.Configs["Startup"].Set("serverside_object_permissions", true);
+
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1002, 1000);
+
+            SceneHelpers.SetupSceneModules(sceneA, config, etmA );
+
+            // We need to set up the permisions module on scene B so that our later use of agent limit to deny
+            // QueryAccess won't succeed anyway because administrators are always allowed in and the default
+            // IsAdministrator if no permissions module is present is true.
+            SceneHelpers.SetupSceneModules(sceneB, config, new object[] { new PermissionsModule(), etmB });
+
+            // Shared scene modules
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
+
+            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            sp.AbsolutePosition = preTeleportPosition;
+
+            // Make sceneB return false on query access
+            sceneB.RegionInfo.RegionSettings.AgentLimit = 0;
+
+            sceneA.RequestTeleportLocation(
+                sp.ControllingClient,
+                sceneB.RegionInfo.RegionHandle,
+                teleportPosition,
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
+
+//            ((TestClient)sp.ControllingClient).CompleteTeleportClientSide();
+
+            Assert.That(sceneB.GetScenePresence(userId), Is.Null);
+
+            ScenePresence sceneASp = sceneA.GetScenePresence(userId);
+            Assert.That(sceneASp, Is.Not.Null);
+            Assert.That(sceneASp.Scene.RegionInfo.RegionName, Is.EqualTo(sceneA.RegionInfo.RegionName));
+            Assert.That(sceneASp.AbsolutePosition, Is.EqualTo(preTeleportPosition));
+
+            Assert.That(sceneA.GetRootAgentCount(), Is.EqualTo(1));
+            Assert.That(sceneA.GetChildAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneB.GetRootAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneB.GetChildAgentCount(), Is.EqualTo(0));
+
+            // TODO: Add assertions to check correct circuit details in both scenes.
+
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
+            // position instead).
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
+
+//            TestHelpers.DisableLogging();
+        }
+
+        /// <summary>
+        /// Test teleport procedures when the target simulator create agent step is refused.
+        /// </summary>
+        [Test]
+        public void TestSameSimulatorSeparatedRegionsCreateAgentFails()
         {
-            results = t;
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            UUID userId = TestHelpers.ParseTail(0x1);
+            Vector3 preTeleportPosition = new Vector3(30, 31, 32);
+
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Modules");
+            config.Configs["Modules"].Set("EntityTransferModule", etmA.Name);
+            config.Configs["Modules"].Set("SimulationServices", lscm.Name);
+
+            config.AddConfig("EntityTransfer");
+
+            // In order to run a single threaded regression test we do not want the entity transfer module waiting
+            // for a callback from the destination scene before removing its avatar data.
+            config.Configs["EntityTransfer"].Set("wait_for_callback", false);
+
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1002, 1000);
+
+            SceneHelpers.SetupSceneModules(sceneA, config, etmA);
+            SceneHelpers.SetupSceneModules(sceneB, config, etmB);
+
+            // Shared scene modules
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
+
+            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            sp.AbsolutePosition = preTeleportPosition;
+
+            // Make sceneB refuse CreateAgent
+            sceneB.LoginsDisabled = true;
+
+            sceneA.RequestTeleportLocation(
+                sp.ControllingClient,
+                sceneB.RegionInfo.RegionHandle,
+                teleportPosition,
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
+
+//            ((TestClient)sp.ControllingClient).CompleteTeleportClientSide();
+
+            Assert.That(sceneB.GetScenePresence(userId), Is.Null);
+
+            ScenePresence sceneASp = sceneA.GetScenePresence(userId);
+            Assert.That(sceneASp, Is.Not.Null);
+            Assert.That(sceneASp.Scene.RegionInfo.RegionName, Is.EqualTo(sceneA.RegionInfo.RegionName));
+            Assert.That(sceneASp.AbsolutePosition, Is.EqualTo(preTeleportPosition));
+
+            Assert.That(sceneA.GetRootAgentCount(), Is.EqualTo(1));
+            Assert.That(sceneA.GetChildAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneB.GetRootAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneB.GetChildAgentCount(), Is.EqualTo(0));
+
+            // TODO: Add assertions to check correct circuit details in both scenes.
+
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
+            // position instead).
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
+
+//            TestHelpers.DisableLogging();
         }
-        public void run(object o)
+
+        [Test]
+        public void TestSameSimulatorNeighbouringRegionsTeleport()
         {
-            
-            //results.Result = true;
-            log4net.Config.XmlConfigurator.Configure();
-
-            UUID sceneAId = UUID.Parse("00000000-0000-0000-0000-000000000100");
-            UUID sceneBId = UUID.Parse("00000000-0000-0000-0000-000000000200");
-
-            // shared module
-            ISharedRegionModule interregionComms = new LocalSimulationConnectorModule();
-
-
-            Scene sceneB = SceneHelpers.SetupScene("sceneB", sceneBId, 1010, 1010);
-            SceneHelpers.SetupSceneModules(sceneB, new IniConfigSource(), interregionComms);
-            sceneB.RegisterRegionWithGrid();
-
-            Scene sceneA = SceneHelpers.SetupScene("sceneA", sceneAId, 1000, 1000);
-            SceneHelpers.SetupSceneModules(sceneA, new IniConfigSource(), interregionComms);
-            sceneA.RegisterRegionWithGrid();
-
-            UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000041");
-            TestClient client = (TestClient)SceneHelpers.AddScenePresence(sceneA, agentId).ControllingClient;
-
-            ICapabilitiesModule sceneACapsModule = sceneA.RequestModuleInterface<ICapabilitiesModule>();
-
-            results.Result = (sceneACapsModule.GetCapsPath(agentId) == client.CapsSeedUrl);
-            
-            if (!results.Result)
-            {
-                results.Message = "Incorrect caps object path set up in sceneA";
-                return;
-            }
-
-            /*
-            Assert.That(
-                sceneACapsModule.GetCapsPath(agentId),
-                Is.EqualTo(client.CapsSeedUrl),
-                "Incorrect caps object path set up in sceneA");
-            */
-            // FIXME: This is a hack to get the test working - really the normal OpenSim mechanisms should be used.
-            
-
-            client.TeleportTargetScene = sceneB;
-            client.Teleport(sceneB.RegionInfo.RegionHandle, new Vector3(100, 100, 100), new Vector3(40, 40, 40));
-
-            results.Result = (sceneB.GetScenePresence(agentId) != null);
-            if (!results.Result)
-            {
-                results.Message = "Client does not have an agent in sceneB";
-                return;
-            }
-
-            //Assert.That(sceneB.GetScenePresence(agentId), Is.Not.Null, "Client does not have an agent in sceneB");
-            
-            //Assert.That(sceneA.GetScenePresence(agentId), Is.Null, "Client still had an agent in sceneA");
-
-            results.Result = (sceneA.GetScenePresence(agentId) == null);
-            if (!results.Result)
-            {
-                results.Message = "Client still had an agent in sceneA";
-                return;
-            }
-
-            ICapabilitiesModule sceneBCapsModule = sceneB.RequestModuleInterface<ICapabilitiesModule>();
-
-
-            results.Result = ("http://" + sceneB.RegionInfo.ExternalHostName + ":" + sceneB.RegionInfo.HttpPort +
-                              "/CAPS/" + sceneBCapsModule.GetCapsPath(agentId) + "0000/" == client.CapsSeedUrl);
-            if (!results.Result)
-            {
-                results.Message = "Incorrect caps object path set up in sceneB";
-                return;
-            }
-
-            // Temporary assertion - caps url construction should at least be doable through a method.
-            /*
-            Assert.That(
-                "http://" + sceneB.RegionInfo.ExternalHostName + ":" + sceneB.RegionInfo.HttpPort + "/CAPS/" + sceneBCapsModule.GetCapsPath(agentId) + "0000/",
-                Is.EqualTo(client.CapsSeedUrl),
-                "Incorrect caps object path set up in sceneB");
-            */
-            // This assertion will currently fail since we don't remove the caps paths when no longer needed
-            //Assert.That(sceneACapsModule.GetCapsPath(agentId), Is.Null, "sceneA still had a caps object path");
-
-            // TODO: Check that more of everything is as it should be
-
-            // TODO: test what happens if we try to teleport to a region that doesn't exist
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            UUID userId = TestHelpers.ParseTail(0x1);
+
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+
+            IConfigSource config = new IniConfigSource();
+            IConfig modulesConfig = config.AddConfig("Modules");
+            modulesConfig.Set("EntityTransferModule", etmA.Name);
+            modulesConfig.Set("SimulationServices", lscm.Name);
+            IConfig entityTransferConfig = config.AddConfig("EntityTransfer");
+
+            // In order to run a single threaded regression test we do not want the entity transfer module waiting
+            // for a callback from the destination scene before removing its avatar data.
+            entityTransferConfig.Set("wait_for_callback", false);
+
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1001, 1000);
+
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+            SceneHelpers.SetupSceneModules(sceneA, config, new CapabilitiesModule(), etmA);
+            SceneHelpers.SetupSceneModules(sceneB, config, new CapabilitiesModule(), etmB);
+
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
+
+            ScenePresence originalSp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            originalSp.AbsolutePosition = new Vector3(30, 31, 32);
+
+            ScenePresence beforeSceneASp = sceneA.GetScenePresence(userId);
+            Assert.That(beforeSceneASp, Is.Not.Null);
+            Assert.That(beforeSceneASp.IsChildAgent, Is.False);
+
+            ScenePresence beforeSceneBSp = sceneB.GetScenePresence(userId);
+            Assert.That(beforeSceneBSp, Is.Not.Null);
+            Assert.That(beforeSceneBSp.IsChildAgent, Is.True);
+
+            // XXX: A very nasty hack to tell the client about the destination scene without having to crank the whole
+            // UDP stack (?)
+//            ((TestClient)beforeSceneASp.ControllingClient).TeleportTargetScene = sceneB;
+
+            sceneA.RequestTeleportLocation(
+                beforeSceneASp.ControllingClient,
+                sceneB.RegionInfo.RegionHandle,
+                teleportPosition,
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
+
+            ((TestClient)beforeSceneASp.ControllingClient).CompleteTeleportClientSide();
+
+            ScenePresence afterSceneASp = sceneA.GetScenePresence(userId);
+            Assert.That(afterSceneASp, Is.Not.Null);
+            Assert.That(afterSceneASp.IsChildAgent, Is.True);
+
+            ScenePresence afterSceneBSp = sceneB.GetScenePresence(userId);
+            Assert.That(afterSceneBSp, Is.Not.Null);
+            Assert.That(afterSceneBSp.IsChildAgent, Is.False);
+            Assert.That(afterSceneBSp.Scene.RegionInfo.RegionName, Is.EqualTo(sceneB.RegionInfo.RegionName));
+            Assert.That(afterSceneBSp.AbsolutePosition, Is.EqualTo(teleportPosition));
+
+            Assert.That(sceneA.GetRootAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneA.GetChildAgentCount(), Is.EqualTo(1));
+            Assert.That(sceneB.GetRootAgentCount(), Is.EqualTo(1));
+            Assert.That(sceneB.GetChildAgentCount(), Is.EqualTo(0));
+
+            // TODO: Add assertions to check correct circuit details in both scenes.
+
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
+            // position instead).
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
+
+//            TestHelpers.DisableLogging();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
index 5c9a77d..d722a09 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
@@ -60,7 +60,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         {
             TestHelpers.InMethod();
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             scene.Update(1);
             
             Assert.That(scene.Frame, Is.EqualTo(1));
diff --git a/OpenSim/Region/Framework/Scenes/Tests/TaskInventoryTests.cs b/OpenSim/Region/Framework/Scenes/Tests/TaskInventoryTests.cs
index 55c80f5..d15141b 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/TaskInventoryTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/TaskInventoryTests.cs
@@ -58,7 +58,7 @@ namespace OpenSim.Region.Framework.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
             SceneObjectGroup sog1 = SceneHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
@@ -81,7 +81,7 @@ namespace OpenSim.Region.Framework.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
             SceneObjectGroup sog1 = SceneHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
@@ -124,7 +124,7 @@ namespace OpenSim.Region.Framework.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
             SceneObjectGroup sog1 = SceneHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
@@ -153,7 +153,7 @@ namespace OpenSim.Region.Framework.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
             SceneObjectGroup sog1 = SceneHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
diff --git a/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs b/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
index 55fc1e7..44d2d45 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
@@ -58,7 +58,7 @@ namespace OpenSim.Region.Framework.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1001));
             UserAccount user2 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1002));
             InventoryItemBase item1 = UserInventoryHelpers.CreateInventoryItem(scene, "item1", user1.PrincipalID);
@@ -85,7 +85,7 @@ namespace OpenSim.Region.Framework.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1001));
             UserAccount user2 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1002));
             InventoryFolderBase folder1
diff --git a/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs b/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs
index d9fe87c..198e487 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs
@@ -47,7 +47,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         public void Init()
         {
             // FIXME: We don't need a full scene here - it would be enough to set up the asset service.
-            Scene scene = SceneHelpers.SetupScene();
+            Scene scene = new SceneHelpers().SetupScene();
             m_assetService = scene.AssetService;
             m_uuidGatherer = new UuidGatherer(m_assetService);
         }