54 files changed, 2894 insertions, 1276 deletions
diff --git a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
index 0516cb1..e7b9ba5 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>
+        /// <remarks>
-        void SaveChangedAttachments(IScenePresence sp, bool saveAllScripted);
+        /// 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
@@ -95,11 +114,11 @@ namespace OpenSim.Region.Framework.Interfaces
        void DetachSingleAttachmentToGround(IScenePresence sp, uint objectLocalID);
        /// <summary>
-        /// Detach the given item so that it remains in the user's inventory.
+        /// Detach the given attachment so that it remains in the user's inventory.
        /// </summary>
        /// <param name="sp">/param>
-        /// <param name="itemID"></param>
+        /// <param name="grp">The attachment to detach.</param>
-        void DetachSingleAttachmentToInv(IScenePresence sp, UUID itemID);
+        void DetachSingleAttachmentToInv(IScenePresence sp, SceneObjectGroup grp);
        
        /// Update the position of an attachment.
        /// </summary>
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
index 32f4eea..4274cbe 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
@@ -81,13 +81,18 @@ namespace OpenSim.Region.Framework.Interfaces
        /// <summary>
        /// Start all the scripts contained in this entity's inventory
        /// </summary>
-        void CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource);
+        /// <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();
        /// <summary>
-        /// Stop all the scripts in this entity.
+        /// Stop and remove all the scripts in this entity from the scene.
        /// </summary>
        /// <param name="sceneObjectBeingDeleted">
        /// Should be true if these scripts are being removed because the scene
@@ -96,13 +101,22 @@ namespace OpenSim.Region.Framework.Interfaces
        void RemoveScriptInstances(bool sceneObjectBeingDeleted);
        /// <summary>
+        /// Stop all the scripts in this entity.
+        /// </summary>
+        void StopScriptInstances();
+        /// <summary>
        /// Start a script which is in this entity's inventory.
        /// </summary>
        /// <param name="item"></param>
        /// <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,12 +127,16 @@ 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);
        /// <summary>
-        /// Stop a script which is in this prim's inventory.
+        /// Stop and remove a script which is in this prim's inventory from the scene.
        /// </summary>
        /// <param name="itemId"></param>
        /// <param name="sceneObjectBeingDeleted">
@@ -128,6 +146,12 @@ namespace OpenSim.Region.Framework.Interfaces
        void RemoveScriptInstance(UUID itemId, bool sceneObjectBeingDeleted);
        /// <summary>
+        /// Stop a script which is in this prim's inventory.
+        /// </summary>
+        /// <param name="itemId"></param>
+        void StopScriptInstance(UUID itemId);
+        /// <summary>
        /// Add an item to this entity's inventory.  If an item with the same name already exists, then an alternative
        /// name is chosen.
        /// </summary>
@@ -166,6 +190,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 +211,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 +275,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,
+        /// <summary>
-                                                      Vector3 lookAt, uint teleportFlags);
+        /// 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).
+        /// A list of the items created.  If there was more than one object and objects are not being coaleseced in
-        /// FIXME: This is not very useful.  It would be far more useful to return a list of items instead.
+        /// 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..d582149 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>
@@ -152,6 +184,14 @@ namespace OpenSim.Region.Framework.Interfaces
        bool Stand(UUID agentID, Scene scene);
        /// <summary>
+        /// Get the NPC to touch an object.
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="partID"></param>
+        /// <returns>true if the touch is actually attempted, false if not</returns>
+        bool Touch(UUID agentID, UUID partID);
+        /// <summary>
        /// Delete an NPC.
        /// </summary>
        /// <param name="agentID">The UUID of the NPC</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..e6b926c 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>
@@ -66,6 +72,10 @@ namespace OpenSim.Region.Framework.Interfaces
        /// <returns></returns>
        List<SceneObjectGroup> GetAttachments(uint attachmentPoint);
+        /// <summary>
+        /// Does this avatar have any attachments?
+        /// </summary>
+        /// <returns></returns>
        bool HasAttachments();
        // Don't use these methods directly.  Instead, use the AttachmentsModule
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(
+//                m_log.DebugFormat(
-//                "[SCENE PRESENCE ANIMATOR]: Determined animation {0} for {1} in UpdateMovementAnimations()",
+//                    "[SCENE PRESENCE ANIMATOR]: Determined animation {0} for {1} in UpdateMovementAnimations()",
-//                CurrentMovementAnimation, m_scenePresence.Name);
+//                    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(
+//                        m_log.DebugFormat(
-                            "[ASYNC DELETER]: Sending object to user's inventory, action {1}, count {2}, {0} item(s) remaining.",
+//                            "[ASYNC DELETER]: Sending object to user's inventory, action {1}, count {2}, {0} item(s) remaining.",
-                            left, x.action, x.objectGroups.Count);
+//                            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 (AgentTransactionsModule != null)
-                    if (agentTransactions != 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}",
+//                "[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);
+//                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, 
+                    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, (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>();
+                        AgentTransactionsModule.HandleTaskItemUpdateFromTransaction(
-                        if (agentTransactions != null)
+                            remoteClient, part, transactionID, currentItem);
-                        {
-                            agentTransactions.HandleTaskItemUpdateFromTransaction(
+//                        if ((InventoryType)itemInfo.InvType == InventoryType.Notecard)
-                                remoteClient, part, transactionID, currentItem);
+//                            remoteClient.SendAgentAlertMessage("Notecard saved", false);
-    
+//                        else if ((InventoryType)itemInfo.InvType == InventoryType.LSL)
-//                            if ((InventoryType)itemInfo.InvType == InventoryType.Notecard)
+//                            remoteClient.SendAgentAlertMessage("Script saved", false);
-//                                remoteClient.SendAgentAlertMessage("Notecard saved", false);
+//                        else
-//                            else if ((InventoryType)itemInfo.InvType == InventoryType.LSL)
+//                            remoteClient.SendAgentAlertMessage("Item saved", false);
-//                                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..eae8b8e 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.
@@ -114,6 +120,9 @@ namespace OpenSim.Region.Framework.Scenes
        {
            get { return m_defaultDrawDistance; }
        }
+        private List<string> m_AllowedViewers = new List<string>();
+        private List<string> m_BannedViewers = new List<string>();
        
        // TODO: need to figure out how allow client agents but deny
        // root agents when ACL denies access to root agent
@@ -163,7 +172,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 +225,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 +467,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                if (m_simulationService == null)
                    m_simulationService = RequestModuleInterface<ISimulationService>();
                return m_simulationService;
            }
        }
@@ -513,6 +523,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 +602,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,14 +633,13 @@ 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;
            m_SimulationDataService = simDataService;
            m_EstateDataService = estateDataService;
            m_regionHandle = m_regInfo.RegionHandle;
-            m_regionName = m_regInfo.RegionName;
            m_lastIncoming = 0;
            m_lastOutgoing = 0;
@@ -630,7 +656,7 @@ namespace OpenSim.Region.Framework.Scenes
            // resave.
            // FIXME: It shouldn't be up to the database plugins to create this data - we should do it when a new
            // region is set up and avoid these gyrations.
-            RegionSettings rs = simDataService.LoadRegionSettings(m_regInfo.RegionID);
+            RegionSettings rs = simDataService.LoadRegionSettings(RegionInfo.RegionID);
            bool updatedTerrainTextures = false;
            if (rs.TerrainTexture1 == UUID.Zero)
            {
@@ -659,10 +685,10 @@ namespace OpenSim.Region.Framework.Scenes
            if (updatedTerrainTextures)
                rs.Save();
-            m_regInfo.RegionSettings = rs;
+            RegionInfo.RegionSettings = rs;
            if (estateDataService != null)
-                m_regInfo.EstateSettings = estateDataService.LoadEstateSettings(m_regInfo.RegionID, false);
+                RegionInfo.EstateSettings = estateDataService.LoadEstateSettings(RegionInfo.RegionID, false);
            #endregion Region Settings
@@ -726,6 +752,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 +764,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 =
@@ -781,6 +811,24 @@ namespace OpenSim.Region.Framework.Scenes
                        }
                    }
+                    string grant = startupConfig.GetString("AllowedViewerList", String.Empty);
+                    if (grant.Length > 0)
+                    {
+                        foreach (string viewer in grant.Split(','))
+                        {
+                            m_AllowedViewers.Add(viewer.Trim().ToLower());
+                        }
+                    }
+                    grant = startupConfig.GetString("BannedViewerList", String.Empty);
+                    if (grant.Length > 0)
+                    {
+                        foreach (string viewer in grant.Split(','))
+                        {
+                            m_BannedViewers.Add(viewer.Trim().ToLower());
+                        }
+                    }
                    MinFrameTime              = startupConfig.GetFloat( "MinFrameTime",                      MinFrameTime);
                    m_update_backup           = startupConfig.GetInt(   "UpdateStorageEveryNFrames",         m_update_backup);
                    m_update_coarse_locations = startupConfig.GetInt(   "UpdateCoarseLocationsEveryNFrames", m_update_coarse_locations);
@@ -833,13 +881,11 @@ namespace OpenSim.Region.Framework.Scenes
            StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats;
        }
-        /// <summary>
+        public Scene(RegionInfo regInfo) : base(regInfo)
-        /// 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);  //<---
@@ -862,12 +908,9 @@ namespace OpenSim.Region.Framework.Scenes
            WestBorders.Add(westBorder);
            BordersLocked = false;
-            m_regInfo = regInfo;
            m_eventManager = new EventManager();
            m_permissions = new ScenePermissions(this);
-//            m_lastUpdate = Util.EnvironmentTickCount();
        }
        #endregion
@@ -936,8 +979,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)
+                            if (EntityTransferModule != null && agent.PresenceType != PresenceType.Npc)
-                                m_teleportModule.EnableChildAgent(agent, otherRegion);
+                                EntityTransferModule.EnableChildAgent(agent, otherRegion);
                        });
                    }
                    catch (NullReferenceException)
@@ -950,7 +993,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 +1087,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 +1117,8 @@ namespace OpenSim.Region.Framework.Scenes
                    {
                        ForEachRootScenePresence(delegate(ScenePresence agent)
                        {
-                            if (m_teleportModule != null && agent.PresenceType != PresenceType.Npc)
+                            if (EntityTransferModule != null && agent.PresenceType != PresenceType.Npc)
-                                m_teleportModule.EnableChildAgent(agent, r);
+                                EntityTransferModule.EnableChildAgent(agent, r);
                        });
                    }
                    catch (NullReferenceException)
@@ -1208,8 +1251,8 @@ namespace OpenSim.Region.Framework.Scenes
            m_sceneGraph.Close();
-            if (!GridService.DeregisterRegion(m_regInfo.RegionID))
+            if (!GridService.DeregisterRegion(RegionInfo.RegionID))
-                m_log.WarnFormat("[SCENE]: Deregister from grid failed for region {0}", m_regInfo.RegionName);
+                m_log.WarnFormat("[SCENE]: Deregister from grid failed for region {0}", Name);
            // call the base class Close method.
            base.Close();
@@ -1265,8 +1308,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 +1432,41 @@ namespace OpenSim.Region.Framework.Scenes
                endFrame = Frame + frames;
            float physicsFPS = 0f;
-            int tmpPhysicsMS, tmpPhysicsMS2, tmpAgentMS, tmpTempOnRezMS, evMS, backMS, terMS;
+            int previousFrameTick, tmpMS;
-            int previousFrameTick;
+            int maintc = Util.EnvironmentTickCount();
-            int maintc;
-            int sleepMS;
-            int framestart;
            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 +1475,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 +1492,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);
+                        backupMS = Util.EnvironmentTickCountSubtract(tmpMS);
-                    }
-    
-                    if (Frame % m_update_terrain == 0)
-                    {
-                        terMS = Util.EnvironmentTickCount();
-                        UpdateTerrain();
-                        terrainMS = Util.EnvironmentTickCountSubtract(terMS);
                    }
    
                    //if (Frame % m_update_land == 0)
@@ -1481,29 +1523,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 +1543,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 +1573,36 @@ namespace OpenSim.Region.Framework.Scenes
                previousFrameTick = m_lastFrameTick;
                m_lastFrameTick = Util.EnvironmentTickCount();
-                maintc = Util.EnvironmentTickCountSubtract(m_lastFrameTick, framestart);
+                tmpMS = Util.EnvironmentTickCountSubtract(m_lastFrameTick, maintc);
-                maintc = (int)(MinFrameTime * 1000) - 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)
+                // if (Frame%m_update_avatars == 0)
-                    Thread.Sleep(maintc);
+                //   UpdateInWorldTime();
+                StatsReporter.AddPhysicsFPS(physicsFPS);
+                StatsReporter.AddTimeDilation(TimeDilation);
+                StatsReporter.AddFPS(1);
-                sleepMS = Util.EnvironmentTickCountSubtract(sleepMS);
-                frameMS = Util.EnvironmentTickCountSubtract(framestart);
-                StatsReporter.addSleepMS(sleepMS);
                StatsReporter.addFrameMS(frameMS);
-                
+                StatsReporter.addAgentMS(agentMS);
-                // Optionally warn if a frame takes double the amount of time that it should.
+                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))
@@ -1757,14 +1789,14 @@ namespace OpenSim.Region.Framework.Scenes
        public void StoreWindlightProfile(RegionLightShareData wl)
        {
-            m_regInfo.WindlightSettings = wl;
+            RegionInfo.WindlightSettings = wl;
            SimulationDataService.StoreRegionWindlightSettings(wl);
            m_eventManager.TriggerOnSaveNewWindlightProfile();
        }
        public void LoadWindlightProfile()
        {
-            m_regInfo.WindlightSettings = SimulationDataService.LoadRegionWindlightSettings(RegionInfo.RegionID);
+            RegionInfo.WindlightSettings = SimulationDataService.LoadRegionWindlightSettings(RegionInfo.RegionID);
            m_eventManager.TriggerOnSaveNewWindlightProfile();
        }
@@ -2083,9 +2115,8 @@ namespace OpenSim.Region.Framework.Scenes
                sceneObject.SetGroup(groupID, null);
            }
-            IUserManagement uman = RequestModuleInterface<IUserManagement>();
+            if (UserManagementModule != null)
-            if (uman != null)
+                sceneObject.RootPart.CreatorIdentification = UserManagementModule.GetUserUUI(ownerID);
-                sceneObject.RootPart.CreatorIdentification = uman.GetUserUUI(ownerID);
            sceneObject.ScheduleGroupForFullUpdate();
@@ -2250,13 +2281,30 @@ namespace OpenSim.Region.Framework.Scenes
        /// <summary>
        /// Synchronously delete the given object from the scene.
        /// </summary>
+        /// <remarks>
+        /// Scripts are also removed.
+        /// </remarks>
        /// <param name="group">Object Id</param>
        /// <param name="silent">Suppress broadcasting changes to other clients.</param>
        public void DeleteSceneObject(SceneObjectGroup group, bool silent)
+        {
+            DeleteSceneObject(group, silent, true);
+        }
+        /// <summary>
+        /// Synchronously delete the given object from the scene.
+        /// </summary>
+        /// <param name="group">Object Id</param>
+        /// <param name="silent">Suppress broadcasting changes to other clients.</param>
+        /// <param name="removeScripts">If true, then scripts are removed.  If false, then they are only stopped.</para>
+        public void DeleteSceneObject(SceneObjectGroup group, bool silent, bool removeScripts)
        {            
 //            m_log.DebugFormat("[SCENE]: Deleting scene object {0} {1}", group.Name, group.UUID);
-            group.RemoveScriptInstances(true);
+            if (removeScripts)
+                group.RemoveScriptInstances(true);
+            else
+                group.StopScriptInstances();
            SceneObjectPart[] partList = group.Parts;
@@ -2306,7 +2354,7 @@ namespace OpenSim.Region.Framework.Scenes
                        ForceSceneObjectBackup(so);                
                    
                    so.DetachFromBackup();
-                    SimulationDataService.RemoveObject(so.UUID, m_regInfo.RegionID);                                        
+                    SimulationDataService.RemoveObject(so.UUID, RegionInfo.RegionID);
                }
                                    
                // We need to keep track of this state in case this group is still queued for further backup.
@@ -2363,8 +2411,8 @@ namespace OpenSim.Region.Framework.Scenes
                return;
            }
-            if (m_teleportModule != null)
+            if (EntityTransferModule != null)
-                m_teleportModule.Cross(grp, attemptedPosition, silent);
+                EntityTransferModule.Cross(grp, attemptedPosition, silent);
        }
        public Border GetCrossedBorder(Vector3 position, Cardinals gridline)
@@ -2564,7 +2612,16 @@ namespace OpenSim.Region.Framework.Scenes
            }
            catch (Exception e)
            {
-                m_log.WarnFormat("[SCENE]: Problem casting object, exception {0}{1}", e.Message, e.StackTrace);
+                m_log.WarnFormat("[INTERREGION]: Problem casting object, exception {0}{1}", e.Message, e.StackTrace);
+                return false;
+            }
+            // If the user is banned, we won't let any of their objects
+            // enter. Period.
+            //
+            if (RegionInfo.EstateSettings.IsBanned(newObject.OwnerID, 36))
+            {
+                m_log.InfoFormat("[INTERREGION]: Denied prim crossing for banned avatar {0}", newObject.OwnerID);
                return false;
            }
@@ -2575,32 +2632,30 @@ namespace OpenSim.Region.Framework.Scenes
            if (!AddSceneObject(newObject))
            {
-                m_log.DebugFormat("[SCENE]: Problem adding scene object {0} in {1} ", sog.UUID, RegionInfo.RegionName);
+                m_log.DebugFormat(
+                    "[INTERREGION]: Problem adding scene object {0} in {1} ", newObject.UUID, RegionInfo.RegionName);
                return false;
            }
-            // For attachments, we need to wait until the agent is root
-            // before we restart the scripts, or else some functions won't work.
            if (!newObject.IsAttachment)
            {
-                newObject.RootPart.ParentGroup.CreateScriptInstances(0, false, DefaultScriptEngine, GetStateSource(newObject));
+                // FIXME: It would be better to never add the scene object at all rather than add it and then delete
-                newObject.ResumeScripts();
+                // it
-            }
+                if (!Permissions.CanObjectEntry(newObject.UUID, true, newObject.AbsolutePosition))
-            else
-            {
-                ScenePresence sp;
-                if (TryGetScenePresence(newObject.OwnerID, out sp))
                {
-                    // If the scene presence is here and already a root
+                    // Deny non attachments based on parcel settings
-                    // agent, we came from a ;egacy region. Start the scripts
+                    //
-                    // here as they used to start.
+                    m_log.Info("[INTERREGION]: Denied prim crossing because of parcel settings");
-                    // TODO: Remove in 0.7.3
-                    if (!sp.IsChildAgent)
+                    DeleteSceneObject(newObject, false);
-                    {
-                        newObject.RootPart.ParentGroup.CreateScriptInstances(0, false, DefaultScriptEngine, GetStateSource(newObject));
+                    return false;
-                        newObject.ResumeScripts();
-                    }
                }
+                // For attachments, we need to wait until the agent is root
+                // before we restart the scripts, or else some functions won't work.
+                newObject.RootPart.ParentGroup.CreateScriptInstances(0, false, DefaultScriptEngine, GetStateSource(newObject));
+                newObject.ResumeScripts();
            }
            // Do this as late as possible so that listeners have full access to the incoming object
@@ -2610,28 +2665,6 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Attachment rezzing
-        /// </summary>
-        /// <param name="userID">Agent Unique ID</param>
-        /// <param name="itemID">Object ID</param>
-        /// <returns>False</returns>
-        public virtual bool IncomingCreateObject(UUID userID, UUID itemID)
-        {
-            m_log.DebugFormat(" >>> IncomingCreateObject(userID, itemID) <<< {0} {1}", userID, itemID);
-            // Commented out since this is as yet unused and is arguably not the appropriate place to do this, as
-            // attachments are being rezzed elsewhere in AddNewClient()
-//            ScenePresence sp = GetScenePresence(userID);
-//            if (sp != null && AttachmentsModule != null)
-//            {
-//                uint attPt = (uint)sp.Appearance.GetAttachpoint(itemID);
-//                AttachmentsModule.RezSingleAttachmentFromInventory(sp.ControllingClient, itemID, attPt);
-//            }
-            return false;
-        }
-        /// <summary>
        /// Adds a Scene Object group to the Scene.
        /// Verifies that the creator of the object is not banned from the simulator.
        /// Checks if the item is an Attachment
@@ -2650,15 +2683,13 @@ namespace OpenSim.Region.Framework.Scenes
            // enter. Period.
            //
            int flags = GetUserFlags(sceneObject.OwnerID);
-            if (m_regInfo.EstateSettings.IsBanned(sceneObject.OwnerID, flags))
+            if (RegionInfo.EstateSettings.IsBanned(sceneObject.OwnerID, flags))
            {
                m_log.InfoFormat("[INTERREGION]: Denied prim crossing for banned avatar {0}", sceneObject.OwnerID);
                return false;
            }
-            sceneObject.SetScene(this);
            // Force allocation of new LocalId
            //
            SceneObjectPart[] parts = sceneObject.Parts;
@@ -2684,10 +2715,10 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    SceneObjectGroup grp = sceneObject;
-                    m_log.DebugFormat(
+//                    m_log.DebugFormat(
-                        "[ATTACHMENT]: Received attachment {0}, inworld asset id {1}", grp.FromItemID, grp.UUID);
+//                        "[ATTACHMENT]: Received attachment {0}, inworld asset id {1}", grp.FromItemID, grp.UUID);
-                    m_log.DebugFormat(
+//                    m_log.DebugFormat(
-                        "[ATTACHMENT]: Attach to avatar {0} at position {1}", sp.UUID, grp.AbsolutePosition);
+//                        "[ATTACHMENT]: Attach to avatar {0} at position {1}", sp.UUID, grp.AbsolutePosition);
                    RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
                    
@@ -2714,18 +2745,6 @@ namespace OpenSim.Region.Framework.Scenes
                    return false;
                }
                AddRestoredSceneObject(sceneObject, true, false);
-                if (!Permissions.CanObjectEntry(sceneObject.UUID,
-                        true, sceneObject.AbsolutePosition))
-                {
-                    // Deny non attachments based on parcel settings
-                    //
-                    m_log.Info("[INTERREGION]: Denied prim crossing because of parcel settings");
-                    DeleteSceneObject(sceneObject, false);
-                    return false;
-                }
            }
            return true;
@@ -2783,7 +2802,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 +2863,13 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="aCircuit"></param>
        private void CacheUserName(ScenePresence sp, AgentCircuitData aCircuit)
        {
-            IUserManagement uMan = RequestModuleInterface<IUserManagement>();
+            if (UserManagementModule != null)
-            if (uMan != 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 +2888,7 @@ namespace OpenSim.Region.Framework.Scenes
                        }
                    }
-                    uMan.AddUser(aCircuit.AgentID, first, last, homeURL);
+                    UserManagementModule.AddUser(aCircuit.AgentID, first, last, homeURL);
                }
            }
        }
@@ -3207,8 +3226,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)
+            if (EntityTransferModule != null)
-                return m_teleportModule.TeleportHome(agentId, client);
+            {
+                EntityTransferModule.TeleportHome(agentId, client);
+            }
            else
            {
                m_log.DebugFormat("[SCENE]: Unable to teleport user home: no AgentTransferModule is active");
@@ -3370,65 +3391,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(
+                    avatar.StandUp();
-                        "[SCENE]: Removing {0} agent {1} from region {2}",
+                }
-                        (isChildAgent ? "child" : "root"), agentID, RegionInfo.RegionName);
-                    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
+                // 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
+                // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
-                    if (closeChildAgents && CapsModule != null)
+                if (closeChildAgents && CapsModule != null)
-                        CapsModule.RemoveCaps(agentID);
+                    CapsModule.RemoveCaps(agentID);
-                    // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
+                // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
-                    // this method is doing is HORRIBLE!!!
+                // this method is doing is HORRIBLE!!!
-                    avatar.Scene.NeedSceneCacheClear(avatar.UUID);
+                avatar.Scene.NeedSceneCacheClear(avatar.UUID);
-                    if (closeChildAgents && !avatar.IsChildAgent)
+                if (closeChildAgents && !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)
                {
-                    // We don't know which count to remove it from
+                    List<ulong> regions = avatar.KnownRegionHandles;
-                    // Avatar is already disposed :/
+                    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)
-    
-                    if (AttachmentsModule != null && !isChildAgent && avatar.PresenceType != PresenceType.Npc)
                    {
-                        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))
+                        bool saveChanged
-                            AttachmentsModule.SaveChangedAttachments(avatar, false);
+                            = avatar.PresenceType != PresenceType.Npc
+                                && (UserManagementModule == null || UserManagementModule.IsLocalGridUser(avatar.UUID));
+                        AttachmentsModule.DeRezAttachments(avatar, saveChanged, false);
                    }
-    
                    ForEachClient(
                        delegate(IClientAPI client)
                        {
@@ -3436,43 +3474,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
+                // It's possible for child agents to have transactions if changes are being made cross-border.
-                {
+                if (AgentTransactionsModule != null)
-                    avatar.Close();
+                    AgentTransactionsModule.RemoveAgentAssetTransactions(agentID);
-                }
-                catch (NullReferenceException)
+                avatar.Close();
-                {
-                    //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");
                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 +3584,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 +3600,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,
+                RegionInfo.RegionName,
-                agent.AgentID, agent.circuitcode, agent.IPAddress, agent.Viewer, ((TPFlags)teleportFlags).ToString(), agent.startpos);
+                (agent.child ? "child" : "root"),
+                agent.firstname,
+                agent.lastname,
+                agent.AgentID,
+                agent.circuitcode,
+                agent.IPAddress,
+                agent.Viewer,
+                ((TPFlags)teleportFlags).ToString(),
+                agent.startpos
+            );
            if (LoginsDisabled)
            {
@@ -3579,6 +3618,50 @@ namespace OpenSim.Region.Framework.Scenes
                return false;
            }
+            //Check if the viewer is banned or in the viewer access list
+            //We check if the substring is listed for higher flexebility
+            bool ViewerDenied = true;
+            //Check if the specific viewer is listed in the allowed viewer list
+            if (m_AllowedViewers.Count > 0)
+            {
+                foreach (string viewer in m_AllowedViewers)
+                {
+                    if (viewer == agent.Viewer.Substring(0, viewer.Length).Trim().ToLower())
+                    {
+                        ViewerDenied = false;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                ViewerDenied = false;
+            }
+            //Check if the viewer is in the banned list
+            if (m_BannedViewers.Count > 0)
+            {
+                foreach (string viewer in m_BannedViewers)
+                {
+                    if (viewer == agent.Viewer.Substring(0, viewer.Length).Trim().ToLower())
+                    {
+                        ViewerDenied = true;
+                        break;
+                    }
+                }
+            }
+            if (ViewerDenied)
+            {
+                m_log.DebugFormat(
+                    "[SCENE]: Access denied for {0} {1} using {2}",
+                    agent.firstname, agent.lastname, agent.Viewer);
+                reason = "Access denied, your viewer is banned by the region owner";
+                return false;
+            }           
            ScenePresence sp = GetScenePresence(agent.AgentID);
            if (sp != null && !sp.IsChildAgent)
@@ -3586,7 +3669,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 +3699,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 +3734,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 +3757,7 @@ namespace OpenSim.Region.Framework.Scenes
            agent.teleportFlags = teleportFlags;
            m_authenticateHandler.AddNewCircuit(agent.circuitcode, agent);
-            if (vialogin) 
+            if (vialogin)
            {
 //                CleanDroppedAttachments();
@@ -3714,8 +3798,7 @@ namespace OpenSim.Region.Framework.Scenes
                                agent.startpos.Z = 720;
                        }
                    }
-                }
+                } else
-                else
                {
                    if (agent.startpos.X > EastBorders[0].BorderLine.Z)
                    {
@@ -3741,10 +3824,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
+                        // We have multiple SpawnPoints, Route the agent to a random or sequential one
-                        agent.startpos =  spawnpoints[Util.RandomClass.Next(spawnpoints.Count)].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
+                        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
                    {
@@ -3867,9 +3959,9 @@ namespace OpenSim.Region.Framework.Scenes
                }
            }
-            if (m_regInfo.EstateSettings != null)
+            if (RegionInfo.EstateSettings != null)
            {
-                if (m_regInfo.EstateSettings.IsBanned(agent.AgentID,0))
+                if (RegionInfo.EstateSettings.IsBanned(agent.AgentID, 0))
                {
                    m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user is on the banlist",
                                     agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
@@ -3901,7 +3993,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
            bool groupAccess = false;
-            UUID[] estateGroups = m_regInfo.EstateSettings.EstateGroups;
+            UUID[] estateGroups = RegionInfo.EstateSettings.EstateGroups;
            if (estateGroups != null)
            {
@@ -3919,8 +4011,8 @@ namespace OpenSim.Region.Framework.Scenes
                m_log.ErrorFormat("[CONNECTION BEGIN]: EstateGroups is null!");
            }
-            if (!m_regInfo.EstateSettings.PublicAccess &&
+            if (!RegionInfo.EstateSettings.PublicAccess &&
-                !m_regInfo.EstateSettings.HasAccess(agent.AgentID) &&
+                !RegionInfo.EstateSettings.HasAccess(agent.AgentID) &&
                !groupAccess)
            {
                m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user does not have access to the estate",
@@ -3981,41 +4073,41 @@ namespace OpenSim.Region.Framework.Scenes
            return m_authenticateHandler.TryChangeCiruitCode(oldcc, newcc);
        }
-        /// <summary>
+//        /// <summary>
-        /// The Grid has requested that we log-off a user.  Log them off.
+//        /// The Grid has requested that we log-off a user.  Log them off.
-        /// </summary>
+//        /// </summary>
-        /// <param name="AvatarID">Unique ID of the avatar to log-off</param>
+//        /// <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="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>
+//        /// <param name="message">message to display to the user.  Reason for being logged off</param>
-        public void HandleLogOffUserFromGrid(UUID AvatarID, UUID RegionSecret, string message)
+//        public void HandleLogOffUserFromGrid(UUID AvatarID, UUID RegionSecret, string message)
-        {
+//        {
-            ScenePresence loggingOffUser = GetScenePresence(AvatarID);
+//            ScenePresence loggingOffUser = GetScenePresence(AvatarID);
-            if (loggingOffUser != null)
+//            if (loggingOffUser != null)
-            {
+//            {
-                UUID localRegionSecret = UUID.Zero;
+//                UUID localRegionSecret = UUID.Zero;
-                bool parsedsecret = UUID.TryParse(m_regInfo.regionSecret, out localRegionSecret);
+//                bool parsedsecret = UUID.TryParse(RegionInfo.regionSecret, out localRegionSecret);
+//
-                // Region Secret is used here in case a new sessionid overwrites an old one on the user server.
+//                // 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.
+//                // Will update the user server in a few revisions to use it.
+//
-                if (RegionSecret == loggingOffUser.ControllingClient.SecureSessionId || (parsedsecret && RegionSecret == localRegionSecret))
+//                if (RegionSecret == loggingOffUser.ControllingClient.SecureSessionId || (parsedsecret && RegionSecret == localRegionSecret))
-                {
+//                {
-                    m_sceneGridService.SendCloseChildAgentConnections(loggingOffUser.UUID, loggingOffUser.KnownRegionHandles);
+//                    m_sceneGridService.SendCloseChildAgentConnections(loggingOffUser.UUID, loggingOffUser.KnownRegionHandles);
-                    loggingOffUser.ControllingClient.Kick(message);
+//                    loggingOffUser.ControllingClient.Kick(message);
-                    // Give them a second to receive the message!
+//                    // Give them a second to receive the message!
-                    Thread.Sleep(1000);
+//                    Thread.Sleep(1000);
-                    loggingOffUser.ControllingClient.Close();
+//                    loggingOffUser.ControllingClient.Close();
-                }
+//                }
-                else
+//                else
-                {
+//                {
-                    m_log.Info("[USERLOGOFF]: System sending the LogOff user message failed to sucessfully authenticate");
+//                    m_log.Info("[USERLOGOFF]: System sending the LogOff user message failed to sucessfully authenticate");
-                }
+//                }
-            }
+//            }
-            else
+//            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());
+//                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 +4160,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);
+                m_log.DebugFormat(
-                return false;
+                    "[SCENE]: Denying root agent entry to {0} in {1}: no allowed parcel",
-            }
+                    cAgentData.AgentID, RegionInfo.RegionName);
-            int num = m_sceneGraph.GetNumberOfScenePresences();
-            if (num >= RegionInfo.RegionSettings.AgentLimit)
+                return false;
-            {
-                if (!Permissions.IsAdministrator(cAgentData.AgentID))
-                    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 +4216,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;
+            ScenePresence sp = null;
-            while ((childAgentUpdate = GetScenePresence(agentID)) == null && (ntimes-- > 0))
+            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 +4275,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
+                presence.ControllingClient.Close();
-                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);
-                }
                return true;
            }
@@ -4245,13 +4323,13 @@ namespace OpenSim.Region.Framework.Scenes
            ScenePresence sp = GetScenePresence(remoteClient.AgentId);
            if (sp != null)
            {
-                uint regionX = m_regInfo.RegionLocX;
+                uint regionX = RegionInfo.RegionLocX;
-                uint regionY = m_regInfo.RegionLocY;
+                uint regionY = RegionInfo.RegionLocY;
                Utils.LongToUInts(regionHandle, out regionX, out regionY);
-                int shiftx = (int) regionX - (int) m_regInfo.RegionLocX * (int)Constants.RegionSize;
+                int shiftx = (int) regionX - (int) RegionInfo.RegionLocX * (int)Constants.RegionSize;
-                int shifty = (int) regionY - (int) m_regInfo.RegionLocY * (int)Constants.RegionSize;
+                int shifty = (int) regionY - (int) RegionInfo.RegionLocY * (int)Constants.RegionSize;
                position.X += shiftx;
                position.Y += shifty;
@@ -4274,7 +4352,7 @@ namespace OpenSim.Region.Framework.Scenes
                if (!result)
                {
-                    regionHandle = m_regInfo.RegionHandle;
+                    regionHandle = RegionInfo.RegionHandle;
                }
                else
                {
@@ -4283,8 +4361,10 @@ namespace OpenSim.Region.Framework.Scenes
                    position.Y -= shifty;
                }
-                if (m_teleportModule != null)
+                if (EntityTransferModule != null)
-                    m_teleportModule.Teleport(sp, regionHandle, position, lookAt, teleportFlags);
+                {
+                    EntityTransferModule.Teleport(sp, regionHandle, position, lookAt, teleportFlags);
+                }
                else
                {
                    m_log.DebugFormat("[SCENE]: Unable to perform teleports: no AgentTransferModule is active");
@@ -4295,8 +4375,10 @@ namespace OpenSim.Region.Framework.Scenes
        public bool CrossAgentToNewRegion(ScenePresence agent, bool isFlying)
        {
-            if (m_teleportModule != null)
+            if (EntityTransferModule != null)
-                return m_teleportModule.Cross(agent, isFlying);
+            {
+                return EntityTransferModule.Cross(agent, isFlying);
+            }
            else
            {
                m_log.DebugFormat("[SCENE]: Unable to cross agent to neighbouring region, because there is no AgentTransferModule");
@@ -4598,6 +4680,17 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
+        /// Get all the scene object groups.
+        /// </summary>
+        /// <returns>
+        /// The scene object groups.  If the scene is empty then an empty list is returned.
+        /// </returns>
+        public List<SceneObjectGroup> GetSceneObjectGroups()
+        {
+            return m_sceneGraph.GetSceneObjectGroups();
+        }
+        /// <summary>
        /// Get a group via its UUID
        /// </summary>
        /// <param name="fullID"></param>
@@ -4776,7 +4869,7 @@ namespace OpenSim.Region.Framework.Scenes
        public void DeleteFromStorage(UUID uuid)
        {
-            SimulationDataService.RemoveObject(uuid, m_regInfo.RegionID);
+            SimulationDataService.RemoveObject(uuid, RegionInfo.RegionID);
        }
        public int GetHealth(out int flags, out string message)
@@ -5257,7 +5350,7 @@ Environment.Exit(1);
            IEstateDataService estateDataService = EstateDataService;
            if (estateDataService != null)
            {
-                m_regInfo.EstateSettings = estateDataService.LoadEstateSettings(m_regInfo.RegionID, false);
+                RegionInfo.EstateSettings = estateDataService.LoadEstateSettings(RegionInfo.RegionID, false);
                TriggerEstateSunUpdate();
            }
        }
@@ -5444,29 +5537,58 @@ Environment.Exit(1);
                throw new Exception(error);
        }
-        // This method is called across the simulation connector to
+        /// <summary>
-        // determine if a given agent is allowed in this region
+        /// This method is called across the simulation connector to
-        // AS A ROOT AGENT. Returning false here will prevent them
+        /// determine if a given agent is allowed in this region
-        // from logging into the region, teleporting into the region
+        /// AS A ROOT AGENT
-        // or corssing the broder walking, but will NOT prevent
+        /// </summary>
-        // child agent creation, thereby emulating the SL behavior.
+        /// <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 +5759,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/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index 9b8a3ae..e8134cd 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -51,6 +51,8 @@ namespace OpenSim.Region.Framework.Scenes
        #endregion
        #region Fields
+        public string Name { get { return RegionInfo.RegionName; } }
        
        public IConfigSource Config
        {
@@ -148,6 +150,11 @@ namespace OpenSim.Region.Framework.Scenes
        #endregion
+        public SceneBase(RegionInfo regInfo)
+        {
+            RegionInfo = regInfo;
+        }
        #region Update Methods
        /// <summary>
@@ -211,10 +218,7 @@ namespace OpenSim.Region.Framework.Scenes
        ///
        /// </summary>
        /// <returns></returns>
-        public virtual RegionInfo RegionInfo
+        public virtual RegionInfo RegionInfo { get; private set; }
-        {
-            get { return m_regInfo; }
-        }
        #region admin stuff
        
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 0587846..c3d66eb 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
@@ -394,9 +401,9 @@ namespace OpenSim.Region.Framework.Scenes
            if (Entities.ContainsKey(sceneObject.UUID))
            {
-//                m_log.DebugFormat(
+                m_log.DebugFormat(
-//                    "[SCENEGRAPH]: Scene graph for {0} already contains object {1} in AddSceneObject()",
+                    "[SCENEGRAPH]: Scene graph for {0} already contains object {1} in AddSceneObject()",
-//                    m_parentScene.RegionInfo.RegionName, sceneObject.UUID);
+                    m_parentScene.RegionInfo.RegionName, sceneObject.UUID);
                return false;
            }
@@ -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>
@@ -1042,6 +1038,18 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
+        /// Get all the scene object groups.
+        /// </summary>
+        /// <returns>
+        /// The scene object groups.  If the scene is empty then an empty list is returned.
+        /// </returns>
+        protected internal List<SceneObjectGroup> GetSceneObjectGroups()
+        {
+            lock (SceneObjectGroupsByFullID)
+                return new List<SceneObjectGroup>(SceneObjectGroupsByFullID.Values);
+        }
+        /// <summary>
        /// Get a group in the scene
        /// </summary>
        /// <param name="fullID">UUID of the group</param>
@@ -1184,11 +1192,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="action"></param>
        protected internal void ForEachSOG(Action<SceneObjectGroup> action)
        {
-            List<SceneObjectGroup> objlist;
+            foreach (SceneObjectGroup obj in GetSceneObjectGroups())
-            lock (SceneObjectGroupsByFullID)
-                objlist = new List<SceneObjectGroup>(SceneObjectGroupsByFullID.Values);
-            foreach (SceneObjectGroup obj in objlist)
            {
                try
                {
@@ -2065,12 +2069,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)
            {
@@ -2100,25 +2106,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
@@ -2150,11 +2156,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..26524fb 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
@@ -54,20 +54,32 @@ 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,
+        /// <param name="startParam"></param>
-                string engine, int stateSource)
+        /// <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>
-        /// Stop the scripts contained in all the prims in this group
+        /// Stop and remove the scripts contained in all the prims in this group
        /// </summary>
        public void RemoveScriptInstances(bool sceneObjectBeingDeleted)
        {
@@ -77,6 +89,14 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
+        /// Stop the scripts contained in all the prims in this group
+        /// </summary>
+        public void StopScriptInstances()
+        {
+            Array.ForEach<SceneObjectPart>(m_parts.GetArray(), p => p.Inventory.StopScriptInstances());
+        }
+        /// <summary>
        /// Add an inventory item from a user's inventory to a prim in this scene object.
        /// </summary>
        /// <param name="agentID">The agent adding the item.</param>
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 96eeec4..cc7d0fb 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -131,6 +131,15 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        /// <summary>
+        /// This indicates whether the object has changed such that it needs to be repersisted to permenant storage
+        /// (the database).
+        /// </summary>
+        /// <remarks>
+        /// Ultimately, this should be managed such that region modules can change it at the end of a set of operations
+        /// so that either all changes are preserved or none at all.  However, currently, a large amount of internal
+        /// code will set this anyway when some object properties are changed.
+        /// </remarks>
        public bool HasGroupChanged
        {
            set
@@ -244,6 +253,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;
@@ -1649,16 +1674,6 @@ namespace OpenSim.Region.Framework.Scenes
        {
            return Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);
        }
-        /// <summary>
-        /// Added as a way for the storage provider to reset the scene,
-        /// most likely a better way to do this sort of thing but for now...
-        /// </summary>
-        /// <param name="scene"></param>
-        public void SetScene(Scene scene)
-        {
-            m_scene = scene;
-        }
        
        /// <summary>
        /// Set a part to act as the root part for this scene object
@@ -1816,8 +1831,9 @@ namespace OpenSim.Region.Framework.Scenes
                        part.ClearUpdateSchedule();
                        if (part == m_rootPart)
                        {
-                            if (!IsAttachment || (AttachedAvatar == avatar.ControllingClient.AgentId) ||
+                            if (!IsAttachment
-                                (AttachmentPoint < 31) || (AttachmentPoint > 38))
+                                || AttachedAvatar == avatar.ControllingClient.AgentId
+                                || !HasPrivateAttachmentPoint)
                                avatar.ControllingClient.SendKillObject(m_regionHandle, new List<uint> { part.LocalId });
                        }
                    }
@@ -2527,8 +2543,13 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Schedule a full update for this scene object
+        /// Schedule a full update for this scene object to all interested viewers.
        /// </summary>
+        /// <remarks>
+        /// Ultimately, this should be managed such that region modules can invoke it at the end of a set of operations
+        /// so that either all changes are sent at once.  However, currently, a large amount of internal
+        /// code will set this anyway when some object properties are changed.
+        /// </remarks>
        public void ScheduleGroupForFullUpdate()
        {
 //            if (IsAttachment)
@@ -2547,8 +2568,13 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Schedule a terse update for this scene object
+        /// Schedule a terse update for this scene object to all interested viewers.
        /// </summary>
+        /// <remarks>
+        /// Ultimately, this should be managed such that region modules can invoke it at the end of a set of operations
+        /// so that either all changes are sent at once.  However, currently, a large amount of internal
+        /// code will set this anyway when some object properties are changed.
+        /// </remarks>
        public void ScheduleGroupForTerseUpdate()
        {
 //            m_log.DebugFormat("[SOG]: Scheduling terse update for {0} {1}", Name, UUID);
@@ -2678,6 +2704,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)
        {
@@ -2759,6 +2789,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)
@@ -2810,6 +2841,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)
@@ -2821,6 +2857,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>
@@ -2846,6 +2887,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>
@@ -2979,6 +3025,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>
@@ -3494,7 +3542,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>
@@ -3609,6 +3657,11 @@ namespace OpenSim.Region.Framework.Scenes
                m_scene.PhysicsScene.AddPhysicsActorTaint(actor);
            }
+            if (IsAttachment)
+            {
+                m_rootPart.AttachedPos = pos;
+            }
            AbsolutePosition = pos;
            HasGroupChanged = true;
@@ -4195,7 +4248,86 @@ 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;
+        }
+        /// <summary>
+        /// Gets the number of sitting avatars.
+        /// </summary>
+        /// <remarks>This applies to all sitting avatars whether there is a sit target set or not.</remarks>
+        /// <returns></returns>
+        public int GetSittingAvatarsCount()
+        {
+             int count = 0;
+             Array.ForEach<SceneObjectPart>(m_parts.GetArray(), p => count += p.GetSittingAvatarsCount());
+             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 16a8588..2410970 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -147,6 +147,21 @@ namespace OpenSim.Region.Framework.Scenes
            get { return ParentGroup.RootPart == this; } 
        }
+        /// <summary>
+        /// Is an explicit sit target set for this part?
+        /// </summary>
+        public bool IsSitTargetSet
+        {
+            get
+            {
+                return
+                    !(SitTargetPosition == Vector3.Zero
+                      && (SitTargetOrientation == Quaternion.Identity // Valid Zero Rotation quaternion
+                       || SitTargetOrientation.X == 0f && SitTargetOrientation.Y == 0f && SitTargetOrientation.Z == 1f && SitTargetOrientation.W == 0f // W-Z Mapping was invalid at one point
+                       || SitTargetOrientation.X == 0f && SitTargetOrientation.Y == 0f && SitTargetOrientation.Z == 0f && SitTargetOrientation.W == 0f)); // Invalid Quaternion
+            }
+        }
        #region Fields
        public bool AllowedDrop;
@@ -426,7 +441,6 @@ namespace OpenSim.Region.Framework.Scenes
        private uint _category;
        private Int32 _creationDate;
        private uint _parentID = 0;
-        private UUID m_sitTargetAvatar = UUID.Zero;
        private uint _baseMask = (uint)PermissionMask.All;
        private uint _ownerMask = (uint)PermissionMask.All;
        private uint _groupMask = (uint)PermissionMask.None;
@@ -1024,7 +1038,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
@@ -1309,13 +1334,20 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// ID of the avatar that is sat on us.  If there is no such avatar then is UUID.Zero
+        /// ID of the avatar that is sat on us if we have a sit target.  If there is no such avatar then is UUID.Zero
        /// </summary>
-        public UUID SitTargetAvatar
+        public UUID SitTargetAvatar { get; set; }
-        {
-            get { return m_sitTargetAvatar; }
+        /// <summary>
-            set { m_sitTargetAvatar = value; }
+        /// IDs of all avatars start on this object part.
-        }
+        /// </summary>
+        /// <remarks>
+        /// We need to track this so that we can stop sat upon prims from being attached.
+        /// </remarks>
+        /// <value>
+        /// null if there are no sitting avatars.  This is to save us create a hashset for every prim in a scene.
+        /// </value>
+        private HashSet<UUID> m_sittingAvatars;
        public virtual UUID RegionID
        {
@@ -2111,7 +2143,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>
@@ -2216,6 +2248,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;
@@ -3174,8 +3209,9 @@ namespace OpenSim.Region.Framework.Scenes
            if (ParentGroup.IsDeleted)
                return;
-            if (ParentGroup.IsAttachment && (ParentGroup.AttachedAvatar != remoteClient.AgentId) &&
+            if (ParentGroup.IsAttachment
-                (ParentGroup.AttachmentPoint >= 31) && (ParentGroup.AttachmentPoint <= 38))
+                && ParentGroup.AttachedAvatar != remoteClient.AgentId
+                && ParentGroup.HasPrivateAttachmentPoint)
                return;
            if (remoteClient.AgentId == OwnerID)
@@ -3694,7 +3730,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.
@@ -3724,10 +3759,12 @@ namespace OpenSim.Region.Framework.Scenes
        public void SetPhysicsAxisRotation()
        {
-            if (PhysActor != null)
+            PhysicsActor pa = PhysActor;
+            if (pa != null)
            {
-                PhysActor.LockAngularMotion(RotationAxis);
+                pa.LockAngularMotion(RotationAxis);
-                ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+                ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(pa);
            }
        }
@@ -4444,7 +4481,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);
@@ -4460,7 +4497,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);
@@ -4476,7 +4513,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();
            }
@@ -4598,7 +4635,6 @@ namespace OpenSim.Region.Framework.Scenes
                        }
 */
                    }
                    else // it already has a physical representation
                    {
                        DoPhysicsPropertyUpdate(UsePhysics, false); // Update physical status.
@@ -5074,8 +5110,9 @@ namespace OpenSim.Region.Framework.Scenes
            if (ParentGroup.IsDeleted)
                return;
-            if (ParentGroup.IsAttachment && ((ParentGroup.RootPart != this) ||
+            if (ParentGroup.IsAttachment
-                ((ParentGroup.AttachedAvatar != remoteClient.AgentId) && (ParentGroup.AttachmentPoint >= 31) && (ParentGroup.AttachmentPoint <= 38))))
+                && (ParentGroup.RootPart != this
+                    || ParentGroup.AttachedAvatar != remoteClient.AgentId && ParentGroup.HasPrivateAttachmentPoint))
                return;
            
            // Causes this thread to dig into the Client Thread Data.
@@ -5147,5 +5184,99 @@ namespace OpenSim.Region.Framework.Scenes
                Inventory.UpdateInventoryItem(item, false, false);
            }
        }
+        /// <summary>
+        /// Record an avatar sitting on this part.
+        /// </summary>
+        /// <remarks>This is called for all the sitting avatars whether there is a sit target set or not.</remarks>
+        /// <returns>
+        /// true if the avatar was not already recorded, false otherwise.
+        /// </returns>
+        /// <param name='avatarId'></param>
+        protected internal bool AddSittingAvatar(UUID avatarId)
+        {
+            if (IsSitTargetSet && SitTargetAvatar == UUID.Zero)
+                SitTargetAvatar = avatarId;
+            HashSet<UUID> sittingAvatars = m_sittingAvatars;
+            if (sittingAvatars == null)
+                sittingAvatars = new HashSet<UUID>();
+            lock (sittingAvatars)
+            {
+                m_sittingAvatars = sittingAvatars;
+                return m_sittingAvatars.Add(avatarId);
+            }
+        }
+        /// <summary>
+        /// Remove an avatar recorded as sitting on this part.
+        /// </summary>
+        /// <remarks>This applies to all sitting avatars whether there is a sit target set or not.</remarks>
+        /// <returns>
+        /// true if the avatar was present and removed, false if it was not present.
+        /// </returns>
+        /// <param name='avatarId'></param>
+        protected internal bool RemoveSittingAvatar(UUID avatarId)
+        {
+            if (SitTargetAvatar == avatarId)
+                SitTargetAvatar = UUID.Zero;
+            HashSet<UUID> sittingAvatars = m_sittingAvatars;
+            // This can occur under a race condition where another thread
+            if (sittingAvatars == null)
+                return false;
+            lock (sittingAvatars)
+            {
+                if (sittingAvatars.Remove(avatarId))
+                {
+                    if (sittingAvatars.Count == 0)
+                        m_sittingAvatars = null;
+                    return true;
+                }
+            }
+            return false;
+        }
+        /// <summary>
+        /// Get a copy of the list of sitting avatars.
+        /// </summary>
+        /// <remarks>This applies to all sitting avatars whether there is a sit target set or not.</remarks>
+        /// <returns>A hashset of the sitting avatars.  Returns null if there are no sitting avatars.</returns>
+        public HashSet<UUID> GetSittingAvatars()
+        {
+            HashSet<UUID> sittingAvatars = m_sittingAvatars;
+            if (sittingAvatars == null)
+            {
+                return null;
+            }
+            else
+            {
+                lock (sittingAvatars)
+                    return new HashSet<UUID>(sittingAvatars);
+            }
+        }
+        /// <summary>
+        /// Gets the number of sitting avatars.
+        /// </summary>
+        /// <remarks>This applies to all sitting avatars whether there is a sit target set or not.</remarks>
+        /// <returns></returns>
+        public int GetSittingAvatarsCount()
+        {
+            HashSet<UUID> sittingAvatars = m_sittingAvatars;
+            if (sittingAvatars == null)
+                return 0;
+            lock (sittingAvatars)
+                return sittingAvatars.Count;
+        }
    }
 }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index 959046a..e5e29d0 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);
+            List<TaskInventoryItem> items = GetInventoryItems();
-            if (0 == Items.Count)
-            {
+            if (items.Count == 0)
-                m_items.LockItemsForWrite(false);
                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)
@@ -234,7 +232,7 @@ namespace OpenSim.Region.Framework.Scenes
        private void QueryScriptStates()
        {
-            if (m_part == null || m_part.ParentGroup == null)
+            if (m_part == null || m_part.ParentGroup == null || m_part.ParentGroup.Scene == null)
                return;
            IScriptModule[] engines = m_part.ParentGroup.Scene.RequestModuleInterfaces<IScriptModule>();
@@ -262,19 +260,16 @@ namespace OpenSim.Region.Framework.Scenes
            Items.LockItemsForRead(false);
        }
-        /// <summary>
+        public int CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
-        /// Start all the scripts contained in this prim's inventory
-        /// </summary>
-        public void CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
        {
-            Items.LockItemsForRead(true);
+            int scriptsValidForStarting = 0;
-            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
-            Items.LockItemsForRead(false);
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
-            foreach (TaskInventoryItem item in items)
+            foreach (TaskInventoryItem item in scripts)
-            {
+                if (CreateScriptInstance(item, startParam, postOnRez, engine, stateSource))
-                if ((int)InventoryType.LSL == item.InvType)
+                    scriptsValidForStarting++;
-                    CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
-            }
+            return scriptsValidForStarting;
        }
        public ArrayList GetScriptErrors(UUID itemID)
@@ -297,7 +292,7 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Stop all the scripts in this prim.
+        /// Stop and remove all the scripts in this prim.
        /// </summary>
        /// <param name="sceneObjectBeingDeleted">
        /// Should be true if these scripts are being removed because the scene
@@ -305,26 +300,28 @@ namespace OpenSim.Region.Framework.Scenes
        /// </param>
        public void RemoveScriptInstances(bool sceneObjectBeingDeleted)
        {
-            Items.LockItemsForRead(true);
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
-            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            foreach (TaskInventoryItem item in scripts)
-            Items.LockItemsForRead(false);
-            foreach (TaskInventoryItem item in items)
            {
-                if ((int)InventoryType.LSL == item.InvType)
+                RemoveScriptInstance(item.ItemID, sceneObjectBeingDeleted);
-                {
+                m_part.RemoveScriptEvents(item.ItemID);
-                    RemoveScriptInstance(item.ItemID, sceneObjectBeingDeleted);
-                    m_part.RemoveScriptEvents(item.ItemID);
-                }
            }
        }
        /// <summary>
+        /// Stop all the scripts in this prim.
+        /// </summary>
+        public void StopScriptInstances()
+        {
+            GetInventoryItems(InventoryType.LSL).ForEach(i => StopScriptInstance(i));
+        }
+        /// <summary>
        /// Start a script which is in this prim's inventory.
        /// </summary>
        /// <param name="item"></param>
-        /// <returns></returns>
+        /// <returns>true if the script instance was created, false otherwise</returns>
-        public void CreateScriptInstance(TaskInventoryItem item, int startParam, bool postOnRez, string engine, int stateSource)
+        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 +329,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_items.LockItemsForWrite(true);
-                        m_part.ParentGroup.Scene.m_trustBinaries)
+                m_items[item.ItemID].PermsMask = 0;
-                {
+                m_items[item.ItemID].PermsGranter = UUID.Zero;
-                    m_items.LockItemsForWrite(true);
+                m_items.LockItemsForWrite(false);
-                    m_items[item.ItemID].PermsMask = 0;
+                m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
-                    m_items[item.ItemID].PermsGranter = UUID.Zero;
+                    m_part.LocalId, item.ItemID, String.Empty, startParam, postOnRez, engine, stateSource);
-                    m_items.LockItemsForWrite(false);
+                StoreScriptErrors(item.ItemID, null);
-                    m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
+                m_part.ParentGroup.AddActiveScriptCount(1);
-                        m_part.LocalId, item.ItemID, String.Empty, startParam, postOnRez, engine, stateSource);
+                m_part.ScheduleFullUpdate();
-                    StoreScriptErrors(item.ItemID, null);
+                return true;
-                    m_part.ParentGroup.AddActiveScriptCount(1);
+            }
-                    m_part.ScheduleFullUpdate();
-                    return;
-                }
-                AssetBase asset = m_part.ParentGroup.Scene.AssetService.Get(item.AssetID.ToString());
+            AssetBase asset = m_part.ParentGroup.Scene.AssetService.Get(item.AssetID.ToString());
-                if (null == asset)
+            if (null == asset)
-                {
+            {
-                    string msg = String.Format("asset ID {0} could not be found", item.AssetID);
+                m_log.ErrorFormat(
-                    StoreScriptError(item.ItemID, msg);
+                    "[PRIM INVENTORY]: Couldn't start script {0}, {1} at {2} in {3} since asset ID {4} could not be found",
-                    m_log.ErrorFormat(
+                    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].OldItemID = item.OldItemID;
-                    m_items[item.ItemID].PermsMask = 0;
+                m_items[item.ItemID].PermsMask = 0;
-                    m_items[item.ItemID].PermsGranter = UUID.Zero;
+                m_items[item.ItemID].PermsGranter = UUID.Zero;
-                    m_items.LockItemsForWrite(false);
+                m_items.LockItemsForWrite(false);
                
-                    string script = Utils.BytesToString(asset.Data);
+                string script = Utils.BytesToString(asset.Data);
-                    m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
+                m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
-                        m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
+                    m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
-                    StoreScriptErrors(item.ItemID, null);
+                StoreScriptErrors(item.ItemID, null);
-                    if (!item.ScriptRunning)
+                if (!item.ScriptRunning)
-                        m_part.ParentGroup.Scene.EventManager.TriggerStopScript(
+                    m_part.ParentGroup.Scene.EventManager.TriggerStopScript(
-                            m_part.LocalId, item.ItemID);
+                        m_part.LocalId, item.ItemID);
-                    m_part.ParentGroup.AddActiveScriptCount(1);
+                m_part.ParentGroup.AddActiveScriptCount(1);
-                    m_part.ScheduleFullUpdate();
+                m_part.ScheduleFullUpdate();
-                }
+                return true;
            }
        }
@@ -459,7 +465,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 +473,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)
@@ -597,7 +604,7 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Stop a script which is in this prim's inventory.
+        /// Stop and remove a script which is in this prim's inventory.
        /// </summary>
        /// <param name="itemId"></param>
        /// <param name="sceneObjectBeingDeleted">
@@ -616,7 +623,36 @@ namespace OpenSim.Region.Framework.Scenes
            }
            else
            {
-                m_log.ErrorFormat(
+                m_log.WarnFormat(
+                    "[PRIM INVENTORY]: " +
+                    "Couldn't stop script with ID {0} since it couldn't be found for prim {1}, {2} at {3} in {4}",
+                    itemId, m_part.Name, m_part.UUID, 
+                    m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
+            }
+        }
+        /// <summary>
+        /// Stop a script which is in this prim's inventory.
+        /// </summary>
+        /// <param name="itemId"></param>
+        /// <param name="sceneObjectBeingDeleted">
+        /// Should be true if this script is being removed because the scene
+        /// object is being deleted.  This will prevent spurious updates to the client.
+        /// </param>
+        public void StopScriptInstance(UUID itemId)
+        {
+            TaskInventoryItem scriptItem;
+            lock (m_items)
+                m_items.TryGetValue(itemId, out scriptItem);
+            if (scriptItem != null)
+            {
+                StopScriptInstance(scriptItem);
+            }
+            else
+            {
+                m_log.WarnFormat(
                    "[PRIM INVENTORY]: " +
                    "Couldn't stop script with ID {0} since it couldn't be found for prim {1}, {2} at {3} in {4}",
                    itemId, m_part.Name, m_part.UUID, 
@@ -625,6 +661,22 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
+        /// Stop a script which is in this prim's inventory.
+        /// </summary>
+        /// <param name="itemId"></param>
+        /// <param name="sceneObjectBeingDeleted">
+        /// Should be true if this script is being removed because the scene
+        /// object is being deleted.  This will prevent spurious updates to the client.
+        /// </param>
+        public void StopScriptInstance(TaskInventoryItem item)
+        {
+            m_part.ParentGroup.Scene.EventManager.TriggerStopScript(m_part.LocalId, item.ItemID);
+            // At the moment, even stopped scripts are counted as active, which is probably wrong.
+//            m_part.ParentGroup.AddActiveScriptCount(-1);
+        }
+        /// <summary>
        /// Check if the inventory holds an item with a given name.
        /// </summary>
        /// <param name="name"></param>
@@ -770,14 +822,22 @@ namespace OpenSim.Region.Framework.Scenes
            return item;
        }
-        /// <summary>
+        public TaskInventoryItem GetInventoryItem(string name)
-        /// Get inventory items by name.
+        {
-        /// </summary>
+            m_items.LockItemsForRead(true);
-        /// <param name="name"></param>
+            foreach (TaskInventoryItem item in m_items.Values)
-        /// <returns>
+            {
-        /// A list of inventory items with that name.
+                if (item.Name == name)
-        /// If no inventory item has that name then an empty list is returned.
+                {
-        /// </returns>
+                    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 +1307,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 +1341,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 +1406,24 @@ namespace OpenSim.Region.Framework.Scenes
        {
            List<TaskInventoryItem> ret = new List<TaskInventoryItem>();
-            lock (m_items)
+            Items.LockItemsForRead(true);
-                ret = new List<TaskInventoryItem>(m_items.Values);
+            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)
+            Items.LockItemsForRead(true);
-            {
-                foreach (TaskInventoryItem item in m_items.Values)
+            foreach (TaskInventoryItem item in m_items.Values)
-                    if (item.InvType == (int)InventoryType.LSL)
+                if (item.InvType == (int)type)
-                        ret.Add(item);
+                    ret.Add(item);
-            }
+            Items.LockItemsForRead(false);
            return ret;
        }
@@ -1335,35 +1445,32 @@ namespace OpenSim.Region.Framework.Scenes
            if (engines.Length == 0) // No engine at all
                return ret;
-            Items.LockItemsForRead(true);
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
-            foreach (TaskInventoryItem item in m_items.Values)
+            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 (oldIDs)
-                            if (n != String.Empty)
+                            {
+                                if (!ret.ContainsKey(item.OldItemID))
+                                    ret[item.OldItemID] = n;
+                            }
+                            else
                            {
-                                if (oldIDs)
+                                if (!ret.ContainsKey(item.ItemID))
-                                {
+                                    ret[item.ItemID] = n;
-                                    if (!ret.ContainsKey(item.OldItemID))
-                                        ret[item.OldItemID] = n;
-                                }
-                                else
-                                {
-                                    if (!ret.ContainsKey(item.ItemID))
-                                        ret[item.ItemID] = n;
-                                }
-                                break;
                            }
+                            break;
                        }
                    }
                }
            }
-            Items.LockItemsForRead(false);
            return ret;
        }
        
@@ -1373,27 +1480,27 @@ namespace OpenSim.Region.Framework.Scenes
            if (engines.Length == 0)
                return;
+            List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
-            Items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in scripts)
-            foreach (TaskInventoryItem item in m_items.Values)
            {
-                if (item.InvType == (int)InventoryType.LSL)
+                foreach (IScriptModule engine in engines)
                {
-                    foreach (IScriptModule engine in engines)
+                    if (engine != null)
                    {
-                        if (engine != null)
+//                        m_log.DebugFormat(
-                        {
+//                            "[PRIM INVENTORY]: Resuming script {0} {1} for {2}, OwnerChanged {3}",
-                            if (item.OwnerChanged)
+//                            item.Name, item.ItemID, item.OwnerID, item.OwnerChanged);
-                                engine.PostScriptEvent(item.ItemID, "changed", new Object[] { (int)Changed.OWNER });
-                            item.OwnerChanged = false;
+                        engine.ResumeScript(item.ItemID);
-                            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 4940063..e27d309 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();
            }
        }
@@ -586,6 +594,12 @@ namespace OpenSim.Region.Framework.Scenes
        private UUID m_parentUUID = UUID.Zero;
        /// <summary>
+        /// Are we sitting on an object?
+        /// </summary>
+        /// <remarks>A more readable way of testing presence sit status than ParentID == 0</remarks>
+        public bool IsSatOnObject { get { return ParentID != 0; } }
+        /// <summary>
        /// If the avatar is sitting, the prim that it's sitting on.  If not sitting then null.
        /// </summary>
        /// <remarks>
@@ -1087,23 +1101,13 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="pos"></param>
        public void Teleport(Vector3 pos)
        {
-            bool isFlying = Flying;
+            TeleportWithMomentum(pos, Vector3.Zero);
-            RemoveFromPhysicalScene();
-            Velocity = Vector3.Zero;
-            CheckLandingPoint(ref pos);
-            AbsolutePosition = pos;
-            AddToPhysicalScene(isFlying);
-            SendTerseUpdateToAllClients();
-        }
-        public void TeleportWithMomentum(Vector3 pos)
-        {
-            TeleportWithMomentum(pos, null);
        }
        public void TeleportWithMomentum(Vector3 pos, Vector3? v)
        {
+            if (ParentID != (uint)0)
+                StandUp();
            bool isFlying = Flying;
            Vector3 vel = Velocity;
            RemoveFromPhysicalScene();
@@ -1283,17 +1287,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
@@ -1308,7 +1328,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);
@@ -1361,7 +1380,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)
            {
@@ -1471,14 +1490,8 @@ namespace OpenSim.Region.Framework.Scenes
                }
            }
-            lock (scriptedcontrols)
+            uint flagsForScripts = (uint)flags;
-            {
+            flags = RemoveIgnoredControls(flags, IgnoredControls);
-                if (scriptedcontrols.Count > 0)
-                {
-                    SendControlToScripts((uint)flags);
-                    flags = RemoveIgnoredControls(flags, IgnoredControls);
-                }
-            }
            if ((flags & AgentManager.ControlFlags.AGENT_CONTROL_SIT_ON_GROUND) != 0)
                HandleAgentSitOnGround();
@@ -1492,6 +1505,7 @@ namespace OpenSim.Region.Framework.Scenes
            PhysicsActor actor = PhysicsActor;
            if (actor == null)
            {
+                SendControlsToScripts(flagsForScripts);
                return;
            }
@@ -1571,7 +1585,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;
                            }
@@ -1584,7 +1598,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;
@@ -1665,11 +1679,14 @@ namespace OpenSim.Region.Framework.Scenes
 //                    }
 //                }
-//                if (update_movementflag && ParentID == 0)
+                if (update_movementflag && ParentID == 0)
-//                    Animator.UpdateMovementAnimations();
+                    Animator.UpdateMovementAnimations();
+                SendControlsToScripts(flagsForScripts);
            }
            m_scene.EventManager.TriggerOnClientMovement(this);
+            TriggerScenePresenceUpdated();
        }
        /// <summary>
@@ -1929,10 +1946,6 @@ namespace OpenSim.Region.Framework.Scenes
                    }
                }
-                // Reset sit target.
-                if (part.SitTargetAvatar == UUID)
-                    part.SitTargetAvatar = UUID.Zero;
                part.ParentGroup.DeleteAvatar(UUID);
 //                ParentPosition = part.GetWorldPosition();
                ControllingClient.SendClearFollowCamProperties(part.ParentUUID);
@@ -1950,6 +1963,8 @@ namespace OpenSim.Region.Framework.Scenes
                SendAvatarDataToAllAgents();
                m_requestedSitTargetID = 0;
+                part.RemoveSittingAvatar(UUID);
                if (part != null)
                    part.ParentGroup.TriggerScriptChangedEvent(Changed.LINK);
            }
@@ -1983,15 +1998,7 @@ namespace OpenSim.Region.Framework.Scenes
            //look for prims with explicit sit targets that are available
            foreach (SceneObjectPart part in partArray)
            {
-                // Is a sit target available?
+                if (part.IsSitTargetSet && part.SitTargetAvatar == UUID.Zero)
-                Vector3 avSitOffset = part.SitTargetPosition;
-                Quaternion avSitOrientation = part.SitTargetOrientation;
-                UUID avOnTargetAlready = part.SitTargetAvatar;
-                bool SitTargetUnOccupied = avOnTargetAlready == UUID.Zero;
-                bool SitTargetisSet = avSitOffset != Vector3.Zero || avSitOrientation != Quaternion.Identity;
-                if (SitTargetisSet && SitTargetUnOccupied)
                {
                    //switch the target to this prim
                    return part;
@@ -2002,10 +2009,8 @@ namespace OpenSim.Region.Framework.Scenes
            return targetPart;
        }
-        private void SendSitResponse(UUID targetID, Vector3 offset, Quaternion pSitOrientation)
+        private void SendSitResponse(UUID targetID, Vector3 offset, Quaternion sitOrientation)
        {
-            Vector3 pos = new Vector3();
-            Quaternion sitOrientation = pSitOrientation;
            Vector3 cameraEyeOffset = Vector3.Zero;
            Vector3 cameraAtOffset = Vector3.Zero;
            bool forceMouselook = false;
@@ -2017,54 +2022,39 @@ namespace OpenSim.Region.Framework.Scenes
            // TODO: determine position to sit at based on scene geometry; don't trust offset from client
            // see http://wiki.secondlife.com/wiki/User:Andrew_Linden/Office_Hours/2007_11_06 for details on how LL does it
-            // Is a sit target available?
-            Vector3 avSitOffSet = part.SitTargetPosition;
-            Quaternion avSitOrientation = part.SitTargetOrientation;
-            UUID avOnTargetAlready = part.SitTargetAvatar;
-            bool SitTargetUnOccupied = (!(avOnTargetAlready != UUID.Zero));
-            bool SitTargetisSet =
-                (!(avSitOffSet == Vector3.Zero &&
-                   (
-                       avSitOrientation == Quaternion.Identity // Valid Zero Rotation quaternion
-                       || avSitOrientation.X == 0f && avSitOrientation.Y == 0f && avSitOrientation.Z == 1f && avSitOrientation.W == 0f // W-Z Mapping was invalid at one point
-                       || avSitOrientation.X == 0f && avSitOrientation.Y == 0f && avSitOrientation.Z == 0f && avSitOrientation.W == 0f // Invalid Quaternion
-                   )
-                   ));
-//                m_log.DebugFormat("[SCENE PRESENCE]: {0} {1}", SitTargetisSet, SitTargetUnOccupied);
            if (PhysicsActor != null)
                m_sitAvatarHeight = PhysicsActor.Size.Z * 0.5f;
            bool canSit = false;
-            pos = part.AbsolutePosition + offset;
+            Vector3 pos = part.AbsolutePosition + offset;
-            if (SitTargetisSet)
+            if (part.IsSitTargetSet && part.SitTargetAvatar == UUID.Zero)
            {
-                if (SitTargetUnOccupied)
+//                    m_log.DebugFormat(
-                {
+//                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is set and unoccupied",
-                    m_log.DebugFormat(
+//                        Name, part.Name, part.LocalId);
-                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is set and unoccupied",
-                        Name, part.Name, part.LocalId);
-                    part.SitTargetAvatar = UUID;
+                offset = part.SitTargetPosition;
-                    offset = new Vector3(avSitOffSet.X, avSitOffSet.Y, avSitOffSet.Z);
+                sitOrientation = part.SitTargetOrientation;
-                    sitOrientation = avSitOrientation;
+                canSit = true;
-                    canSit = true;
-                }
            }
            else
            {
                if (Util.GetDistanceTo(AbsolutePosition, pos) <= 10)
                {
-                    m_log.DebugFormat(
+//                    m_log.DebugFormat(
-                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is unset and within 10m",
+//                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is unset and within 10m",
-                        Name, part.Name, part.LocalId);
+//                        Name, part.Name, part.LocalId);
                    AbsolutePosition = pos + new Vector3(0.0f, 0.0f, m_sitAvatarHeight);
                    canSit = true;
                }
+//                else
+//                {
+//                    m_log.DebugFormat(
+//                        "[SCENE PRESENCE]: Ignoring sit request of {0} on {1} {2} because sit target is unset and outside 10m",
+//                        Name, part.Name, part.LocalId);
+//                }
            }
            if (canSit)
@@ -2075,6 +2065,8 @@ namespace OpenSim.Region.Framework.Scenes
                    RemoveFromPhysicalScene();
                }
+                part.AddSittingAvatar(UUID);
                cameraAtOffset = part.GetCameraAtOffset();
                cameraEyeOffset = part.GetCameraEyeOffset();
                forceMouselook = part.GetForceMouselook();
@@ -2351,6 +2343,15 @@ namespace OpenSim.Region.Framework.Scenes
            if (part != null)
            {
+                if (part.ParentGroup.IsAttachment)
+                {
+                    m_log.WarnFormat(
+                        "[SCENE PRESENCE]: Avatar {0} tried to sit on part {1} from object {2} in {3} but this is an attachment for avatar id {4}",
+                        Name, part.Name, part.ParentGroup.Name, Scene.Name, part.ParentGroup.AttachedAvatar);
+                    return;
+                }
                if (part.SitTargetAvatar == UUID)
                {
                    Vector3 sitTargetPos = part.SitTargetPosition;
@@ -2616,6 +2617,7 @@ namespace OpenSim.Region.Framework.Scenes
                m_scene.ForEachClient(SendTerseUpdateToClient);
            }
+            TriggerScenePresenceUpdated();
        }
        public void SendCoarseLocations(List<Vector3> coarseLocations, List<UUID> avatarUUIDs)
@@ -2694,7 +2696,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
@@ -3099,8 +3101,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("---> 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("---> y: " + y + "; newy:" + newRegionY + "; Abs:" + (int)Math.Abs((int)(y - newRegionY)));
                    if (Util.IsOutsideView(DrawDistance, x, newRegionX, y, newRegionY))
                    {
                        byebyeRegions.Add(handle);
@@ -3157,7 +3159,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;
@@ -3269,31 +3271,8 @@ namespace OpenSim.Region.Framework.Scenes
            catch { }
            cAgent.DefaultAnim = Animator.Animations.DefaultAnimation;
-            // Attachment objects
+            if (Scene.AttachmentsModule != null)
-            List<SceneObjectGroup> attachments = GetAttachments();
+                Scene.AttachmentsModule.CopyAttachments(this, cAgent);
-            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);
-                }
-            }
        }
        private void CopyFrom(AgentData cAgent)
@@ -3301,6 +3280,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;
@@ -3365,18 +3347,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)
+            if (Scene.AttachmentsModule != null)
-            {
+                Scene.AttachmentsModule.CopyAttachments(cAgent, this);
-                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);
-                }
-            }
        }
        public bool CopyAgent(out IAgentData agent)
@@ -3402,6 +3374,7 @@ namespace OpenSim.Region.Framework.Scenes
                Velocity = force;
                m_forceToApply = null;
+                TriggerScenePresenceUpdated();
            }
        }
@@ -3509,23 +3482,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 (localid == 0)
+                {
-                if (part != null && part.ParentGroup.Damage != -1.0f)
+                    part = null;
-                    Health -= part.ParentGroup.Damage;
+                }
+                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)
@@ -3541,7 +3544,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);
+                }
            }
        }
@@ -3553,9 +3565,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>();
@@ -3624,6 +3633,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)
@@ -3841,77 +3907,92 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
-        internal void SendControlToScripts(uint flags)
+        private void SendControlsToScripts(uint flags)
        {
-            ScriptControlled allflags = ScriptControlled.CONTROL_ZERO;
+            // 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.
-            if (MouseDown)
+            lock (scriptedcontrols)
            {
-                allflags = LastCommands & (ScriptControlled.CONTROL_ML_LBUTTON | ScriptControlled.CONTROL_LBUTTON);
+                if (scriptedcontrols.Count <= 0)
-                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LBUTTON_UP) != 0 || (flags & unchecked((uint)AgentManager.ControlFlags.AGENT_CONTROL_ML_LBUTTON_UP)) != 0)
+                    return;
+                ScriptControlled allflags = ScriptControlled.CONTROL_ZERO;
+    
+                if (MouseDown)
                {
-                    allflags = ScriptControlled.CONTROL_ZERO;
+                    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_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)
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LEFT_POS) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_POS) != 0)
-            {
+                {
-                allflags |= ScriptControlled.CONTROL_ML_LBUTTON;
+                    allflags |= ScriptControlled.CONTROL_LEFT;
-                MouseDown = true;
+                }
-            }
+    
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LBUTTON_DOWN) != 0)
+                if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_LEFT_NEG) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_NEG) != 0)
-            {
+                {
-                allflags |= ScriptControlled.CONTROL_LBUTTON;
+                    allflags |= ScriptControlled.CONTROL_RIGHT;
-                MouseDown = true;
+                }
-            }
+    
+                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
+                // optimization; we have to check per script, but if nothing is pressed and nothing changed, we can skip that
-            if ((flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_AT_POS) != 0 || (flags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_POS) != 0)
+                if (allflags != ScriptControlled.CONTROL_ZERO || allflags != LastCommands)
-            {
-                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)
                {
                    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
@@ -3919,9 +4000,9 @@ namespace OpenSim.Region.Framework.Scenes
                        }
                    }
                }
+    
+                LastCommands = allflags;
            }
-            LastCommands = allflags;
        }
        internal static AgentManager.ControlFlags RemoveIgnoredControls(AgentManager.ControlFlags flags, ScriptControlled ignored)
@@ -4001,7 +4082,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)
@@ -4015,13 +4096,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))
                {
@@ -4029,28 +4110,92 @@ namespace OpenSim.Region.Framework.Scenes
                    if (spawnPoints.Length == 0)
                        return;
-                    float distance = 9999;
+                    int index;
-                    int closest = -1;
+                    bool selected = false;
-                    for (int i = 0 ; i < spawnPoints.Length ; i++)
+                    switch (m_scene.SpawnPointRouting)
                    {
-                        Vector3 spawnPosition = spawnPoints[i].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
+                        case "random":
-                        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);
+                            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;
+                    }
                }
            }
        }
@@ -4095,7 +4240,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 abca14f..2372d6b 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -1537,51 +1537,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();
+            return SceneObjectSerializer.FromXml2Format(xmlString);
-            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;
-                }
-            }
        }
        /// <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);
+                SceneObjectGroup obj = DeserializeGroupFromXml2(aPrimNode.OuterXml);
-                if (obj != null && startScripts)
+                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
+        private static readonly log4net.ILog m_log
-//            = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+            = 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,
+            VirtualSizeKb = 21,
-            ResidentSizeKB = 22,
+            ResidentSizeKb = 22,
            PendingLocalUploads = 23,
            UnAckedBytes = 24,
            PhysicsPinnedTasks = 25,
-            PhysicsLODTasks = 26,
+            PhysicsLodTasks = 26,
-            PhysicsStepMS = 27,
+            SimPhysicsStepMs = 27,
-            PhysicsShapeMS = 28,
+            SimPhysicsShapeMs = 28,
-            PhysicsOtherMS = 29,
+            SimPhysicsOtherMs = 29,
-            PhysicsMemory = 30,
+            SimPhysicsMemory = 30,
-            ScriptEPS = 31,
+            ScriptEps = 31,
-            SimSpareTime = 32,
+            SimSpareMs = 32,
-            SimSleepTime = 33,
+            SimSleepMs = 33,
-            IOPumpTime = 34
+            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 int m_statsUpdatesEveryMS = 3000;
-        private float statsUpdateFactor = 0;
+        private float m_statsUpdateFactor;
-        private float m_timeDilation = 0;
+        private float m_timeDilation;
-        private int m_fps = 0;
+        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 lastReportedSimFPS;
-        private float[] lastReportedSimStats = new float[23];
+        private float[] lastReportedSimStats = new float[22];
-        private float m_pfps = 0;
+        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_frameMS;
-        private int m_netMS = 0;
+        private int m_spareMS;
-        private int m_agentMS = 0;
+        private int m_netMS;
-        private int m_physicsMS = 0;
+        private int m_agentMS;
-        private int m_imageMS = 0;
+        private int m_physicsMS;
-        private int m_otherMS = 0;
+        private int m_imageMS;
-        private int m_sleeptimeMS = 0;
+        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_rootAgents;
-        private int m_childAgents = 0;
+        private int m_childAgents;
-        private int m_numPrim = 0;
+        private int m_numPrim;
-        private int m_inPacketsPerSecond = 0;
+        private int m_inPacketsPerSecond;
-        private int m_outPacketsPerSecond = 0;
+        private int m_outPacketsPerSecond;
-        private int m_activePrim = 0;
+        private int m_activePrim;
-        private int m_unAckedBytes = 0;
+        private int m_unAckedBytes;
-        private int m_pendingDownloads = 0;
+        private int m_pendingDownloads;
-        private int m_pendingUploads = 0;
+        private int m_pendingUploads = 0;  // FIXME: Not currently filled in
-        private int m_activeScripts = 0;
+        private int m_activeScripts;
-        private int m_scriptLinesPerSecond = 0;
+        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.Interval = m_statsUpdatesEveryMS;
-            m_report.Elapsed += statsHeartBeat;
+            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;
+            m_statsUpdatesEveryMS = ms;
-            statsUpdateFactor = (float)(statsUpdatesEveryMS / 1000);
+            m_statsUpdateFactor = (float)(m_statsUpdatesEveryMS / 1000);
-            m_report.Interval = statsUpdatesEveryMS;
+            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 = m_frameMS / framesUpdated;
-                sb[8].StatValue = TotalFrameTime;
                sb[9].StatID = (uint)Stats.NetMS;
-                //                sb[9].StatValue = m_netMS / statsUpdateFactor;
+                sb[9].StatValue = m_netMS / framesUpdated;
-                sb[9].StatValue = m_netMS * perframe;
                sb[10].StatID = (uint)Stats.PhysicsMS;
-                //                sb[10].StatValue = m_physicsMS / statsUpdateFactor;
+                sb[10].StatValue = m_physicsMS / framesUpdated;
-                sb[10].StatValue = m_physicsMS * perframe;
                sb[11].StatID = (uint)Stats.ImageMS ;
-                //                sb[11].StatValue = m_imageMS / statsUpdateFactor;
+                sb[11].StatValue = m_imageMS / framesUpdated;
-                sb[11].StatValue = m_imageMS * perframe;
                sb[12].StatID = (uint)Stats.OtherMS;
-                //                sb[12].StatValue = m_otherMS / statsUpdateFactor;
+                sb[12].StatValue = m_otherMS / framesUpdated;
-                sb[12].StatValue = m_otherMS * perframe;
                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 / framesUpdated;
-                sb[16].StatValue = m_agentMS * perframe;
                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].StatID = (uint)Stats.SimSpareMs;
-                sb[21].StatValue = sparetime;
+                sb[21].StatValue = m_spareMS / framesUpdated;
-                sb[22].StatID = (uint)Stats.SimSleepTime;
+                for (int i = 0; i < 22; i++)
-                sb[22].StatValue = sleeptime;
-               
-                for (int i = 0; i < 23; 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..3398a53 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,11 +185,16 @@ namespace OpenSim.Region.Framework.Scenes.Tests
        {
            TestHelpers.InMethod();
-            TestScene scene = SceneHelpers.SetupScene();
+            TestScene scene = new SceneHelpers().SetupScene();
-            SceneObjectPart part = SceneHelpers.AddSceneObject(scene);
+            SceneObjectGroup so = SceneHelpers.AddSceneObject(scene);
-            scene.DeleteSceneObject(part.ParentGroup, false);
-            SceneObjectPart retrievedPart = scene.GetSceneObjectPart(part.LocalId);
+            Assert.That(so.IsDeleted, Is.False);
+            scene.DeleteSceneObject(so, false);
+            Assert.That(so.IsDeleted, Is.True);
+            SceneObjectPart retrievedPart = scene.GetSceneObjectPart(so.LocalId);
            Assert.That(retrievedPart, Is.Null);
        }
        
@@ -204,24 +209,28 @@ 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;
            sogd.Enabled = false;
-            SceneObjectPart part = SceneHelpers.AddSceneObject(scene);
+            SceneObjectGroup so = SceneHelpers.AddSceneObject(scene);
            IClientAPI client = SceneHelpers.AddScenePresence(scene, agentId).ControllingClient;
-            scene.DeRezObjects(client, new System.Collections.Generic.List<uint>() { part.LocalId }, UUID.Zero, DeRezAction.Delete, UUID.Zero);
+            scene.DeRezObjects(client, new System.Collections.Generic.List<uint>() { so.LocalId }, UUID.Zero, DeRezAction.Delete, UUID.Zero);
-            SceneObjectPart retrievedPart = scene.GetSceneObjectPart(part.LocalId);
+            SceneObjectPart retrievedPart = scene.GetSceneObjectPart(so.LocalId);
            Assert.That(retrievedPart, Is.Not.Null);
+            Assert.That(so.IsDeleted, Is.False);
            sogd.InventoryDeQueueAndDelete();
-            SceneObjectPart retrievedPart2 = scene.GetSceneObjectPart(part.LocalId);
+            Assert.That(so.IsDeleted, Is.True);
+            SceneObjectPart retrievedPart2 = scene.GetSceneObjectPart(so.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..0e525c9 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,11 +71,11 @@ 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 = SceneHelpers.AddSceneObject(scene);
-            SceneObjectGroup grp1 = part1.ParentGroup;
+            SceneObjectPart part1 = grp1.RootPart;
-            SceneObjectPart part2 = SceneHelpers.AddSceneObject(scene);
+            SceneObjectGroup grp2 = SceneHelpers.AddSceneObject(scene);
-            SceneObjectGroup grp2 = part2.ParentGroup;
+            SceneObjectPart part2 = grp2.RootPart;
            grp1.AbsolutePosition = new Vector3(10, 10, 10);
            grp2.AbsolutePosition = Vector3.Zero;
@@ -153,15 +153,15 @@ 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 = SceneHelpers.AddSceneObject(scene);
-            SceneObjectGroup grp1 = part1.ParentGroup;
+            SceneObjectPart part1 = grp1.RootPart;
-            SceneObjectPart part2 = SceneHelpers.AddSceneObject(scene);
+            SceneObjectGroup grp2 = SceneHelpers.AddSceneObject(scene);
-            SceneObjectGroup grp2 = part2.ParentGroup;
+            SceneObjectPart part2 = grp2.RootPart;
-            SceneObjectPart part3 = SceneHelpers.AddSceneObject(scene);
+            SceneObjectGroup grp3 = SceneHelpers.AddSceneObject(scene);
-            SceneObjectGroup grp3 = part3.ParentGroup;
+            SceneObjectPart part3 = grp3.RootPart;
-            SceneObjectPart part4 = SceneHelpers.AddSceneObject(scene);
+            SceneObjectGroup grp4 = SceneHelpers.AddSceneObject(scene);
-            SceneObjectGroup grp4 = part4.ParentGroup;
+            SceneObjectPart part4 = grp4.RootPart;
            grp1.AbsolutePosition = new Vector3(10, 10, 10);
            grp2.AbsolutePosition = Vector3.Zero;
@@ -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..e931859 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
@@ -52,8 +52,8 @@ 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;
+            SceneObjectGroup g1 = SceneHelpers.AddSceneObject(scene);
            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();
+            m_scene.AddSceneObject(m_so1);
-            SceneObjectGroup so = SceneHelpers.CreateSceneObject(1, UUID.Zero);
-            SceneObjectPart rootPart = so.RootPart;
+            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);
+            SceneHelpers sh = new SceneHelpers();
-            scene2 = SceneHelpers.SetupScene("Neighbour x+1", UUID.Random(), 1001, 1000);
-            scene3 = SceneHelpers.SetupScene("Neighbour x-1", UUID.Random(), 999, 1000);
+            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 myScene1 = new SceneHelpers().SetupScene("Neighbour y", UUID.Random(), 1000, 1000);
-            TestScene myScene2 = SceneHelpers.SetupScene("Neighbour y + 1", UUID.Random(), 1001, 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..493ab70 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs
@@ -26,6 +26,7 @@
 */
 using System;
+using System.Collections.Generic;
 using System.Reflection;
 using Nini.Config;
 using NUnit.Framework;
@@ -50,7 +51,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));
        }
@@ -64,11 +65,13 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Vector3 startPos = new Vector3(10.1f, 0, 0);
            m_sp.AbsolutePosition = startPos;
-            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene);
+            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene).RootPart;
            m_sp.HandleAgentRequestSit(m_sp.ControllingClient, m_sp.UUID, part.UUID, Vector3.Zero);
            Assert.That(part.SitTargetAvatar, Is.EqualTo(UUID.Zero));
+            Assert.That(part.GetSittingAvatarsCount(), Is.EqualTo(0));
+            Assert.That(part.GetSittingAvatars(), Is.Null);
            Assert.That(m_sp.ParentID, Is.EqualTo(0));
        }
@@ -82,11 +85,17 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Vector3 startPos = new Vector3(9.9f, 0, 0);
            m_sp.AbsolutePosition = startPos;
-            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene);
+            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene).RootPart;
            m_sp.HandleAgentRequestSit(m_sp.ControllingClient, m_sp.UUID, part.UUID, Vector3.Zero);
+            Assert.That(m_sp.PhysicsActor, Is.Null);
            Assert.That(part.SitTargetAvatar, Is.EqualTo(UUID.Zero));
+            Assert.That(part.GetSittingAvatarsCount(), Is.EqualTo(1));
+            HashSet<UUID> sittingAvatars = part.GetSittingAvatars();
+            Assert.That(sittingAvatars.Count, Is.EqualTo(1));
+            Assert.That(sittingAvatars.Contains(m_sp.UUID));
            Assert.That(m_sp.ParentID, Is.EqualTo(part.LocalId));
        }
@@ -100,14 +109,10 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Vector3 startPos = new Vector3(1, 1, 1);
            m_sp.AbsolutePosition = startPos;
-            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene);
+            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene).RootPart;
            m_sp.HandleAgentRequestSit(m_sp.ControllingClient, m_sp.UUID, part.UUID, Vector3.Zero);
-            Assert.That(part.SitTargetAvatar, Is.EqualTo(UUID.Zero));
-            Assert.That(m_sp.ParentID, Is.EqualTo(part.LocalId));
-            Assert.That(m_sp.PhysicsActor, Is.Null);
            // FIXME: This is different for live avatars - z position is adjusted.  This is half the height of the
            // default avatar.
            // Curiously, Vector3.ToString() will not display the last two places of the float.  For example,
@@ -119,6 +124,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            m_sp.StandUp();
            Assert.That(part.SitTargetAvatar, Is.EqualTo(UUID.Zero));
+            Assert.That(part.GetSittingAvatarsCount(), Is.EqualTo(0));
+            Assert.That(part.GetSittingAvatars(), Is.Null);
            Assert.That(m_sp.ParentID, Is.EqualTo(0));
            Assert.That(m_sp.PhysicsActor, Is.Not.Null);
        }
@@ -133,7 +140,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Vector3 startPos = new Vector3(128, 128, 30);
            m_sp.AbsolutePosition = startPos;
-            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene);
+            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene).RootPart;
            part.SitTargetPosition = new Vector3(0, 0, 1);
            m_sp.HandleAgentRequestSit(m_sp.ControllingClient, m_sp.UUID, part.UUID, Vector3.Zero);
@@ -145,11 +152,20 @@ namespace OpenSim.Region.Framework.Scenes.Tests
                Is.EqualTo(part.AbsolutePosition + part.SitTargetPosition + ScenePresence.SIT_TARGET_ADJUSTMENT));
            Assert.That(m_sp.PhysicsActor, Is.Null);
+            Assert.That(part.GetSittingAvatarsCount(), Is.EqualTo(1));
+            HashSet<UUID> sittingAvatars = part.GetSittingAvatars();
+            Assert.That(sittingAvatars.Count, Is.EqualTo(1));
+            Assert.That(sittingAvatars.Contains(m_sp.UUID));
            m_sp.StandUp();
            Assert.That(part.SitTargetAvatar, Is.EqualTo(UUID.Zero));
            Assert.That(m_sp.ParentID, Is.EqualTo(0));
            Assert.That(m_sp.PhysicsActor, Is.Not.Null);
+            Assert.That(part.SitTargetAvatar, Is.EqualTo(UUID.Zero));
+            Assert.That(part.GetSittingAvatarsCount(), Is.EqualTo(0));
+            Assert.That(part.GetSittingAvatars(), Is.Null);
        }
        [Test]
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>
+        [TestFixtureSetUp]
-        /// Test a teleport between two regions that are not neighbours and do not share any neighbours in common.
+        public void FixtureInit()
-        /// </summary>
+        {
-        /// Does not yet do what is says on the tin.
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
-        /// Commenting for now
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
-        //[Test, LongRunning]
+        }
-        public void TestSimpleNotNeighboursTeleport()
+        [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();
+//            log4net.Config.XmlConfigurator.Configure();
-            results.Result = false;
-            results.Message = "Test did not run";
+            EntityTransferModule etm = new EntityTransferModule();
-            TestRunning testClass = new TestRunning(results);
+            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
+            Assert.That(scene.GetRootAgentCount(), Is.EqualTo(1));
-            // A thread abort exception in the simulator code.
+            Assert.That(scene.GetChildAgentCount(), Is.EqualTo(0));
-            testThread.Start();
-            testThread.Join();
-            Assert.That(testClass.results.Result, Is.EqualTo(true), testClass.results.Message);
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
-            // Console.WriteLine("Beginning test {0}", MethodBase.GetCurrentMethod());
+            // position instead).
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
        }
-        [TearDown]
+        [Test]
-        public void TearDown()
+        public void TestSameSimulatorSeparatedRegionsTeleport()
        {
-            try
+            TestHelpers.InMethod();
-            {
+//            log4net.Config.XmlConfigurator.Configure();
-                if (MainServer.Instance != null) MainServer.Instance.Stop();
-            }
+            UUID userId = TestHelpers.ParseTail(0x1);
-            catch (NullReferenceException)
-            { }
+            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
+            UUID userId = TestHelpers.ParseTail(0x1);
-    {
+            Vector3 preTeleportPosition = new Vector3(30, 31, 32);
-        public bool Result = false;
-        public string Message = string.Empty;
-    }
-    public class TestRunning
+            EntityTransferModule etmA = new EntityTransferModule();
-    {
+            EntityTransferModule etmB = new EntityTransferModule();
-        public ThreadRunResults results;
-        public TestRunning(ThreadRunResults t)
+            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()
        {
-            
+            TestHelpers.InMethod();
-            //results.Result = true;
+//            TestHelpers.EnableLogging();
-            log4net.Config.XmlConfigurator.Configure();
+            UUID userId = TestHelpers.ParseTail(0x1);
-            UUID sceneAId = UUID.Parse("00000000-0000-0000-0000-000000000100");
-            UUID sceneBId = UUID.Parse("00000000-0000-0000-0000-000000000200");
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
-            // shared module
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
-            ISharedRegionModule interregionComms = new LocalSimulationConnectorModule();
+            IConfigSource config = new IniConfigSource();
+            IConfig modulesConfig = config.AddConfig("Modules");
-            Scene sceneB = SceneHelpers.SetupScene("sceneB", sceneBId, 1010, 1010);
+            modulesConfig.Set("EntityTransferModule", etmA.Name);
-            SceneHelpers.SetupSceneModules(sceneB, new IniConfigSource(), interregionComms);
+            modulesConfig.Set("SimulationServices", lscm.Name);
-            sceneB.RegisterRegionWithGrid();
+            IConfig entityTransferConfig = config.AddConfig("EntityTransfer");
-            Scene sceneA = SceneHelpers.SetupScene("sceneA", sceneAId, 1000, 1000);
+            // In order to run a single threaded regression test we do not want the entity transfer module waiting
-            SceneHelpers.SetupSceneModules(sceneA, new IniConfigSource(), interregionComms);
+            // for a callback from the destination scene before removing its avatar data.
-            sceneA.RegisterRegionWithGrid();
+            entityTransferConfig.Set("wait_for_callback", false);
-            UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000041");
+            SceneHelpers sh = new SceneHelpers();
-            TestClient client = (TestClient)SceneHelpers.AddScenePresence(sceneA, agentId).ControllingClient;
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1001, 1000);
-            ICapabilitiesModule sceneACapsModule = sceneA.RequestModuleInterface<ICapabilitiesModule>();
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
-            results.Result = (sceneACapsModule.GetCapsPath(agentId) == client.CapsSeedUrl);
+            SceneHelpers.SetupSceneModules(sceneA, config, new CapabilitiesModule(), etmA);
-            
+            SceneHelpers.SetupSceneModules(sceneB, config, new CapabilitiesModule(), etmB);
-            if (!results.Result)
-            {
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
-                results.Message = "Incorrect caps object path set up in sceneA";
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
-                return;
-            }
+            ScenePresence originalSp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            originalSp.AbsolutePosition = new Vector3(30, 31, 32);
-            /*
-            Assert.That(
+            ScenePresence beforeSceneASp = sceneA.GetScenePresence(userId);
-                sceneACapsModule.GetCapsPath(agentId),
+            Assert.That(beforeSceneASp, Is.Not.Null);
-                Is.EqualTo(client.CapsSeedUrl),
+            Assert.That(beforeSceneASp.IsChildAgent, Is.False);
-                "Incorrect caps object path set up in sceneA");
-            */
+            ScenePresence beforeSceneBSp = sceneB.GetScenePresence(userId);
-            // FIXME: This is a hack to get the test working - really the normal OpenSim mechanisms should be used.
+            Assert.That(beforeSceneBSp, Is.Not.Null);
-            
+            Assert.That(beforeSceneBSp.IsChildAgent, Is.True);
-            client.TeleportTargetScene = sceneB;
+            // XXX: A very nasty hack to tell the client about the destination scene without having to crank the whole
-            client.Teleport(sceneB.RegionInfo.RegionHandle, new Vector3(100, 100, 100), new Vector3(40, 40, 40));
+            // UDP stack (?)
+//            ((TestClient)beforeSceneASp.ControllingClient).TeleportTargetScene = sceneB;
-            results.Result = (sceneB.GetScenePresence(agentId) != null);
-            if (!results.Result)
+            sceneA.RequestTeleportLocation(
-            {
+                beforeSceneASp.ControllingClient,
-                results.Message = "Client does not have an agent in sceneB";
+                sceneB.RegionInfo.RegionHandle,
-                return;
+                teleportPosition,
-            }
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
-            //Assert.That(sceneB.GetScenePresence(agentId), Is.Not.Null, "Client does not have an agent in sceneB");
-            
+            ((TestClient)beforeSceneASp.ControllingClient).CompleteTeleportClientSide();
-            //Assert.That(sceneA.GetScenePresence(agentId), Is.Null, "Client still had an agent in sceneA");
+            ScenePresence afterSceneASp = sceneA.GetScenePresence(userId);
-            results.Result = (sceneA.GetScenePresence(agentId) == null);
+            Assert.That(afterSceneASp, Is.Not.Null);
-            if (!results.Result)
+            Assert.That(afterSceneASp.IsChildAgent, Is.True);
-            {
-                results.Message = "Client still had an agent in sceneA";
+            ScenePresence afterSceneBSp = sceneB.GetScenePresence(userId);
-                return;
+            Assert.That(afterSceneBSp, Is.Not.Null);
-            }
+            Assert.That(afterSceneBSp.IsChildAgent, Is.False);
+            Assert.That(afterSceneBSp.Scene.RegionInfo.RegionName, Is.EqualTo(sceneB.RegionInfo.RegionName));
-            ICapabilitiesModule sceneBCapsModule = sceneB.RequestModuleInterface<ICapabilitiesModule>();
+            Assert.That(afterSceneBSp.AbsolutePosition, Is.EqualTo(teleportPosition));
+            Assert.That(sceneA.GetRootAgentCount(), Is.EqualTo(0));
-            results.Result = ("http://" + sceneB.RegionInfo.ExternalHostName + ":" + sceneB.RegionInfo.HttpPort +
+            Assert.That(sceneA.GetChildAgentCount(), Is.EqualTo(1));
-                              "/CAPS/" + sceneBCapsModule.GetCapsPath(agentId) + "0000/" == client.CapsSeedUrl);
+            Assert.That(sceneB.GetRootAgentCount(), Is.EqualTo(1));
-            if (!results.Result)
+            Assert.That(sceneB.GetChildAgentCount(), Is.EqualTo(0));
-            {
-                results.Message = "Incorrect caps object path set up in sceneB";
+            // TODO: Add assertions to check correct circuit details in both scenes.
-                return;
-            }
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
+            // position instead).
-            // Temporary assertion - caps url construction should at least be doable through a method.
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
-            /*
-            Assert.That(
+//            TestHelpers.DisableLogging();
-                "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
        }
    }
-}
+}
+\ 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..a51e4e3 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,11 +124,13 @@ 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;
-            TaskInventoryItem sopItem1 = TaskInventoryHelpers.AddNotecard(scene, sop1);
+            TaskInventoryItem sopItem1
+                = TaskInventoryHelpers.AddNotecard(
+                    scene, sop1, "ncItem", TestHelpers.ParseTail(0x800), TestHelpers.ParseTail(0x900));
            InventoryFolderBase folder 
                = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, user1.PrincipalID, "Objects")[0];
@@ -153,11 +155,14 @@ 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;
-            TaskInventoryItem sopItem1 = TaskInventoryHelpers.AddNotecard(scene, sop1);
+            TaskInventoryItem sopItem1
+                = TaskInventoryHelpers.AddNotecard(
+                    scene, sop1, "ncItem", TestHelpers.ParseTail(0x800), TestHelpers.ParseTail(0x900));
            
            // Perform test
            scene.MoveTaskInventoryItem(user1.PrincipalID, UUID.Zero, sop1, sopItem1.ItemID);
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);
        }