42 files changed, 2713 insertions, 1788 deletions

diff --git a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
index 788f42b..6bbdd7d 100644
--- a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
@@ -37,6 +37,27 @@ namespace OpenSim.Region.Framework.Interfaces
     public interface IAttachmentsModule
     {
         /// <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>
+        void RezAttachments(IScenePresence sp);
+
+        /// <summary>
+        /// Save the attachments that have change on this presence.
+        /// </summary>
+        /// <param name="sp"></param>
+        void SaveChangedAttachments(IScenePresence sp);
+
+        /// <summary>
+        /// Delete all the presence's attachments from the scene
+        /// </summary>
+        /// <param name="sp">
+        /// This is done when a root agent leaves/is demoted to child (for instance, on logout, teleport or region cross).
+        /// </param>
+        /// <param name="silent"></param>
+        void DeleteAttachmentsFromScene(IScenePresence sp, bool silent);
+
+        /// <summary>
         /// Attach an object to an avatar from the world.
         /// </summary>
         /// <param name="controllingClient"></param>
@@ -48,13 +69,11 @@ namespace OpenSim.Region.Framework.Interfaces
             IClientAPI remoteClient, uint objectLocalID, uint AttachmentPt, bool silent);
 
         /// <summary>
-        /// Attach an object to an avatar.
+        /// Attach an object to an avatar
         /// </summary>
-        /// <param name="controllingClient"></param>
-        /// <param name="localID"></param>
-        /// <param name="attachPoint"></param>
-        /// <param name="rot"></param>
-        /// <param name="attachPos"></param>
+        /// <param name="remoteClient"></param>
+        /// <param name="grp"></param>
+        /// <param name="AttachmentPt"></param>
         /// <param name="silent"></param>
         /// <returns>true if the object was successfully attached, false otherwise</returns>
         bool AttachObject(
@@ -67,7 +86,7 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="itemID"></param>
         /// <param name="AttachmentPt"></param>
         /// <returns>The scene object that was attached.  Null if the scene object could not be found</returns>
-        UUID RezSingleAttachmentFromInventory(IClientAPI remoteClient, UUID itemID, uint AttachmentPt);
+        ISceneEntity RezSingleAttachmentFromInventory(IClientAPI remoteClient, UUID itemID, uint AttachmentPt);
 
         /// <summary>
         /// Rez an attachment from user inventory
@@ -80,7 +99,7 @@ namespace OpenSim.Region.Framework.Interfaces
         /// False is required so that we don't attempt to update information when a user enters a scene with the
         /// attachment already correctly set up in inventory.
         /// <returns>The uuid of the scene object that was attached.  Null if the scene object could not be found</returns>
-        UUID RezSingleAttachmentFromInventory(
+        ISceneEntity RezSingleAttachmentFromInventory(
             IClientAPI remoteClient, UUID itemID, uint AttachmentPt, bool updateInventoryStatus);
 
         // Same as above, but also load script states from a separate doc
@@ -101,9 +120,10 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <summary>
         /// Detach an object from the avatar.
         /// </summary>
-        ///
+        /// <remarks>
         /// This method is called in response to a client's detach request, so we only update the information in
         /// inventory
+        /// </remarks>
         /// <param name="objectLocalID"></param>
         /// <param name="remoteClient"></param>
         void DetachObject(uint objectLocalID, IClientAPI remoteClient);
@@ -111,12 +131,12 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <summary>
         /// Detach the given item to the ground.
         /// </summary>
-        /// <param name="itemID"></param>
+        /// <param name="objectLocalID"></param>
         /// <param name="remoteClient"></param>
-        void DetachSingleAttachmentToGround(UUID itemID, IClientAPI remoteClient);
+        void DetachSingleAttachmentToGround(uint objectLocalID, IClientAPI remoteClient);
 
         /// <summary>
-        /// Update the user inventory to show a detach.
+        /// Detach the given item so that it remains in the user's inventory.
         /// </summary>
         /// <param name="itemID">
         /// A <see cref="UUID"/>
@@ -124,23 +144,15 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <param name="remoteClient">
         /// A <see cref="IClientAPI"/>
         /// </param>
-        void ShowDetachInUserInventory(UUID itemID, IClientAPI remoteClient);
+        void DetachSingleAttachmentToInv(UUID itemID, IClientAPI remoteClient);
         
         /// <summary>
         /// Update the user inventory with a changed attachment
         /// </summary>
-        /// <param name="remoteClient">
-        /// A <see cref="IClientAPI"/>
-        /// </param>
-        /// <param name="grp">
-        /// A <see cref="SceneObjectGroup"/>
-        /// </param>
-        /// <param name="itemID">
-        /// A <see cref="UUID"/>
-        /// </param>
-        /// <param name="agentID">
-        /// A <see cref="UUID"/>
-        /// </param>
+        /// <param name="remoteClient"></param>
+        /// <param name="grp"></param>
+        /// <param name="itemID"></param>
+        /// <param name="agentID"></param>
         void UpdateKnownItem(IClientAPI remoteClient, SceneObjectGroup grp, UUID itemID, UUID agentID);
     }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/IAvatarFactory.cs b/OpenSim/Region/Framework/Interfaces/IAvatarFactory.cs
index d0e5609..4dbddf4 100644
--- a/OpenSim/Region/Framework/Interfaces/IAvatarFactory.cs
+++ b/OpenSim/Region/Framework/Interfaces/IAvatarFactory.cs
@@ -25,6 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System.Collections.Generic;
 using OpenMetaverse;
 using OpenSim.Framework;
 
@@ -32,6 +33,30 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface IAvatarFactory
     {
+        /// <summary>
+        /// Send the appearance of an avatar to others in the scene.
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <returns></returns>
+        bool SendAppearance(UUID agentId);
+
+        /// <summary>
+        /// Return the baked texture ids of the given agent.
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <returns>An empty list if this agent has no baked textures (e.g. because it's a child agent)</returns>
+        Dictionary<BakeType, Primitive.TextureEntryFace> GetBakedTextureFaces(UUID agentId);
+
+        /// <summary>
+        /// Save the baked textures for the given agent permanently in the asset database.
+        /// </summary>
+        /// <remarks>
+        /// This is used to preserve apperance textures for NPCs
+        /// </remarks>
+        /// <param name="agentId"></param>
+        /// <returns>true if a valid agent was found, false otherwise</returns>
+        bool SaveBakedTextures(UUID agentId);
+
         bool ValidateBakedTextureCache(IClientAPI client);
         void QueueAppearanceSend(UUID agentid);
         void QueueAppearanceSave(UUID agentid);
diff --git a/OpenSim/Region/Framework/Interfaces/IInventoryAccessModule.cs b/OpenSim/Region/Framework/Interfaces/IInventoryAccessModule.cs
index da11e61..1904011 100644
--- a/OpenSim/Region/Framework/Interfaces/IInventoryAccessModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IInventoryAccessModule.cs
@@ -54,10 +54,58 @@ namespace OpenSim.Region.Framework.Interfaces
         /// FIXME: This is not very useful.  It would be far more useful to return a list of items instead.
         /// </returns>
         UUID CopyToInventory(DeRezAction action, UUID folderID, List<SceneObjectGroup> objectGroups, IClientAPI remoteClient);
-        
-        SceneObjectGroup RezObject(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart,
-                                    UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
-                                    bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment);
+
+        /// <summary>
+        /// Rez an object into the scene from the user's inventory
+        /// </summary>
+        /// <remarks>
+        /// FIXME: It would be really nice if inventory access modules didn't also actually do the work of rezzing
+        /// things to the scene.  The caller should be doing that, I think.
+        /// </remarks>
+        /// <param name="remoteClient"></param>
+        /// <param name="itemID"></param>
+        /// <param name="RayEnd"></param>
+        /// <param name="RayStart"></param>
+        /// <param name="RayTargetID"></param>
+        /// <param name="BypassRayCast"></param>
+        /// <param name="RayEndIsIntersection"></param>
+        /// <param name="RezSelected"></param>
+        /// <param name="RemoveItem"></param>
+        /// <param name="fromTaskID"></param>
+        /// <param name="attachment"></param>
+        /// <returns>The SceneObjectGroup rezzed or null if rez was unsuccessful.</returns>
+        SceneObjectGroup RezObject(
+            IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart,
+            UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
+            bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment);
+
+        /// <summary>
+        /// Rez an object into the scene from the user's inventory
+        /// </summary>
+        /// <remarks>
+        /// FIXME: It would be really nice if inventory access modules didn't also actually do the work of rezzing
+        /// things to the scene.  The caller should be doing that, I think.
+        /// </remarks>
+        /// <param name="remoteClient"></param>
+        /// <param name="item">
+        /// The item from which the object asset came.  Can be null, in which case pre and post rez item adjustment and checks are not performed.
+        /// </param>
+        /// <param name="assetID">The asset id for the object to rez.</param>
+        /// <param name="RayEnd"></param>
+        /// <param name="RayStart"></param>
+        /// <param name="RayTargetID"></param>
+        /// <param name="BypassRayCast"></param>
+        /// <param name="RayEndIsIntersection"></param>
+        /// <param name="RezSelected"></param>
+        /// <param name="RemoveItem"></param>
+        /// <param name="fromTaskID"></param>
+        /// <param name="attachment"></param>
+        /// <returns>The SceneObjectGroup rezzed or null if rez was unsuccessful.</returns>
+        SceneObjectGroup RezObject(
+            IClientAPI remoteClient, InventoryItemBase item, UUID assetID, Vector3 RayEnd, Vector3 RayStart,
+            UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
+            bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment);
+
         void TransferInventoryAssets(InventoryItemBase item, UUID sender, UUID receiver);
 
         /// <summary>
diff --git a/OpenSim/Region/Framework/Interfaces/INPCModule.cs b/OpenSim/Region/Framework/Interfaces/INPCModule.cs
index 21a755f..5e5c4a1 100644
--- a/OpenSim/Region/Framework/Interfaces/INPCModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/INPCModule.cs
@@ -26,15 +26,80 @@
  */
 
 using OpenMetaverse;
+using OpenSim.Framework;
 using OpenSim.Region.Framework.Scenes;
 
 namespace OpenSim.Region.Framework.Interfaces
 {
     public interface INPCModule
     {
-        UUID CreateNPC(string firstname, string lastname, Vector3 position, Scene scene, UUID cloneAppearanceFrom);
-        void Autopilot(UUID agentID, Scene scene, Vector3 pos);
-        void Say(UUID agentID, Scene scene, string text);
-        void DeleteNPC(UUID agentID, Scene scene);
+        /// <summary>
+        /// Create an NPC
+        /// </summary>
+        /// <param name="firstname"></param>
+        /// <param name="lastname"></param>
+        /// <param name="position"></param>
+        /// <param name="scene"></param>
+        /// <param name="appearance">The avatar appearance to use for the new NPC.</param>
+        /// <returns>The UUID of the ScenePresence created.</returns>
+        UUID CreateNPC(string firstname, string lastname, Vector3 position, Scene scene, AvatarAppearance appearance);
+
+        /// <summary>
+        /// Check if the agent is an NPC.
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="scene"></param>
+        /// <returns>True if the agent is an NPC in the given scene.  False otherwise.</returns>
+        bool IsNPC(UUID agentID, Scene scene);
+
+        /// <summary>
+        /// Set the appearance for an NPC.
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="appearance"></param>
+        /// <param name="scene"></param>
+        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        bool SetNPCAppearance(UUID agentID, AvatarAppearance appearance, Scene scene);
+
+        /// <summary>
+        /// Move an NPC to a target over time.
+        /// </summary>
+        /// <param name="agentID">The UUID of the NPC</param>
+        /// <param name="scene"></param>
+        /// <param name="pos"></param>
+        /// <param name="noFly">
+        /// If true, then the avatar will attempt to walk to the location even if it's up in the air.
+        /// This is to allow walking on prims.
+        /// </param>
+        /// <param name="landAtTarget">
+        /// If true and the avatar is flying when it reaches the target, land.
+        /// </param>
+        /// <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);
+
+        /// <summary>
+        /// Stop the NPC's current movement.
+        /// </summary>
+        /// <param name="agentID">The UUID of the NPC</param>
+        /// <param name="scene"></param>
+        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        bool StopMoveToTarget(UUID agentID, Scene scene);
+
+        /// <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>
+        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        bool Say(UUID agentID, Scene scene, string text);
+
+        /// <summary>
+        /// Delete an NPC.
+        /// </summary>
+        /// <param name="agentID">The UUID of the NPC</param>
+        /// <param name="scene"></param>
+        /// <returns>True if the operation succeeded, false if there was no such agent or the agent was not an NPC</returns>
+        bool DeleteNPC(UUID agentID, Scene scene);
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IScenePresence.cs b/OpenSim/Region/Framework/Interfaces/IScenePresence.cs
new file mode 100644
index 0000000..8913133
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/IScenePresence.cs
@@ -0,0 +1,88 @@
+/*
+ * 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 OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.Framework.Interfaces
+{
+    /// <summary>
+    /// An agent in the scene.
+    /// </summary>
+    /// <remarks>
+    /// Interface is a work in progress.  Please feel free to add other required properties and methods.
+    /// </remarks>
+    public interface IScenePresence : ISceneEntity
+    {
+        /// <value>
+        /// The client controlling this presence
+        /// </value>
+        IClientAPI ControllingClient { get; }
+
+        /// <summary>
+        /// What type of presence is this?  User, NPC, etc.
+        /// </summary>
+        PresenceType PresenceType { get; }
+
+        /// <summary>
+        /// Avatar appearance data.
+        /// </summary>
+        /// <remarks>
+        // Because appearance setting is in a module, we actually need
+        // to give it access to our appearance directly, otherwise we
+        // get a synchronization issue.
+        /// </remarks>
+        AvatarAppearance Appearance { get; set; }
+
+        /// <summary>
+        /// The scene objects attached to this avatar.
+        /// </summary>
+        /// <returns>
+        /// A copy of the list.
+        /// </returns>
+        /// <remarks>
+        ///  Do not change this list directly - use the attachments module.
+        /// </remarks>
+        List<SceneObjectGroup> GetAttachments();
+
+        /// <summary>
+        /// The scene objects attached to this avatar at a specific attachment point.
+        /// </summary>
+        /// <param name="attachmentPoint"></param>
+        /// <returns></returns>
+        List<SceneObjectGroup> GetAttachments(uint attachmentPoint);
+
+        bool HasAttachments();
+
+        // Don't use these methods directly.  Instead, use the AttachmentsModule
+        void AddAttachment(SceneObjectGroup gobj);
+        void RemoveAttachment(SceneObjectGroup gobj);
+        void ClearAttachments();
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/ISimulatorFeaturesModule.cs b/OpenSim/Region/Framework/Interfaces/ISimulatorFeaturesModule.cs
new file mode 100644
index 0000000..8cef14e
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/ISimulatorFeaturesModule.cs
@@ -0,0 +1,43 @@
+/*
+ * 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 OpenMetaverse.StructuredData;
+
+namespace OpenSim.Region.Framework.Interfaces
+{
+    /// <summary>
+    /// Add remove or retrieve Simulator Features that will be given to a viewer via the SimulatorFeatures capability.
+    /// </summary>
+    public interface ISimulatorFeaturesModule
+    {
+        void AddFeature(string name, OSD value);
+        bool RemoveFeature(string name);
+        bool TryGetFeature(string name, out OSD value);
+        OSDMap GetFeatures();
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IUserManagement.cs b/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
index 5d30aa8..c66e053 100644
--- a/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
+++ b/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
@@ -5,13 +5,48 @@ using OpenMetaverse;
 
 namespace OpenSim.Region.Framework.Interfaces
 {
+    /// <summary>
+    /// This maintains the relationship between a UUID and a user name.
+    /// </summary>
     public interface IUserManagement
     {
         string GetUserName(UUID uuid);
         string GetUserHomeURL(UUID uuid);
         string GetUserUUI(UUID uuid);
         string GetUserServerURL(UUID uuid, string serverType);
-        void AddUser(UUID uuid, string userData);
+
+        /// <summary>
+        /// Add a user.
+        /// </summary>
+        /// <remarks>
+        /// If an account is found for the UUID, then the names in this will be used rather than any information
+        /// extracted from creatorData.
+        /// </remarks>
+        /// <param name="uuid"></param>
+        /// <param name="creatorData">The creator data for this user.</param>
+        void AddUser(UUID uuid, string creatorData);
+
+        /// <summary>
+        /// Add a user.
+        /// </summary>
+        /// <remarks>
+        /// The UUID is related to the name without any other checks being performed, such as user account presence.
+        /// </remarks>
+        /// <param name="uuid"></param>
+        /// <param name="firstName"></param>
+        /// <param name="lastName"></param>
+        void AddUser(UUID uuid, string firstName, string lastName);
+
+        /// <summary>
+        /// Add a user.
+        /// </summary>
+        /// <remarks>
+        /// The arguments apart from uuid are formed into a creatorData string and processing proceeds as for the
+        /// AddUser(UUID uuid, string creatorData) method.
+        /// </remarks>
+        /// <param name="uuid"></param>
+        /// <param name="firstName"></param>
+        /// <param name="profileURL"></param>
         void AddUser(UUID uuid, string firstName, string lastName, string profileURL);
     }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/IWorldComm.cs b/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
index 8da99a0..dafbf30 100644
--- a/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
+++ b/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
@@ -81,6 +81,26 @@ namespace OpenSim.Region.Framework.Interfaces
         void DeliverMessage(ChatTypeEnum type, int channel, string name, UUID id, string msg);
 
         /// <summary>
+        /// Delivers the message to a specified object in the region.
+        /// </summary>
+        /// <param name='target'>
+        /// Target.
+        /// </param>
+        /// <param name='channel'>
+        /// Channel.
+        /// </param>
+        /// <param name='name'>
+        /// Name.
+        /// </param>
+        /// <param name='id'>
+        /// Identifier.
+        /// </param>
+        /// <param name='msg'>
+        /// Message.
+        /// </param>
+        bool DeliverMessageTo(UUID target, int channel, Vector3 pos, string name, UUID id, string msg, out string error);
+
+        /// <summary>
         /// Are there any listen events ready to be dispatched?
         /// </summary>
         /// <returns>boolean indication</returns>
diff --git a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
index 9c103cb..4925175 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
@@ -27,6 +27,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Reflection;
+using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
@@ -40,6 +42,8 @@ namespace OpenSim.Region.Framework.Scenes.Animation
     /// </summary>
     public class ScenePresenceAnimator
     {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         public AnimationSet Animations
         {
             get { return m_animations;  }
@@ -79,6 +83,8 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             if (m_scenePresence.IsChildAgent)
                 return;
 
+//            m_log.DebugFormat("[SCENE PRESENCE ANIMATOR]: Adding animation {0} for {1}", animID, m_scenePresence.Name);
+
             if (m_animations.Add(animID, m_scenePresence.ControllingClient.NextAnimationSequenceNumber, objectID))
                 SendAnimPack();
         }
@@ -93,6 +99,8 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             if (animID == UUID.Zero)
                 return;
 
+//            m_log.DebugFormat("[SCENE PRESENCE ANIMATOR]: Adding animation {0} {1} for {2}", animID, name, m_scenePresence.Name);
+
             AddAnimation(animID, objectID);
         }
 
@@ -136,6 +144,10 @@ TrySetMovementAnimation("STAND");
                 if (m_animations.TrySetDefaultAnimation(
                     anim, m_scenePresence.ControllingClient.NextAnimationSequenceNumber, m_scenePresence.UUID))
                 {
+//                    m_log.DebugFormat(
+//                        "[SCENE PRESENCE ANIMATOR]: Updating movement animation to {0} for {1}",
+//                        anim, m_scenePresence.Name);
+
                     // 16384 is CHANGED_ANIMATION
                     m_scenePresence.SendScriptEventToAttachments("changed", new Object[] { (int)Changed.ANIMATION});
                     SendAnimPack();
@@ -353,7 +365,7 @@ TrySetMovementAnimation("STAND");
 /* This section removed, replaced by jumping section
             m_animTickFall = 0;
 
-            if (move.Z > 0f)
+            if (move.Z > 0.2f)
             {
                 // Jumping
                 if (!jumping)
diff --git a/OpenSim/Region/Framework/Scenes/AsyncInventorySender.cs b/OpenSim/Region/Framework/Scenes/AsyncInventorySender.cs
index 06cd14b..9cb5674 100644
--- a/OpenSim/Region/Framework/Scenes/AsyncInventorySender.cs
+++ b/OpenSim/Region/Framework/Scenes/AsyncInventorySender.cs
@@ -70,7 +70,7 @@ namespace OpenSim.Region.Framework.Scenes
     /// </remarks>
     public class AsyncInventorySender
     {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         protected Scene m_scene;
 
diff --git a/OpenSim/Region/Framework/Scenes/EntityBase.cs b/OpenSim/Region/Framework/Scenes/EntityBase.cs
index 6fd38e5..213431a 100644
--- a/OpenSim/Region/Framework/Scenes/EntityBase.cs
+++ b/OpenSim/Region/Framework/Scenes/EntityBase.cs
@@ -66,12 +66,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Signals whether this entity was in a scene but has since been removed from it.
         /// </summary>
-        public bool IsDeleted
-        {
-            get { return m_isDeleted; }
-            set { m_isDeleted = value; }
-        }
-        protected bool m_isDeleted;
+        public bool IsDeleted { get; protected internal set; }
 
         protected Vector3 m_pos;
 
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 3ec4e59..65c6a29 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -169,8 +169,7 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void AvatarEnteringNewParcel(ScenePresence avatar, int localLandID, UUID regionID);
         public event AvatarEnteringNewParcel OnAvatarEnteringNewParcel;
 
-        public delegate void SignificantClientMovement(IClientAPI remote_client);
-        public event SignificantClientMovement OnSignificantClientMovement;
+        public event Action<ScenePresence> OnSignificantClientMovement;
 
         public delegate void IncomingInstantMessage(GridInstantMessage message);
         public event IncomingInstantMessage OnIncomingInstantMessage;
@@ -1616,16 +1615,16 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void TriggerSignificantClientMovement(IClientAPI client)
+        public void TriggerSignificantClientMovement(ScenePresence presence)
         {
-            SignificantClientMovement handlerSignificantClientMovement = OnSignificantClientMovement;
+            Action<ScenePresence> handlerSignificantClientMovement = OnSignificantClientMovement;
             if (handlerSignificantClientMovement != null)
             {
-                foreach (SignificantClientMovement d in handlerSignificantClientMovement.GetInvocationList())
+                foreach (Action<ScenePresence> d in handlerSignificantClientMovement.GetInvocationList())
                 {
                     try
                     {
-                        d(client);
+                        d(presence);
                     }
                     catch (Exception e)
                     {
diff --git a/OpenSim/Region/Framework/Scenes/Prioritizer.cs b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
index 657df15..0a34a4c 100644
--- a/OpenSim/Region/Framework/Scenes/Prioritizer.cs
+++ b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
@@ -116,14 +116,13 @@ namespace OpenSim.Region.Framework.Scenes
             return priority;
         }
 
-
         private uint GetPriorityByTime(IClientAPI client, ISceneEntity entity)
         {
             // And anything attached to this avatar gets top priority as well
             if (entity is SceneObjectPart)
             {
                 SceneObjectPart sop = (SceneObjectPart)entity;
-                if (sop.ParentGroup.RootPart.IsAttachment && client.AgentId == sop.ParentGroup.RootPart.AttachedAvatar)
+                if (sop.ParentGroup.IsAttachment && client.AgentId == sop.ParentGroup.AttachedAvatar)
                     return 1;
             }
 
@@ -136,7 +135,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (entity is SceneObjectPart)
             {
                 SceneObjectPart sop = (SceneObjectPart)entity;
-                if (sop.ParentGroup.RootPart.IsAttachment && client.AgentId == sop.ParentGroup.RootPart.AttachedAvatar)
+                if (sop.ParentGroup.IsAttachment && client.AgentId == sop.ParentGroup.AttachedAvatar)
                     return 1;
             }
 
@@ -149,7 +148,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (entity is SceneObjectPart)
             {
                 SceneObjectPart sop = (SceneObjectPart)entity;
-                if (sop.ParentGroup.RootPart.IsAttachment && client.AgentId == sop.ParentGroup.RootPart.AttachedAvatar)
+                if (sop.ParentGroup.IsAttachment && client.AgentId == sop.ParentGroup.AttachedAvatar)
                     return 1;
             }
 
@@ -172,7 +171,7 @@ namespace OpenSim.Region.Framework.Scenes
                     if (entity is SceneObjectPart)
                     {
                         // Attachments are high priority, 
-                        if (((SceneObjectPart)entity).ParentGroup.RootPart.IsAttachment)
+                        if (((SceneObjectPart)entity).ParentGroup.IsAttachment)
                             return 1;
 
                         // Non physical prims are lower priority than physical prims
@@ -209,8 +208,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (entity is SceneObjectPart)
             {
                 SceneObjectGroup group = (entity as SceneObjectPart).ParentGroup;
-                if (group != null)
-                    entityPos = group.AbsolutePosition;
+                entityPos = group.AbsolutePosition;
             }
 
             // Use the camera position for local agents and avatar position for remote agents
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index dbefb4a..89f3683 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -211,16 +211,10 @@ namespace OpenSim.Region.Framework.Scenes
 
             // Retrieve group
             SceneObjectPart part = GetSceneObjectPart(primId);
-            SceneObjectGroup group = part.ParentGroup;
-            if (null == group)
-            {
-                m_log.ErrorFormat(
-                    "[PRIM INVENTORY]: " +
-                    "Prim inventory update requested for item ID {0} in prim ID {1} but this prim does not exist",
-                    itemId, primId);
-
+            if (part == null)
                 return new ArrayList();
-            }
+
+            SceneObjectGroup group = part.ParentGroup;
 
             // Retrieve item
             TaskInventoryItem item = group.GetInventoryItem(part.LocalId, itemId);
@@ -709,7 +703,10 @@ namespace OpenSim.Region.Framework.Scenes
                     newName = item.Name;
                 }
 
-                if (remoteClient.AgentId == oldAgentID || (LibraryService != null && LibraryService.LibraryRootFolder != null && oldAgentID == LibraryService.LibraryRootFolder.Owner))
+                if (remoteClient.AgentId == oldAgentID
+                    || (LibraryService != null
+                        && LibraryService.LibraryRootFolder != null
+                        && oldAgentID == LibraryService.LibraryRootFolder.Owner))
                 {
                     CreateNewInventoryItem(
                         remoteClient, item.CreatorId, item.CreatorData, newFolderID, newName, item.Flags, callbackID, asset, (sbyte)item.InvType,
@@ -981,23 +978,14 @@ namespace OpenSim.Region.Framework.Scenes
                 if (item == null)
                     return;
 
-                if (item.Type == 10)
-                {
-                    part.RemoveScriptEvents(itemID);
-                    EventManager.TriggerRemoveScript(localID, itemID);
-                }
-                
-                group.RemoveInventoryItem(localID, itemID);
-                part.GetProperties(remoteClient);
-            }
-            else
+            if (item.Type == 10)
             {
-                m_log.ErrorFormat(
-                    "[PRIM INVENTORY]: " +
-                    "Removal of item {0} requested of prim {1} but this prim does not exist",
-                    itemID,
-                    localID);
+                part.RemoveScriptEvents(itemID);
+                EventManager.TriggerRemoveScript(localID, itemID);
             }
+            
+            group.RemoveInventoryItem(localID, itemID);
+            part.GetProperties(remoteClient);
         }
 
         private InventoryItemBase CreateAgentInventoryItemFromTask(UUID destAgent, SceneObjectPart part, UUID itemId)
@@ -1780,7 +1768,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
                 // Already deleted by someone else
-                if (part.ParentGroup == null || part.ParentGroup.IsDeleted)
+                if (part.ParentGroup.IsDeleted)
                 {
                     //Client still thinks the object exists, kill it
                     deleteIDs.Add(localID);
@@ -2158,6 +2146,9 @@ namespace OpenSim.Region.Framework.Scenes
             foreach (uint localID in localIDs)
             {
                 SceneObjectPart part = GetSceneObjectPart(localID);
+                    if (part == null)
+                        continue;
+
                 if (!groups.Contains(part.ParentGroup))
                     groups.Add(part.ParentGroup);
             }
@@ -2203,6 +2194,8 @@ namespace OpenSim.Region.Framework.Scenes
             foreach (uint localID in localIDs)
             {
                 SceneObjectPart part = GetSceneObjectPart(localID);
+                    if (part == null)
+                        continue;
                 part.GetProperties(remoteClient);
             }
         }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index 9bef443..9da57a8 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -191,10 +191,6 @@ namespace OpenSim.Region.Framework.Scenes
             if (part == null)
                 return;
             
-            // The prim is in the process of being deleted.
-            if (null == part.ParentGroup.RootPart)
-                return;
-            
             // A deselect packet contains all the local prims being deselected.  However, since selection is still
             // group based we only want the root prim to trigger a full update - otherwise on objects with many prims
             // we end up sending many duplicate ObjectUpdates
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index ec82cc3..26fe61d 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -635,6 +635,10 @@ namespace OpenSim.Region.Framework.Scenes
                                           "delete object name <name>",
                                           "Delete object by name", HandleDeleteObject);
 
+            MainConsole.Instance.Commands.AddCommand("region", false, "delete object outside",
+                                          "delete object outside",
+                                          "Delete all objects outside boundaries", HandleDeleteObject);
+
             //Bind Storage Manager functions to some land manager functions for this scene
             EventManager.OnLandObjectAdded +=
                 new EventManager.LandObjectAdded(simDataService.StoreLandObject);
@@ -1703,20 +1707,20 @@ namespace OpenSim.Region.Framework.Scenes
 
             m_sceneGridService.SetScene(this);
 
-            // If we generate maptiles internally at all, the maptile generator
-            // will register the region. If not, do it here
-            if (m_generateMaptiles)
+            GridRegion region = new GridRegion(RegionInfo);
+            string error = GridService.RegisterRegion(RegionInfo.ScopeID, region);
+            if (error != String.Empty)
             {
-                RegenerateMaptile(null, null);
+                throw new Exception(error);
             }
-            else
+
+            // Generate the maptile asynchronously, because sometimes it can be very slow and we
+            // don't want this to delay starting the region.
+            if (m_generateMaptiles)
             {
-                GridRegion region = new GridRegion(RegionInfo);
-                string error = GridService.RegisterRegion(RegionInfo.ScopeID, region);
-                if (error != String.Empty)
-                {
-                    throw new Exception(error);
-                }
+                Util.FireAndForget(delegate {
+                    RegenerateMaptile(null, null);
+                });
             }
         }
 
@@ -1757,6 +1761,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Loads the World's objects
         /// </summary>
+        /// <param name="regionID"></param>
         public virtual void LoadPrimsFromStorage(UUID regionID)
         {
             LoadingPrims = true;
@@ -1769,20 +1774,13 @@ namespace OpenSim.Region.Framework.Scenes
             foreach (SceneObjectGroup group in PrimsFromDB)
             {
                 EventManager.TriggerOnSceneObjectLoaded(group);
-                
-                if (group.RootPart == null)
-                {
-                    m_log.ErrorFormat(
-                        "[SCENE]: Found a SceneObjectGroup with m_rootPart == null and {0} children",
-                        group.Parts == null ? 0 : group.PrimCount);
-                }
-
                 AddRestoredSceneObject(group, true, true);
                 SceneObjectPart rootPart = group.GetChildPart(group.UUID);
                 rootPart.Flags &= ~PrimFlags.Scripted;
                 rootPart.TrimPermissions();
-                group.CheckSculptAndLoad();
-                //rootPart.DoPhysicsPropertyUpdate(UsePhysics, true);
+
+                // Don't do this here - it will get done later on when sculpt data is loaded.
+//                group.CheckSculptAndLoad();
             }
 
             m_log.Info("[SCENE]: Loaded " + PrimsFromDB.Count.ToString() + " SceneObject(s)");
@@ -2643,10 +2641,11 @@ namespace OpenSim.Region.Framework.Scenes
         #region Add/Remove Avatar Methods
 
         /// <summary>
-        /// Adding a New Client and Create a Presence for it.
+        /// Add a new client and create a child agent for it.
         /// </summary>
         /// <param name="client"></param>
-        public override void AddNewClient(IClientAPI client)
+        /// <param name="type">The type of agent to add.</param>
+        public override void AddNewClient(IClientAPI client, PresenceType type)
         {
             AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(client.CircuitCode);
             bool vialogin = false;
@@ -2667,7 +2666,7 @@ namespace OpenSim.Region.Framework.Scenes
                 m_clientManager.Add(client);
                 SubscribeToClientEvents(client);
 
-                ScenePresence sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance);
+                ScenePresence sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
                 m_eventManager.TriggerOnNewPresence(sp);
 
                 sp.TeleportFlags = (TeleportFlags)aCircuit.teleportFlags;
@@ -2678,16 +2677,17 @@ namespace OpenSim.Region.Framework.Scenes
                 if (aCircuit.child == false)
                 {
                     sp.IsChildAgent = false;
-                    Util.FireAndForget(delegate(object o) { sp.RezAttachments(); });
+                    Util.FireAndForget(delegate(object o) { AttachmentsModule.RezAttachments(sp); });
                 }
             }
 
-            if (TryGetScenePresence(client.AgentId, out presence))
+            ScenePresence createdSp = GetScenePresence(client.AgentId);
+            if (createdSp != null)
             {
                 m_LastLogin = Util.EnvironmentTickCount();
 
                 // Cache the user's name
-                CacheUserName(aCircuit);
+                CacheUserName(createdSp, aCircuit);
 
                 EventManager.TriggerOnNewClient(client);
                 if (vialogin)
@@ -2702,28 +2702,41 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        private void CacheUserName(AgentCircuitData aCircuit)
+        /// <summary>
+        /// Cache the user name for later use.
+        /// </summary>
+        /// <param name="sp"></param>
+        /// <param name="aCircuit"></param>
+        private void CacheUserName(ScenePresence sp, AgentCircuitData aCircuit)
         {
             IUserManagement uMan = RequestModuleInterface<IUserManagement>();
             if (uMan != null)
             {
-                string homeURL = string.Empty;
                 string first = aCircuit.firstname, last = aCircuit.lastname;
 
-                if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
-                    homeURL = aCircuit.ServiceURLs["HomeURI"].ToString();
-
-                if (aCircuit.lastname.StartsWith("@"))
+                if (sp.PresenceType == PresenceType.Npc)
+                {
+                    uMan.AddUser(aCircuit.AgentID, first, last);
+                }
+                else
                 {
-                    string[] parts = aCircuit.firstname.Split('.');
-                    if (parts.Length >= 2)
+                    string homeURL = string.Empty;
+
+                    if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
+                        homeURL = aCircuit.ServiceURLs["HomeURI"].ToString();
+
+                    if (aCircuit.lastname.StartsWith("@"))
                     {
-                        first = parts[0];
-                        last = parts[1];
+                        string[] parts = aCircuit.firstname.Split('.');
+                        if (parts.Length >= 2)
+                        {
+                            first = parts[0];
+                            last = parts[1];
+                        }
                     }
-                }
 
-                uMan.AddUser(aCircuit.AgentID, first, last, homeURL);
+                    uMan.AddUser(aCircuit.AgentID, first, last, homeURL);
+                }
             }
         }
 
@@ -2821,12 +2834,14 @@ namespace OpenSim.Region.Framework.Scenes
         
         public virtual void SubscribeToClientPrimEvents(IClientAPI client)
         {
-            client.OnUpdatePrimGroupPosition += m_sceneGraph.UpdatePrimPosition;
+            client.OnUpdatePrimGroupPosition += m_sceneGraph.UpdatePrimGroupPosition;
             client.OnUpdatePrimSinglePosition += m_sceneGraph.UpdatePrimSinglePosition;
-            client.OnUpdatePrimGroupRotation += m_sceneGraph.UpdatePrimRotation;
-            client.OnUpdatePrimGroupMouseRotation += m_sceneGraph.UpdatePrimRotation;
+
+            client.OnUpdatePrimGroupRotation += m_sceneGraph.UpdatePrimGroupRotation;
+            client.OnUpdatePrimGroupMouseRotation += m_sceneGraph.UpdatePrimGroupRotation;
             client.OnUpdatePrimSingleRotation += m_sceneGraph.UpdatePrimSingleRotation;
             client.OnUpdatePrimSingleRotationPosition += m_sceneGraph.UpdatePrimSingleRotationPosition;
+            
             client.OnUpdatePrimScale += m_sceneGraph.UpdatePrimScale;
             client.OnUpdatePrimGroupScale += m_sceneGraph.UpdatePrimGroupScale;
             client.OnUpdateExtraParams += m_sceneGraph.UpdateExtraParam;
@@ -2856,7 +2871,6 @@ namespace OpenSim.Region.Framework.Scenes
             client.OnUndo += m_sceneGraph.HandleUndo;
             client.OnRedo += m_sceneGraph.HandleRedo;
             client.OnObjectDescription += m_sceneGraph.PrimDescription;
-            client.OnObjectDrop += m_sceneGraph.DropObject;
             client.OnObjectIncludeInSearch += m_sceneGraph.MakeObjectSearchable;
             client.OnObjectOwner += ObjectOwner;
         }
@@ -2949,12 +2963,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         public virtual void UnSubscribeToClientPrimEvents(IClientAPI client)
         {
-            client.OnUpdatePrimGroupPosition -= m_sceneGraph.UpdatePrimPosition;
+            client.OnUpdatePrimGroupPosition -= m_sceneGraph.UpdatePrimGroupPosition;
             client.OnUpdatePrimSinglePosition -= m_sceneGraph.UpdatePrimSinglePosition;
-            client.OnUpdatePrimGroupRotation -= m_sceneGraph.UpdatePrimRotation;
-            client.OnUpdatePrimGroupMouseRotation -= m_sceneGraph.UpdatePrimRotation;
+
+            client.OnUpdatePrimGroupRotation -= m_sceneGraph.UpdatePrimGroupRotation;
+            client.OnUpdatePrimGroupMouseRotation -= m_sceneGraph.UpdatePrimGroupRotation;
             client.OnUpdatePrimSingleRotation -= m_sceneGraph.UpdatePrimSingleRotation;
             client.OnUpdatePrimSingleRotationPosition -= m_sceneGraph.UpdatePrimSingleRotationPosition;
+
             client.OnUpdatePrimScale -= m_sceneGraph.UpdatePrimScale;
             client.OnUpdatePrimGroupScale -= m_sceneGraph.UpdatePrimGroupScale;
             client.OnUpdateExtraParams -= m_sceneGraph.UpdateExtraParam;
@@ -2982,7 +2998,6 @@ namespace OpenSim.Region.Framework.Scenes
             client.OnUndo -= m_sceneGraph.HandleUndo;
             client.OnRedo -= m_sceneGraph.HandleRedo;
             client.OnObjectDescription -= m_sceneGraph.PrimDescription;
-            client.OnObjectDrop -= m_sceneGraph.DropObject;
             client.OnObjectIncludeInSearch -= m_sceneGraph.MakeObjectSearchable;
             client.OnObjectOwner -= ObjectOwner;
         }
@@ -3098,58 +3113,51 @@ namespace OpenSim.Region.Framework.Scenes
                 Vector3 AXOrigin = new Vector3(RayStart.X, RayStart.Y, RayStart.Z);
                 Vector3 AXdirection = new Vector3(direction.X, direction.Y, direction.Z);
 
-                if (target2.ParentGroup != null)
-                {
-                    pos = target2.AbsolutePosition;
-                    //m_log.Info("[OBJECT_REZ]: TargetPos: " + pos.ToString() + ", RayStart: " + RayStart.ToString() + ", RayEnd: " + RayEnd.ToString() + ", Volume: " + Util.GetDistanceTo(RayStart,RayEnd).ToString() + ", mag1: " + Util.GetMagnitude(RayStart).ToString() + ", mag2: " + Util.GetMagnitude(RayEnd).ToString());
+                pos = target2.AbsolutePosition;
+                //m_log.Info("[OBJECT_REZ]: TargetPos: " + pos.ToString() + ", RayStart: " + RayStart.ToString() + ", RayEnd: " + RayEnd.ToString() + ", Volume: " + Util.GetDistanceTo(RayStart,RayEnd).ToString() + ", mag1: " + Util.GetMagnitude(RayStart).ToString() + ", mag2: " + Util.GetMagnitude(RayEnd).ToString());
 
-                    // TODO: Raytrace better here
+                // TODO: Raytrace better here
 
-                    //EntityIntersection ei = m_sceneGraph.GetClosestIntersectingPrim(new Ray(AXOrigin, AXdirection));
-                    Ray NewRay = new Ray(AXOrigin, AXdirection);
+                //EntityIntersection ei = m_sceneGraph.GetClosestIntersectingPrim(new Ray(AXOrigin, AXdirection));
+                Ray NewRay = new Ray(AXOrigin, AXdirection);
 
-                    // Ray Trace against target here
-                    EntityIntersection ei = target2.TestIntersectionOBB(NewRay, Quaternion.Identity, frontFacesOnly, CopyCenters);
+                // Ray Trace against target here
+                EntityIntersection ei = target2.TestIntersectionOBB(NewRay, Quaternion.Identity, frontFacesOnly, CopyCenters);
 
-                    // Un-comment out the following line to Get Raytrace results printed to the console.
-                    //m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
-                    float ScaleOffset = 0.5f;
+                // Un-comment out the following line to Get Raytrace results printed to the console.
+                //m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
+                float ScaleOffset = 0.5f;
 
-                    // If we hit something
-                    if (ei.HitTF)
-                    {
-                        Vector3 scale = target.Scale;
-                        Vector3 scaleComponent = new Vector3(ei.AAfaceNormal.X, ei.AAfaceNormal.Y, ei.AAfaceNormal.Z);
-                        if (scaleComponent.X != 0) ScaleOffset = scale.X;
-                        if (scaleComponent.Y != 0) ScaleOffset = scale.Y;
-                        if (scaleComponent.Z != 0) ScaleOffset = scale.Z;
-                        ScaleOffset = Math.Abs(ScaleOffset);
-                        Vector3 intersectionpoint = new Vector3(ei.ipoint.X, ei.ipoint.Y, ei.ipoint.Z);
-                        Vector3 normal = new Vector3(ei.normal.X, ei.normal.Y, ei.normal.Z);
-                        Vector3 offset = normal * (ScaleOffset / 2f);
-                        pos = intersectionpoint + offset;
+                // If we hit something
+                if (ei.HitTF)
+                {
+                    Vector3 scale = target.Scale;
+                    Vector3 scaleComponent = new Vector3(ei.AAfaceNormal.X, ei.AAfaceNormal.Y, ei.AAfaceNormal.Z);
+                    if (scaleComponent.X != 0) ScaleOffset = scale.X;
+                    if (scaleComponent.Y != 0) ScaleOffset = scale.Y;
+                    if (scaleComponent.Z != 0) ScaleOffset = scale.Z;
+                    ScaleOffset = Math.Abs(ScaleOffset);
+                    Vector3 intersectionpoint = new Vector3(ei.ipoint.X, ei.ipoint.Y, ei.ipoint.Z);
+                    Vector3 normal = new Vector3(ei.normal.X, ei.normal.Y, ei.normal.Z);
+                    Vector3 offset = normal * (ScaleOffset / 2f);
+                    pos = intersectionpoint + offset;
 
-                        // stick in offset format from the original prim
-                        pos = pos - target.ParentGroup.AbsolutePosition;
-                        if (CopyRotates)
-                        {
-                            Quaternion worldRot = target2.GetWorldRotation();
+                    // stick in offset format from the original prim
+                    pos = pos - target.ParentGroup.AbsolutePosition;
+                    if (CopyRotates)
+                    {
+                        Quaternion worldRot = target2.GetWorldRotation();
 
-                            // SceneObjectGroup obj = m_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
-                            m_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
-                            //obj.Rotation = worldRot;
-                            //obj.UpdateGroupRotationR(worldRot);
-                        }
-                        else
-                        {
-                            m_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID);
-                        }
+                        // SceneObjectGroup obj = m_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
+                        m_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
+                        //obj.Rotation = worldRot;
+                        //obj.UpdateGroupRotationR(worldRot);
+                    }
+                    else
+                    {
+                        m_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID);
                     }
-
-                    return;
                 }
-
-                return;
             }
         }
 
@@ -3192,7 +3200,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (aCircuit == null)
             {
                 m_log.DebugFormat("[APPEARANCE] Client did not supply a circuit. Non-Linden? Creating default appearance.");
-                appearance = new AvatarAppearance(client.AgentId);
+                appearance = new AvatarAppearance();
                 return;
             }
 
@@ -3200,15 +3208,11 @@ namespace OpenSim.Region.Framework.Scenes
             if (appearance == null)
             {
                 m_log.DebugFormat("[APPEARANCE]: Appearance not found in {0}, returning default", RegionInfo.RegionName);
-                appearance = new AvatarAppearance(client.AgentId);
+                appearance = new AvatarAppearance();
             }
         }
 
-        /// <summary>
-        /// Remove the given client from the scene.
-        /// </summary>
-        /// <param name="agentID"></param>
-        public override void RemoveClient(UUID agentID)
+        public override void RemoveClient(UUID agentID, bool closeChildAgents)
         {
             CheckHeartbeat();
             bool childagentYN = false;
@@ -3229,15 +3233,17 @@ namespace OpenSim.Region.Framework.Scenes
                         (childagentYN ? "child" : "root"), agentID, RegionInfo.RegionName);
 
                     m_sceneGraph.removeUserCount(!childagentYN);
-                    
-                    if (CapsModule != null)
+
+                    // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
+                    // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
+                    if (closeChildAgents && CapsModule != null)
                         CapsModule.RemoveCaps(agentID);
 
                     // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
                     // this method is doing is HORRIBLE!!!
                     avatar.Scene.NeedSceneCacheClear(avatar.UUID);
 
-                    if (!avatar.IsChildAgent)
+                    if (closeChildAgents && !avatar.IsChildAgent)
                     {
                         //List<ulong> childknownRegions = new List<ulong>();
                         //List<ulong> ckn = avatar.KnownChildRegionHandles;
@@ -3263,8 +3269,8 @@ namespace OpenSim.Region.Framework.Scenes
                 m_eventManager.TriggerOnRemovePresence(agentID);
                 m_log.Debug("[Scene] Finished OnRemovePresence");
 
-                if (avatar != null && (!avatar.IsChildAgent))
-                    avatar.SaveChangedAttachments();
+                if (AttachmentsModule != null && !avatar.IsChildAgent && avatar.PresenceType != PresenceType.Npc)
+                    AttachmentsModule.SaveChangedAttachments(avatar);
 
                 if (avatar != null && (!avatar.IsChildAgent))
                     avatar.SaveChangedAttachments();
@@ -3304,7 +3310,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 m_log.Debug("[Scene] Done. Firing RemoveCircuit");
                 m_authenticateHandler.RemoveCircuit(avatar.ControllingClient.CircuitCode);
-                CleanDroppedAttachments();
+//                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));
@@ -3540,7 +3546,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (vialogin) 
             {
-                CleanDroppedAttachments();
+//                CleanDroppedAttachments();
 
                 if (TestBorderCross(agent.startpos, Cardinals.E))
                 {
@@ -3699,11 +3705,12 @@ namespace OpenSim.Region.Framework.Scenes
                       
             if (AuthorizationService != null)
             {
-                if (!AuthorizationService.IsAuthorizedForRegion(agentID.ToString(), RegionInfo.RegionID.ToString(),out reason))
+                if (!AuthorizationService.IsAuthorizedForRegion(
+                    agent.AgentID.ToString(), agent.firstname, agent.lastname, RegionInfo.RegionID.ToString(), out reason))
                 {
                     m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} at {1} because the user does not have access to the region",
                                      agentID, RegionInfo.RegionName);
-                    //reason = String.Format("You are not currently on the access list for {0}",RegionInfo.RegionName);
+                    
                     return false;
                 }
             }
@@ -4033,8 +4040,11 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Tries to teleport agent to other region.
+        /// Tries to teleport agent to another region.
         /// </summary>
+        /// <remarks>
+        /// The region name must exactly match that given.
+        /// </remarks>
         /// <param name="remoteClient"></param>
         /// <param name="regionName"></param>
         /// <param name="position"></param>
@@ -4043,15 +4053,16 @@ namespace OpenSim.Region.Framework.Scenes
         public void RequestTeleportLocation(IClientAPI remoteClient, string regionName, Vector3 position,
                                             Vector3 lookat, uint teleportFlags)
         {
-            List<GridRegion> regions = GridService.GetRegionsByName(RegionInfo.ScopeID, regionName, 1);
-            if (regions == null || regions.Count == 0)
+            GridRegion region = GridService.GetRegionByName(RegionInfo.ScopeID, regionName);
+
+            if (region == null)
             {
                 // can't find the region: Tell viewer and abort
                 remoteClient.SendTeleportFailed("The region '" + regionName + "' could not be found.");
                 return;
             }
 
-            RequestTeleportLocation(remoteClient, regions[0].RegionHandle, position, lookat, teleportFlags);
+            RequestTeleportLocation(remoteClient, region.RegionHandle, position, lookat, teleportFlags);
         }
 
         /// <summary>
@@ -4353,7 +4364,7 @@ namespace OpenSim.Region.Framework.Scenes
                 //  their scripts will actually run.
                 //      -- Leaf, Tue Aug 12 14:17:05 EDT 2008
                 SceneObjectPart parent = part.ParentGroup.RootPart;
-                if (parent != null && parent.IsAttachment)
+                if (part.ParentGroup.IsAttachment)
                     return ScriptDanger(parent, parent.GetWorldPosition());
                 else
                     return ScriptDanger(part, part.GetWorldPosition());
@@ -5122,11 +5133,19 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void HandleDeleteObject(string module, string[] cmd)
         {
-            if (cmd.Length < 4)
+            if (cmd.Length < 3)
                 return;
 
             string mode = cmd[2];
-            string o = cmd[3];
+            string o = "";
+
+            if (mode != "outside")
+            {
+                if (cmd.Length < 4)
+                    return;
+
+                o = cmd[3];
+            }
 
             List<SceneObjectGroup> deletes = new List<SceneObjectGroup>();
 
@@ -5168,10 +5187,35 @@ namespace OpenSim.Region.Framework.Scenes
                                 deletes.Add(g);
                         });
                 break;
+            case "outside":
+                ForEachSOG(delegate (SceneObjectGroup g)
+                        {
+                            SceneObjectPart rootPart = g.RootPart;
+                            bool delete = false;
+
+                            if (rootPart.GroupPosition.Z < 0.0 || rootPart.GroupPosition.Z > 10000.0)
+                            {
+                                delete = true;
+                            }
+                            else
+                            {
+                                ILandObject parcel = LandChannel.GetLandObject(rootPart.GroupPosition.X, rootPart.GroupPosition.Y);
+
+                                if (parcel == null || parcel.LandData.Name == "NO LAND")
+                                    delete = true;
+                            }
+
+                            if (delete && !g.IsAttachment && !deletes.Contains(g))
+                                deletes.Add(g);
+                        });
+                break;
             }
 
             foreach (SceneObjectGroup g in deletes)
+            {
+                m_log.InfoFormat("[SCENE]: Deleting object {0}", g.UUID);
                 DeleteSceneObject(g, false);
+            }
         }
 
         private void HandleReloadEstate(string module, string[] cmd)
@@ -5268,10 +5312,40 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void CleanDroppedAttachments()
-        {
-            List<SceneObjectGroup> objectsToDelete =
-                    new List<SceneObjectGroup>();
+//        public void CleanDroppedAttachments()
+//        {
+//            List<SceneObjectGroup> objectsToDelete =
+//                    new List<SceneObjectGroup>();
+//
+//            lock (m_cleaningAttachments)
+//            {
+//                ForEachSOG(delegate (SceneObjectGroup grp)
+//                        {
+//                            if (grp.RootPart.Shape.PCode == 0 && grp.RootPart.Shape.State != 0 && (!objectsToDelete.Contains(grp)))
+//                            {
+//                                UUID agentID = grp.OwnerID;
+//                                if (agentID == UUID.Zero)
+//                                {
+//                                    objectsToDelete.Add(grp);
+//                                    return;
+//                                }
+//
+//                                ScenePresence sp = GetScenePresence(agentID);
+//                                if (sp == null)
+//                                {
+//                                    objectsToDelete.Add(grp);
+//                                    return;
+//                                }
+//                            }
+//                        });
+//            }
+//
+//            foreach (SceneObjectGroup grp in objectsToDelete)
+//            {
+//                m_log.InfoFormat("[SCENE]: Deleting dropped attachment {0} of user {1}", grp.UUID, grp.OwnerID);
+//                DeleteSceneObject(grp, true);
+//            }
+//        }
 
             lock (m_cleaningAttachments)
             {
diff --git a/OpenSim/Region/Framework/Scenes/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index f343bc8..bf861b8 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -177,18 +177,8 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region Add/Remove Agent/Avatar
 
-        /// <summary>
-        /// Register the new client with the scene.  The client starts off as a child agent - the later agent crossing
-        /// will promote it to a root agent during login.
-        /// </summary>
-        /// <param name="client"></param
-        public abstract void AddNewClient(IClientAPI client);
-
-        /// <summary>
-        /// Remove a client from the scene
-        /// </summary>
-        /// <param name="agentID"></param>
-        public abstract void RemoveClient(UUID agentID);
+        public abstract void AddNewClient(IClientAPI client, PresenceType type);
+        public abstract void RemoveClient(UUID agentID, bool closeChildAgents);
 
         public bool TryGetScenePresence(UUID agentID, out object scenePresence)
         {
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index 39d4a29..29edf13 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -403,7 +403,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </returns>
         protected bool AddSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, bool sendClientUpdates)
         {
-            if (sceneObject == null || sceneObject.RootPart == null || sceneObject.RootPart.UUID == UUID.Zero)
+            if (sceneObject == null || sceneObject.RootPart.UUID == UUID.Zero)
                 return false;
 
             if (Entities.ContainsKey(sceneObject.UUID))
@@ -613,13 +613,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_activeScripts += number;
         }
 
-        public void DropObject(uint objectLocalID, IClientAPI remoteClient)
-        {
-            SceneObjectGroup group = GetGroupByPrim(objectLocalID);
-            if (group != null)
-                m_parentScene.AttachmentsModule.DetachSingleAttachmentToGround(group.UUID, remoteClient);
-        }
-
         protected internal void HandleUndo(IClientAPI remoteClient, UUID primId)
         {
             if (primId != UUID.Zero)
@@ -629,11 +622,13 @@ namespace OpenSim.Region.Framework.Scenes
                     part.Undo();
             }
         }
+
         protected internal void HandleRedo(IClientAPI remoteClient, UUID primId)
         {
             if (primId != UUID.Zero)
             {
                 SceneObjectPart part = m_parentScene.GetSceneObjectPart(primId);
+
                 if (part != null)
                     part.Redo();
             }
@@ -653,12 +648,13 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        protected internal ScenePresence CreateAndAddChildScenePresence(IClientAPI client, AvatarAppearance appearance)
+        protected internal ScenePresence CreateAndAddChildScenePresence(
+            IClientAPI client, AvatarAppearance appearance, PresenceType type)
         {
             ScenePresence newAvatar = null;
 
             // ScenePresence always defaults to child agent
-            newAvatar = new ScenePresence(client, m_parentScene, m_regInfo, appearance);
+            newAvatar = new ScenePresence(client, m_parentScene, m_regInfo, appearance, type);
 
             AddScenePresence(newAvatar);
 
@@ -1285,19 +1281,20 @@ namespace OpenSim.Region.Framework.Scenes
         #region Client Event handlers
 
         /// <summary>
-        ///
+        /// Update the scale of an individual prim.
         /// </summary>
         /// <param name="localID"></param>
         /// <param name="scale"></param>
         /// <param name="remoteClient"></param>
         protected internal void UpdatePrimScale(uint localID, Vector3 scale, IClientAPI remoteClient)
         {
-            SceneObjectGroup group = GetGroupByPrim(localID);
-            if (group != null)
+            SceneObjectPart part = GetSceneObjectPart(localID);
+
+            if (part != null)
             {
-                if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(part.ParentGroup.UUID, remoteClient.AgentId))
                 {
-                    group.Resize(scale, localID);
+                    part.Resize(scale);
                 }
             }
         }
@@ -1309,7 +1306,7 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
-                    group.GroupResize(scale, localID);
+                    group.GroupResize(scale);
                 }
             }
         }
@@ -1363,19 +1360,18 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId))
                 {
-                    group.UpdateSingleRotation(rot,pos, localID);
+                    group.UpdateSingleRotation(rot, pos, localID);
                 }
             }
         }
 
-
         /// <summary>
-        ///
+        /// Update the rotation of a whole group.
         /// </summary>
         /// <param name="localID"></param>
         /// <param name="rot"></param>
         /// <param name="remoteClient"></param>
-        protected internal void UpdatePrimRotation(uint localID, Quaternion rot, IClientAPI remoteClient)
+        protected internal void UpdatePrimGroupRotation(uint localID, Quaternion rot, IClientAPI remoteClient)
         {
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
@@ -1394,7 +1390,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="pos"></param>
         /// <param name="rot"></param>
         /// <param name="remoteClient"></param>
-        protected internal void UpdatePrimRotation(uint localID, Vector3 pos, Quaternion rot, IClientAPI remoteClient)
+        protected internal void UpdatePrimGroupRotation(uint localID, Vector3 pos, Quaternion rot, IClientAPI remoteClient)
         {
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
@@ -1425,12 +1421,12 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Update the position of the given part
+        /// Update the position of the given group.
         /// </summary>
         /// <param name="localID"></param>
         /// <param name="pos"></param>
         /// <param name="remoteClient"></param>
-        public void UpdatePrimPosition(uint localID, Vector3 pos, IClientAPI remoteClient)
+        public void UpdatePrimGroupPosition(uint localID, Vector3 pos, IClientAPI remoteClient)
         {
             SceneObjectGroup group = GetGroupByPrim(localID);
             
@@ -1481,21 +1477,26 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        ///
+        /// Update the flags on a scene object.  This covers properties such as phantom, physics and temporary.
         /// </summary>
+        /// <remarks>
+        /// This is currently handling the incoming call from the client stack (e.g. LLClientView).
+        /// </remarks>
         /// <param name="localID"></param>
-        /// <param name="packet"></param>
+        /// <param name="UsePhysics"></param>
+        /// <param name="SetTemporary"></param>
+        /// <param name="SetPhantom"></param>
         /// <param name="remoteClient"></param>
-        /// This routine seems to get called when a user changes object settings in the viewer.
-        /// If some one can confirm that, please change the comment according.
-        protected internal void UpdatePrimFlags(uint localID, bool UsePhysics, bool IsTemporary, bool IsPhantom, IClientAPI remoteClient)
+        protected internal void UpdatePrimFlags(
+            uint localID, bool UsePhysics, bool SetTemporary, bool SetPhantom, IClientAPI remoteClient)
         {
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
                 if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
-                    group.UpdatePrimFlags(localID, UsePhysics, IsTemporary, IsPhantom, false); // VolumeDetect can't be set via UI and will always be off when a change is made there
+                    // VolumeDetect can't be set via UI and will always be off when a change is made there
+                    group.UpdatePrimFlags(localID, UsePhysics, SetTemporary, SetPhantom, false);
                 }
             }
         }
@@ -1618,8 +1619,11 @@ namespace OpenSim.Region.Framework.Scenes
                 if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     SceneObjectPart part = m_parentScene.GetSceneObjectPart(primLocalID);
-                    part.ClickAction = Convert.ToByte(clickAction);
-                    group.HasGroupChanged = true;
+                    if (part != null)
+                    {
+                            part.ClickAction = Convert.ToByte(clickAction);
+                            group.HasGroupChanged = true;
+                    }
                 }
             }
         }
@@ -1632,8 +1636,11 @@ namespace OpenSim.Region.Framework.Scenes
                 if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     SceneObjectPart part = m_parentScene.GetSceneObjectPart(primLocalID);
-                    part.Material = Convert.ToByte(material);
-                    group.HasGroupChanged = true;
+                    if (part != null)
+                    {
+                        part.Material = Convert.ToByte(material);
+                        group.HasGroupChanged = true;
+                    }
                 }
             }
         }
@@ -1706,23 +1713,24 @@ namespace OpenSim.Region.Framework.Scenes
                 parentGroup.areUpdatesSuspended = true;
 
                 List<SceneObjectGroup> childGroups = new List<SceneObjectGroup>();
-                if (parentGroup != null)
+
+                // We do this in reverse to get the link order of the prims correct
+                for (int i = children.Count - 1; i >= 0; i--)
                 {
-                    // We do this in reverse to get the link order of the prims correct
-                    for (int i = children.Count - 1; i >= 0; i--)
-                    {
-                        SceneObjectGroup child = children[i].ParentGroup;
+                    SceneObjectGroup child = children[i].ParentGroup;
 
+                    // Make sure no child prim is set for sale
+                    // So that, on delink, no prims are unwittingly
+                    // left for sale and sold off
+                   
                         if (child != null)
                         {
+                            child.RootPart.ObjectSaleType = 0;
+                            child.RootPart.SalePrice = 10;
                             childGroups.Add(child);
                         }
                     }
                 }
-                else
-                {
-                    return; // parent is null so not in this region
-                }
 
                 foreach (SceneObjectGroup child in childGroups)
                 {
diff --git a/OpenSim/Region/Framework/Scenes/SceneManager.cs b/OpenSim/Region/Framework/Scenes/SceneManager.cs
index 86ba2aa..7fada4b 100644
--- a/OpenSim/Region/Framework/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneManager.cs
@@ -47,12 +47,18 @@ namespace OpenSim.Region.Framework.Scenes
 
         public event RestartSim OnRestartSim;
 
-        private readonly List<Scene> m_localScenes;
+        private static SceneManager m_instance = null;
+        public static SceneManager Instance
+        { 
+            get { return m_instance; } 
+        }
+
+        private readonly List<Scene> m_localScenes = new List<Scene>();
         private Scene m_currentScene = null;
 
         public List<Scene> Scenes
         {
-            get { return m_localScenes; }
+            get { return new List<Scene>(m_localScenes); }
         }
 
         public Scene CurrentScene
@@ -66,13 +72,12 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_currentScene == null)
                 {
-                    if (m_localScenes.Count > 0)
+                    lock (m_localScenes)
                     {
-                        return m_localScenes[0];
-                    }
-                    else
-                    {
-                        return null;
+                        if (m_localScenes.Count > 0)
+                            return m_localScenes[0];
+                        else
+                            return null;
                     }
                 }
                 else
@@ -84,6 +89,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public SceneManager()
         {
+            m_instance = this;
             m_localScenes = new List<Scene>();
         }
 
@@ -91,17 +97,21 @@ namespace OpenSim.Region.Framework.Scenes
         {
             // collect known shared modules in sharedModules
             Dictionary<string, IRegionModule> sharedModules = new Dictionary<string, IRegionModule>();
-            for (int i = 0; i < m_localScenes.Count; i++)
+
+            lock (m_localScenes)
             {
-                // extract known shared modules from scene
-                foreach (string k in m_localScenes[i].Modules.Keys)
+                for (int i = 0; i < m_localScenes.Count; i++)
                 {
-                    if (m_localScenes[i].Modules[k].IsSharedModule &&
-                        !sharedModules.ContainsKey(k))
-                        sharedModules[k] = m_localScenes[i].Modules[k];
+                    // extract known shared modules from scene
+                    foreach (string k in m_localScenes[i].Modules.Keys)
+                    {
+                        if (m_localScenes[i].Modules[k].IsSharedModule &&
+                            !sharedModules.ContainsKey(k))
+                            sharedModules[k] = m_localScenes[i].Modules[k];
+                    }
+                    // close scene/region
+                    m_localScenes[i].Close();
                 }
-                // close scene/region
-                m_localScenes[i].Close();
             }
 
             // all regions/scenes are now closed, we can now safely
@@ -114,13 +124,16 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void Close(Scene cscene)
         {
-            if (m_localScenes.Contains(cscene))
+            lock (m_localScenes)
             {
-                for (int i = 0; i < m_localScenes.Count; i++)
+                if (m_localScenes.Contains(cscene))
                 {
-                    if (m_localScenes[i].Equals(cscene))
+                    for (int i = 0; i < m_localScenes.Count; i++)
                     {
-                        m_localScenes[i].Close();
+                        if (m_localScenes[i].Equals(cscene))
+                        {
+                            m_localScenes[i].Close();
+                        }
                     }
                 }
             }
@@ -129,27 +142,33 @@ namespace OpenSim.Region.Framework.Scenes
         public void Add(Scene scene)
         {
             scene.OnRestart += HandleRestart;
-            m_localScenes.Add(scene);
+
+            lock (m_localScenes)
+                m_localScenes.Add(scene);
         }
 
         public void HandleRestart(RegionInfo rdata)
         {
             m_log.Error("[SCENEMANAGER]: Got Restart message for region:" + rdata.RegionName + " Sending up to main");
             int RegionSceneElement = -1;
-            for (int i = 0; i < m_localScenes.Count; i++)
+
+            lock (m_localScenes)
             {
-                if (rdata.RegionName == m_localScenes[i].RegionInfo.RegionName)
+                for (int i = 0; i < m_localScenes.Count; i++)
                 {
-                    RegionSceneElement = i;
+                    if (rdata.RegionName == m_localScenes[i].RegionInfo.RegionName)
+                    {
+                        RegionSceneElement = i;
+                    }
                 }
-            }
 
-            // Now we make sure the region is no longer known about by the SceneManager
-            // Prevents duplicates.
+                // Now we make sure the region is no longer known about by the SceneManager
+                // Prevents duplicates.
 
-            if (RegionSceneElement >= 0)
-            {
-                m_localScenes.RemoveAt(RegionSceneElement);
+                if (RegionSceneElement >= 0)
+                {
+                    m_localScenes.RemoveAt(RegionSceneElement);
+                }
             }
 
             // Send signal to main that we're restarting this sim.
@@ -160,28 +179,32 @@ namespace OpenSim.Region.Framework.Scenes
         {
             RegionInfo Result = null;
 
-            for (int i = 0; i < m_localScenes.Count; i++)
-            {
-                if (m_localScenes[i].RegionInfo.RegionHandle == regionHandle)
-                {
-                    // Inform other regions to tell their avatar about me
-                    Result = m_localScenes[i].RegionInfo;
-                }
-            }
-            if (Result != null)
+            lock (m_localScenes)
             {
                 for (int i = 0; i < m_localScenes.Count; i++)
                 {
-                    if (m_localScenes[i].RegionInfo.RegionHandle != regionHandle)
+                    if (m_localScenes[i].RegionInfo.RegionHandle == regionHandle)
                     {
                         // Inform other regions to tell their avatar about me
-                        //m_localScenes[i].OtherRegionUp(Result);
+                        Result = m_localScenes[i].RegionInfo;
                     }
                 }
-            }
-            else
-            {
-                m_log.Error("[REGION]: Unable to notify Other regions of this Region coming up");
+
+                if (Result != null)
+                {
+                    for (int i = 0; i < m_localScenes.Count; i++)
+                    {
+                        if (m_localScenes[i].RegionInfo.RegionHandle != regionHandle)
+                        {
+                            // Inform other regions to tell their avatar about me
+                            //m_localScenes[i].OtherRegionUp(Result);
+                        }
+                    }
+                }
+                else
+                {
+                    m_log.Error("[REGION]: Unable to notify Other regions of this Region coming up");
+                }
             }
         }
 
@@ -285,7 +308,8 @@ namespace OpenSim.Region.Framework.Scenes
         {
             if (m_currentScene == null)
             {
-                m_localScenes.ForEach(func);
+                lock (m_localScenes)
+                    m_localScenes.ForEach(func);
             }
             else
             {
@@ -314,12 +338,15 @@ namespace OpenSim.Region.Framework.Scenes
             }
             else
             {
-                foreach (Scene scene in m_localScenes)
+                lock (m_localScenes)
                 {
-                    if (String.Compare(scene.RegionInfo.RegionName, regionName, true) == 0)
+                    foreach (Scene scene in m_localScenes)
                     {
-                        m_currentScene = scene;
-                        return true;
+                        if (String.Compare(scene.RegionInfo.RegionName, regionName, true) == 0)
+                        {
+                            m_currentScene = scene;
+                            return true;
+                        }
                     }
                 }
 
@@ -331,12 +358,15 @@ namespace OpenSim.Region.Framework.Scenes
         {
             m_log.Debug("Searching for Region: '" + regionID + "'");
 
-            foreach (Scene scene in m_localScenes)
+            lock (m_localScenes)
             {
-                if (scene.RegionInfo.RegionID == regionID)
+                foreach (Scene scene in m_localScenes)
                 {
-                    m_currentScene = scene;
-                    return true;
+                    if (scene.RegionInfo.RegionID == regionID)
+                    {
+                        m_currentScene = scene;
+                        return true;
+                    }
                 }
             }
 
@@ -345,26 +375,33 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetScene(string regionName, out Scene scene)
         {
-            foreach (Scene mscene in m_localScenes)
+            lock (m_localScenes)
             {
-                if (String.Compare(mscene.RegionInfo.RegionName, regionName, true) == 0)
+                foreach (Scene mscene in m_localScenes)
                 {
-                    scene = mscene;
-                    return true;
+                    if (String.Compare(mscene.RegionInfo.RegionName, regionName, true) == 0)
+                    {
+                        scene = mscene;
+                        return true;
+                    }
                 }
             }
+
             scene = null;
             return false;
         }
 
         public bool TryGetScene(UUID regionID, out Scene scene)
         {
-            foreach (Scene mscene in m_localScenes)
+            lock (m_localScenes)
             {
-                if (mscene.RegionInfo.RegionID == regionID)
+                foreach (Scene mscene in m_localScenes)
                 {
-                    scene = mscene;
-                    return true;
+                    if (mscene.RegionInfo.RegionID == regionID)
+                    {
+                        scene = mscene;
+                        return true;
+                    }
                 }
             }
             
@@ -374,13 +411,16 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetScene(uint locX, uint locY, out Scene scene)
         {
-            foreach (Scene mscene in m_localScenes)
+            lock (m_localScenes)
             {
-                if (mscene.RegionInfo.RegionLocX == locX &&
-                    mscene.RegionInfo.RegionLocY == locY)
+                foreach (Scene mscene in m_localScenes)
                 {
-                    scene = mscene;
-                    return true;
+                    if (mscene.RegionInfo.RegionLocX == locX &&
+                        mscene.RegionInfo.RegionLocY == locY)
+                    {
+                        scene = mscene;
+                        return true;
+                    }
                 }
             }
             
@@ -390,13 +430,16 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetScene(IPEndPoint ipEndPoint, out Scene scene)
         {
-            foreach (Scene mscene in m_localScenes)
+            lock (m_localScenes)
             {
-                if ((mscene.RegionInfo.InternalEndPoint.Equals(ipEndPoint.Address)) &&
-                    (mscene.RegionInfo.InternalEndPoint.Port == ipEndPoint.Port))
+                foreach (Scene mscene in m_localScenes)
                 {
-                    scene = mscene;
-                    return true;
+                    if ((mscene.RegionInfo.InternalEndPoint.Equals(ipEndPoint.Address)) &&
+                        (mscene.RegionInfo.InternalEndPoint.Port == ipEndPoint.Port))
+                    {
+                        scene = mscene;
+                        return true;
+                    }
                 }
             }
             
@@ -465,11 +508,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         public RegionInfo GetRegionInfo(UUID regionID)
         {
-            foreach (Scene scene in m_localScenes)
+            lock (m_localScenes)
             {
-                if (scene.RegionInfo.RegionID == regionID)
+                foreach (Scene scene in m_localScenes)
                 {
-                    return scene.RegionInfo;
+                    if (scene.RegionInfo.RegionID == regionID)
+                    {
+                        return scene.RegionInfo;
+                    }
                 }
             }
 
@@ -488,11 +534,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetScenePresence(UUID avatarId, out ScenePresence avatar)
         {
-            foreach (Scene scene in m_localScenes)
+            lock (m_localScenes)
             {
-                if (scene.TryGetScenePresence(avatarId, out avatar))
+                foreach (Scene scene in m_localScenes)
                 {
-                    return true;
+                    if (scene.TryGetScenePresence(avatarId, out avatar))
+                    {
+                        return true;
+                    }
                 }
             }
 
@@ -503,12 +552,16 @@ namespace OpenSim.Region.Framework.Scenes
         public bool TryGetAvatarsScene(UUID avatarId, out Scene scene)
         {
             ScenePresence avatar = null;
-            foreach (Scene mScene in m_localScenes)
+
+            lock (m_localScenes)
             {
-                if (mScene.TryGetScenePresence(avatarId, out avatar))
+                foreach (Scene mScene in m_localScenes)
                 {
-                    scene = mScene;
-                    return true;
+                    if (mScene.TryGetScenePresence(avatarId, out avatar))
+                    {
+                        scene = mScene;
+                        return true;
+                    }
                 }
             }
 
@@ -518,17 +571,22 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void CloseScene(Scene scene)
         {
-            m_localScenes.Remove(scene);
+            lock (m_localScenes)
+                m_localScenes.Remove(scene);
+
             scene.Close();
         }
 
         public bool TryGetAvatarByName(string avatarName, out ScenePresence avatar)
         {
-            foreach (Scene scene in m_localScenes)
+            lock (m_localScenes)
             {
-                if (scene.TryGetAvatarByName(avatarName, out avatar))
+                foreach (Scene scene in m_localScenes)
                 {
-                    return true;
+                    if (scene.TryGetAvatarByName(avatarName, out avatar))
+                    {
+                        return true;
+                    }
                 }
             }
 
@@ -538,7 +596,8 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void ForEachScene(Action<Scene> action)
         {
-            m_localScenes.ForEach(action);
+            lock (m_localScenes)
+                m_localScenes.ForEach(action);
         }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 6c47645..b1b76dd 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -209,25 +209,87 @@ namespace OpenSim.Region.Framework.Scenes
                 return true;
             return false;
         }
-        
-        /// <value>
+
+        /// <summary>
         /// Is this scene object acting as an attachment?
-        /// 
-        /// We return false if the group has already been deleted.
-        ///
-        /// TODO: At the moment set must be done on the part itself.  There may be a case for doing it here since I
-        /// presume either all or no parts in a linkset can be part of an attachment (in which
-        /// case the value would get proprogated down into all the descendent parts).
-        /// </value>
-        public bool IsAttachment
+        /// </summary>
+        public bool IsAttachment { get; set; }
+
+        /// <summary>
+        /// The avatar to which this scene object is attached.
+        /// </summary>
+        /// <remarks>
+        /// If we're not attached to an avatar then this is UUID.Zero
+        /// </remarks>
+        public UUID AttachedAvatar { get; set; }
+
+        /// <summary>
+        /// Attachment point of this scene object to an avatar.
+        /// </summary>
+        /// <remarks>
+        /// 0 if we're not attached to anything
+        /// </remarks>
+        public uint AttachmentPoint
         {
             get
             {
-                if (!IsDeleted)
-                    return m_rootPart.IsAttachment;
-                
-                return false;
+                return m_rootPart.Shape.State;
             }
+
+            set
+            {
+                IsAttachment = value != 0;
+                m_rootPart.Shape.State = (byte)value;
+            }
+        }
+
+        public void ClearPartAttachmentData()
+        {
+            AttachmentPoint = 0;
+
+            // Even though we don't use child part state parameters for attachments any more, we still need to set
+            // these to zero since having them non-zero in rezzed scene objects will crash some clients.  Even if
+            // we store them correctly, scene objects that we receive from elsewhere might not.
+            foreach (SceneObjectPart part in Parts)
+                part.Shape.State = 0;
+        }
+
+        /// <summary>
+        /// Is this scene object phantom?
+        /// </summary>
+        /// <remarks>
+        /// Updating must currently take place through UpdatePrimFlags()
+        /// </remarks>
+        public bool IsPhantom
+        {
+            get { return (RootPart.Flags & PrimFlags.Phantom) != 0; }
+        }
+
+        /// <summary>
+        /// Does this scene object use physics?
+        /// </summary>
+        /// <remarks>
+        /// Updating must currently take place through UpdatePrimFlags()
+        /// </remarks>
+        public bool UsesPhysics
+        {
+            get { return (RootPart.Flags & PrimFlags.TemporaryOnRez) != 0; }
+        }
+
+        /// <summary>
+        /// Is this scene object temporary?
+        /// </summary>
+        /// <remarks>
+        /// Updating must currently take place through UpdatePrimFlags()
+        /// </remarks>
+        public bool IsTemporary
+        {
+            get { return (RootPart.Flags & PrimFlags.TemporaryOnRez) != 0; }
+        }
+
+        public bool IsVolumeDetect
+        {
+            get { return RootPart.VolumeDetectActive; }
         }
 
         public float scriptScore;
@@ -261,11 +323,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public override string Name
         {
-            get {
-                if (RootPart == null)
-                    return String.Empty;
-                return RootPart.Name;
-            }
+            get { return RootPart.Name; }
             set { RootPart.Name = value; }
         }
 
@@ -305,6 +363,38 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_rootPart.RotationOffset; }
         }
 
+        public Vector3 GroupScale
+        {
+            get
+            {
+                Vector3 minScale = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionSize);
+                Vector3 maxScale = Vector3.Zero;
+                Vector3 finalScale = new Vector3(0.5f, 0.5f, 0.5f);
+    
+                SceneObjectPart[] parts = m_parts.GetArray();
+                for (int i = 0; i < parts.Length; i++)
+                {
+                    SceneObjectPart part = parts[i];
+                    Vector3 partscale = part.Scale;
+                    Vector3 partoffset = part.OffsetPosition;
+    
+                    minScale.X = (partscale.X + partoffset.X < minScale.X) ? partscale.X + partoffset.X : minScale.X;
+                    minScale.Y = (partscale.Y + partoffset.Y < minScale.Y) ? partscale.Y + partoffset.Y : minScale.Y;
+                    minScale.Z = (partscale.Z + partoffset.Z < minScale.Z) ? partscale.Z + partoffset.Z : minScale.Z;
+    
+                    maxScale.X = (partscale.X + partoffset.X > maxScale.X) ? partscale.X + partoffset.X : maxScale.X;
+                    maxScale.Y = (partscale.Y + partoffset.Y > maxScale.Y) ? partscale.Y + partoffset.Y : maxScale.Y;
+                    maxScale.Z = (partscale.Z + partoffset.Z > maxScale.Z) ? partscale.Z + partoffset.Z : maxScale.Z;
+                }
+    
+                finalScale.X = (minScale.X > maxScale.X) ? minScale.X : maxScale.X;
+                finalScale.Y = (minScale.Y > maxScale.Y) ? minScale.Y : maxScale.Y;
+                finalScale.Z = (minScale.Z > maxScale.Z) ? minScale.Z : maxScale.Z;
+    
+                return finalScale;
+            }
+        }
+
         public UUID GroupID
         {
             get { return m_rootPart.GroupID; }
@@ -344,11 +434,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Check both the attachment property and the relevant properties of the underlying root part.
         /// </summary>
+        /// <remarks>
         /// This is necessary in some cases, particularly when a scene object has just crossed into a region and doesn't
         /// have the IsAttachment property yet checked.
         /// 
         /// FIXME: However, this should be fixed so that this property
         /// propertly reflects the underlying status.
+        /// </remarks>
         /// <returns></returns>
         public bool IsAttachmentCheckFull()
         {
@@ -682,7 +774,7 @@ namespace OpenSim.Region.Framework.Scenes
                 part.ParentID = m_rootPart.LocalId;
                 //m_log.DebugFormat("[SCENE]: Given local id {0} to part {1}, linknum {2}, parent {3} {4}", part.LocalId, part.UUID, part.LinkNum, part.ParentID, part.ParentUUID);
             }
-            
+
             ApplyPhysics(m_scene.m_physicalPrim);
 
             if (RootPart.PhysActor != null)
@@ -693,34 +785,6 @@ namespace OpenSim.Region.Framework.Scenes
             //ScheduleGroupForFullUpdate();
         }
 
-        public Vector3 GroupScale()
-        {
-            Vector3 minScale = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionSize);
-            Vector3 maxScale = Vector3.Zero;
-            Vector3 finalScale = new Vector3(0.5f, 0.5f, 0.5f);
-
-            SceneObjectPart[] parts = m_parts.GetArray();
-            for (int i = 0; i < parts.Length; i++)
-            {
-                SceneObjectPart part = parts[i];
-                Vector3 partscale = part.Scale;
-                Vector3 partoffset = part.OffsetPosition;
-
-                minScale.X = (partscale.X + partoffset.X < minScale.X) ? partscale.X + partoffset.X : minScale.X;
-                minScale.Y = (partscale.Y + partoffset.Y < minScale.Y) ? partscale.Y + partoffset.Y : minScale.Y;
-                minScale.Z = (partscale.Z + partoffset.Z < minScale.Z) ? partscale.Z + partoffset.Z : minScale.Z;
-
-                maxScale.X = (partscale.X + partoffset.X > maxScale.X) ? partscale.X + partoffset.X : maxScale.X;
-                maxScale.Y = (partscale.Y + partoffset.Y > maxScale.Y) ? partscale.Y + partoffset.Y : maxScale.Y;
-                maxScale.Z = (partscale.Z + partoffset.Z > maxScale.Z) ? partscale.Z + partoffset.Z : maxScale.Z;
-            }
-
-            finalScale.X = (minScale.X > maxScale.X) ? minScale.X : maxScale.X;
-            finalScale.Y = (minScale.Y > maxScale.Y) ? minScale.Y : maxScale.Y;
-            finalScale.Z = (minScale.Z > maxScale.Z) ? minScale.Z : maxScale.Z;
-            return finalScale;
-
-        }
         public EntityIntersection TestIntersection(Ray hRay, bool frontFacesOnly, bool faceCenters)
         {
             // We got a request from the inner_scene to raytrace along the Ray hRay
@@ -1082,6 +1146,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+<<<<<<< HEAD
         /// <summary>
         /// Add the avatar to this linkset (avatar is sat).
         /// </summary>
@@ -1263,6 +1328,8 @@ namespace OpenSim.Region.Framework.Scenes
             //m_rootPart.ScheduleFullUpdate();
         }
 
+=======
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
         /// <summary>
         ///
         /// </summary>
@@ -1320,11 +1387,16 @@ namespace OpenSim.Region.Framework.Scenes
         public void AddPart(SceneObjectPart part)
         {
             part.SetParent(this);
+<<<<<<< HEAD
             m_parts.Add(part.UUID, part);
 
             part.LinkNum = m_parts.Count;
 
             if (part.LinkNum == 2 && RootPart != null)
+=======
+            part.LinkNum = m_parts.Add(part.UUID, part);
+            if (part.LinkNum == 2)
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
                 RootPart.LinkNum = 1;
         }
 
@@ -1407,7 +1479,15 @@ namespace OpenSim.Region.Framework.Scenes
 
         public virtual void OnGrabPart(SceneObjectPart part, Vector3 offsetPos, IClientAPI remoteClient)
         {
+<<<<<<< HEAD
             part.StoreUndoState(UndoType.STATE_PRIM_ALL);
+=======
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Processing OnGrabPart for {0} on {1} {2}, offsetPos {3}",
+//                remoteClient.Name, part.Name, part.LocalId, offsetPos);
+
+            part.StoreUndoState();
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
             part.OnGrab(offsetPos, remoteClient);
         }
 
@@ -1711,16 +1791,30 @@ namespace OpenSim.Region.Framework.Scenes
                 dupe.m_isBackedUp = false;
                 dupe.m_parts = new MapAndArray<OpenMetaverse.UUID, SceneObjectPart>();
 
+<<<<<<< HEAD
                 // Warning, The following code related to previousAttachmentStatus is needed so that clones of 
                 // attachments do not bordercross while they're being duplicated.  This is hacktastic!
                 // Normally, setting AbsolutePosition will bordercross a prim if it's outside the region!
                 // unless IsAttachment is true!, so to prevent border crossing, we save it's attachment state 
                 // (which should be false anyway) set it as an Attachment and then set it's Absolute Position, 
                 // then restore it's attachment state
+=======
+            bool previousAttachmentStatus = dupe.IsAttachment;
+            
+            if (!userExposed)
+                dupe.IsAttachment = true;
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
                 // This is only necessary when userExposed is false!
 
+<<<<<<< HEAD
                 bool previousAttachmentStatus = dupe.RootPart.IsAttachment;
+=======
+            if (!userExposed)
+            {
+                dupe.IsAttachment = previousAttachmentStatus;
+            }
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
                 if (!userExposed)
                     dupe.RootPart.IsAttachment = true;
@@ -1781,7 +1875,26 @@ namespace OpenSim.Region.Framework.Scenes
                     dupe.HasGroupChanged = true;
                     dupe.AttachToBackup();
 
+<<<<<<< HEAD
                     ScheduleGroupForFullUpdate();
+=======
+                // Need to duplicate the physics actor as well
+                if (part.PhysActor != null && userExposed)
+                {
+                    PrimitiveBaseShape pbs = newPart.Shape;
+    
+                    newPart.PhysActor
+                        = m_scene.PhysicsScene.AddPrimShape(
+                            string.Format("{0}/{1}", newPart.Name, newPart.UUID),
+                            pbs,
+                            newPart.AbsolutePosition,
+                            newPart.Scale,
+                            newPart.RotationOffset,
+                            part.PhysActor.IsPhysical,
+                            newPart.LocalId);
+    
+                    newPart.DoPhysicsPropertyUpdate(part.PhysActor.IsPhysical, true);
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
                 }
             }
             finally
@@ -1802,36 +1915,24 @@ namespace OpenSim.Region.Framework.Scenes
             SetRootPart(part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, 0, userExposed));
         }
 
-        public void ScriptSetPhysicsStatus(bool UsePhysics)
+        public void ScriptSetPhysicsStatus(bool usePhysics)
         {
-            bool IsTemporary = ((RootPart.Flags & PrimFlags.TemporaryOnRez) != 0);
-            bool IsPhantom = ((RootPart.Flags & PrimFlags.Phantom) != 0);
-            bool IsVolumeDetect = RootPart.VolumeDetectActive;
-            UpdatePrimFlags(RootPart.LocalId, UsePhysics, IsTemporary, IsPhantom, IsVolumeDetect);
+            UpdatePrimFlags(RootPart.LocalId, usePhysics, IsTemporary, IsPhantom, IsVolumeDetect);
         }
 
-        public void ScriptSetTemporaryStatus(bool TemporaryStatus)
+        public void ScriptSetTemporaryStatus(bool makeTemporary)
         {
-            bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
-            bool IsPhantom = ((RootPart.Flags & PrimFlags.Phantom) != 0);
-            bool IsVolumeDetect = RootPart.VolumeDetectActive;
-            UpdatePrimFlags(RootPart.LocalId, UsePhysics, TemporaryStatus, IsPhantom, IsVolumeDetect);
+            UpdatePrimFlags(RootPart.LocalId, UsesPhysics, makeTemporary, IsPhantom, IsVolumeDetect);
         }
 
-        public void ScriptSetPhantomStatus(bool PhantomStatus)
+        public void ScriptSetPhantomStatus(bool makePhantom)
         {
-            bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
-            bool IsTemporary = ((RootPart.Flags & PrimFlags.TemporaryOnRez) != 0);
-            bool IsVolumeDetect = RootPart.VolumeDetectActive;
-            UpdatePrimFlags(RootPart.LocalId, UsePhysics, IsTemporary, PhantomStatus, IsVolumeDetect);
+            UpdatePrimFlags(RootPart.LocalId, UsesPhysics, IsTemporary, makePhantom, IsVolumeDetect);
         }
 
-        public void ScriptSetVolumeDetect(bool VDStatus)
+        public void ScriptSetVolumeDetect(bool makeVolumeDetect)
         {
-            bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
-            bool IsTemporary = ((RootPart.Flags & PrimFlags.TemporaryOnRez) != 0);
-            bool IsPhantom = ((RootPart.Flags & PrimFlags.Phantom) != 0);
-            UpdatePrimFlags(RootPart.LocalId, UsePhysics, IsTemporary, IsPhantom, VDStatus);
+            UpdatePrimFlags(RootPart.LocalId, UsesPhysics, IsTemporary, IsPhantom, makeVolumeDetect);
 
             /*
             ScriptSetPhantomStatus(false);  // What ever it was before, now it's not phantom anymore
@@ -1849,126 +1950,87 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void applyImpulse(Vector3 impulse)
         {
-            // We check if rootpart is null here because scripts don't delete if you delete the host.
-            // This means that unfortunately, we can pass a null physics actor to Simulate!
-            // Make sure we don't do that!
-            SceneObjectPart rootpart = m_rootPart;
-            if (rootpart != null)
+            if (IsAttachment)
             {
-                if (IsAttachment)
+                ScenePresence avatar = m_scene.GetScenePresence(AttachedAvatar);
+                if (avatar != null)
                 {
-                    ScenePresence avatar = m_scene.GetScenePresence(rootpart.AttachedAvatar);
-                    if (avatar != null)
-                    {
-                        avatar.PushForce(impulse);
-                    }
+                    avatar.PushForce(impulse);
                 }
-                else
+            }
+            else
+            {
+                if (RootPart.PhysActor != null)
                 {
-                    if (rootpart.PhysActor != null)
-                    {
-                        rootpart.PhysActor.AddForce(impulse, true);
-                        m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
-                    }
+                    RootPart.PhysActor.AddForce(impulse, true);
+                    m_scene.PhysicsScene.AddPhysicsActorTaint(RootPart.PhysActor);
                 }
             }
         }
 
         public void applyAngularImpulse(Vector3 impulse)
         {
-            // We check if rootpart is null here because scripts don't delete if you delete the host.
-            // This means that unfortunately, we can pass a null physics actor to Simulate!
-            // Make sure we don't do that!
-            SceneObjectPart rootpart = m_rootPart;
-            if (rootpart != null)
+            if (RootPart.PhysActor != null)
             {
-                if (rootpart.PhysActor != null)
+                if (!IsAttachment)
                 {
-                    if (!IsAttachment)
-                    {
-                        rootpart.PhysActor.AddAngularForce(impulse, true);
-                        m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
-                    }
+                    RootPart.PhysActor.AddAngularForce(impulse, true);
+                    m_scene.PhysicsScene.AddPhysicsActorTaint(RootPart.PhysActor);
                 }
             }
         }
 
         public void setAngularImpulse(Vector3 impulse)
         {
-            // We check if rootpart is null here because scripts don't delete if you delete the host.
-            // This means that unfortunately, we can pass a null physics actor to Simulate!
-            // Make sure we don't do that!
-            SceneObjectPart rootpart = m_rootPart;
-            if (rootpart != null)
+            if (RootPart.PhysActor != null)
             {
-                if (rootpart.PhysActor != null)
+                if (!IsAttachment)
                 {
-                    if (!IsAttachment)
-                    {
-                        rootpart.PhysActor.Torque = impulse;
-                        m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
-                    }
+                    RootPart.PhysActor.Torque = impulse;
+                    m_scene.PhysicsScene.AddPhysicsActorTaint(RootPart.PhysActor);
                 }
             }
         }
 
         public Vector3 GetTorque()
         {
-            // We check if rootpart is null here because scripts don't delete if you delete the host.
-            // This means that unfortunately, we can pass a null physics actor to Simulate!
-            // Make sure we don't do that!
-            SceneObjectPart rootpart = m_rootPart;
-            if (rootpart != null)
+            if (RootPart.PhysActor != null)
             {
-                if (rootpart.PhysActor != null)
+                if (!IsAttachment)
                 {
-                    if (!IsAttachment)
-                    {
-                        Vector3 torque = rootpart.PhysActor.Torque;
-                        return torque;
-                    }
+                    Vector3 torque = RootPart.PhysActor.Torque;
+                    return torque;
                 }
             }
+
             return Vector3.Zero;
         }
 
          // This is used by both Double-Click Auto-Pilot and llMoveToTarget() in an attached object
         public void moveToTarget(Vector3 target, float tau)
         {
-            SceneObjectPart rootpart = m_rootPart;
-            if (rootpart != null)
+            if (IsAttachment)
             {
-                if (IsAttachment)
+                ScenePresence avatar = m_scene.GetScenePresence(AttachedAvatar);
+                if (avatar != null)
                 {
-                    ScenePresence avatar = m_scene.GetScenePresence(rootpart.AttachedAvatar);
-                    if (avatar != null)
-                    {
-                        List<string> coords = new List<string>();
-                        uint regionX = 0;
-                        uint regionY = 0;
-                        Utils.LongToUInts(Scene.RegionInfo.RegionHandle, out regionX, out regionY);
-                        target.X += regionX;
-                        target.Y += regionY;
-                        coords.Add(target.X.ToString());
-                        coords.Add(target.Y.ToString());
-                        coords.Add(target.Z.ToString());
-                        avatar.DoMoveToPosition(avatar, "", coords);
-                    }
+                    avatar.MoveToTarget(target, false);
                 }
-                else
+            }
+            else
+            {
+                if (RootPart.PhysActor != null)
                 {
-                    if (rootpart.PhysActor != null)
-                    {
-                        rootpart.PhysActor.PIDTarget = target;
-                        rootpart.PhysActor.PIDTau = tau;
-                        rootpart.PhysActor.PIDActive = true;
-                    }
+                    RootPart.PhysActor.PIDTarget = target;
+                    RootPart.PhysActor.PIDTau = tau;
+                    RootPart.PhysActor.PIDActive = true;
                 }
             }
         }
 
         public void stopMoveToTarget()
         {
+<<<<<<< HEAD
             SceneObjectPart rootpart = m_rootPart;
             if (rootpart != null)
             {
@@ -1985,6 +2047,10 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
             }
+=======
+            if (RootPart.PhysActor != null)
+                RootPart.PhysActor.PIDActive = false;
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
         }
         
         public void rotLookAt(Quaternion target, float strength, float damping)
@@ -2016,6 +2082,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void stopLookAt()
         {
+<<<<<<< HEAD
             SceneObjectPart rootpart = m_rootPart;
             if (rootpart != null)
             {
@@ -2025,6 +2092,10 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
         
+=======
+            if (RootPart.PhysActor != null)
+                RootPart.PhysActor.APIDActive = false;
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
         }
 
         /// <summary>
@@ -2035,22 +2106,18 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="tau">Number of seconds over which to reach target</param>
         public void SetHoverHeight(float height, PIDHoverType hoverType, float tau)
         {
-            SceneObjectPart rootpart = m_rootPart;
-            if (rootpart != null)
+            if (RootPart.PhysActor != null)
             {
-                if (rootpart.PhysActor != null)
+                if (height != 0f)
                 {
-                    if (height != 0f)
-                    {
-                        rootpart.PhysActor.PIDHoverHeight = height;
-                        rootpart.PhysActor.PIDHoverType = hoverType;
-                        rootpart.PhysActor.PIDTau = tau;
-                        rootpart.PhysActor.PIDHoverActive = true;
-                    }
-                    else
-                    {
-                        rootpart.PhysActor.PIDHoverActive = false;
-                    }
+                    RootPart.PhysActor.PIDHoverHeight = height;
+                    RootPart.PhysActor.PIDHoverType = hoverType;
+                    RootPart.PhysActor.PIDTau = tau;
+                    RootPart.PhysActor.PIDHoverActive = true;
+                }
+                else
+                {
+                    RootPart.PhysActor.PIDHoverActive = false;
                 }
             }
         }
@@ -2145,7 +2212,7 @@ namespace OpenSim.Region.Framework.Scenes
             // an object has been deleted from a scene before update was processed.
             // A more fundamental overhaul of the update mechanism is required to eliminate all
             // the race conditions.
-            if (m_isDeleted)
+            if (IsDeleted)
                 return;
 
             // Even temporary objects take part in physics (e.g. temp-on-rez bullets)
@@ -2458,7 +2525,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             m_scene.UnlinkSceneObject(objectGroup, true);
-            objectGroup.m_isDeleted = true;
+            objectGroup.IsDeleted = true;
 
             objectGroup.m_parts.Clear();
             
@@ -2595,9 +2662,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="objectGroup"></param>
         public virtual void DetachFromBackup()
         {
+<<<<<<< HEAD
             m_scene.SceneGraph.FireDetachFromBackup(this);
 
             if (m_isBackedUp)
+=======
+            if (m_isBackedUp && Scene != null)
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
                 m_scene.EventManager.OnBackup -= ProcessBackup;
             
             m_isBackedUp = false;
@@ -2857,14 +2928,15 @@ namespace OpenSim.Region.Framework.Scenes
         /// Update prim flags for this group.
         /// </summary>
         /// <param name="localID"></param>
-        /// <param name="type"></param>
-        /// <param name="inUse"></param>
-        /// <param name="data"></param>
-        public void UpdatePrimFlags(uint localID, bool UsePhysics, bool IsTemporary, bool IsPhantom, bool IsVolumeDetect)
+        /// <param name="UsePhysics"></param>
+        /// <param name="SetTemporary"></param>
+        /// <param name="SetPhantom"></param>
+        /// <param name="SetVolumeDetect"></param>
+        public void UpdatePrimFlags(uint localID, bool UsePhysics, bool SetTemporary, bool SetPhantom, bool SetVolumeDetect)
         {
             SceneObjectPart selectionPart = GetChildPart(localID);
 
-            if (IsTemporary)
+            if (SetTemporary && Scene != null)
             {
                 DetachFromBackup();
                 // Remove from database and parcel prim count
@@ -2876,24 +2948,32 @@ namespace OpenSim.Region.Framework.Scenes
             if (selectionPart != null)
             {
                 SceneObjectPart[] parts = m_parts.GetArray();
-                for (int i = 0; i < parts.Length; i++)
+                
+                if (Scene != null)
                 {
-                    SceneObjectPart part = parts[i];
-                    if (part.Scale.X > m_scene.RegionInfo.PhysPrimMax || 
-                        part.Scale.Y > m_scene.RegionInfo.PhysPrimMax || 
-                        part.Scale.Z > m_scene.RegionInfo.PhysPrimMax)
+                    for (int i = 0; i < parts.Length; i++)
                     {
-                        UsePhysics = false; // Reset physics
-                        break;
+                        SceneObjectPart part = parts[i];
+                        if (part.Scale.X > m_scene.RegionInfo.PhysPrimMax || 
+                            part.Scale.Y > m_scene.RegionInfo.PhysPrimMax || 
+                            part.Scale.Z > m_scene.RegionInfo.PhysPrimMax)
+                        {
+                            UsePhysics = false; // Reset physics
+                            break;
+                        }
                     }
                 }
 
                 RootPart.UpdatePrimFlags(UsePhysics, IsTemporary, IsPhantom, IsVolumeDetect);
                 for (int i = 0; i < parts.Length; i++)
+<<<<<<< HEAD
                 {
                     if (parts[i] != RootPart)
                         parts[i].UpdatePrimFlags(UsePhysics, IsTemporary, IsPhantom, IsVolumeDetect);
                 }
+=======
+                    parts[i].UpdatePrimFlags(UsePhysics, SetTemporary, SetPhantom, SetVolumeDetect);
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
             }
         }
 
@@ -2966,12 +3046,12 @@ namespace OpenSim.Region.Framework.Scenes
         #region Resize
 
         /// <summary>
-        /// Resize the given part
+        /// Resize the entire group of prims.
         /// </summary>
         /// <param name="scale"></param>
-        /// <param name="localID"></param>
-        public void Resize(Vector3 scale, uint localID)
+        public void GroupResize(Vector3 scale)
         {
+<<<<<<< HEAD
             if (scale.X > m_scene.m_maxNonphys)
                 scale.X = m_scene.m_maxNonphys;
             if (scale.Y > m_scene.m_maxNonphys)
@@ -2996,23 +3076,25 @@ namespace OpenSim.Region.Framework.Scenes
                     m_scene.PhysicsScene.AddPhysicsActorTaint(part.PhysActor);
                 }
                 part.Resize(scale);
+=======
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Group resizing {0} {1} from {2} to {3}", Name, LocalId, RootPart.Scale, scale);
 
-                HasGroupChanged = true;
-                part.TriggerScriptChangedEvent(Changed.SCALE);
-                ScheduleGroupForFullUpdate();
+            RootPart.StoreUndoState(true);
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
-                //if (part.UUID == m_rootPart.UUID)
-                //{
-                //if (m_rootPart.PhysActor != null)
-                //{
-                //m_rootPart.PhysActor.Size =
-                //new PhysicsVector(m_rootPart.Scale.X, m_rootPart.Scale.Y, m_rootPart.Scale.Z);
-                //m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
-                //}
-                //}
+            scale.X = Math.Min(scale.X, Scene.m_maxNonphys);
+            scale.Y = Math.Min(scale.Y, Scene.m_maxNonphys);
+            scale.Z = Math.Min(scale.Z, Scene.m_maxNonphys);
+
+            if (RootPart.PhysActor != null && RootPart.PhysActor.IsPhysical)
+            {
+                scale.X = Math.Min(scale.X, Scene.m_maxPhys);
+                scale.Y = Math.Min(scale.Y, Scene.m_maxPhys);
+                scale.Z = Math.Min(scale.Z, Scene.m_maxPhys);
             }
-        }
 
+<<<<<<< HEAD
         public void GroupResize(Vector3 scale, uint localID)
         {
             SceneObjectPart part = GetChildPart(localID);
@@ -3036,24 +3118,50 @@ namespace OpenSim.Region.Framework.Scenes
                 float x = (scale.X / part.Scale.X);
                 float y = (scale.Y / part.Scale.Y);
                 float z = (scale.Z / part.Scale.Z);
+=======
+            float x = (scale.X / RootPart.Scale.X);
+            float y = (scale.Y / RootPart.Scale.Y);
+            float z = (scale.Z / RootPart.Scale.Z);
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
-                SceneObjectPart[] parts;
-                if (x > 1.0f || y > 1.0f || z > 1.0f)
+            SceneObjectPart[] parts;
+            if (x > 1.0f || y > 1.0f || z > 1.0f)
+            {
+                parts = m_parts.GetArray();
+                for (int i = 0; i < parts.Length; i++)
                 {
-                    parts = m_parts.GetArray();
-                    for (int i = 0; i < parts.Length; i++)
+                    SceneObjectPart obPart = parts[i];
+                    if (obPart.UUID != m_rootPart.UUID)
                     {
-                        SceneObjectPart obPart = parts[i];
-                        if (obPart.UUID != m_rootPart.UUID)
+//                        obPart.IgnoreUndoUpdate = true;
+                        Vector3 oldSize = new Vector3(obPart.Scale);
+
+                        float f = 1.0f;
+                        float a = 1.0f;
+
+                        if (RootPart.PhysActor != null && RootPart.PhysActor.IsPhysical)
                         {
-                            obPart.IgnoreUndoUpdate = true;
-                            Vector3 oldSize = new Vector3(obPart.Scale);
+                            if (oldSize.X * x > m_scene.m_maxPhys)
+                            {
+                                f = m_scene.m_maxPhys / oldSize.X;
+                                a = f / x;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            float f = 1.0f;
-                            float a = 1.0f;
+                            if (oldSize.Y * y > m_scene.m_maxPhys)
+                            {
+                                f = m_scene.m_maxPhys / oldSize.Y;
+                                a = f / y;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (part.PhysActor != null && part.PhysActor.IsPhysical)
+                            if (oldSize.Z * z > m_scene.m_maxPhys)
                             {
+<<<<<<< HEAD
                                 if (oldSize.X*x > m_scene.m_maxPhys)
                                 {
                                     f = m_scene.m_maxPhys / oldSize.X;
@@ -3078,9 +3186,20 @@ namespace OpenSim.Region.Framework.Scenes
                                     y *= a;
                                     z *= a;
                                 }
+=======
+                                f = m_scene.m_maxPhys / oldSize.Z;
+                                a = f / z;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
                             }
-                            else
+                        }
+                        else
+                        {
+                            if (oldSize.X * x > m_scene.m_maxNonphys)
                             {
+<<<<<<< HEAD
                                 if (oldSize.X*x > m_scene.m_maxNonphys)
                                 {
                                     f = m_scene.m_maxNonphys / oldSize.X;
@@ -3107,10 +3226,40 @@ namespace OpenSim.Region.Framework.Scenes
                                 }
                             }
                             obPart.IgnoreUndoUpdate = false;
+=======
+                                f = m_scene.m_maxNonphys / oldSize.X;
+                                a = f / x;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
+
+                            if (oldSize.Y * y > m_scene.m_maxNonphys)
+                            {
+                                f = m_scene.m_maxNonphys / oldSize.Y;
+                                a = f / y;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
+
+                            if (oldSize.Z * z > m_scene.m_maxNonphys)
+                            {
+                                f = m_scene.m_maxNonphys / oldSize.Z;
+                                a = f / z;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
                         }
+
+//                        obPart.IgnoreUndoUpdate = false;
                     }
                 }
+            }
 
+<<<<<<< HEAD
                 Vector3 prevScale = part.Scale;
                 prevScale.X *= x;
                 prevScale.Y *= y;
@@ -3121,12 +3270,26 @@ namespace OpenSim.Region.Framework.Scenes
                 part.IgnoreUndoUpdate = true;
                 part.Resize(prevScale);
                 part.IgnoreUndoUpdate = false;
+=======
+            Vector3 prevScale = RootPart.Scale;
+            prevScale.X *= x;
+            prevScale.Y *= y;
+            prevScale.Z *= z;
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
-                parts = m_parts.GetArray();
-                for (int i = 0; i < parts.Length; i++)
+//            RootPart.IgnoreUndoUpdate = true;
+            RootPart.Resize(prevScale);
+//            RootPart.IgnoreUndoUpdate = false;
+
+            parts = m_parts.GetArray();
+            for (int i = 0; i < parts.Length; i++)
+            {
+                SceneObjectPart obPart = parts[i];
+
+                if (obPart.UUID != m_rootPart.UUID)
                 {
-                    SceneObjectPart obPart = parts[i];
                     obPart.IgnoreUndoUpdate = true;
+<<<<<<< HEAD
                     if (obPart.UUID != m_rootPart.UUID)
                     {
                         if (obPart.UUID != m_rootPart.UUID)
@@ -3150,18 +3313,38 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     obPart.IgnoreUndoUpdate = false;
                 }
+=======
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
-                if (part.PhysActor != null)
-                {
-                    part.PhysActor.Size = prevScale;
-                    m_scene.PhysicsScene.AddPhysicsActorTaint(part.PhysActor);
+                    Vector3 currentpos = new Vector3(obPart.OffsetPosition);
+                    currentpos.X *= x;
+                    currentpos.Y *= y;
+                    currentpos.Z *= z;
+
+                    Vector3 newSize = new Vector3(obPart.Scale);
+                    newSize.X *= x;
+                    newSize.Y *= y;
+                    newSize.Z *= z;
+
+                    obPart.Resize(newSize);
+                    obPart.UpdateOffSet(currentpos);
+
+                    obPart.IgnoreUndoUpdate = false;                    
                 }
 
+<<<<<<< HEAD
                 part.IgnoreUndoUpdate = false;
                 HasGroupChanged = true;
                 m_rootPart.TriggerScriptChangedEvent(Changed.SCALE);
                 ScheduleGroupForTerseUpdate();
+=======
+//                obPart.IgnoreUndoUpdate = false;
+//                obPart.StoreUndoState();
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
             }
+
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Finished group resizing {0} {1} to {2}", Name, LocalId, RootPart.Scale);
         }
 
         #endregion
@@ -3174,6 +3357,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="pos"></param>
         public void UpdateGroupPosition(Vector3 pos)
         {
+<<<<<<< HEAD
+=======
+//            m_log.DebugFormat("[SCENE OBJECT GROUP]: Updating group position on {0} {1} to {2}", Name, LocalId, pos);
+
+            RootPart.StoreUndoState(true);
+
+//            SceneObjectPart[] parts = m_parts.GetArray();
+//            for (int i = 0; i < parts.Length; i++)
+//                parts[i].StoreUndoState();
+
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
             if (m_scene.EventManager.TriggerGroupMove(UUID, pos))
             {
                 if (IsAttachment)
@@ -3210,12 +3404,24 @@ namespace OpenSim.Region.Framework.Scenes
         {
             SceneObjectPart part = GetChildPart(localID);
 
+<<<<<<< HEAD
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
                 parts[i].StoreUndoState(UndoType.STATE_PRIM_POSITION);
+=======
+//            SceneObjectPart[] parts = m_parts.GetArray();
+//            for (int i = 0; i < parts.Length; i++)
+//                parts[i].StoreUndoState();
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
             if (part != null)
             {
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT GROUP]: Updating single position of {0} {1} to {2}", part.Name, part.LocalId, pos);
+
+                part.StoreUndoState(false);
+                part.IgnoreUndoUpdate = true;
+
                 if (part.UUID == m_rootPart.UUID)
                 {
                     UpdateRootPosition(pos);
@@ -3226,18 +3432,28 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
                 HasGroupChanged = true;
+                part.IgnoreUndoUpdate = false;
             }
         }
 
         /// <summary>
-        ///
+        /// Update just the root prim position in a linkset
         /// </summary>
         /// <param name="pos"></param>
-        private void UpdateRootPosition(Vector3 pos)
+        public void UpdateRootPosition(Vector3 pos)
         {
+<<<<<<< HEAD
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
                 parts[i].StoreUndoState(UndoType.STATE_PRIM_POSITION);
+=======
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Updating root position of {0} {1} to {2}", Name, LocalId, pos);
+
+//            SceneObjectPart[] parts = m_parts.GetArray();
+//            for (int i = 0; i < parts.Length; i++)
+//                parts[i].StoreUndoState();
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
             Vector3 newPos = new Vector3(pos.X, pos.Y, pos.Z);
             Vector3 oldPos =
@@ -3250,7 +3466,7 @@ namespace OpenSim.Region.Framework.Scenes
             axDiff *= Quaternion.Inverse(partRotation);
             diff = axDiff;
 
-            parts = m_parts.GetArray();
+            SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
             {
                 SceneObjectPart obPart = parts[i];
@@ -3296,9 +3512,20 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="rot"></param>
         public void UpdateGroupRotationR(Quaternion rot)
         {
+<<<<<<< HEAD
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
                 parts[i].StoreUndoState(UndoType.STATE_GROUP_ROTATION);
+=======
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Updating group rotation R of {0} {1} to {2}", Name, LocalId, rot);
+
+//            SceneObjectPart[] parts = m_parts.GetArray();
+//            for (int i = 0; i < parts.Length; i++)
+//                parts[i].StoreUndoState();
+
+            m_rootPart.StoreUndoState(true);
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
             m_rootPart.UpdateRotation(rot);
 
@@ -3320,9 +3547,21 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="rot"></param>
         public void UpdateGroupRotationPR(Vector3 pos, Quaternion rot)
         {
+<<<<<<< HEAD
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
                 parts[i].StoreUndoState(UndoType.STATE_GROUP_ROTATION);
+=======
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Updating group rotation PR of {0} {1} to {2}", Name, LocalId, rot);
+
+//            SceneObjectPart[] parts = m_parts.GetArray();
+//            for (int i = 0; i < parts.Length; i++)
+//                parts[i].StoreUndoState();
+
+            RootPart.StoreUndoState(true);
+            RootPart.IgnoreUndoUpdate = true;
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
 
             m_rootPart.UpdateRotation(rot);
 
@@ -3337,6 +3576,8 @@ namespace OpenSim.Region.Framework.Scenes
 
             HasGroupChanged = true;
             ScheduleGroupForTerseUpdate();
+
+            RootPart.IgnoreUndoUpdate = false;
         }
 
         /// <summary>
@@ -3353,6 +3594,9 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (part != null)
             {
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT GROUP]: Updating single rotation of {0} {1} to {2}", part.Name, part.LocalId, rot);
+
                 if (part.UUID == m_rootPart.UUID)
                 {
                     UpdateRootRotation(rot);
@@ -3374,6 +3618,13 @@ namespace OpenSim.Region.Framework.Scenes
             SceneObjectPart part = GetChildPart(localID);
             if (part != null)
             {
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT GROUP]: Updating single position and rotation of {0} {1} to {2}",
+//                    part.Name, part.LocalId, rot);
+
+                part.StoreUndoState();
+                part.IgnoreUndoUpdate = true;
+
                 if (part.UUID == m_rootPart.UUID)
                 {
                     UpdateRootRotation(rot);
@@ -3390,12 +3641,19 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 else
                 {
+<<<<<<< HEAD
                     part.StoreUndoState(UndoType.STATE_PRIM_ROTATION);
                     part.IgnoreUndoUpdate = true;
                     part.UpdateRotation(rot);
                     part.OffsetPosition = pos;
                     part.IgnoreUndoUpdate = false;
+=======
+                    part.UpdateRotation(rot);
+                    part.OffsetPosition = pos;
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
                 }
+
+                part.IgnoreUndoUpdate = false;
             }
         }
 
@@ -3403,8 +3661,12 @@ namespace OpenSim.Region.Framework.Scenes
         ///
         /// </summary>
         /// <param name="rot"></param>
-        private void UpdateRootRotation(Quaternion rot)
+        public void UpdateRootRotation(Quaternion rot)
         {
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Updating root rotation of {0} {1} to {2}",
+//                Name, LocalId, rot);
+
             Quaternion axRot = rot;
             Quaternion oldParentRot = m_rootPart.RotationOffset;
 
@@ -3436,6 +3698,7 @@ namespace OpenSim.Region.Framework.Scenes
                     axPos *= oldParentRot;
                     axPos *= Quaternion.Inverse(axRot);
                     prim.OffsetPosition = axPos;
+<<<<<<< HEAD
 
                     prim.RotationOffset *= Quaternion.Inverse(prim.GetWorldRotation()) * (oldParentRot * prim.RotationOffset);
 
@@ -3448,6 +3711,32 @@ namespace OpenSim.Region.Framework.Scenes
             }
             HasGroupChanged = true;
             ScheduleGroupForFullUpdate();
+=======
+                    Quaternion primsRot = prim.RotationOffset;
+                    Quaternion newRot = primsRot * oldParentRot;
+                    newRot *= Quaternion.Inverse(axRot);
+                    prim.RotationOffset = newRot;
+                    prim.ScheduleTerseUpdate();
+                    prim.IgnoreUndoUpdate = false;
+                }
+            }
+
+//            for (int i = 0; i < parts.Length; i++)
+//            {
+//                SceneObjectPart childpart = parts[i];
+//                if (childpart != m_rootPart)
+//                {
+////                    childpart.IgnoreUndoUpdate = false;
+////                    childpart.StoreUndoState();
+//                }
+//            }
+
+            m_rootPart.ScheduleTerseUpdate();
+
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Updated root rotation of {0} {1} to {2}",
+//                Name, LocalId, rot);
+>>>>>>> 9f75eaf50e42ef6409fc272ba33a817241907ed8
         }
 
         #endregion
@@ -3462,28 +3751,23 @@ namespace OpenSim.Region.Framework.Scenes
             int yaxis = 4;
             int zaxis = 8;
 
-            if (m_rootPart != null)
-            {
-                setX = ((axis & xaxis) != 0) ? true : false;
-                setY = ((axis & yaxis) != 0) ? true : false;
-                setZ = ((axis & zaxis) != 0) ? true : false;
+            setX = ((axis & xaxis) != 0) ? true : false;
+            setY = ((axis & yaxis) != 0) ? true : false;
+            setZ = ((axis & zaxis) != 0) ? true : false;
 
-                float setval = (rotate10 > 0) ? 1f : 0f;
+            float setval = (rotate10 > 0) ? 1f : 0f;
 
-                if (setX)
-                    m_rootPart.RotationAxis.X = setval;
-                if (setY)
-                    m_rootPart.RotationAxis.Y = setval;
-                if (setZ)
-                    m_rootPart.RotationAxis.Z = setval;
+            if (setX)
+                RootPart.RotationAxis.X = setval;
+            if (setY)
+                RootPart.RotationAxis.Y = setval;
+            if (setZ)
+                RootPart.RotationAxis.Z = setval;
 
-                if (setX || setY || setZ)
-                {
-                    m_rootPart.SetPhysicsAxisRotation();
-                }
-
-            }
+            if (setX || setY || setZ)
+                RootPart.SetPhysicsAxisRotation();
         }
+
         public int registerRotTargetWaypoint(Quaternion target, float tolerance)
         {
             scriptRotTarget waypoint = new scriptRotTarget();
@@ -3611,7 +3895,13 @@ namespace OpenSim.Region.Framework.Scenes
                         foreach (uint idx in m_rotTargets.Keys)
                         {
                             scriptRotTarget target = m_rotTargets[idx];
-                            double angle = Math.Acos(target.targetRot.X * m_rootPart.RotationOffset.X + target.targetRot.Y * m_rootPart.RotationOffset.Y + target.targetRot.Z * m_rootPart.RotationOffset.Z + target.targetRot.W * m_rootPart.RotationOffset.W) * 2;
+                            double angle
+                                = Math.Acos(
+                                    target.targetRot.X * m_rootPart.RotationOffset.X
+                                        + target.targetRot.Y * m_rootPart.RotationOffset.Y
+                                        + target.targetRot.Z * m_rootPart.RotationOffset.Z
+                                        + target.targetRot.W * m_rootPart.RotationOffset.W)
+                                    * 2;
                             if (angle < 0) angle = -angle;
                             if (angle > Math.PI) angle = (Math.PI * 2 - angle);
                             if (angle <= target.tolerance)
@@ -3676,43 +3966,28 @@ namespace OpenSim.Region.Framework.Scenes
 
             return retmass;
         }
-        
+
+        /// <summary>
+        /// If the object is a sculpt/mesh, retrieve the mesh data for each part and reinsert it into each shape so that
+        /// the physics engine can use it.
+        /// </summary>
+        /// <remarks>
+        /// When the physics engine has finished with it, the sculpt data is discarded to save memory.
+        /// </remarks>
         public void CheckSculptAndLoad()
         {
             if (IsDeleted)
                 return;
+
             if ((RootPart.GetEffectiveObjectFlags() & (uint)PrimFlags.Phantom) != 0)
                 return;
 
-            SceneObjectPart[] parts = m_parts.GetArray();
-            for (int i = 0; i < parts.Length; i++)
-            {
-                SceneObjectPart part = parts[i];
-                if (part.Shape.SculptEntry && part.Shape.SculptTexture != UUID.Zero)
-                {
-                    // check if a previously decoded sculpt map has been cached
-                    if (File.Exists(System.IO.Path.Combine("j2kDecodeCache", "smap_" + part.Shape.SculptTexture.ToString())))
-                    {
-                        part.SculptTextureCallback(part.Shape.SculptTexture, null);
-                    }
-                    else
-                    {
-                        m_scene.AssetService.Get(
-                            part.Shape.SculptTexture.ToString(), part, AssetReceived);
-                    }
-                }
-            }
-        }
+//            m_log.Debug("Processing CheckSculptAndLoad for {0} {1}", Name, LocalId);
 
-        protected void AssetReceived(string id, Object sender, AssetBase asset)
-        {
-            SceneObjectPart sop = (SceneObjectPart)sender;
+            SceneObjectPart[] parts = m_parts.GetArray();
 
-            if (sop != null)
-            {
-                if (asset != null)
-                    sop.SculptTextureCallback(asset.FullID, asset);
-            }
+            for (int i = 0; i < parts.Length; i++)
+                parts[i].CheckSculptAndLoad();
         }
 
         /// <summary>
@@ -3747,19 +4022,12 @@ namespace OpenSim.Region.Framework.Scenes
             return String.Format("{0} {1} ({2})", Name, UUID, AbsolutePosition);
         }
 
-        public void SetAttachmentPoint(byte point)
-        {
-            SceneObjectPart[] parts = m_parts.GetArray();
-            for (int i = 0; i < parts.Length; i++)
-                parts[i].SetAttachmentPoint(point);
-        }
-
         #region ISceneObject
         
         public virtual ISceneObject CloneForNewScene()
         {
             SceneObjectGroup sog = Copy(false);
-            sog.m_isDeleted = false;
+            sog.IsDeleted = false;
             return sog;
         }
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 037f384..893faf8 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using System.Drawing;
+using System.IO;
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Security.Permissions;
@@ -216,28 +217,18 @@ namespace OpenSim.Region.Framework.Scenes
         /// </value>
         private UUID m_fromUserInventoryItemID;
         
-        
         public UUID FromUserInventoryItemID
         {
             get { return m_fromUserInventoryItemID; }
+            set { m_fromUserInventoryItemID = value; }
         }
 
-        
-        public bool IsAttachment;
-
-        
         public scriptEvents AggregateScriptEvents;
 
         
-        public UUID AttachedAvatar;
-
-        
         public Vector3 AttachedPos;
 
         
-        public uint AttachmentPoint;
-
-        
         public Vector3 RotationAxis = Vector3.One;
 
         
@@ -269,12 +260,9 @@ namespace OpenSim.Region.Framework.Scenes
         }
         protected SceneObjectPartInventory m_inventory;
 
-        
         public bool Undoing;
-
         
         public bool IgnoreUndoUpdate = false;
-
         
         private PrimFlags LocalFlags;
         
@@ -296,8 +284,8 @@ namespace OpenSim.Region.Framework.Scenes
         private bool m_occupied;                                        // KF if any av is sitting on this prim
         private string m_text = String.Empty;
         private string m_touchName = String.Empty;
-        private readonly UndoStack<UndoState> m_undo = new UndoStack<UndoState>(5);
-        private readonly UndoStack<UndoState> m_redo = new UndoStack<UndoState>(5);
+        private readonly Stack<UndoState> m_undo = new Stack<UndoState>(5);
+        private readonly Stack<UndoState> m_redo = new Stack<UndoState>(5);
         private UUID _creatorID;
 
         private bool m_passTouches;
@@ -323,7 +311,6 @@ namespace OpenSim.Region.Framework.Scenes
         protected string m_name;
         protected Vector3 m_offsetPosition;
 
-        // FIXME, TODO, ERROR: 'ParentGroup' can't be in here, move it out.
         protected SceneObjectGroup m_parentGroup;
         protected byte[] m_particleSystem = Utils.EmptyBytes;
         protected ulong m_regionHandle;
@@ -424,7 +411,6 @@ namespace OpenSim.Region.Framework.Scenes
             CreateSelected = true;
 
             TrimPermissions();
-            //m_undo = new UndoStack<UndoState>(ParentGroup.GetSceneMaxUndo());
             
             m_inventory = new SceneObjectPartInventory(this);
         }
@@ -619,6 +605,7 @@ namespace OpenSim.Region.Framework.Scenes
             set
             {
                 m_passTouches = value;
+
                 if (ParentGroup != null)
                     ParentGroup.HasGroupChanged = true;
             }
@@ -744,9 +731,9 @@ namespace OpenSim.Region.Framework.Scenes
                     return m_groupPosition;
                 }
 
-                if (IsAttachment)
+                if (m_parentGroup.IsAttachment)
                 {
-                    ScenePresence sp = m_parentGroup.Scene.GetScenePresence(AttachedAvatar);
+                    ScenePresence sp = m_parentGroup.Scene.GetScenePresence(ParentGroup.AttachedAvatar);
                     if (sp != null)
                         return sp.AbsolutePosition;
                 }
@@ -794,7 +781,6 @@ namespace OpenSim.Region.Framework.Scenes
             set
             {
                 Vector3 oldpos = m_offsetPosition;
-                StoreUndoState(UndoType.STATE_PRIM_POSITION);
                 m_offsetPosition = value;
 
                 if (ParentGroup != null && !ParentGroup.IsDeleted)
@@ -834,7 +820,7 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (IsRoot)
                 {
-                    if (IsAttachment)
+                    if (m_parentGroup.IsAttachment)
                         return AttachedPos;
                     else
                         return AbsolutePosition;
@@ -887,7 +873,9 @@ namespace OpenSim.Region.Framework.Scenes
                             actor.Orientation = resultingrotation;
                             //m_log.Info("[PART]: RO2:" + actor.Orientation.ToString());
                         }
-                        m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(actor);
+
+                        if (m_parentGroup != null)
+                            m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(actor);
                         //}
                     }
                     catch (Exception ex)
@@ -895,7 +883,6 @@ namespace OpenSim.Region.Framework.Scenes
                         m_log.Error("[SCENEOBJECTPART]: ROTATIONOFFSET" + ex.Message);
                     }
                 }
-
             }
         }
 
@@ -1044,30 +1031,39 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_shape; }
             set { m_shape = value; }
         }
-        
+
+        /// <summary>
+        /// Change the scale of this part.
+        /// </summary>
         public Vector3 Scale
         {
             get { return m_shape.Scale; }
             set
             {
-                StoreUndoState(UndoType.STATE_PRIM_SCALE);
                 if (m_shape != null)
                 {
+                    StoreUndoState();
+
                     m_shape.Scale = value;
 
                     PhysicsActor actor = PhysActor;
-                    if (actor != null && m_parentGroup != null)
+                    if (actor != null)
                     {
                         if (m_parentGroup.Scene != null)
                         {
                             if (m_parentGroup.Scene.PhysicsScene != null)
                             {
                                 actor.Size = m_shape.Scale;
-                                m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(actor);
+
+                                if (Shape.SculptEntry)
+                                    CheckSculptAndLoad();
+                                else
+                                    ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
                             }
                         }
                     }
                 }
+
                 TriggerScriptChangedEvent(Changed.SCALE);
             }
         }
@@ -1092,13 +1088,12 @@ namespace OpenSim.Region.Framework.Scenes
             set
             {
                 m_mediaUrl = value;
-                
+
                 if (ParentGroup != null)
                     ParentGroup.HasGroupChanged = true;
             }
         }
 
-        
         public bool CreateSelected
         {
             get { return m_createSelected; }
@@ -1118,7 +1113,10 @@ namespace OpenSim.Region.Framework.Scenes
         {
             get
             {
-                return GroupPosition + (m_offsetPosition * ParentGroup.RootPart.RotationOffset);
+                if (m_parentGroup.IsAttachment)
+                    return GroupPosition;
+
+                return m_offsetPosition + m_groupPosition;
             }
         }
 
@@ -1138,7 +1136,6 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_sitTargetOrientation = value; }
         }
 
-
         public Vector3 SitTargetPosition
         {
             get { return m_sitTargetPosition; }
@@ -1268,7 +1265,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Property flags.  See OpenMetaverse.PrimFlags 
         /// </summary>
+        /// <remarks>
         /// Example properties are PrimFlags.Phantom and PrimFlags.DieAtEdge
+        /// </remarks>
         public PrimFlags Flags
         {
             get { return _flags; }
@@ -1298,7 +1297,7 @@ namespace OpenSim.Region.Framework.Scenes
         {
             get
             {
-                if (ParentGroup != null && ParentGroup.Scene != null)
+                if (ParentGroup.Scene != null)
                     return ParentGroup.Scene.RegionInfo.RegionID;
                 else
                     return UUID.Zero;
@@ -1313,14 +1312,13 @@ namespace OpenSim.Region.Framework.Scenes
             get
             {
                 if (ParentGroup != null)
-                {
                     _parentUUID = ParentGroup.UUID;
-                }
+
                 return _parentUUID;
             }
+
             set { _parentUUID = value; }
         }
-
         
         public string SitAnimation
         {
@@ -1555,10 +1553,7 @@ namespace OpenSim.Region.Framework.Scenes
                 impulse = newimpulse;
             }
 
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.applyAngularImpulse(impulse);
-            }
+            m_parentGroup.applyAngularImpulse(impulse);
         }
 
         /// <summary>
@@ -1581,19 +1576,7 @@ namespace OpenSim.Region.Framework.Scenes
                 impulse = newimpulse;
             }
 
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.setAngularImpulse(impulse);
-            }
-        }
-
-        public Vector3 GetTorque()
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.GetTorque();
-            }
-            return Vector3.Zero;
+            m_parentGroup.setAngularImpulse(impulse);
         }
 
         /// <summary>
@@ -1623,7 +1606,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                 // The only time the physics scene shouldn't know about the prim is if it's phantom or an attachment, which is phantom by definition
                 // or flexible
-                if (!isPhantom && !IsAttachment && !(Shape.PathCurve == (byte) Extrusion.Flexible))
+                if (!isPhantom && !m_parentGroup.IsAttachment && !(Shape.PathCurve == (byte) Extrusion.Flexible))
                 {
                     try
                     {
@@ -1635,7 +1618,6 @@ namespace OpenSim.Region.Framework.Scenes
                                 RotationOffset,
                                 RigidBody,
                                 m_localId);
-                        PhysActor.SetMaterial(Material);
                     }
                     catch
                     {
@@ -1647,6 +1629,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         PhysActor.SOPName = this.Name; // save object name and desc into the PhysActor so ODE internals know the joint/body info
                         PhysActor.SOPDescription = this.Description;
+                        PhysActor.SetMaterial(Material);
                         DoPhysicsPropertyUpdate(RigidBody, true);
                         PhysActor.SetVolumeDetect(VolumeDetectActive ? 1 : 0);
                     }
@@ -1658,19 +1641,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void ClearUndoState()
-        {
-            lock (m_undo)
-            {
-                m_undo.Clear();
-            }
-            lock (m_redo)
-            {
-                m_redo.Clear();
-            }
-            StoreUndoState(UndoType.STATE_ALL);
-        }
-
         public byte ConvertScriptUintToByte(uint indata)
         {
             byte outdata = (byte)TextureAnimFlags.NONE;
@@ -1751,7 +1721,8 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (dupe.m_shape.SculptEntry && dupe.m_shape.SculptTexture != UUID.Zero)
                 {
-                    m_parentGroup.Scene.AssetService.Get(dupe.m_shape.SculptTexture.ToString(), dupe, AssetReceived); 
+                    ParentGroup.Scene.AssetService.Get(
+                        dupe.m_shape.SculptTexture.ToString(), dupe, dupe.AssetReceived);
                 }
                 
                 bool UsePhysics = ((dupe.Flags & PrimFlags.Physics) != 0);
@@ -1765,14 +1736,20 @@ namespace OpenSim.Region.Framework.Scenes
             return dupe;
         }
 
+        /// <summary>
+        /// Called back by asynchronous asset fetch.
+        /// </summary>
+        /// <param name="id">ID of asset received</param>
+        /// <param name="sender">Register</param>
+        /// <param name="asset"></param>
         protected void AssetReceived(string id, Object sender, AssetBase asset)
         {
             if (asset != null)
-            {
-                SceneObjectPart sop = (SceneObjectPart)sender;
-                if (sop != null)
-                    sop.SculptTextureCallback(asset.FullID, asset);
-            }
+                SculptTextureCallback(asset);
+            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);
         }
 
         public static SceneObjectPart Create()
@@ -1789,97 +1766,111 @@ namespace OpenSim.Region.Framework.Scenes
             return part;
         }
 
-        public void DoPhysicsPropertyUpdate(bool UsePhysics, bool isNew)
+        /// <summary>
+        /// Do a physics property update for a NINJA joint.
+        /// </summary>
+        /// <param name="UsePhysics"></param>
+        /// <param name="isNew"></param>
+        protected void DoPhysicsPropertyUpdateForNinjaJoint(bool UsePhysics, bool isNew)
         {
-            if (IsJoint())
+            if (UsePhysics)
             {
-                if (UsePhysics)
-                {
-                    // by turning a joint proxy object physical, we cause creation of a joint in the ODE scene.
-                    // note that, as a special case, joints have no bodies or geoms in the physics scene, even though they are physical.
+                // by turning a joint proxy object physical, we cause creation of a joint in the ODE scene.
+                // note that, as a special case, joints have no bodies or geoms in the physics scene, even though they are physical.
 
-                    PhysicsJointType jointType;
-                    if (IsHingeJoint())
-                    {
-                        jointType = PhysicsJointType.Hinge;
-                    }
-                    else if (IsBallJoint())
-                    {
-                        jointType = PhysicsJointType.Ball;
-                    }
-                    else
-                    {
-                        jointType = PhysicsJointType.Ball;
-                    }
+                PhysicsJointType jointType;
+                if (IsHingeJoint())
+                {
+                    jointType = PhysicsJointType.Hinge;
+                }
+                else if (IsBallJoint())
+                {
+                    jointType = PhysicsJointType.Ball;
+                }
+                else
+                {
+                    jointType = PhysicsJointType.Ball;
+                }
 
-                    List<string> bodyNames = new List<string>();
-                    string RawParams = Description;
-                    string[] jointParams = RawParams.Split(" ".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries);
-                    string trackedBodyName = null;
-                    if (jointParams.Length >= 2)
+                List<string> bodyNames = new List<string>();
+                string RawParams = Description;
+                string[] jointParams = RawParams.Split(" ".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries);
+                string trackedBodyName = null;
+                if (jointParams.Length >= 2)
+                {
+                    for (int iBodyName = 0; iBodyName < 2; iBodyName++)
                     {
-                        for (int iBodyName = 0; iBodyName < 2; iBodyName++)
+                        string bodyName = jointParams[iBodyName];
+                        bodyNames.Add(bodyName);
+                        if (bodyName != "NULL")
                         {
-                            string bodyName = jointParams[iBodyName];
-                            bodyNames.Add(bodyName);
-                            if (bodyName != "NULL")
+                            if (trackedBodyName == null)
                             {
-                                if (trackedBodyName == null)
-                                {
-                                    trackedBodyName = bodyName;
-                                }
+                                trackedBodyName = bodyName;
                             }
                         }
                     }
+                }
 
-                    SceneObjectPart trackedBody = m_parentGroup.Scene.GetSceneObjectPart(trackedBodyName); // FIXME: causes a sequential lookup
-                    Quaternion localRotation = Quaternion.Identity;
-                    if (trackedBody != null)
-                    {
-                        localRotation = Quaternion.Inverse(trackedBody.RotationOffset) * this.RotationOffset;
-                    }
-                    else
-                    {
-                        // error, output it below
-                    }
-
-                    PhysicsJoint joint;
+                SceneObjectPart trackedBody = m_parentGroup.Scene.GetSceneObjectPart(trackedBodyName); // FIXME: causes a sequential lookup
+                Quaternion localRotation = Quaternion.Identity;
+                if (trackedBody != null)
+                {
+                    localRotation = Quaternion.Inverse(trackedBody.RotationOffset) * this.RotationOffset;
+                }
+                else
+                {
+                    // error, output it below
+                }
 
-                    joint = m_parentGroup.Scene.PhysicsScene.RequestJointCreation(Name, jointType,
-                        AbsolutePosition,
-                        this.RotationOffset,
-                        Description,
-                        bodyNames,
-                        trackedBodyName,
-                        localRotation);
+                PhysicsJoint joint;
 
-                    if (trackedBody == null)
-                    {
-                        ParentGroup.Scene.jointErrorMessage(joint, "warning: tracked body name not found! joint location will not be updated properly. joint: " + Name);
-                    }
+                joint = m_parentGroup.Scene.PhysicsScene.RequestJointCreation(Name, jointType,
+                    AbsolutePosition,
+                    this.RotationOffset,
+                    Description,
+                    bodyNames,
+                    trackedBodyName,
+                    localRotation);
 
+                if (trackedBody == null)
+                {
+                    ParentGroup.Scene.jointErrorMessage(joint, "warning: tracked body name not found! joint location will not be updated properly. joint: " + Name);
+                }
+            }
+            else
+            {
+                if (isNew)
+                {
+                    // if the joint proxy is new, and it is not physical, do nothing. There is no joint in ODE to
+                    // delete, and if we try to delete it, due to asynchronous processing, the deletion request
+                    // will get processed later at an indeterminate time, which could cancel a later-arriving
+                    // joint creation request.
                 }
                 else
                 {
-                    if (isNew)
-                    {
-                        // if the joint proxy is new, and it is not physical, do nothing. There is no joint in ODE to
-                        // delete, and if we try to delete it, due to asynchronous processing, the deletion request
-                        // will get processed later at an indeterminate time, which could cancel a later-arriving
-                        // joint creation request.
-                    }
-                    else
-                    {
-                        // here we turn off the joint object, so remove the joint from the physics scene
-                        m_parentGroup.Scene.PhysicsScene.RequestJointDeletion(Name); // FIXME: what if the name changed?
+                    // here we turn off the joint object, so remove the joint from the physics scene
+                    m_parentGroup.Scene.PhysicsScene.RequestJointDeletion(Name); // FIXME: what if the name changed?
 
-                        // make sure client isn't interpolating the joint proxy object
-                        Velocity = Vector3.Zero;
-                        AngularVelocity = Vector3.Zero;
-                        Acceleration = Vector3.Zero;
-                    }
+                    // make sure client isn't interpolating the joint proxy object
+                    Velocity = Vector3.Zero;
+                    AngularVelocity = Vector3.Zero;
+                    Acceleration = Vector3.Zero;
                 }
             }
+        }
+
+        /// <summary>
+        /// Do a physics propery update for this part.
+        /// </summary>
+        /// <param name="UsePhysics"></param>
+        /// <param name="isNew"></param>
+        public void DoPhysicsPropertyUpdate(bool UsePhysics, bool isNew)
+        {
+            if (IsJoint())
+            {
+                DoPhysicsPropertyUpdateForNinjaJoint(UsePhysics, isNew);
+            }
             else
             {
                 if (PhysActor != null)
@@ -1919,7 +1910,6 @@ namespace OpenSim.Region.Framework.Scenes
 
                         PhysActor.IsPhysical = UsePhysics;
 
-
                         // If we're not what we're supposed to be in the physics scene, recreate ourselves.
                         //m_parentGroup.Scene.PhysicsScene.RemovePrim(PhysActor);
                         /// that's not wholesome.  Had to make Scene public
@@ -1943,7 +1933,13 @@ namespace OpenSim.Region.Framework.Scenes
                             }
                         }
                     }
-                    m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+
+                    // If this part is a sculpt then delay the physics update until we've asynchronously loaded the
+                    // mesh data.
+                    if (Shape.SculptEntry)
+                        CheckSculptAndLoad();
+                    else
+                        m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
                 }
             }
         }
@@ -1955,22 +1951,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public static SceneObjectPart FromXml(XmlTextReader xmlReader)
         {
-            return FromXml(UUID.Zero, xmlReader);
-        }
-
-        /// <summary>
-        /// Restore this part from the serialized xml representation.
-        /// </summary>
-        /// <param name="fromUserInventoryItemId">The inventory id from which this part came, if applicable</param>
-        /// <param name="xmlReader"></param>
-        /// <returns></returns>
-        public static SceneObjectPart FromXml(UUID fromUserInventoryItemId, XmlTextReader xmlReader)
-        {
             SceneObjectPart part = SceneObjectSerializer.Xml2ToSOP(xmlReader);
-            part.m_fromUserInventoryItemID = fromUserInventoryItemId;
 
             // for tempOnRez objects, we have to fix the Expire date.
-            if ((part.Flags & PrimFlags.TemporaryOnRez) != 0) part.ResetExpire();
+            if ((part.Flags & PrimFlags.TemporaryOnRez) != 0)
+                part.ResetExpire();
 
             return part;
         }
@@ -1982,8 +1967,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool GetDieAtEdge()
         {
-            if (m_parentGroup == null)
-                return false;
             if (m_parentGroup.IsDeleted)
                 return false;
 
@@ -1992,8 +1975,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool GetReturnAtEdge()
         {
-            if (m_parentGroup == null)
-                return false;
             if (m_parentGroup.IsDeleted)
                 return false;
 
@@ -2002,8 +1983,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetReturnAtEdge(bool p)
         {
-            if (m_parentGroup == null)
-                return;
             if (m_parentGroup.IsDeleted)
                 return;
 
@@ -2012,8 +1991,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool GetBlockGrab()
         {
-            if (m_parentGroup == null)
-                return false;
             if (m_parentGroup.IsDeleted)
                 return false;
 
@@ -2022,8 +1999,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetBlockGrab(bool p)
         {
-            if (m_parentGroup == null)
-                return;
             if (m_parentGroup.IsDeleted)
                 return;
 
@@ -2032,8 +2007,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetStatusSandbox(bool p)
         {
-            if (m_parentGroup == null)
-                return;
             if (m_parentGroup.IsDeleted)
                 return;
             StatusSandboxPos = m_parentGroup.RootPart.AbsolutePosition;
@@ -2042,8 +2015,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool GetStatusSandbox()
         {
-            if (m_parentGroup == null)
-                return false;
             if (m_parentGroup.IsDeleted)
                 return false;
 
@@ -2085,25 +2056,17 @@ namespace OpenSim.Region.Framework.Scenes
         public Vector3 GetGeometricCenter()
         {
             if (PhysActor != null)
-            {
                 return new Vector3(PhysActor.CenterOfMass.X, PhysActor.CenterOfMass.Y, PhysActor.CenterOfMass.Z);
-            }
             else
-            {
                 return new Vector3(0, 0, 0);
-            }
         }
 
         public float GetMass()
         {
             if (PhysActor != null)
-            {
                 return PhysActor.Mass;
-            }
             else
-            {
                 return 0;
-            }
         }
 
         public Vector3 GetForce()
@@ -2119,19 +2082,12 @@ namespace OpenSim.Region.Framework.Scenes
             client.SendObjectPropertiesReply(this);
         }
 
-        public UUID GetRootPartUUID()
-        {
-            if (m_parentGroup != null)
-            {
-                return m_parentGroup.UUID;
-            }
-            return UUID.Zero;
-        }
-
         /// <summary>
         /// Method for a prim to get it's world position from the group.
-        /// Remember, the Group Position simply gives the position of the group itself
         /// </summary>
+        /// <remarks>
+        /// Remember, the Group Position simply gives the position of the group itself
+        /// </remarks>
         /// <returns>A Linked Child Prim objects position in world</returns>
         public Vector3 GetWorldPosition()
         {
@@ -2249,8 +2205,6 @@ namespace OpenSim.Region.Framework.Scenes
                 m_lastColliders.Remove(localID);
             }
 
-            if (m_parentGroup == null)
-                return;
             if (m_parentGroup.IsDeleted)
                 return;
 
@@ -2271,9 +2225,6 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if (localId == 0)
                             continue;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
                         
                         if (m_parentGroup.Scene == null)
                             return;
@@ -2282,7 +2233,8 @@ namespace OpenSim.Region.Framework.Scenes
                         string data = "";
                         if (obj != null)
                         {
-                            if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(obj.UUID.ToString()) || m_parentGroup.RootPart.CollisionFilter.ContainsValue(obj.Name))
+                            if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(obj.UUID.ToString())
+                                || m_parentGroup.RootPart.CollisionFilter.ContainsValue(obj.Name))
                             {
                                 bool found = m_parentGroup.RootPart.CollisionFilter.TryGetValue(1,out data);
                                 //If it is 1, it is to accept ONLY collisions from this object
@@ -2329,7 +2281,8 @@ namespace OpenSim.Region.Framework.Scenes
                             {
                                 if (av.LocalId == localId)
                                 {
-                                    if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.UUID.ToString()) || m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.Name))
+                                    if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.UUID.ToString())
+                                        || m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.Name))
                                     {
                                         bool found = m_parentGroup.RootPart.CollisionFilter.TryGetValue(1, out data);
                                         //If it is 1, it is to accept ONLY collisions from this avatar
@@ -2377,12 +2330,10 @@ namespace OpenSim.Region.Framework.Scenes
                     if (colliding.Count > 0)
                     {
                         StartCollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
                         
                         if (m_parentGroup.Scene == null)
                             return;
+
                         if (m_parentGroup.PassCollision == true)
                         {
                             //TODO: Add pass to root prim!
@@ -2403,9 +2354,6 @@ namespace OpenSim.Region.Framework.Scenes
                         // always running this check because if the user deletes the object it would return a null reference.
                         if (localId == 0)
                             continue;
-
-                        if (m_parentGroup == null)
-                            return;
                         
                         if (m_parentGroup.Scene == null)
                             return;
@@ -2414,7 +2362,8 @@ namespace OpenSim.Region.Framework.Scenes
                         string data = "";
                         if (obj != null)
                         {
-                            if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(obj.UUID.ToString()) || m_parentGroup.RootPart.CollisionFilter.ContainsValue(obj.Name))
+                            if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(obj.UUID.ToString())
+                                || m_parentGroup.RootPart.CollisionFilter.ContainsValue(obj.Name))
                             {
                                 bool found = m_parentGroup.RootPart.CollisionFilter.TryGetValue(1,out data);
                                 //If it is 1, it is to accept ONLY collisions from this object
@@ -2461,7 +2410,8 @@ namespace OpenSim.Region.Framework.Scenes
                             {
                                 if (av.LocalId == localId)
                                 {
-                                    if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.UUID.ToString()) || m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.Name))
+                                    if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.UUID.ToString())
+                                        || m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.Name))
                                     {
                                         bool found = m_parentGroup.RootPart.CollisionFilter.TryGetValue(1, out data);
                                         //If it is 1, it is to accept ONLY collisions from this avatar
@@ -2509,9 +2459,6 @@ namespace OpenSim.Region.Framework.Scenes
                     if (colliding.Count > 0)
                     {
                         CollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
                         
                         if (m_parentGroup.Scene == null)
                             return;
@@ -2532,11 +2479,9 @@ namespace OpenSim.Region.Framework.Scenes
                         if (localId == 0)
                             continue;
 
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
                         if (m_parentGroup.Scene == null)
                             return;
+
                         SceneObjectPart obj = m_parentGroup.Scene.GetSceneObjectPart(localId);
                         string data = "";
                         if (obj != null)
@@ -2588,7 +2533,8 @@ namespace OpenSim.Region.Framework.Scenes
                             {
                                 if (av.LocalId == localId)
                                 {
-                                    if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.UUID.ToString()) || m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.Name))
+                                    if (m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.UUID.ToString())
+                                        || m_parentGroup.RootPart.CollisionFilter.ContainsValue(av.Name))
                                     {
                                         bool found = m_parentGroup.RootPart.CollisionFilter.TryGetValue(1, out data);
                                         //If it is 1, it is to accept ONLY collisions from this avatar
@@ -2637,9 +2583,6 @@ namespace OpenSim.Region.Framework.Scenes
                     if (colliding.Count > 0)
                     {
                         EndCollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
                         
                         if (m_parentGroup.Scene == null)
                             return;
@@ -2648,6 +2591,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
             }
+
             if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.land_collision_start) != 0)
             {
                 if (startedColliders.Count > 0)
@@ -2675,9 +2619,6 @@ namespace OpenSim.Region.Framework.Scenes
                     if (colliding.Count > 0)
                     {
                         LandStartCollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
 
                         if (m_parentGroup.Scene == null)
                             return;
@@ -2686,6 +2627,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
             }
+
             if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.land_collision) != 0)
             {
                 if (m_lastColliders.Count > 0)
@@ -2713,9 +2655,6 @@ namespace OpenSim.Region.Framework.Scenes
                     if (colliding.Count > 0)
                     {
                         LandCollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
 
                         if (m_parentGroup.Scene == null)
                             return;
@@ -2724,6 +2663,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
             }
+
             if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.land_collision_end) != 0)
             {
                 if (endedColliders.Count > 0)
@@ -2751,9 +2691,6 @@ namespace OpenSim.Region.Framework.Scenes
                     if (colliding.Count > 0)
                     {
                         LandEndCollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
 
                         if (m_parentGroup.Scene == null)
                             return;
@@ -2777,10 +2714,12 @@ namespace OpenSim.Region.Framework.Scenes
         {
             if (PhysActor != null)
             {
-                
                 Vector3 newpos = new Vector3(PhysActor.Position.GetBytes(), 0);
                 
-                if (m_parentGroup.Scene.TestBorderCross(newpos, Cardinals.N) | m_parentGroup.Scene.TestBorderCross(newpos, Cardinals.S) | m_parentGroup.Scene.TestBorderCross(newpos, Cardinals.E) | m_parentGroup.Scene.TestBorderCross(newpos, Cardinals.W))
+                if (m_parentGroup.Scene.TestBorderCross(newpos, Cardinals.N)
+                    | m_parentGroup.Scene.TestBorderCross(newpos, Cardinals.S)
+                    | m_parentGroup.Scene.TestBorderCross(newpos, Cardinals.E)
+                    | m_parentGroup.Scene.TestBorderCross(newpos, Cardinals.W))
                 {
                     m_parentGroup.AbsolutePosition = newpos;
                     return;
@@ -2869,13 +2808,29 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Resize this part.
+        /// Set the scale of this part.
         /// </summary>
+        /// <remarks>
+        /// Unlike the scale property, this checks the new size against scene limits and schedules a full property
+        /// update to viewers.
+        /// </remarks>
         /// <param name="scale"></param>
         public void Resize(Vector3 scale)
         {
-            StoreUndoState(UndoType.STATE_PRIM_SCALE);
-            m_shape.Scale = scale;
+            scale.X = Math.Min(scale.X, ParentGroup.Scene.m_maxNonphys);
+            scale.Y = Math.Min(scale.Y, ParentGroup.Scene.m_maxNonphys);
+            scale.Z = Math.Min(scale.Z, ParentGroup.Scene.m_maxNonphys);
+
+            if (PhysActor != null && PhysActor.IsPhysical)
+            {
+                scale.X = Math.Min(scale.X, ParentGroup.Scene.m_maxPhys);
+                scale.Y = Math.Min(scale.Y, ParentGroup.Scene.m_maxPhys);
+                scale.Z = Math.Min(scale.Z, ParentGroup.Scene.m_maxPhys);
+            }
+
+//            m_log.DebugFormat("[SCENE OBJECT PART]: Resizing {0} {1} to {2}", Name, LocalId, scale);
+
+            Scale = scale;
 
             ParentGroup.HasGroupChanged = true;
             ScheduleFullUpdate();
@@ -2886,20 +2841,48 @@ namespace OpenSim.Region.Framework.Scenes
                 m_parentGroup.rotLookAt(target, strength, damping);  // This calls method in SceneObjectGroup.
         }
 
+        public void rotLookAt(Quaternion target, float strength, float damping)
+        {
+            if (m_parentGroup.IsAttachment)
+            {
+                /*
+                    ScenePresence avatar = m_scene.GetScenePresence(rootpart.AttachedAvatar);
+                    if (avatar != null)
+                    {
+                    Rotate the Av?
+                    } */
+            }
+            else
+            {
+                APIDDamp = damping;
+                APIDStrength = strength;
+                APIDTarget = target;
+            }
+        }
+
+        public void startLookAt(Quaternion rot, float damp, float strength)
+        {
+            APIDDamp = damp;
+            APIDStrength = strength;
+            APIDTarget = rot;
+        }
+
+        public void stopLookAt()
+        {
+            APIDTarget = Quaternion.Identity;
+        }
+
         /// <summary>
         /// Schedules this prim for a full update
         /// </summary>
         public void ScheduleFullUpdate()
         {
 //            m_log.DebugFormat("[SCENE OBJECT PART]: Scheduling full update for {0} {1}", Name, LocalId);
-            
-            if (m_parentGroup != null)
-            {
-                if (!m_parentGroup.areUpdatesSuspended)
-                {
-                    m_parentGroup.QueueForUpdateCheck();   
-                }
-            }
+
+            if (m_parentGroup == null)
+                return;
+
+            m_parentGroup.QueueForUpdateCheck();
 
             int timeNow = Util.UnixTimeSinceEpoch();
 
@@ -2928,13 +2911,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void ScheduleTerseUpdate()
         {
+            if (m_parentGroup == null)
+                return;
+
             if (m_updateFlag < 1)
             {
-                if (m_parentGroup != null)
-                {
-                    m_parentGroup.HasGroupChanged = true;
-                    m_parentGroup.QueueForUpdateCheck();
-                }
+                m_parentGroup.HasGroupChanged = true;
+                m_parentGroup.QueueForUpdateCheck();
+
                 TimeStampTerse = (uint) Util.UnixTimeSinceEpoch();
                 m_updateFlag = 1;
 
@@ -2944,40 +2928,16 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void ScriptSetPhantomStatus(bool Phantom)
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.ScriptSetPhantomStatus(Phantom);
-            }
-        }
-
-        public void ScriptSetTemporaryStatus(bool Temporary)
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.ScriptSetTemporaryStatus(Temporary);
-            }
-        }
-
         public void ScriptSetPhysicsStatus(bool UsePhysics)
         {
-            if (m_parentGroup == null)
-                DoPhysicsPropertyUpdate(UsePhysics, false);
-            else
-                m_parentGroup.ScriptSetPhysicsStatus(UsePhysics);
+            m_parentGroup.ScriptSetPhysicsStatus(UsePhysics);
         }
 
-        public void ScriptSetVolumeDetect(bool SetVD)
-        {
-
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.ScriptSetVolumeDetect(SetVD);
-            }
-        }
-
-        public void SculptTextureCallback(UUID textureID, AssetBase texture)
+        /// <summary>
+        /// Set sculpt and mesh data, and tell the physics engine to process the change.
+        /// </summary>
+        /// <param name="texture">The mesh itself.</param>
+        public void SculptTextureCallback(AssetBase texture)
         {
             if (m_shape.SculptEntry)
             {
@@ -2985,14 +2945,17 @@ namespace OpenSim.Region.Framework.Scenes
                 //if (texture != null)
                 {
                     if (texture != null)
+                    {
+//                        m_log.DebugFormat(
+//                            "[SCENE OBJECT PART]: Setting sculpt data for {0} on SculptTextureCallback()", Name);
+
                         m_shape.SculptData = texture.Data;
+                    }
 
                     if (PhysActor != null)
                     {
-                        // Tricks physics engine into thinking we've changed the part shape.
-                        PrimitiveBaseShape m_newshape = m_shape.Copy();
-                        PhysActor.Shape = m_newshape;
-                        m_shape = m_newshape;
+                        // Update the physics actor with the new loaded sculpt data and set the taint signal.
+                        PhysActor.Shape = m_shape;
 
                         m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
                     }
@@ -3000,16 +2963,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-//        /// <summary>
-//        ///
-//        /// </summary>
-//        /// <param name="remoteClient"></param>
-//        public void SendFullUpdate(IClientAPI remoteClient, uint clientFlags)
-//        {
-//            m_parentGroup.SendPartFullUpdate(remoteClient, this, clientFlags);
-//        }
-
-
         /// <summary>
         /// Send a full update to the client for the given part
         /// </summary>
@@ -3017,12 +2970,15 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="clientFlags"></param>
         protected internal void SendFullUpdate(IClientAPI remoteClient, uint clientFlags)
         {
+            if (m_parentGroup == null)
+                return;
+
 //            m_log.DebugFormat(
 //                "[SOG]: Sendinging part full update to {0} for {1} {2}", remoteClient.Name, part.Name, part.LocalId);
             
             if (IsRoot)
             {
-                if (IsAttachment)
+                if (m_parentGroup.IsAttachment)
                 {
                     SendFullUpdateToClient(remoteClient, AttachedPos, clientFlags);
                 }
@@ -3042,6 +2998,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void SendFullUpdateToAllClients()
         {
+            if (m_parentGroup == null)
+                return;
+
             m_parentGroup.Scene.ForEachScenePresence(delegate(ScenePresence avatar)
             {
                 SendFullUpdate(avatar.ControllingClient, avatar.GenerateClientFlags(UUID));
@@ -3054,6 +3013,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="agentID"></param>
         public void SendFullUpdateToAllClientsExcept(UUID agentID)
         {
+            if (m_parentGroup == null)
+                return;
+
             m_parentGroup.Scene.ForEachScenePresence(delegate(ScenePresence avatar)
             {
                 // Ugly reference :(
@@ -3082,9 +3044,12 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="clientFlags"></param>
         public void SendFullUpdateToClient(IClientAPI remoteClient, Vector3 lPos, uint clientFlags)
         {
+            if (ParentGroup == null)
+                return;
+
             // Suppress full updates during attachment editing
             //
-            if (ParentGroup.IsSelected && IsAttachment)
+            if (ParentGroup.IsSelected && ParentGroup.IsAttachment)
                 return;
             
             if (ParentGroup.IsDeleted)
@@ -3177,7 +3142,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             UUID ownerID = _ownerID;
             UUID objectID = ParentGroup.RootPart.UUID;
-            UUID parentID = GetRootPartUUID();
+            UUID parentID = ParentGroup.UUID;
 
             UUID soundID = UUID.Zero;
             Vector3 position = AbsolutePosition; // region local
@@ -3215,7 +3180,7 @@ namespace OpenSim.Region.Framework.Scenes
                         ParentGroup.PlaySoundMasterPrim = this;
                         ownerID = _ownerID;
                         objectID = ParentGroup.RootPart.UUID;
-                        parentID = GetRootPartUUID();
+                        parentID = ParentGroup.UUID;
                         position = AbsolutePosition; // region local
                         regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
                         if (triggered)
@@ -3226,7 +3191,7 @@ namespace OpenSim.Region.Framework.Scenes
                         {
                             ownerID = prim._ownerID;
                             objectID = prim.ParentGroup.RootPart.UUID;
-                            parentID = prim.GetRootPartUUID();
+                            parentID = prim.ParentGroup.UUID;
                             position = prim.AbsolutePosition; // region local
                             regionHandle = prim.ParentGroup.Scene.RegionInfo.RegionHandle;
                             if (triggered)
@@ -3263,45 +3228,23 @@ namespace OpenSim.Region.Framework.Scenes
             });
         }
 
-        public void SetAttachmentPoint(uint AttachmentPoint)
-        {
-            this.AttachmentPoint = AttachmentPoint;
-
-            if (AttachmentPoint != 0)
-            {
-                IsAttachment = true;
-            }
-            else
-            {
-                IsAttachment = false;
-            }
-
-            // save the attachment point.
-            //if (AttachmentPoint != 0)
-            //{
-                m_shape.State = (byte)AttachmentPoint;
-            //}
-        }
-
         public void SetAxisRotation(int axis, int rotate)
         {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.SetAxisRotation(axis, rotate);
-            }
+            m_parentGroup.SetAxisRotation(axis, rotate);
+
             //Cannot use ScriptBaseClass constants as no referance to it currently.
             if (axis == 2)//STATUS_ROTATE_X
                 STATUS_ROTATE_X = rotate;
+
             if (axis == 4)//STATUS_ROTATE_Y
                 STATUS_ROTATE_Y = rotate;
+
             if (axis == 8)//STATUS_ROTATE_Z
                 STATUS_ROTATE_Z = rotate;
         }
 
         public void SetDieAtEdge(bool p)
         {
-            if (m_parentGroup == null)
-                return;
             if (m_parentGroup.IsDeleted)
                 return;
 
@@ -3554,7 +3497,7 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        ///
+        /// Set the parent group of this prim.
         /// </summary>
         public void SetParent(SceneObjectGroup parent)
         {
@@ -3611,8 +3554,11 @@ namespace OpenSim.Region.Framework.Scenes
         {
             Text = text;
 
-            ParentGroup.HasGroupChanged = true;
-            ScheduleFullUpdate();
+            if (ParentGroup != null)
+            {
+                ParentGroup.HasGroupChanged = true;
+                ScheduleFullUpdate();
+            }
         }
         
         public void StopLookAt()
@@ -3646,24 +3592,44 @@ namespace OpenSim.Region.Framework.Scenes
         }
         public void StoreUndoState(UndoType type)
         {
-            if (!Undoing && (m_parentGroup == null || m_parentGroup.RootPart == null || !m_parentGroup.RootPart.Undoing))
+            StoreUndoState(false);
+        }
+
+        public void StoreUndoState(bool forGroup)
+        {
+            if (!Undoing)
             {
                 if (!IgnoreUndoUpdate)
                 {
-                    if (m_parentGroup != null)
+                    if (ParentGroup != null)
                     {
                         lock (m_undo)
                         {
                             if (m_undo.Count > 0)
                             {
                                 UndoState last = m_undo.Peek();
-                                
+                                if (last != null)
+                                {
+                                    // TODO: May need to fix for group comparison
+                                    if (last.Compare(this))
+                                    {
+    //                                        m_log.DebugFormat(
+    //                                            "[SCENE OBJECT PART]: Not storing undo for {0} {1} since current state is same as last undo state, initial stack size {2}",
+    //                                            Name, LocalId, m_undo.Count);
+    
+                                        return;
+                                    }
+                                }
                             }
-
+    
+    //                            m_log.DebugFormat(
+    //                                "[SCENE OBJECT PART]: Storing undo state for {0} {1}, forGroup {2}, initial stack size {3}",
+    //                                Name, LocalId, forGroup, m_undo.Count);
+    
                             if (m_parentGroup.GetSceneMaxUndo() > 0)
                             {
-                                UndoState lastUndo = m_undo.Peek();
-
+                                UndoState nUndo = new UndoState(this, forGroup);
+    
                                 UndoState nUndo = new UndoState(this, type);
 
                                 if (lastUndo != null)
@@ -3677,11 +3643,114 @@ namespace OpenSim.Region.Framework.Scenes
                                     }
                                 }
                                 m_undo.Push(nUndo);
+    
+                                if (m_redo.Count > 0)
+                                    m_redo.Clear();
+    
+    //                                m_log.DebugFormat(
+    //                                    "[SCENE OBJECT PART]: Stored undo state for {0} {1}, forGroup {2}, stack size now {3}",
+    //                                    Name, LocalId, forGroup, m_undo.Count);
                             }
+                        }
+                    }
+                }
+//                else
+//                {
+//                    m_log.DebugFormat("[SCENE OBJECT PART]: Ignoring undo store for {0} {1}", Name, LocalId);
+//                }
+            }
+//            else
+//            {
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT PART]: Ignoring undo store for {0} {1} since already undoing", Name, LocalId);
+//            }
+        }
+
+        /// <summary>
+        /// Return number of undos on the stack.  Here temporarily pending a refactor.
+        /// </summary>
+        public int UndoCount
+        {
+            get
+            {
+                lock (m_undo)
+                    return m_undo.Count;
+            }
+        }
+
+        public void Undo()
+        {
+            lock (m_undo)
+            {
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT PART]: Handling undo request for {0} {1}, stack size {2}",
+//                    Name, LocalId, m_undo.Count);
+
+                if (m_undo.Count > 0)
+                {
+                    UndoState goback = m_undo.Pop();
 
+                    if (goback != null)
+                    {
+                        UndoState nUndo = null;
+        
+                        if (m_parentGroup.GetSceneMaxUndo() > 0)
+                        {
+                            nUndo = new UndoState(this, goback.ForGroup);
                         }
+
+                        goback.PlaybackState(this);
+
+                        if (nUndo != null)
+                            m_redo.Push(nUndo);
                     }
                 }
+
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT PART]: Handled undo request for {0} {1}, stack size now {2}",
+//                    Name, LocalId, m_undo.Count);
+            }
+        }
+
+        public void Redo()
+        {
+            lock (m_undo)
+            {
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT PART]: Handling redo request for {0} {1}, stack size {2}",
+//                    Name, LocalId, m_redo.Count);
+
+                if (m_redo.Count > 0)
+                {
+                    UndoState gofwd = m_redo.Pop();
+    
+                    if (gofwd != null)
+                    {
+                        if (m_parentGroup.GetSceneMaxUndo() > 0)
+                        {
+                            UndoState nUndo = new UndoState(this, gofwd.ForGroup);
+    
+                            m_undo.Push(nUndo);
+                        }
+    
+                        gofwd.PlayfwdState(this);
+                    }
+
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT PART]: Handled redo request for {0} {1}, stack size now {2}",
+//                    Name, LocalId, m_redo.Count);
+                }
+            }
+        }
+
+        public void ClearUndoState()
+        {
+//            m_log.DebugFormat("[SCENE OBJECT PART]: Clearing undo and redo stacks in {0} {1}", Name, LocalId);
+
+            lock (m_undo)
+            {
+                m_undo.Clear();
+                m_redo.Clear();
             }
         }
 
@@ -4145,46 +4214,6 @@ namespace OpenSim.Region.Framework.Scenes
             _nextOwnerMask &= (uint)PermissionMask.All;
         }
 
-        public void Undo()
-        {
-            lock (m_undo)
-            {
-                if (m_undo.Count > 0)
-                {
-                    UndoState nUndo = null;
-                    UndoState goback = m_undo.Pop();
-                    if (m_parentGroup.GetSceneMaxUndo() > 0)
-                    {
-                        nUndo = new UndoState(this, goback.Type);
-                    }
-
-                    
-                    if (goback != null)
-                    {
-                        goback.PlaybackState(this);
-                        if (nUndo != null)
-                            m_redo.Push(nUndo);
-                    }
-                }
-            }
-        }
-
-        public void Redo()
-        {
-            lock (m_redo)
-            {
-                UndoState gofwd = m_redo.Pop();
-                if (m_parentGroup.GetSceneMaxUndo() > 0)
-                {
-                    UndoState nUndo = new UndoState(this, gofwd.Type);
-
-                    m_undo.Push(nUndo);
-                }
-                if (gofwd != null)
-                    gofwd.PlayfwdState(this);
-            }
-        }
-
         public void UpdateExtraParam(ushort type, bool inUse, byte[] data)
         {
             m_shape.ReadInUpdateExtraParam(type, inUse, data);
@@ -4197,8 +4226,11 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
 
-            ParentGroup.HasGroupChanged = true;
-            ScheduleFullUpdate();
+            if (ParentGroup != null)
+            {
+                ParentGroup.HasGroupChanged = true;
+                ScheduleFullUpdate();
+            }
         }
 
         public void UpdateGroupPosition(Vector3 pos)
@@ -4345,14 +4377,21 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void UpdatePrimFlags(bool UsePhysics, bool IsTemporary, bool IsPhantom, bool IsVD)
+        /// <summary>
+        /// Update the flags on this prim.  This covers properties such as phantom, physics and temporary.
+        /// </summary>
+        /// <param name="UsePhysics"></param>
+        /// <param name="SetTemporary"></param>
+        /// <param name="SetPhantom"></param>
+        /// <param name="SetVD"></param>
+        public void UpdatePrimFlags(bool UsePhysics, bool SetTemporary, bool SetPhantom, bool SetVD)
         {
             bool wasUsingPhysics = ((Flags & PrimFlags.Physics) != 0);
             bool wasTemporary = ((Flags & PrimFlags.TemporaryOnRez) != 0);
             bool wasPhantom = ((Flags & PrimFlags.Phantom) != 0);
             bool wasVD = VolumeDetectActive;
 
-            if ((UsePhysics == wasUsingPhysics) && (wasTemporary == IsTemporary) && (wasPhantom == IsPhantom) && (IsVD==wasVD))
+            if ((UsePhysics == wasUsingPhysics) && (wasTemporary == SetTemporary) && (wasPhantom == SetPhantom) && (SetVD == wasVD))
             {
                 return;
             }
@@ -4362,32 +4401,31 @@ namespace OpenSim.Region.Framework.Scenes
             // that...
             // ... if VD is changed, all others are not.
             // ... if one of the others is changed, VD is not.
-            if (IsVD) // VD is active, special logic applies
+            if (SetVD) // VD is active, special logic applies
             {
                 // State machine logic for VolumeDetect
                 // More logic below
-                bool phanReset = (IsPhantom != wasPhantom) && !IsPhantom;
+                bool phanReset = (SetPhantom != wasPhantom) && !SetPhantom;
 
                 if (phanReset) // Phantom changes from on to off switch VD off too
                 {
-                    IsVD = false;               // Switch it of for the course of this routine
+                    SetVD = false;               // Switch it of for the course of this routine
                     VolumeDetectActive = false; // and also permanently
                     if (PhysActor != null)
                         PhysActor.SetVolumeDetect(0);   // Let physics know about it too
                 }
                 else
                 {
-                    IsPhantom = false;
                     // If volumedetect is active we don't want phantom to be applied.
                     // If this is a new call to VD out of the state "phantom"
                     // this will also cause the prim to be visible to physics
+                    SetPhantom = false;
                 }
-
             }
 
             if (UsePhysics && IsJoint())
             {
-                IsPhantom = true;
+                SetPhantom = true;
             }
 
             if (UsePhysics)
@@ -4396,14 +4434,12 @@ namespace OpenSim.Region.Framework.Scenes
                 if (!wasUsingPhysics)
                 {
                     DoPhysicsPropertyUpdate(UsePhysics, false);
-                    if (m_parentGroup != null)
+
+                    if (!m_parentGroup.IsDeleted)
                     {
-                        if (!m_parentGroup.IsDeleted)
+                        if (LocalId == m_parentGroup.RootPart.LocalId)
                         {
-                            if (LocalId == m_parentGroup.RootPart.LocalId)
-                            {
-                                m_parentGroup.CheckSculptAndLoad();
-                            }
+                            m_parentGroup.CheckSculptAndLoad();
                         }
                     }
                 }
@@ -4417,8 +4453,9 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
 
-
-            if (IsPhantom || IsAttachment || (Shape.PathCurve == (byte)Extrusion.Flexible)) // note: this may have been changed above in the case of joints
+            if (SetPhantom
+                || ParentGroup.IsAttachment
+                || (Shape.PathCurve == (byte)Extrusion.Flexible)) // note: this may have been changed above in the case of joints
             {
                 AddFlag(PrimFlags.Phantom);
                 if (PhysActor != null)
@@ -4432,7 +4469,11 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 RemFlag(PrimFlags.Phantom);
 
+                if (ParentGroup.Scene == null)
+                    return;
+
                 PhysicsActor pa = PhysActor;
+
                 if (pa == null)
                 {
                     // It's not phantom anymore. So make sure the physics engine get's knowledge of it
@@ -4444,22 +4485,21 @@ namespace OpenSim.Region.Framework.Scenes
                         RotationOffset,
                         UsePhysics,
                         m_localId);
-                    PhysActor.SetMaterial(Material);
 
                     pa = PhysActor;
                     if (pa != null)
                     {
+                        PhysActor.SetMaterial(Material);
                         DoPhysicsPropertyUpdate(UsePhysics, true);
-                        if (m_parentGroup != null)
+
+                        if (!m_parentGroup.IsDeleted)
                         {
-                            if (!m_parentGroup.IsDeleted)
+                            if (LocalId == m_parentGroup.RootPart.LocalId)
                             {
-                                if (LocalId == m_parentGroup.RootPart.LocalId)
-                                {
-                                    m_parentGroup.CheckSculptAndLoad();
-                                }
+                                m_parentGroup.CheckSculptAndLoad();
                             }
                         }
+
                         if (
                             ((AggregateScriptEvents & scriptEvents.collision) != 0) ||
                             ((AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
@@ -4470,8 +4510,8 @@ namespace OpenSim.Region.Framework.Scenes
                             (CollisionSound != UUID.Zero)
                             )
                         {
-                                PhysActor.OnCollisionUpdate += PhysicsCollision;
-                                PhysActor.SubscribeEvents(1000);
+                            PhysActor.OnCollisionUpdate += PhysicsCollision;
+                            PhysActor.SubscribeEvents(1000);
                         }
                     }
                 }
@@ -4480,20 +4520,18 @@ namespace OpenSim.Region.Framework.Scenes
                     pa.IsPhysical = UsePhysics;
 
                     DoPhysicsPropertyUpdate(UsePhysics, false); // Update physical status. If it's phantom this will remove the prim
-                    if (m_parentGroup != null)
+
+                    if (!m_parentGroup.IsDeleted)
                     {
-                        if (!m_parentGroup.IsDeleted)
+                        if (LocalId == m_parentGroup.RootPart.LocalId)
                         {
-                            if (LocalId == m_parentGroup.RootPart.LocalId)
-                            {
-                                m_parentGroup.CheckSculptAndLoad();
-                            }
+                            m_parentGroup.CheckSculptAndLoad();
                         }
                     }
                 }
             }
 
-            if (IsVD)
+            if (SetVD)
             {
                 // If the above logic worked (this is urgent candidate to unit tests!)
                 // we now have a physicsactor.
@@ -4508,18 +4546,19 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
             else
-            {   // Remove VolumeDetect in any case. Note, it's safe to call SetVolumeDetect as often as you like
+            {
+                // Remove VolumeDetect in any case. Note, it's safe to call SetVolumeDetect as often as you like
                 // (mumbles, well, at least if you have infinte CPU powers :-))
                 PhysicsActor pa = this.PhysActor;
                 if (pa != null)
                 {
                     PhysActor.SetVolumeDetect(0);
                 }
+
                 this.VolumeDetectActive = false;
             }
 
-
-            if (IsTemporary)
+            if (SetTemporary)
             {
                 AddFlag(PrimFlags.TemporaryOnRez);
             }
@@ -4529,8 +4568,13 @@ namespace OpenSim.Region.Framework.Scenes
             }
             //            m_log.Debug("Update:  PHY:" + UsePhysics.ToString() + ", T:" + IsTemporary.ToString() + ", PHA:" + IsPhantom.ToString() + " S:" + CastsShadows.ToString());
 
-            ParentGroup.HasGroupChanged = true;
-            ScheduleFullUpdate();
+            if (ParentGroup != null)
+            {
+                ParentGroup.HasGroupChanged = true;
+                ScheduleFullUpdate();
+            }
+
+//            m_log.DebugFormat("[SCENE OBJECT PART]: Updated PrimFlags on {0} {1} to {2}", Name, LocalId, Flags);
         }
 
         public void UpdateRotation(Quaternion rot)
@@ -4541,8 +4585,12 @@ namespace OpenSim.Region.Framework.Scenes
                 (rot.W != RotationOffset.W))
             {
                 RotationOffset = rot;
-                ParentGroup.HasGroupChanged = true;
-                ScheduleTerseUpdate();
+
+                if (ParentGroup != null)
+                {
+                    ParentGroup.HasGroupChanged = true;
+                    ScheduleTerseUpdate();
+                }
             }
         }
 
@@ -4570,6 +4618,7 @@ namespace OpenSim.Region.Framework.Scenes
             m_shape.PathTaperY = shapeBlock.PathTaperY;
             m_shape.PathTwist = shapeBlock.PathTwist;
             m_shape.PathTwistBegin = shapeBlock.PathTwistBegin;
+
             if (PhysActor != null)
             {
                 PhysActor.Shape = m_shape;
@@ -4591,11 +4640,46 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// If the part is a sculpt/mesh, retrieve the mesh data and reinsert it into the shape so that the physics
+        /// engine can use it.
+        /// </summary>
+        /// <remarks>
+        /// When the physics engine has finished with it, the sculpt data is discarded to save memory.
+        /// </remarks>
+        public void CheckSculptAndLoad()
+        {
+//            m_log.DebugFormat("Processing CheckSculptAndLoad for {0} {1}", Name, LocalId);
+
+            if (ParentGroup.IsDeleted)
+                return;
+
+            if ((ParentGroup.RootPart.GetEffectiveObjectFlags() & (uint)PrimFlags.Phantom) != 0)
+                return;
+
+            if (Shape.SculptEntry && Shape.SculptTexture != UUID.Zero)
+            {
+                // check if a previously decoded sculpt map has been cached
+                // We don't read the file here - the meshmerizer will do that later.
+                // TODO: Could we simplify the meshmerizer code by reading and setting the data here?
+                if (File.Exists(System.IO.Path.Combine("j2kDecodeCache", "smap_" + Shape.SculptTexture.ToString())))
+                {
+                    SculptTextureCallback(null);
+                }
+                else
+                {
+                    ParentGroup.Scene.AssetService.Get(Shape.SculptTexture.ToString(), this, AssetReceived);
+                }
+            }
+        }
+
+        /// <summary>
         /// Update the textures on the part.
         /// </summary>
+        /// <remarks>
         /// Added to handle bug in libsecondlife's TextureEntry.ToBytes()
         /// not handling RGBA properly. Cycles through, and "fixes" the color
         /// info
+        /// </remarks>
         /// <param name="tex"></param>
         public void UpdateTexture(Primitive.TextureEntry tex)
         {
@@ -4687,7 +4771,6 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     PhysActor.OnCollisionUpdate += PhysicsCollision;
                     PhysActor.SubscribeEvents(1000);
-
                 }
             }
             else
@@ -4699,14 +4782,6 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
 
-            if (m_parentGroup == null)
-            {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Scheduling part {0} {1} for full update in aggregateScriptEvents() since m_parentGroup == null", Name, LocalId);
-                ScheduleFullUpdate();
-                return;
-            }
-
             //if ((GetEffectiveObjectFlags() & (uint)PrimFlags.Scripted) != 0)
             //{
             //    m_parentGroup.Scene.EventManager.OnScriptTimerEvent += handleTimerAccounting;
@@ -4716,7 +4791,7 @@ namespace OpenSim.Region.Framework.Scenes
             //    m_parentGroup.Scene.EventManager.OnScriptTimerEvent -= handleTimerAccounting;
             //}
 
-            LocalFlags=(PrimFlags)objectflagupdate;
+            LocalFlags = (PrimFlags)objectflagupdate;
 
             if (m_parentGroup != null && m_parentGroup.RootPart == this)
             {
@@ -4730,40 +4805,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public int registerTargetWaypoint(Vector3 target, float tolerance)
-        {
-            if (m_parentGroup != null)
-            {
-                return m_parentGroup.registerTargetWaypoint(target, tolerance);
-            }
-            return 0;
-        }
-
-        public void unregisterTargetWaypoint(int handle)
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.unregisterTargetWaypoint(handle);
-            }
-        }
-
-        public int registerRotTargetWaypoint(Quaternion target, float tolerance)
-        {
-            if (m_parentGroup != null)
-            {
-                return m_parentGroup.registerRotTargetWaypoint(target, tolerance);
-            }
-            return 0;
-        }
-
-        public void unregisterRotTargetWaypoint(int handle)
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.unregisterRotTargetWaypoint(handle);
-            }
-        }
-
         public void SetCameraAtOffset(Vector3 v)
         {
             m_cameraAtOffset = v;
@@ -4803,10 +4844,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SendTerseUpdateToClient(IClientAPI remoteClient)
         {
-            if (ParentGroup == null || ParentGroup.IsDeleted)
+            if (ParentGroup.IsDeleted)
                 return;
 
-            if (IsAttachment && ParentGroup.RootPart != this)
+            if (ParentGroup.IsAttachment && ParentGroup.RootPart != this)
                 return;
             
             // Causes this thread to dig into the Client Thread Data.
@@ -4827,6 +4868,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             Inventory.ApplyNextOwnerPermissions();
         }
+
         public void UpdateLookAt()
         {
             try
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index 56680df..1f0840d 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -118,14 +118,17 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Reset UUIDs for all the items in the prim's inventory.  This involves either generating
+        /// Reset UUIDs for all the items in the prim's inventory.
+        /// </summary>
+        /// <remarks>
+        /// This involves either generating
         /// new ones or setting existing UUIDs to the correct parent UUIDs.
         ///
         /// If this method is called and there are inventory items, then we regard the inventory as having changed.
-        /// </summary>
-        /// <param name="linkNum">Link number for the part</param>
+        /// </remarks>
         public void ResetInventoryIDs()
         {
+            if (null == m_part)
             m_items.LockItemsForWrite(true);
 
             if (Items.Count == 0)
@@ -212,7 +215,7 @@ namespace OpenSim.Region.Framework.Scenes
             // Don't let this set the HasGroupChanged flag for attachments
             // as this happens during rez and we don't want a new asset
             // for each attachment each time
-            if (!m_part.ParentGroup.RootPart.IsAttachment)
+            if (!m_part.ParentGroup.IsAttachment)
             {
                 HasInventoryChanged = true;
                 m_part.ParentGroup.HasGroupChanged = true;
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index d2f84e3..de9b1f3 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -67,7 +67,7 @@ namespace OpenSim.Region.Framework.Scenes
 
     public delegate void SendCourseLocationsMethod(UUID scene, ScenePresence presence, List<Vector3> coarseLocations, List<UUID> avatarUUIDs);
 
-    public class ScenePresence : EntityBase, ISceneEntity
+    public class ScenePresence : EntityBase, IScenePresence
     {
 //        ~ScenePresence()
 //        {
@@ -76,6 +76,8 @@ namespace OpenSim.Region.Framework.Scenes
         
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        public PresenceType PresenceType { get; private set; }
+
 //        private static readonly byte[] DEFAULT_TEXTURE = AvatarAppearance.GetDefaultTexture().GetBytes();
         private static readonly Array DIR_CONTROL_FLAGS = Enum.GetValues(typeof(Dir_ControlFlags));
         private static readonly Vector3 HEAD_ADJUSTMENT = new Vector3(0f, 0f, 0.3f);
@@ -92,6 +94,13 @@ namespace OpenSim.Region.Framework.Scenes
                 // Value revised by KF 091121 by comparison with SL.
         private static readonly Vector3 SIT_TARGET_ADJUSTMENT = new Vector3(0.0f, 0.0f, 0.418f);
 
+        /// <summary>
+        /// Movement updates for agents in neighboring regions are sent directly to clients.
+        /// This value only affects how often agent positions are sent to neighbor regions
+        /// for things such as distance-based update prioritization
+        /// </summary>
+        public static readonly float SIGNIFICANT_MOVEMENT = 2.0f;
+
         public UUID currentParcelUUID = UUID.Zero;
 
         private ISceneViewer m_sceneViewer;
@@ -105,14 +114,13 @@ namespace OpenSim.Region.Framework.Scenes
         }
         protected ScenePresenceAnimator m_animator;
 
-        /// <value>
-        /// The scene objects attached to this avatar.  Do not change this list directly - use methods such as
-        /// AddAttachment() and RemoveAttachment().  Lock this list when performing any read operations upon it.
-        /// </value>
-        public List<SceneObjectGroup> Attachments
-        {
-            get { return m_attachments; }
-        }
+        /// <summary>
+        /// Attachments recorded on this avatar.
+        /// </summary>
+        /// <remarks>
+        /// TODO: For some reason, we effectively have a list both here and in Appearance.  Need to work out if this is
+        /// necessary.
+        /// </remarks>
 
         protected List<SceneObjectGroup> m_attachments = new List<SceneObjectGroup>();
 
@@ -120,7 +128,7 @@ namespace OpenSim.Region.Framework.Scenes
         private ScriptControlled IgnoredControls = ScriptControlled.CONTROL_ZERO;
         private ScriptControlled LastCommands = ScriptControlled.CONTROL_ZERO;
         private bool MouseDown = false;
-        private SceneObjectGroup proxyObjectGroup;
+//        private SceneObjectGroup proxyObjectGroup;
         //private SceneObjectPart proxyObjectPart = null;
         public Vector3 lastKnownAllowedPosition;
         public Vector4 CollisionPlane = Vector4.UnitW;
@@ -178,7 +186,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         private float m_speedModifier = 1.0f;
 
-        private Quaternion m_bodyRot= Quaternion.Identity;
+        private Quaternion m_bodyRot = Quaternion.Identity;
 
         private Quaternion m_bodyRotPrevious = Quaternion.Identity;
 
@@ -224,8 +232,8 @@ namespace OpenSim.Region.Framework.Scenes
         private string m_nextSitAnimation = String.Empty;
 
         //PauPaw:Proper PID Controler for autopilot************
-        private bool m_moveToPositionInProgress;
-        private Vector3 m_moveToPositionTarget;
+        public bool MovingToTarget { get; private set; }
+        public Vector3 MoveToPositionTarget { get; private set; }
         private Quaternion m_offsetRotation = new Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
 
         private bool m_followCamAuto;
@@ -455,9 +463,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         protected PhysicsActor m_physicsActor;
 
-        /// <value>
-        /// The client controlling this presence
-        /// </value>
         public IClientAPI ControllingClient
         {
             get { return m_controllingClient; }
@@ -765,15 +770,13 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region Constructor(s)
         
-        public ScenePresence()
+        public ScenePresence(
+            IClientAPI client, Scene world, RegionInfo reginfo, AvatarAppearance appearance, PresenceType type)
         {
             m_sendCourseLocationsMethod = SendCoarseLocationsDefault;
-            CreateSceneViewer();
+            m_sceneViewer = new SceneViewer(this);
             m_animator = new ScenePresenceAnimator(this);
-        }
-
-        private ScenePresence(IClientAPI client, Scene world, RegionInfo reginfo) : this()
-        {
+            PresenceType = type;
             m_DrawDistance = world.DefaultDrawDistance;
             m_rootRegionHandle = reginfo.RegionHandle;
             m_controllingClient = client;
@@ -817,19 +820,10 @@ namespace OpenSim.Region.Framework.Scenes
 
             RegisterToEvents();
             SetDirectionVectors();
-        }
 
-        public ScenePresence(IClientAPI client, Scene world, RegionInfo reginfo, AvatarAppearance appearance)
-            : this(client, world, reginfo)
-        {
             m_appearance = appearance;
         }
 
-        private void CreateSceneViewer()
-        {
-            m_sceneViewer = new SceneViewer(this);
-        }
-
         public void RegisterToEvents()
         {
             m_controllingClient.OnCompleteMovementToRegion += CompleteMovement;
@@ -841,8 +835,7 @@ namespace OpenSim.Region.Framework.Scenes
             m_controllingClient.OnStartAnim += HandleStartAnim;
             m_controllingClient.OnStopAnim += HandleStopAnim;
             m_controllingClient.OnForceReleaseControls += HandleForceReleaseControls;
-            m_controllingClient.OnAutoPilotGo += DoAutoPilot;
-            m_controllingClient.AddGenericPacketHandler("autopilot", DoMoveToPosition);
+            m_controllingClient.OnAutoPilotGo += MoveToTarget;
 
             // ControllingClient.OnChildAgentStatus += new StatusChange(this.ChildStatusChange);
             // ControllingClient.OnStopMovement += new GenericCall2(this.StopMovement);
@@ -1029,11 +1022,8 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             float localAVHeight = 1.56f;
-            if (m_appearance != null)
-            {
-                if (m_appearance.AvatarHeight > 0)
-                    localAVHeight = m_appearance.AvatarHeight;
-            }
+            if (m_appearance.AvatarHeight > 0)
+                localAVHeight = m_appearance.AvatarHeight;
 
             float posZLimit = 0;
 
@@ -1047,26 +1037,8 @@ namespace OpenSim.Region.Framework.Scenes
             }
             AbsolutePosition = pos;
 
-            if (m_appearance != null)
-            {
-                if (m_appearance.AvatarHeight > 0)
-                    SetHeight(m_appearance.AvatarHeight);
-            }
-            else
-            {
-                m_log.ErrorFormat("[SCENE PRESENCE]: null appearance in MakeRoot in {0}", Scene.RegionInfo.RegionName);
-                // emergency; this really shouldn't happen
-                m_appearance = new AvatarAppearance(UUID);
-            }
-            
             AddToPhysicalScene(isFlying);
 
-            if (m_appearance != null)
-            {
-                if (m_appearance.AvatarHeight > 0)
-                    SetHeight(m_appearance.AvatarHeight);
-            }
-
             if (m_forceFly)
             {
                 m_physicsActor.Flying = true;
@@ -1087,15 +1059,18 @@ namespace OpenSim.Region.Framework.Scenes
             // and it has already rezzed the attachments and started their scripts.
             // We do the following only for non-login agents, because their scripts
             // haven't started yet.
-            if (wasChild && Attachments != null && Attachments.Count > 0)
+            lock (m_attachments)
             {
-                m_log.DebugFormat("[SCENE PRESENCE]: Restarting scripts in attachments...");
-                // Resume scripts
-                Attachments.ForEach(delegate(SceneObjectGroup sog)
+                if (wasChild && HasAttachments())
                 {
-                    sog.RootPart.ParentGroup.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, GetStateSource());
-                    sog.ResumeScripts();
-                });
+                    m_log.DebugFormat("[SCENE PRESENCE]: Restarting scripts in attachments...");
+                    // Resume scripts
+                    foreach (SceneObjectGroup sog in m_attachments)
+                    {
+                        sog.RootPart.ParentGroup.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, GetStateSource());
+                        sog.ResumeScripts();
+                    }
+                }
             }
 
             // send the animations of the other presences to me
@@ -1105,6 +1080,11 @@ namespace OpenSim.Region.Framework.Scenes
                     presence.Animator.SendAnimPackToClient(ControllingClient);
             });
 
+            // If we don't reset the movement flag here, an avatar that crosses to a neighbouring sim and returns will
+            // stall on the border crossing since the existing child agent will still have the last movement
+            // recorded, which stops the input from being processed.
+            m_movementflag = 0;
+
             m_scene.EventManager.TriggerOnMakeRootAgent(this);
         }
 
@@ -1196,11 +1176,6 @@ namespace OpenSim.Region.Framework.Scenes
             CheckLandingPoint(ref pos);
             AbsolutePosition = pos;
             AddToPhysicalScene(isFlying);
-            if (m_appearance != null)
-            {
-                if (m_appearance.AvatarHeight > 0)
-                    SetHeight(m_appearance.AvatarHeight);
-            }
 
             SendTerseUpdateToAllClients();
             
@@ -1216,22 +1191,10 @@ namespace OpenSim.Region.Framework.Scenes
             CheckLandingPoint(ref pos);
             AbsolutePosition = pos;
             AddToPhysicalScene(isFlying);
-            if (m_appearance != null)
-            {
-                if (m_appearance.AvatarHeight > 0)
-                    SetHeight(m_appearance.AvatarHeight);
-            }
 
             SendTerseUpdateToAllClients();
         }
 
-        /// <summary>
-        ///
-        /// </summary>
-        public void StopMovement()
-        {
-        }
-
         public void StopFlying()
         {
             ControllingClient.StopFlying(this);
@@ -1281,7 +1244,7 @@ namespace OpenSim.Region.Framework.Scenes
         #region Event Handlers
 
         /// <summary>
-        /// Sets avatar height in the phyiscs plugin
+        /// Sets avatar height in the physics plugin
         /// </summary>
         public void SetHeight(float height)
         {
@@ -1294,10 +1257,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Complete Avatar's movement into the region.
-        /// This is called upon a very important packet sent from the client,
-        /// so it's client-controlled. Never call this method directly.
         /// </summary>
-        public void CompleteMovement(IClientAPI client)
+        /// <param name="client"></param>
+        /// <param name="openChildAgents">
+        /// If true, send notification to neighbour regions to expect
+        /// a child agent from the client.  These neighbours can be some distance away, depending right now on the
+        /// configuration of DefaultDrawDistance in the [Startup] section of config
+        /// </param>
+        public void CompleteMovement(IClientAPI client, bool openChildAgents)
         {
 //            DateTime startTime = DateTime.Now;
             
@@ -1338,15 +1305,11 @@ namespace OpenSim.Region.Framework.Scenes
             SendInitialData();
 
             // Create child agents in neighbouring regions
-            if (!m_isChildAgent)
+            if (openChildAgents && !m_isChildAgent)
             {
                 IEntityTransferModule m_agentTransfer = m_scene.RequestModuleInterface<IEntityTransferModule>();
                 if (m_agentTransfer != null)
                     m_agentTransfer.EnableChildAgents(this);
-                else
-                    m_log.DebugFormat(
-                        "[SCENE PRESENCE]: Unable to create child agents in neighbours, because AgentTransferModule is not active for region {0}", 
-                        m_scene.RegionInfo.RegionName);
 
                 IFriendsModule friendsModule = m_scene.RequestModuleInterface<IFriendsModule>();
                 if (friendsModule != null)
@@ -1403,6 +1366,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void HandleAgentUpdate(IClientAPI remoteClient, AgentUpdateArgs agentData)
         {
+//            m_log.DebugFormat("[SCENE PRESENCE]: Received agent update from {0}", remoteClient.Name);
+
             //if (m_isChildAgent)
             //{
             //    // m_log.Debug("DEBUG: HandleAgentUpdate: child agent");
@@ -1445,7 +1410,6 @@ namespace OpenSim.Region.Framework.Scenes
             #region Inputs
 
             AgentManager.ControlFlags flags = (AgentManager.ControlFlags)agentData.ControlFlags;
-            Quaternion bodyRotation = agentData.BodyRotation;
 
             // Camera location in world.  We'll need to raytrace
             // from this location from time to time.
@@ -1530,23 +1494,29 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 return;
             }
-            
-            bool update_movementflag = false;
 
             if (m_allowMovement && !SitGround)
             {
+                Quaternion bodyRotation = agentData.BodyRotation;
+                bool update_rotation = false;
+
+                if (bodyRotation != m_bodyRot)
+                {
+                    Rotation = bodyRotation;
+                    update_rotation = true;
+                }
+
+                bool update_movementflag = false;
+
                 if (agentData.UseClientAgentPosition)
                 {
-                    m_moveToPositionInProgress = (agentData.ClientAgentPosition - AbsolutePosition).Length() > 0.2f;
-                    m_moveToPositionTarget = agentData.ClientAgentPosition;
+                    MovingToTarget = (agentData.ClientAgentPosition - AbsolutePosition).Length() > 0.2f;
+                    MoveToPositionTarget = agentData.ClientAgentPosition;
                 }
 
                 int i = 0;
-                
-                bool update_rotation = false;
                 bool DCFlagKeyPressed = false;
                 Vector3 agent_control_v3 = Vector3.Zero;
-                Quaternion q = bodyRotation;
 
                 bool oldflying = PhysicsActor.Flying;
 
@@ -1577,7 +1547,6 @@ namespace OpenSim.Region.Framework.Scenes
                 if (m_parentID == 0)
                 {
                     bool bAllowUpdateMoveToPosition = false;
-                    bool bResetMoveToPosition = false;
 
                     Vector3[] dirVectors;
 
@@ -1598,8 +1567,8 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if (((uint)flags & (uint)DCF) != 0)
                         {
-                            bResetMoveToPosition = true;
                             DCFlagKeyPressed = true;
+
                             try
                             {
                                 agent_control_v3 += dirVectors[i];
@@ -1615,6 +1584,8 @@ namespace OpenSim.Region.Framework.Scenes
 
                             if ((m_movementflag & (uint)DCF) == 0)
                             {
+
+//                                m_log.DebugFormat("[SCENE PRESENCE]: Updating m_movementflag for {0} with {1}", Name, DCF);
                                 m_movementflag += (byte)(uint)DCF;
                                 update_movementflag = true;
                             }
@@ -1631,10 +1602,10 @@ namespace OpenSim.Region.Framework.Scenes
                                 bAllowUpdateMoveToPosition = true;
                             }
                         }
+
                         i++;
                     }
-                    //Paupaw:Do Proper PID for Autopilot here
-                    if (bResetMoveToPosition)
+                    if (MovingToTarget)
                     {
                         m_moveToPositionTarget = Vector3.Zero;
                         m_moveToPositionInProgress = false;
@@ -1680,12 +1651,10 @@ namespace OpenSim.Region.Framework.Scenes
 //                        if (there)
                         if (Util.GetDistanceTo(abspos, tgt) <= 0.5f)
                         {
-                            // we are close enough to the target
-                            m_moveToPositionTarget = Vector3.Zero;
-                            m_moveToPositionInProgress = false;
+                            ResetMoveToTarget();
                             update_movementflag = true;
                         }
-                        else
+                        else if (bAllowUpdateMoveToPosition)
                         {
                             try
                             {
@@ -1790,14 +1759,26 @@ namespace OpenSim.Region.Framework.Scenes
                 // which occurs later in the main scene loop
                 if (update_movementflag || (update_rotation && DCFlagKeyPressed))
                 {
-                    //                    m_log.DebugFormat("{0} {1}", update_movementflag, (update_rotation && DCFlagKeyPressed));
-                    //                    m_log.DebugFormat(
-                    //                        "In {0} adding velocity to {1} of {2}", m_scene.RegionInfo.RegionName, Name, agent_control_v3);
+//                    m_log.DebugFormat(
+//                        "[SCENE PRESENCE]: In {0} adding velocity of {1} to {2}, umf = {3}, ur = {4}",
+//                        m_scene.RegionInfo.RegionName, agent_control_v3, Name, update_movementflag, update_rotation);
 
                     AddNewMovement(agent_control_v3, q, Nudging);
 
                     
                 }
+//                else
+//                {
+//                    if (!update_movementflag)
+//                    {
+//                        m_log.DebugFormat(
+//                            "[SCENE PRESENCE]: In {0} ignoring requested update of {1} for {2} as update_movementflag = false",
+//                            m_scene.RegionInfo.RegionName, agent_control_v3, Name);
+//                    }
+//                }
+
+                if (update_movementflag && m_parentID == 0)
+                    Animator.UpdateMovementAnimations();
             }
 
             if (update_movementflag && !SitGround)
@@ -1808,30 +1789,18 @@ namespace OpenSim.Region.Framework.Scenes
             m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
         }
 
-        public void DoAutoPilot(uint not_used, Vector3 Pos, IClientAPI remote_client)
+        /// <summary>
+        /// Calculate an update to move the presence to the set target.
+        /// </summary>
+        /// <remarks>
+        /// This doesn't actually perform the movement.  Instead, it adds its vector to agent_control_v3.
+        /// </remarks>
+        /// <param value="agent_control_v3">Cumulative agent movement that this method will update.</param>
+        /// <returns>True if movement has been updated in some way.  False otherwise.</returns>
+        public bool HandleMoveToTargetUpdate(ref Vector3 agent_control_v3)
         {
-            m_autopilotMoving = true;
-            m_autoPilotTarget = Pos;
-            m_sitAtAutoTarget = false;
-            PrimitiveBaseShape proxy = PrimitiveBaseShape.Default;
-            //proxy.PCode = (byte)PCode.ParticleSystem;
-            proxyObjectGroup = new SceneObjectGroup(UUID, Pos, Rotation, proxy);
-            proxyObjectGroup.AttachToScene(m_scene);
-            
-            // Commented out this code since it could never have executed, but might still be informative.
-//            if (proxyObjectGroup != null)
-//            {
-                proxyObjectGroup.SendGroupFullUpdate();
-                remote_client.SendSitResponse(proxyObjectGroup.UUID, Vector3.Zero, Quaternion.Identity, true, Vector3.Zero, Vector3.Zero, false);
-                m_scene.DeleteSceneObject(proxyObjectGroup, false);
-//            }
-//            else
-//            {
-//                m_autopilotMoving = false;
-//                m_autoPilotTarget = Vector3.Zero;
-//                ControllingClient.SendAlertMessage("Autopilot cancelled");
-//            }
-        }
+//            m_log.DebugFormat("[SCENE PRESENCE]: Called HandleMoveToTargetUpdate() for {0}", Name);
+            bool updated = false;
 
         public void StopMoveToPosition()
         {
@@ -1844,31 +1813,186 @@ namespace OpenSim.Region.Framework.Scenes
 //Console.WriteLine("SP:DoMoveToPosition");
             try
             {
-                float locx = 0f;
-                float locy = 0f;
-                float locz = 0f;
-                uint regionX = 0;
-                uint regionY = 0;
-                try
+                double distanceToTarget = Util.GetDistanceTo(AbsolutePosition, MoveToPositionTarget);
+//                        m_log.DebugFormat(
+//                            "[SCENE PRESENCE]: Abs pos of {0} is {1}, target {2}, distance {3}",
+//                            Name, AbsolutePosition, MoveToPositionTarget, distanceToTarget);
+
+                // Check the error term of the current position in relation to the target position
+                if (distanceToTarget <= 1)
                 {
-                    Utils.LongToUInts(Scene.RegionInfo.RegionHandle, out regionX, out regionY);
-                    locx = Convert.ToSingle(args[0]) - (float)regionX;
-                    locy = Convert.ToSingle(args[1]) - (float)regionY;
-                    locz = Convert.ToSingle(args[2]);
+                    // We are close enough to the target
+                    AbsolutePosition = MoveToPositionTarget;
+                    ResetMoveToTarget();
+                    updated = true;
                 }
-                catch (InvalidCastException)
+                else
                 {
-                    m_log.Error("[CLIENT]: Invalid autopilot request");
-                    return;
+                    try
+                    {
+                        // move avatar in 3D at one meter/second towards target, in avatar coordinate frame.
+                        // This movement vector gets added to the velocity through AddNewMovement().
+                        // Theoretically we might need a more complex PID approach here if other
+                        // unknown forces are acting on the avatar and we need to adaptively respond
+                        // to such forces, but the following simple approach seems to works fine.
+                        Vector3 LocalVectorToTarget3D =
+                            (MoveToPositionTarget - AbsolutePosition) // vector from cur. pos to target in global coords
+                            * Matrix4.CreateFromQuaternion(Quaternion.Inverse(Rotation)); // change to avatar coords
+                        // Ignore z component of vector
+//                        Vector3 LocalVectorToTarget2D = new Vector3((float)(LocalVectorToTarget3D.X), (float)(LocalVectorToTarget3D.Y), 0f);
+                        LocalVectorToTarget3D.Normalize();
+
+                        // update avatar movement flags. the avatar coordinate system is as follows:
+                        //
+                        //                        +X (forward)
+                        //
+                        //                        ^
+                        //                        |
+                        //                        |
+                        //                        |
+                        //                        |
+                        //     (left) +Y <--------o--------> -Y
+                        //                       avatar
+                        //                        |
+                        //                        |
+                        //                        |
+                        //                        |
+                        //                        v
+                        //                        -X
+                        //
+
+                        // based on the above avatar coordinate system, classify the movement into
+                        // one of left/right/back/forward.
+                        if (LocalVectorToTarget3D.X < 0) //MoveBack
+                        {
+                            m_movementflag += (byte)(uint)Dir_ControlFlags.DIR_CONTROL_FLAG_BACK;
+                            AgentControlFlags |= (uint)Dir_ControlFlags.DIR_CONTROL_FLAG_BACK;
+                            updated = true;
+                        }
+                        else if (LocalVectorToTarget3D.X > 0) //Move Forward
+                        {
+                            m_movementflag += (byte)(uint)Dir_ControlFlags.DIR_CONTROL_FLAG_FORWARD;
+                            AgentControlFlags |= (uint)Dir_ControlFlags.DIR_CONTROL_FLAG_FORWARD;
+                            updated = true;
+                        }
+
+                        if (LocalVectorToTarget3D.Y > 0) //MoveLeft
+                        {
+                            m_movementflag += (byte)(uint)Dir_ControlFlags.DIR_CONTROL_FLAG_LEFT;
+                            AgentControlFlags |= (uint)Dir_ControlFlags.DIR_CONTROL_FLAG_LEFT;
+                            updated = true;
+                        }
+                        else if (LocalVectorToTarget3D.Y < 0) //MoveRight
+                        {
+                            m_movementflag += (byte)(uint)Dir_ControlFlags.DIR_CONTROL_FLAG_RIGHT;
+                            AgentControlFlags |= (uint)Dir_ControlFlags.DIR_CONTROL_FLAG_RIGHT;
+                            updated = true;
+                        }
+
+                        if (LocalVectorToTarget3D.Z > 0) //Up
+                        {
+                            // Don't set these flags for up or down - doing so will make the avatar crouch or
+                            // keep trying to jump even if walking along level ground
+                            //m_movementflag += (byte)(uint)Dir_ControlFlags.DIR_CONTROL_FLAG_UP;
+                            //AgentControlFlags
+                            //AgentControlFlags |= (uint)Dir_ControlFlags.DIR_CONTROL_FLAG_UP;
+                            updated = true;
+                        }
+                        else if (LocalVectorToTarget3D.Z < 0) //Down
+                        {
+                            //m_movementflag += (byte)(uint)Dir_ControlFlags.DIR_CONTROL_FLAG_DOWN;
+                            //AgentControlFlags |= (uint)Dir_ControlFlags.DIR_CONTROL_FLAG_DOWN;
+                            updated = true;
+                        }
+
+//                        m_log.DebugFormat(
+//                            "[SCENE PRESENCE]: HandleMoveToTargetUpdate adding {0} to move vector {1} for {2}",
+//                            LocalVectorToTarget3D, agent_control_v3, Name);
+
+                        agent_control_v3 += LocalVectorToTarget3D;
+                    }
+                    catch (Exception e)
+                    {
+                        //Avoid system crash, can be slower but...
+                        m_log.DebugFormat("Crash! {0}", e.ToString());
+                    }
                 }
-                m_moveToPositionInProgress = true;
-                m_moveToPositionTarget = new Vector3(locx, locy, locz);
                         }
-            catch (Exception ex)
-            {
-                //Why did I get this error?
-               m_log.Error("[SCENEPRESENCE]: DoMoveToPosition" + ex);
-            }
+
+            return updated;
+        }
+
+        /// <summary>
+        /// Move to the given target over time.
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <param name="noFly">
+        /// If true, then don't allow the avatar to fly to the target, even if it's up in the air.
+        /// This is to allow movement to targets that are known to be on an elevated platform with a continuous path
+        /// from start to finish.
+        /// </param>
+        public void MoveToTarget(Vector3 pos, bool noFly)
+        {
+            m_log.DebugFormat(
+                "[SCENE PRESENCE]: Avatar {0} received request to move to position {1} in {2}",
+                Name, pos, m_scene.RegionInfo.RegionName);
+
+            if (pos.X < 0 || pos.X >= Constants.RegionSize
+                || pos.Y < 0 || pos.Y >= Constants.RegionSize
+                || pos.Z < 0)
+                return;
+
+//            Vector3 heightAdjust = new Vector3(0, 0, Appearance.AvatarHeight / 2);
+//            pos += heightAdjust;
+//
+//            // Anti duck-walking measure
+//            if (Math.Abs(pos.Z - AbsolutePosition.Z) < 0.2f)
+//            {
+////                m_log.DebugFormat("[SCENE PRESENCE]: Adjusting MoveToPosition from {0} to {1}", pos, AbsolutePosition);
+//                pos.Z = AbsolutePosition.Z;
+//            }
+
+            float terrainHeight = (float)m_scene.Heightmap[(int)pos.X, (int)pos.Y];
+            pos.Z = Math.Max(terrainHeight, pos.Z);
+
+            // Fudge factor.  It appears that if one clicks "go here" on a piece of ground, the go here request is
+            // always slightly higher than the actual terrain height.
+            // FIXME: This constrains NOC movements as well, so should be somewhere else.
+            if (pos.Z - terrainHeight < 0.2)
+                pos.Z = terrainHeight;
+
+            m_log.DebugFormat(
+                "[SCENE PRESENCE]: Avatar {0} set move to target {1} (terrain height {2}) in {3}",
+                Name, pos, terrainHeight, m_scene.RegionInfo.RegionName);
+
+            if (noFly)
+                PhysicsActor.Flying = false;
+            else if (pos.Z > terrainHeight)
+                PhysicsActor.Flying = true;
+
+            MovingToTarget = true;
+            MoveToPositionTarget = pos;
+
+            Vector3 agent_control_v3 = new Vector3();
+            HandleMoveToTargetUpdate(ref agent_control_v3);
+            AddNewMovement(agent_control_v3);
+        }
+
+        /// <summary>
+        /// Reset the move to target.
+        /// </summary>
+        public void ResetMoveToTarget()
+        {
+            m_log.DebugFormat("[SCENE PRESENCE]: Resetting move to target for {0}", Name);
+
+            MovingToTarget = false;
+            MoveToPositionTarget = Vector3.Zero;
+
+            // We need to reset the control flag as the ScenePresenceAnimator uses this to determine the correct
+            // resting animation (e.g. hover or stand).  NPCs don't have a client that will quickly reset this flag.
+            // However, the line is here rather than in the NPC module since it also appears necessary to stop a
+            // viewer that uses "go here" from juddering on all subsequent avatar movements.
+            AgentControlFlags = (uint)AgentManager.ControlFlags.NONE;
         }
 
         private void CheckAtSitTarget()
@@ -1997,11 +2121,6 @@ namespace OpenSim.Region.Framework.Scenes
                 m_offsetRotation = new Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
                 SendAvatarDataToAllAgents();
                 m_requestedSitTargetID = 0;
-                if (m_physicsActor != null && m_appearance != null)
-                {
-                    if (m_appearance.AvatarHeight > 0)
-                        SetHeight(m_appearance.AvatarHeight);
-                }
             }
             Animator.TrySetMovementAnimation("STAND");
         }
@@ -2057,7 +2176,7 @@ namespace OpenSim.Region.Framework.Scenes
             bool forceMouselook = false;
 
             //SceneObjectPart part =  m_scene.GetSceneObjectPart(targetID);
-            SceneObjectPart part =  FindNextAvailableSitTarget(targetID);
+            SceneObjectPart part = FindNextAvailableSitTarget(targetID);
             if (part == null) return;
             
             // TODO: determine position to sit at based on scene geometry; don't trust offset from client
@@ -2215,14 +2334,23 @@ namespace OpenSim.Region.Framework.Scenes
                 HandleAgentSit(remoteClient, UUID);
         }
 
+        // public void HandleAgentRequestSit(IClientAPI remoteClient, UUID agentID, UUID targetID, Vector3 offset, string sitAnimation)
         public void HandleAgentRequestSit(IClientAPI remoteClient, UUID agentID, UUID targetID, Vector3 offset)
         {
             if (m_parentID != 0)
             {
                 StandUp();
             }
+
+//            if (!String.IsNullOrEmpty(sitAnimation))
+//            {
+//                m_nextSitAnimation = sitAnimation;
+//            }
+//            else
+//            {
             m_nextSitAnimation = "SIT";
-            
+//            }
+
             //SceneObjectPart part = m_scene.GetSceneObjectPart(targetID);
             SceneObjectPart part = FindNextAvailableSitTarget(targetID);
 
@@ -2247,7 +2375,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
             else
             {
-                
                 m_log.Warn("Sit requested on unknown object: " + targetID.ToString());
             }
 
@@ -2445,44 +2572,7 @@ namespace OpenSim.Region.Framework.Scenes
             SendSitResponse(ControllingClient, m_requestedSitTargetUUID, collisionPoint - m_requestedSitOffset, Quaternion.Identity);
         }
         */
-        public void HandleAgentRequestSit(IClientAPI remoteClient, UUID agentID, UUID targetID, Vector3 offset, string sitAnimation)
-        {
-            if (m_parentID != 0)
-            {
-                StandUp();
-            }
-            if (!String.IsNullOrEmpty(sitAnimation))
-            {
-                m_nextSitAnimation = sitAnimation;
-            }
-            else
-            {
-                m_nextSitAnimation = "SIT";
-            }
-
-            //SceneObjectPart part = m_scene.GetSceneObjectPart(targetID);
-            SceneObjectPart part =  FindNextAvailableSitTarget(targetID);
-            if (part != null)
-            {
-                m_requestedSitTargetID = part.LocalId; 
-                //m_requestedSitOffset = offset;
-                m_requestedSitTargetUUID = targetID;
 
-                m_log.DebugFormat("[SIT]: Client requested Sit Position: {0}", offset);
-
-                if (m_scene.PhysicsScene.SupportsRayCast())
-                {
-                    //SitRayCastAvatarPosition(part);
-                    //return;
-                }
-            }
-            else
-            {
-                m_log.Warn("Sit requested on unknown object: " + targetID);
-            }
-            
-            SendSitResponse(remoteClient, targetID, offset, Quaternion.Identity);
-        }
 
         public void HandleAgentSit(IClientAPI remoteClient, UUID agentID)
         {
@@ -2669,8 +2759,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             m_perfMonMS = Util.EnvironmentTickCount();
 
-            Rotation = rotation;
-            Vector3 direc = vec * rotation;
+            Vector3 direc = vec * Rotation;
             direc.Normalize();
             PhysicsActor actor = m_physicsActor;
 
@@ -2901,13 +2990,7 @@ namespace OpenSim.Region.Framework.Scenes
             // We have an appearance but we may not have the baked textures. Check the asset cache 
             // to see if all the baked textures are already here. 
             if (m_scene.AvatarFactory != null)
-            {
                 cachedappearance = m_scene.AvatarFactory.ValidateBakedTextureCache(m_controllingClient);
-            }
-            else
-            {
-                m_log.WarnFormat("[SCENEPRESENCE]: AvatarFactory not set for {0}", Name);
-            }
             
             // If we aren't using a cached appearance, then clear out the baked textures
             if (!cachedappearance)
@@ -3064,19 +3147,21 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="avatar"></param>
         public void SendAppearanceToAgent(ScenePresence avatar)
         {
-//          m_log.WarnFormat("[SP] Send appearance from {0} to {1}",m_uuid,avatar.ControllingClient.AgentId);
+//            m_log.DebugFormat(
+//                "[SCENE PRESENCE] Send appearance from {0} {1} to {2} {3}", Name, m_uuid, avatar.Name, avatar.UUID);
 
             avatar.ControllingClient.SendAppearance(
-                m_appearance.Owner, m_appearance.VisualParams, m_appearance.Texture.GetBytes());
+                UUID, m_appearance.VisualParams, m_appearance.Texture.GetBytes());
         }
 
-        // Because appearance setting is in a module, we actually need
-        // to give it access to our appearance directly, otherwise we
-        // get a synchronization issue.
         public AvatarAppearance Appearance
         {
             get { return m_appearance; }
-            set { m_appearance = value; }
+            set
+            {
+                m_appearance = value;
+//                m_log.DebugFormat("[SCENE PRESENCE]: Set appearance for {0} to {1}", Name, value);
+            }
         }
 
         #endregion
@@ -3088,15 +3173,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         protected void CheckForSignificantMovement()
         {
-            // Movement updates for agents in neighboring regions are sent directly to clients.
-            // This value only affects how often agent positions are sent to neighbor regions
-            // for things such as distance-based update prioritization
-            const float SIGNIFICANT_MOVEMENT = 2.0f;
-
             if (Util.GetDistanceTo(AbsolutePosition, posLastSignificantMove) > SIGNIFICANT_MOVEMENT)
             {
                 posLastSignificantMove = AbsolutePosition;
-                m_scene.EventManager.TriggerSignificantClientMovement(m_controllingClient);
+                m_scene.EventManager.TriggerSignificantClientMovement(this);
             }
 
             // Minimum Draw distance is 64 meters, the Radius of the draw distance sphere is 32m
@@ -3579,7 +3659,7 @@ namespace OpenSim.Region.Framework.Scenes
                     ISceneObject clone = sog.CloneForNewScene();
                     // Attachment module assumes that GroupPosition holds the offsets...!
                     ((SceneObjectGroup)clone).RootPart.GroupPosition = sog.RootPart.AttachedPos;
-                    ((SceneObjectGroup)clone).RootPart.IsAttachment = false;
+                    ((SceneObjectGroup)clone).IsAttachment = false;
                     cAgent.AttachmentObjects.Add(clone);
                     string state = sog.GetStateSnapshot();
                     cAgent.AttachmentObjectStates.Add(state);
@@ -3746,6 +3826,8 @@ if (m_animator.m_jumping) force.Z = m_animator.m_jumpVelocity;     // add for ju
             m_physicsActor.OnOutOfBounds += OutOfBoundsCall; // Called for PhysicsActors when there's something wrong
             m_physicsActor.SubscribeEvents(500);
             m_physicsActor.LocalID = LocalId;
+
+            SetHeight(m_appearance.AvatarHeight);
         }
 
         private void OutOfBoundsCall(Vector3 pos)
@@ -4001,19 +4083,7 @@ if (m_animator.m_jumping) force.Z = m_animator.m_jumpVelocity;     // add for ju
 
         public void Close()
         {
-            lock (m_attachments)
-            {
-                // Delete attachments from scene
-                // Don't try to save, as this thread won't live long
-                // enough to complete the save. This would cause no copy
-                // attachments to poof!
-                //
-                foreach (SceneObjectGroup grp in m_attachments)
-                {
-                    m_scene.DeleteSceneObject(grp, false);
-                }
-                m_attachments.Clear();
-            }
+            m_scene.AttachmentsModule.DeleteAttachmentsFromScene(this, false);
             
             lock (m_knownChildRegions)
             {
@@ -4048,9 +4118,19 @@ if (m_animator.m_jumping) force.Z = m_animator.m_jumpVelocity;     // add for ju
                 m_attachments.Add(gobj);
             }
         }
-        
+
+        /// <summary>
+        /// Get all the presence's attachments.
+        /// </summary>
+        /// <returns>A copy of the list which contains the attachments.</returns>
+        public List<SceneObjectGroup> GetAttachments()
+        {
+            lock (m_attachments)
+                return new List<SceneObjectGroup>(m_attachments);
+        }
+
         /// <summary>
-        /// Get the scene object attached to the given point.
+        /// Get the scene objects attached to the given point.
         /// </summary>
         /// <param name="attachmentPoint"></param>
         /// <returns>Returns an empty list if there were no attachments at the point.</returns>
@@ -4062,7 +4142,7 @@ if (m_animator.m_jumping) force.Z = m_animator.m_jumpVelocity;     // add for ju
             {
                 foreach (SceneObjectGroup so in m_attachments)
                 {
-                    if (attachmentPoint == so.RootPart.AttachmentPoint)
+                    if (attachmentPoint == so.AttachmentPoint)
                         attachments.Add(so);
                 }
             }
@@ -4072,7 +4152,8 @@ if (m_animator.m_jumping) force.Z = m_animator.m_jumpVelocity;     // add for ju
 
         public bool HasAttachments()
         {
-            return m_attachments.Count > 0;
+            lock (m_attachments)
+                return m_attachments.Count > 0;
         }
 
         public bool HasScriptedAttachments()
@@ -4094,12 +4175,16 @@ if (m_animator.m_jumping) force.Z = m_animator.m_jumpVelocity;     // add for ju
         public void RemoveAttachment(SceneObjectGroup gobj)
         {
             lock (m_attachments)
-            {
-                if (m_attachments.Contains(gobj))
-                {
-                    m_attachments.Remove(gobj);
-                }
-            }
+                m_attachments.Remove(gobj);
+        }
+
+        /// <summary>
+        /// Clear all attachments
+        /// </summary>
+        public void ClearAttachments()
+        {
+            lock (m_attachments)
+                m_attachments.Clear();
         }
 
         public bool ValidateAttachments()
@@ -4110,12 +4195,22 @@ if (m_animator.m_jumping) force.Z = m_animator.m_jumpVelocity;     // add for ju
                 foreach (SceneObjectGroup gobj in m_attachments)
                 {
                     if (gobj == null)
+                    {
+                        m_log.WarnFormat(
+                            "[SCENE PRESENCE]: Failed to validate an attachment for {0} since it was null", Name);
                         return false;
+                    }
 
                     if (gobj.IsDeleted)
+                    {
+                        m_log.WarnFormat(
+                            "[SCENE PRESENCE]: Failed to validate attachment {0} {1} for {2} since it had been deleted",
+                            gobj.Name, gobj.UUID, Name);
                         return false;
+                    }
                 }
             }
+
             return true;
         }
 
@@ -4553,4 +4648,4 @@ if (m_animator.m_jumping) force.Z = m_animator.m_jumpVelocity;     // add for ju
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/SceneViewer.cs b/OpenSim/Region/Framework/Scenes/SceneViewer.cs
index f04ed4d..501487a 100644
--- a/OpenSim/Region/Framework/Scenes/SceneViewer.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneViewer.cs
@@ -110,7 +110,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     SceneObjectPart part = m_partsUpdateQueue.Dequeue();
                     
-                    if (part.ParentGroup == null || part.ParentGroup.IsDeleted)
+                    if (part.ParentGroup.IsDeleted)
                         continue;
                     
                     if (m_updateTimes.ContainsKey(part.UUID))
@@ -120,8 +120,7 @@ namespace OpenSim.Region.Framework.Scenes
                         // We deal with the possibility that two updates occur at
                         // the same unix time at the update point itself.
 
-                        if ((update.LastFullUpdateTime < part.TimeStampFull) ||
-                                part.IsAttachment)
+                        if ((update.LastFullUpdateTime < part.TimeStampFull) || part.ParentGroup.IsAttachment)
                         {
     //                            m_log.DebugFormat(
     //                                "[SCENE PRESENCE]: Fully   updating prim {0}, {1} - part timestamp {2}",
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index d6e8223..11dad6c 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -53,19 +53,9 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         /// <summary>
         /// Deserialize a scene object from the original xml format
         /// </summary>
-        /// <param name="serialization"></param>
+        /// <param name="xmlData"></param>
         /// <returns></returns>
-        public static SceneObjectGroup FromOriginalXmlFormat(string serialization)
-        {
-            return FromOriginalXmlFormat(UUID.Zero, serialization);
-        }
-        
-        /// <summary>
-        /// Deserialize a scene object from the original xml format
-        /// </summary>
-        /// <param name="serialization"></param>
-        /// <returns></returns>
-        public static SceneObjectGroup FromOriginalXmlFormat(UUID fromUserInventoryItemID, string xmlData)
+        public static SceneObjectGroup FromOriginalXmlFormat(string xmlData)
         {
             //m_log.DebugFormat("[SOG]: Starting deserialization of SOG");
             //int time = System.Environment.TickCount;
@@ -87,7 +77,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
                 sr = new StringReader(parts[0].InnerXml);
                 reader = new XmlTextReader(sr);
-                SceneObjectGroup sceneObject = new SceneObjectGroup(SceneObjectPart.FromXml(fromUserInventoryItemID, reader));
+                SceneObjectGroup sceneObject = new SceneObjectGroup(SceneObjectPart.FromXml(reader));
                 reader.Close();
                 sr.Close();
 
@@ -102,7 +92,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                     sceneObject.AddPart(part);
                     part.LinkNum = linkNum;
                     part.TrimPermissions();
-                    part.StoreUndoState(UndoType.STATE_ALL);
                     reader.Close();
                     sr.Close();
                 }
@@ -128,26 +117,36 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         /// <returns></returns>
         public static string ToOriginalXmlFormat(SceneObjectGroup sceneObject)
         {
+            return ToOriginalXmlFormat(sceneObject, true);
+        }
+
+        /// <summary>
+        /// Serialize a scene object to the original xml format
+        /// </summary>
+        /// <param name="sceneObject"></param>
+        /// <param name="doScriptStates">Control whether script states are also serialized.</para>
+        /// <returns></returns>
+        public static string ToOriginalXmlFormat(SceneObjectGroup sceneObject, bool doScriptStates)
+        {
             using (StringWriter sw = new StringWriter())
             {
                 using (XmlTextWriter writer = new XmlTextWriter(sw))
                 {
-                    ToOriginalXmlFormat(sceneObject, writer);
+                    ToOriginalXmlFormat(sceneObject, writer, doScriptStates);
                 }
 
                 return sw.ToString();
             }
         }
-        
 
         /// <summary>
         /// Serialize a scene object to the original xml format
         /// </summary>
         /// <param name="sceneObject"></param>
         /// <returns></returns>
-        public static void ToOriginalXmlFormat(SceneObjectGroup sceneObject, XmlTextWriter writer)
+        public static void ToOriginalXmlFormat(SceneObjectGroup sceneObject, XmlTextWriter writer, bool doScriptStates)
         {
-            ToOriginalXmlFormat(sceneObject, writer, false);
+            ToOriginalXmlFormat(sceneObject, writer, doScriptStates, false);
         }
         
         /// <summary>
@@ -157,10 +156,11 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         /// <param name="writer"></param>
         /// <param name="noRootElement">If false, don't write the enclosing SceneObjectGroup element</param>
         /// <returns></returns>
-        public static void ToOriginalXmlFormat(SceneObjectGroup sceneObject, XmlTextWriter writer, bool noRootElement)
+        public static void ToOriginalXmlFormat(
+            SceneObjectGroup sceneObject, XmlTextWriter writer, bool doScriptStates, bool noRootElement)
         {
-            //m_log.DebugFormat("[SERIALIZER]: Starting serialization of {0}", Name);
-            //int time = System.Environment.TickCount;
+//            m_log.DebugFormat("[SERIALIZER]: Starting serialization of {0}", sceneObject.Name);
+//            int time = System.Environment.TickCount;
 
             if (!noRootElement)
                 writer.WriteStartElement(String.Empty, "SceneObjectGroup", String.Empty);
@@ -183,12 +183,14 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             }
 
             writer.WriteEndElement(); // OtherParts
-            sceneObject.SaveScriptedState(writer);
+
+            if (doScriptStates)
+                sceneObject.SaveScriptedState(writer);
             
             if (!noRootElement)
                 writer.WriteEndElement(); // SceneObjectGroup
 
-            //m_log.DebugFormat("[SERIALIZER]: Finished serialization of SOG {0}, {1}ms", Name, System.Environment.TickCount - time);
+//            m_log.DebugFormat("[SERIALIZER]: Finished serialization of SOG {0}, {1}ms", sceneObject.Name, System.Environment.TickCount - time);
         }        
 
         protected static void ToXmlFormat(SceneObjectPart part, XmlTextWriter writer)
@@ -236,15 +238,14 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                     if (originalLinkNum != 0)
                         part.LinkNum = originalLinkNum;
 
-                    part.StoreUndoState(UndoType.STATE_ALL);
                     reader.Close();
                     sr.Close();
                 }
 
                 // Script state may, or may not, exist. Not having any, is NOT
                 // ever a problem.
-
                 sceneObject.LoadScriptState(doc);
+                
                 return sceneObject;
             }
             catch (Exception e)
@@ -1592,4 +1593,4 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
         #endregion
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/AttachmentTests.cs b/OpenSim/Region/Framework/Scenes/Tests/AttachmentTests.cs
deleted file mode 100644
index cff649b..0000000
--- a/OpenSim/Region/Framework/Scenes/Tests/AttachmentTests.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Text;
-using System.Threading;
-using System.Timers;
-using Timer=System.Timers.Timer;
-using Nini.Config;
-using NUnit.Framework;
-using OpenMetaverse;
-using OpenSim.Framework;
-using OpenSim.Framework.Communications;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.CoreModules.World.Serialiser;
-using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
-using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
-
-namespace OpenSim.Region.Framework.Scenes.Tests
-{
-    /// <summary>
-    /// Attachment tests
-    /// </summary>
-    [TestFixture]
-    public class AttachmentTests
-    {
-        public Scene scene, scene2;
-        public UUID agent1;
-        public static Random random;
-        public ulong region1, region2;
-        public AgentCircuitData acd1;
-        public SceneObjectGroup sog1, sog2, sog3;
-
-        [TestFixtureSetUp]
-        public void Init()
-        {
-            TestHelper.InMethod();
-            
-            scene = SceneSetupHelpers.SetupScene("Neighbour x", UUID.Random(), 1000, 1000);
-            scene2 = SceneSetupHelpers.SetupScene("Neighbour x+1", UUID.Random(), 1001, 1000);
-
-            ISharedRegionModule interregionComms = new LocalSimulationConnectorModule();
-            interregionComms.Initialise(new IniConfigSource());
-            interregionComms.PostInitialise();
-            SceneSetupHelpers.SetupSceneModules(scene, new IniConfigSource(), interregionComms);
-            SceneSetupHelpers.SetupSceneModules(scene2, new IniConfigSource(), interregionComms);
-
-            agent1 = UUID.Random();
-            random = new Random();
-            sog1 = NewSOG(UUID.Random(), scene, agent1);
-            sog2 = NewSOG(UUID.Random(), scene, agent1);
-            sog3 = NewSOG(UUID.Random(), scene, agent1);
-
-            //ulong neighbourHandle = Utils.UIntsToLong((uint)(neighbourx * Constants.RegionSize), (uint)(neighboury * Constants.RegionSize));
-            region1 = scene.RegionInfo.RegionHandle;
-            region2 = scene2.RegionInfo.RegionHandle;
-            
-            SceneSetupHelpers.AddRootAgent(scene, agent1);
-        }     
-        
-        [Test]
-        public void T030_TestAddAttachments()
-        {
-            TestHelper.InMethod();
-
-            ScenePresence presence = scene.GetScenePresence(agent1);
-
-            presence.AddAttachment(sog1);
-            presence.AddAttachment(sog2);
-            presence.AddAttachment(sog3);
-
-            Assert.That(presence.HasAttachments(), Is.True);
-            Assert.That(presence.ValidateAttachments(), Is.True);
-        }
-
-        [Test]
-        public void T031_RemoveAttachments()
-        {
-            TestHelper.InMethod();
-
-            ScenePresence presence = scene.GetScenePresence(agent1);
-            presence.RemoveAttachment(sog1);
-            presence.RemoveAttachment(sog2);
-            presence.RemoveAttachment(sog3);
-            Assert.That(presence.HasAttachments(), Is.False);
-        }
-
-        // I'm commenting this test because scene setup NEEDS InventoryService to 
-        // be non-null
-        //[Test]
-        public void T032_CrossAttachments()
-        {
-            TestHelper.InMethod();
-
-            ScenePresence presence = scene.GetScenePresence(agent1);
-            ScenePresence presence2 = scene2.GetScenePresence(agent1);
-            presence2.AddAttachment(sog1);
-            presence2.AddAttachment(sog2);
-
-            ISharedRegionModule serialiser = new SerialiserModule();
-            SceneSetupHelpers.SetupSceneModules(scene, new IniConfigSource(), serialiser);
-            SceneSetupHelpers.SetupSceneModules(scene2, new IniConfigSource(), serialiser);
-
-            Assert.That(presence.HasAttachments(), Is.False, "Presence has attachments before cross");
-
-            //Assert.That(presence2.CrossAttachmentsIntoNewRegion(region1, true), Is.True, "Cross was not successful");
-            Assert.That(presence2.HasAttachments(), Is.False, "Presence2 objects were not deleted");
-            Assert.That(presence.HasAttachments(), Is.True, "Presence has not received new objects");
-        }   
-        
-        private SceneObjectGroup NewSOG(UUID uuid, Scene scene, UUID agent)
-        {
-            SceneObjectPart sop = new SceneObjectPart();
-            sop.Name = RandomName();
-            sop.Description = RandomName();
-            sop.Text = RandomName();
-            sop.SitName = RandomName();
-            sop.TouchName = RandomName();
-            sop.UUID = uuid;
-            sop.Shape = PrimitiveBaseShape.Default;
-            sop.Shape.State = 1;
-            sop.OwnerID = agent;
-
-            SceneObjectGroup sog = new SceneObjectGroup(sop);
-            sog.SetScene(scene);
-
-            return sog;
-        }        
-        
-        private static string RandomName()
-        {
-            StringBuilder name = new StringBuilder();
-            int size = random.Next(5,12);
-            char ch;
-            for (int i = 0; i < size; i++)
-            {
-                ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65))) ;
-                name.Append(ch);
-            }
-            
-            return name.ToString();
-        }        
-    }
-}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/BorderTests.cs b/OpenSim/Region/Framework/Scenes/Tests/BorderTests.cs
index 3a0dd00..ab6311b 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/BorderTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/BorderTests.cs
@@ -41,7 +41,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestCross()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             List<Border> testborders = new List<Border>();
 
@@ -99,7 +99,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestCrossSquare512()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             List<Border> testborders = new List<Border>();
 
@@ -179,7 +179,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestCrossRectangle512x256()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             List<Border> testborders = new List<Border>();
 
@@ -259,7 +259,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestCrossOdd512x512w256hole()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             List<Border> testborders = new List<Border>();
             //   512____
diff --git a/OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs b/OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs
index f69a4b4..a5d2b23 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs
@@ -45,12 +45,12 @@ namespace OpenSim.Region.Framework.Scenes.Tests
     {
         static public Random random;
         SceneObjectGroup found;
-        Scene scene = SceneSetupHelpers.SetupScene();
+        Scene scene = SceneHelpers.SetupScene();
 
         [Test]
         public void T010_AddObjects()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             random = new Random();
             SceneObjectGroup found;
@@ -85,7 +85,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void T011_ThreadAddRemoveTest()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             // This test adds and removes with mutiple threads, attempting to break the 
             // uuid and localid dictionary coherence.
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs
index 895f2bb..9a60e50 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs
@@ -43,8 +43,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestDuplicateObject()
         {
-            TestHelper.InMethod();
-            Scene scene = SceneSetupHelpers.SetupScene();
+            TestHelpers.InMethod();
+            Scene scene = SceneHelpers.SetupScene();
 
             UUID ownerId = new UUID("00000000-0000-0000-0000-000000000010");
             string part1Name = "part1";
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
index 0a82c4f..1ea2329 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs
@@ -49,9 +49,9 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestAddSceneObject()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 
-            Scene scene = SceneSetupHelpers.SetupScene();
+            Scene scene = SceneHelpers.SetupScene();
 
             string objName = "obj1";
             UUID objUuid = new UUID("00000000-0000-0000-0000-000000000001");
@@ -76,9 +76,9 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         /// </summary>
         public void TestAddExistingSceneObjectUuid()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 
-            Scene scene = SceneSetupHelpers.SetupScene();
+            Scene scene = SceneHelpers.SetupScene();
 
             string obj1Name = "Alfred";
             string obj2Name = "Betty";
@@ -110,10 +110,10 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestDeleteSceneObject()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
-            TestScene scene = SceneSetupHelpers.SetupScene();
-            SceneObjectPart part = SceneSetupHelpers.AddSceneObject(scene);
+            TestScene scene = SceneHelpers.SetupScene();
+            SceneObjectPart part = SceneHelpers.AddSceneObject(scene);
             scene.DeleteSceneObject(part.ParentGroup, false);
             
             SceneObjectPart retrievedPart = scene.GetSceneObjectPart(part.LocalId);
@@ -126,20 +126,20 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestDeleteSceneObjectAsync()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             //log4net.Config.XmlConfigurator.Configure();
 
             UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000001");
 
-            TestScene scene = SceneSetupHelpers.SetupScene();
+            TestScene scene = 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 = SceneSetupHelpers.AddSceneObject(scene);
+            SceneObjectPart part = SceneHelpers.AddSceneObject(scene);
 
-            IClientAPI client = SceneSetupHelpers.AddRootAgent(scene, agentId);
+            IClientAPI client = SceneHelpers.AddScenePresence(scene, agentId).ControllingClient;
             scene.DeRezObjects(client, new System.Collections.Generic.List<uint>() { part.LocalId }, UUID.Zero, DeRezAction.Delete, UUID.Zero);
 
             SceneObjectPart retrievedPart = scene.GetSceneObjectPart(part.LocalId);
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
index 5357a06..654b1a2 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
@@ -56,17 +56,17 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestDeRezSceneObject()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
                         
             UUID userId = UUID.Parse("10000000-0000-0000-0000-000000000001");
             
-            TestScene scene = SceneSetupHelpers.SetupScene();
+            TestScene scene = SceneHelpers.SetupScene();
             IConfigSource configSource = new IniConfigSource();
             IConfig config = configSource.AddConfig("Startup");
             config.Set("serverside_object_permissions", true);
-            SceneSetupHelpers.SetupSceneModules(scene, configSource, new object[] { new PermissionsModule() });
-            TestClient client = SceneSetupHelpers.AddRootAgent(scene, userId);
+            SceneHelpers.SetupSceneModules(scene, configSource, new object[] { new PermissionsModule() });
+            IClientAPI client = SceneHelpers.AddScenePresence(scene, userId).ControllingClient;
             
             // Turn off the timer on the async sog deleter - we'll crank it by hand for this test.
             AsyncSceneObjectGroupDeleter sogd = scene.SceneObjectGroupDeleter;
@@ -94,18 +94,18 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestDeRezSceneObjectNotOwner()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
                         
             UUID userId = UUID.Parse("10000000-0000-0000-0000-000000000001");
             UUID objectOwnerId = UUID.Parse("20000000-0000-0000-0000-000000000001");
             
-            TestScene scene = SceneSetupHelpers.SetupScene();
+            TestScene scene = SceneHelpers.SetupScene();
             IConfigSource configSource = new IniConfigSource();
             IConfig config = configSource.AddConfig("Startup");
             config.Set("serverside_object_permissions", true);
-            SceneSetupHelpers.SetupSceneModules(scene, configSource, new object[] { new PermissionsModule() });            
-            TestClient client = SceneSetupHelpers.AddRootAgent(scene, userId);
+            SceneHelpers.SetupSceneModules(scene, configSource, new object[] { new PermissionsModule() });            
+            IClientAPI client = SceneHelpers.AddScenePresence(scene, userId).ControllingClient;
             
             // Turn off the timer on the async sog deleter - we'll crank it by hand for this test.
             AsyncSceneObjectGroupDeleter sogd = scene.SceneObjectGroupDeleter;
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs
index cb1d531..2912a46 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs
@@ -50,14 +50,14 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestLinkDelink2SceneObjects()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             bool debugtest = false; 
 
-            Scene scene = SceneSetupHelpers.SetupScene();
-            SceneObjectPart part1 = SceneSetupHelpers.AddSceneObject(scene);
+            Scene scene = SceneHelpers.SetupScene();
+            SceneObjectPart part1 = SceneHelpers.AddSceneObject(scene);
             SceneObjectGroup grp1 = part1.ParentGroup;
-            SceneObjectPart part2 = SceneSetupHelpers.AddSceneObject(scene);
+            SceneObjectPart part2 = SceneHelpers.AddSceneObject(scene);
             SceneObjectGroup grp2 = part2.ParentGroup;
 
             grp1.AbsolutePosition = new Vector3(10, 10, 10);
@@ -132,18 +132,18 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestLinkDelink2groups4SceneObjects()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             bool debugtest = false;
 
-            Scene scene = SceneSetupHelpers.SetupScene();
-            SceneObjectPart part1 = SceneSetupHelpers.AddSceneObject(scene);
+            Scene scene = SceneHelpers.SetupScene();
+            SceneObjectPart part1 = SceneHelpers.AddSceneObject(scene);
             SceneObjectGroup grp1 = part1.ParentGroup;
-            SceneObjectPart part2 = SceneSetupHelpers.AddSceneObject(scene);
+            SceneObjectPart part2 = SceneHelpers.AddSceneObject(scene);
             SceneObjectGroup grp2 = part2.ParentGroup;
-            SceneObjectPart part3 = SceneSetupHelpers.AddSceneObject(scene);
+            SceneObjectPart part3 = SceneHelpers.AddSceneObject(scene);
             SceneObjectGroup grp3 = part3.ParentGroup;
-            SceneObjectPart part4 = SceneSetupHelpers.AddSceneObject(scene);
+            SceneObjectPart part4 = SceneHelpers.AddSceneObject(scene);
             SceneObjectGroup grp4 = part4.ParentGroup;
 
             grp1.AbsolutePosition = new Vector3(10, 10, 10);
@@ -266,10 +266,10 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestNewSceneObjectLinkPersistence()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             //log4net.Config.XmlConfigurator.Configure();
             
-            TestScene scene = SceneSetupHelpers.SetupScene();
+            TestScene scene = SceneHelpers.SetupScene();
             
             string rootPartName = "rootpart";
             UUID rootPartUuid = new UUID("00000000-0000-0000-0000-000000000001");
@@ -305,10 +305,10 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestDelinkPersistence()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             //log4net.Config.XmlConfigurator.Configure();
             
-            TestScene scene = SceneSetupHelpers.SetupScene();
+            TestScene scene = 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
new file mode 100644
index 0000000..b49c6e7
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
@@ -0,0 +1,104 @@
+/*
+ * 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 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>
+    /// Basic scene object resize tests
+    /// </summary>
+    [TestFixture]
+    public class SceneObjectResizeTests
+    {
+        /// <summary>
+        /// Test resizing an object
+        /// </summary>
+        [Test]
+        public void TestResizeSceneObject()
+        {
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            Scene scene = SceneHelpers.SetupScene();
+            SceneObjectGroup g1 = SceneHelpers.AddSceneObject(scene).ParentGroup;
+
+            g1.GroupResize(new Vector3(2, 3, 4));
+
+            SceneObjectGroup g1Post = scene.GetSceneObjectGroup(g1.UUID);
+
+            Assert.That(g1Post.RootPart.Scale.X, Is.EqualTo(2));
+            Assert.That(g1Post.RootPart.Scale.Y, Is.EqualTo(3));
+            Assert.That(g1Post.RootPart.Scale.Z, Is.EqualTo(4));
+
+            Assert.That(g1Post.RootPart.UndoCount, Is.EqualTo(1));
+        }
+
+        /// <summary>
+        /// Test resizing an individual part in a scene object.
+        /// </summary>
+        [Test]
+        public void TestResizeSceneObjectPart()
+        {
+            TestHelpers.InMethod();
+            //log4net.Config.XmlConfigurator.Configure();
+
+            Scene scene = SceneHelpers.SetupScene();
+
+            SceneObjectGroup g1 = SceneHelpers.CreateSceneObject(2, UUID.Zero);
+            g1.RootPart.Scale = new Vector3(2, 3, 4);
+            g1.Parts[1].Scale = new Vector3(5, 6, 7);
+
+            scene.AddSceneObject(g1);
+
+            SceneObjectGroup g1Post = scene.GetSceneObjectGroup(g1.UUID);
+
+            g1Post.Parts[1].Resize(new Vector3(8, 9, 10));
+
+            SceneObjectGroup g1PostPost = scene.GetSceneObjectGroup(g1.UUID);
+
+            SceneObjectPart g1RootPart = g1PostPost.RootPart;
+            SceneObjectPart g1ChildPart = g1PostPost.Parts[1];
+
+            Assert.That(g1RootPart.Scale.X, Is.EqualTo(2));
+            Assert.That(g1RootPart.Scale.Y, Is.EqualTo(3));
+            Assert.That(g1RootPart.Scale.Z, Is.EqualTo(4));
+
+            Assert.That(g1ChildPart.Scale.X, Is.EqualTo(8));
+            Assert.That(g1ChildPart.Scale.Y, Is.EqualTo(9));
+            Assert.That(g1ChildPart.Scale.Z, Is.EqualTo(10));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectStatusTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectStatusTests.cs
new file mode 100644
index 0000000..2a342d5
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectStatusTests.cs
@@ -0,0 +1,66 @@
+/*
+ * 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 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>
+    /// Basic scene object status tests
+    /// </summary>
+    [TestFixture]
+    public class SceneObjectStatusTests
+    {
+        [Test]
+        public void TestSetPhantom()
+        {
+            TestHelpers.InMethod();
+
+//            Scene scene = SceneSetupHelpers.SetupScene();
+            SceneObjectGroup so = SceneHelpers.CreateSceneObject(1, UUID.Zero);
+            SceneObjectPart rootPart = so.RootPart;
+            Assert.That(rootPart.Flags, Is.EqualTo(PrimFlags.None));
+
+            so.ScriptSetPhantomStatus(true);
+
+//            Console.WriteLine("so.RootPart.Flags [{0}]", so.RootPart.Flags);
+            Assert.That(rootPart.Flags, Is.EqualTo(PrimFlags.Phantom));
+
+            so.ScriptSetPhantomStatus(false);
+
+            Assert.That(rootPart.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 77bd4c2..c13d82e 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
@@ -53,12 +53,12 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestShareWithGroup()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
                         
             UUID userId = UUID.Parse("10000000-0000-0000-0000-000000000001");
             
-            TestScene scene = SceneSetupHelpers.SetupScene();
+            TestScene scene = SceneHelpers.SetupScene();
             IConfigSource configSource = new IniConfigSource();
             
             IConfig startupConfig = configSource.AddConfig("Startup");
@@ -69,13 +69,13 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             groupsConfig.Set("Module", "GroupsModule");            
             groupsConfig.Set("DebugEnabled", true);            
                        
-            SceneSetupHelpers.SetupSceneModules(
+            SceneHelpers.SetupSceneModules(
                 scene, configSource, new object[] 
                    { new PermissionsModule(), 
                      new GroupsModule(), 
                      new MockGroupsServicesConnector() });
             
-            TestClient client = SceneSetupHelpers.AddRootAgent(scene, userId);            
+            IClientAPI client = SceneHelpers.AddScenePresence(scene, userId).ControllingClient;            
             
             IGroupsModule groupsModule = scene.RequestModuleInterface<IGroupsModule>();     
             
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
index 03ac252..ce9d418 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
@@ -51,7 +51,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
     /// Scene presence tests
     /// </summary>
     [TestFixture]
-    public class ScenePresenceTests
+    public class ScenePresenceAgentTests
     {
         public Scene scene, scene2, scene3;
         public UUID agent1, agent2, agent3;
@@ -64,90 +64,140 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [TestFixtureSetUp]
         public void Init()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
-            scene = SceneSetupHelpers.SetupScene("Neighbour x", UUID.Random(), 1000, 1000);
-            scene2 = SceneSetupHelpers.SetupScene("Neighbour x+1", UUID.Random(), 1001, 1000);
-            scene3 = SceneSetupHelpers.SetupScene("Neighbour x-1", UUID.Random(), 999, 1000);
+            scene = SceneHelpers.SetupScene("Neighbour x", UUID.Random(), 1000, 1000);
+            scene2 = SceneHelpers.SetupScene("Neighbour x+1", UUID.Random(), 1001, 1000);
+            scene3 = SceneHelpers.SetupScene("Neighbour x-1", UUID.Random(), 999, 1000);
 
             ISharedRegionModule interregionComms = new LocalSimulationConnectorModule();
             interregionComms.Initialise(new IniConfigSource());
             interregionComms.PostInitialise();
-            SceneSetupHelpers.SetupSceneModules(scene, new IniConfigSource(), interregionComms);
-            SceneSetupHelpers.SetupSceneModules(scene2, new IniConfigSource(), interregionComms);
-            SceneSetupHelpers.SetupSceneModules(scene3, new IniConfigSource(), interregionComms);
+            SceneHelpers.SetupSceneModules(scene, new IniConfigSource(), interregionComms);
+            SceneHelpers.SetupSceneModules(scene2, new IniConfigSource(), interregionComms);
+            SceneHelpers.SetupSceneModules(scene3, new IniConfigSource(), interregionComms);
 
             agent1 = UUID.Random();
             agent2 = UUID.Random();
             agent3 = UUID.Random();
             random = new Random();
-            sog1 = NewSOG(UUID.Random(), scene, agent1);
-            sog2 = NewSOG(UUID.Random(), scene, agent1);
-            sog3 = NewSOG(UUID.Random(), scene, agent1);
+            sog1 = SceneHelpers.CreateSceneObject(1, agent1);
+            scene.AddSceneObject(sog1);
+            sog2 = SceneHelpers.CreateSceneObject(1, agent1);
+            scene.AddSceneObject(sog2);
+            sog3 = SceneHelpers.CreateSceneObject(1, agent1);
+            scene.AddSceneObject(sog3);
 
-            //ulong neighbourHandle = Utils.UIntsToLong((uint)(neighbourx * Constants.RegionSize), (uint)(neighboury * Constants.RegionSize));
             region1 = scene.RegionInfo.RegionHandle;
             region2 = scene2.RegionInfo.RegionHandle;
             region3 = scene3.RegionInfo.RegionHandle;
         }
 
-        /// <summary>
-        /// Test adding a root agent to a scene.  Doesn't yet actually complete crossing the agent into the scene.
-        /// </summary>
         [Test]
-        public void T010_TestAddRootAgent()
+        public void TestCloseAgent()
         {
-            TestHelper.InMethod();
-
-            string firstName = "testfirstname";
-
-            AgentCircuitData agent = new AgentCircuitData();
-            agent.AgentID = agent1;
-            agent.firstname = firstName;
-            agent.lastname = "testlastname";
-            agent.SessionID = UUID.Random();
-            agent.SecureSessionID = UUID.Random();
-            agent.circuitcode = 123;
-            agent.BaseFolder = UUID.Zero;
-            agent.InventoryFolder = UUID.Zero;
-            agent.startpos = Vector3.Zero;
-            agent.CapsPath = GetRandomCapsObjectPath();
-            agent.ChildrenCapSeeds = new Dictionary<ulong, string>();
-            agent.child = true;
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
 
-            scene.PresenceService.LoginAgent(agent.AgentID.ToString(), agent.SessionID, agent.SecureSessionID);
+            TestScene scene = SceneHelpers.SetupScene();
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
 
-            string reason;
-            scene.NewUserConnection(agent, (uint)TeleportFlags.ViaLogin, out reason);
-            testclient = new TestClient(agent, scene);
-            scene.AddNewClient(testclient);
+            Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(sp.UUID), Is.Not.Null);
 
-            ScenePresence presence = scene.GetScenePresence(agent1);
+            scene.IncomingCloseAgent(sp.UUID);
 
-            Assert.That(presence, Is.Not.Null, "presence is null");
-            Assert.That(presence.Firstname, Is.EqualTo(firstName), "First name not same");
-            acd1 = agent;
+            Assert.That(scene.GetScenePresence(sp.UUID), Is.Null);
+            Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(sp.UUID), Is.Null);
         }
 
         /// <summary>
-        /// Test removing an uncrossed root agent from a scene.
+        /// Test that if a root agent logs into a region, a child agent is also established in the neighbouring region
         /// </summary>
+        /// <remarks>
+        /// Please note that unlike the other tests here, this doesn't rely on structures
+        /// </remarks>
         [Test]
-        public void T011_TestRemoveRootAgent()
+        public void TestChildAgentEstablished()
         {
-            TestHelper.InMethod();
-
-            scene.RemoveClient(agent1);
-
-            ScenePresence presence = scene.GetScenePresence(agent1);
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+            
+            UUID agent1Id = UUID.Parse("00000000-0000-0000-0000-000000000001");
+            
+            TestScene myScene1 = SceneHelpers.SetupScene("Neighbour y", UUID.Random(), 1000, 1000);
+//            TestScene myScene2 = SceneHelpers.SetupScene("Neighbour y + 1", UUID.Random(), 1001, 1000);
+            
+            IConfigSource configSource = new IniConfigSource();
+            configSource.AddConfig("Modules").Set("EntityTransferModule", "BasicEntityTransferModule");                      
+            EntityTransferModule etm = new EntityTransferModule();
+            
+            SceneHelpers.SetupSceneModules(myScene1, configSource, etm);            
+            
+            SceneHelpers.AddScenePresence(myScene1, agent1Id);
+//            ScenePresence childPresence = myScene2.GetScenePresence(agent1);
 
-            Assert.That(presence, Is.Null, "presence is not null");
+            // TODO: Need to do a fair amount of work to allow synchronous establishment of child agents
+//            Assert.That(childPresence, Is.Not.Null);
+//            Assert.That(childPresence.IsChildAgent, Is.True);
         }
 
+//        /// <summary>
+//        /// Test adding a root agent to a scene.  Doesn't yet actually complete crossing the agent into the scene.
+//        /// </summary>
+//        [Test]
+//        public void T010_TestAddRootAgent()
+//        {
+//            TestHelpers.InMethod();
+//
+//            string firstName = "testfirstname";
+//
+//            AgentCircuitData agent = new AgentCircuitData();
+//            agent.AgentID = agent1;
+//            agent.firstname = firstName;
+//            agent.lastname = "testlastname";
+//            agent.SessionID = UUID.Random();
+//            agent.SecureSessionID = UUID.Random();
+//            agent.circuitcode = 123;
+//            agent.BaseFolder = UUID.Zero;
+//            agent.InventoryFolder = UUID.Zero;
+//            agent.startpos = Vector3.Zero;
+//            agent.CapsPath = GetRandomCapsObjectPath();
+//            agent.ChildrenCapSeeds = new Dictionary<ulong, string>();
+//            agent.child = true;
+//
+//            scene.PresenceService.LoginAgent(agent.AgentID.ToString(), agent.SessionID, agent.SecureSessionID);
+//
+//            string reason;
+//            scene.NewUserConnection(agent, (uint)TeleportFlags.ViaLogin, out reason);
+//            testclient = new TestClient(agent, scene);
+//            scene.AddNewClient(testclient);
+//
+//            ScenePresence presence = scene.GetScenePresence(agent1);
+//
+//            Assert.That(presence, Is.Not.Null, "presence is null");
+//            Assert.That(presence.Firstname, Is.EqualTo(firstName), "First name not same");
+//            acd1 = agent;
+//        }
+//
+//        /// <summary>
+//        /// Test removing an uncrossed root agent from a scene.
+//        /// </summary>
+//        [Test]
+//        public void T011_TestRemoveRootAgent()
+//        {
+//            TestHelpers.InMethod();
+//
+//            scene.RemoveClient(agent1);
+//
+//            ScenePresence presence = scene.GetScenePresence(agent1);
+//
+//            Assert.That(presence, Is.Null, "presence is not null");
+//        }
+
         [Test]
         public void T012_TestAddNeighbourRegion()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 
             string reason;
 
@@ -157,7 +207,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             scene.NewUserConnection(acd1, 0, out reason);
             if (testclient == null)
                 testclient = new TestClient(acd1, scene);
-            scene.AddNewClient(testclient);
+            scene.AddNewClient(testclient, PresenceType.User);
 
             ScenePresence presence = scene.GetScenePresence(agent1);
             presence.MakeRootAgent(new Vector3(90,90,90),false);
@@ -175,7 +225,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void T013_TestRemoveNeighbourRegion()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 
             ScenePresence presence = scene.GetScenePresence(agent1);
             presence.RemoveNeighbourRegion(region3);
@@ -188,37 +238,6 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             CompleteAvatarMovement
             */
         }
-        
-        /// <summary>
-        /// Test that if a root agent logs into a region, a child agent is also established in the neighbouring region
-        /// </summary>
-        /// <remarks>
-        /// Please note that unlike the other tests here, this doesn't rely on structures
-        /// </remarks>
-        [Test]
-        public void TestChildAgentEstablished()
-        {
-            TestHelper.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
-            
-            UUID agent1Id = UUID.Parse("00000000-0000-0000-0000-000000000001");
-            
-            TestScene myScene1 = SceneSetupHelpers.SetupScene("Neighbour y", UUID.Random(), 1000, 1000);
-            TestScene myScene2 = SceneSetupHelpers.SetupScene("Neighbour y + 1", UUID.Random(), 1001, 1000);            
-            
-            IConfigSource configSource = new IniConfigSource();
-            configSource.AddConfig("Modules").Set("EntityTransferModule", "BasicEntityTransferModule");                      
-            EntityTransferModule etm = new EntityTransferModule();
-            
-            SceneSetupHelpers.SetupSceneModules(myScene1, configSource, etm);            
-            
-            SceneSetupHelpers.AddRootAgent(myScene1, agent1Id);
-            ScenePresence childPresence = myScene2.GetScenePresence(agent1);
-            
-            // TODO: Need to do a fair amount of work to allow synchronous establishment of child agents
-//            Assert.That(childPresence, Is.Not.Null);
-//            Assert.That(childPresence.IsChildAgent, Is.True);
-        }
 
         // I'm commenting this test because it does not represent
         // crossings. The Thread.Sleep's in here are not meaningful mocks,
@@ -230,7 +249,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         //[Test]
         public void T021_TestCrossToNewRegion()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 
             scene.RegisterRegionWithGrid();
             scene2.RegisterRegionWithGrid();
@@ -238,7 +257,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             // Adding child agent to region 1001
             string reason;
             scene2.NewUserConnection(acd1,0, out reason);
-            scene2.AddNewClient(testclient);
+            scene2.AddNewClient(testclient, PresenceType.User);
 
             ScenePresence presence = scene.GetScenePresence(agent1);
             presence.MakeRootAgent(new Vector3(0,unchecked(Constants.RegionSize-1),0), true);
@@ -338,6 +357,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             agent.InventoryFolder = UUID.Zero;
             agent.startpos = Vector3.Zero;
             agent.CapsPath = GetRandomCapsObjectPath();
+            agent.Appearance = new AvatarAppearance();
 
             acd1 = agent;
         }
@@ -349,37 +369,5 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             capsPath = capsPath.Remove(capsPath.Length - 4, 4);
             return capsPath;
         }
-
-        private SceneObjectGroup NewSOG(UUID uuid, Scene scene, UUID agent)
-        {
-            SceneObjectPart sop = new SceneObjectPart();
-            sop.Name = RandomName();
-            sop.Description = RandomName();
-            sop.Text = RandomName();
-            sop.SitName = RandomName();
-            sop.TouchName = RandomName();
-            sop.UUID = uuid;
-            sop.Shape = PrimitiveBaseShape.Default;
-            sop.Shape.State = 1;
-            sop.OwnerID = agent;
-
-            SceneObjectGroup sog = new SceneObjectGroup(sop);
-            sog.SetScene(scene);
-
-            return sog;
-        }
-
-        private static string RandomName()
-        {
-            StringBuilder name = new StringBuilder();
-            int size = random.Next(5,12);
-            char ch ;
-            for (int i=0; i<size; i++)
-            {
-                ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65))) ;
-                name.Append(ch);
-            }
-            return name.ToString();
-        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/StandaloneTeleportTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
index 1b5a54e..39bb43a 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/StandaloneTeleportTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
@@ -44,7 +44,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
     /// Teleport tests in a standalone OpenSim
     /// </summary>
     [TestFixture]
-    public class StandaloneTeleportTests
+    public class ScenePresenceTeleportTests
     {
         /// <summary>
         /// Test a teleport between two regions that are not neighbours and do not share any neighbours in common.
@@ -54,7 +54,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         //[Test, LongRunning]
         public void TestSimpleNotNeighboursTeleport()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             ThreadRunResults results = new ThreadRunResults();
             results.Result = false;
             results.Message = "Test did not run";
@@ -116,16 +116,16 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             ISharedRegionModule interregionComms = new LocalSimulationConnectorModule();
 
 
-            Scene sceneB = SceneSetupHelpers.SetupScene("sceneB", sceneBId, 1010, 1010);
-            SceneSetupHelpers.SetupSceneModules(sceneB, new IniConfigSource(), interregionComms);
+            Scene sceneB = SceneHelpers.SetupScene("sceneB", sceneBId, 1010, 1010);
+            SceneHelpers.SetupSceneModules(sceneB, new IniConfigSource(), interregionComms);
             sceneB.RegisterRegionWithGrid();
 
-            Scene sceneA = SceneSetupHelpers.SetupScene("sceneA", sceneAId, 1000, 1000);
-            SceneSetupHelpers.SetupSceneModules(sceneA, new IniConfigSource(), interregionComms);
+            Scene sceneA = SceneHelpers.SetupScene("sceneA", sceneAId, 1000, 1000);
+            SceneHelpers.SetupSceneModules(sceneA, new IniConfigSource(), interregionComms);
             sceneA.RegisterRegionWithGrid();
 
             UUID agentId = UUID.Parse("00000000-0000-0000-0000-000000000041");
-            TestClient client = SceneSetupHelpers.AddRootAgent(sceneA, agentId);
+            TestClient client = (TestClient)SceneHelpers.AddScenePresence(sceneA, agentId).ControllingClient;
 
             ICapabilitiesModule sceneACapsModule = sceneA.RequestModuleInterface<ICapabilitiesModule>();
 
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
index 13d93f9..8b8aea5 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
@@ -58,9 +58,9 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestUpdateScene()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 
-            Scene scene = SceneSetupHelpers.SetupScene();
+            Scene scene = SceneHelpers.SetupScene();
             scene.Update();
             
             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 f4e14d4..1abef8d 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/TaskInventoryTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/TaskInventoryTests.cs
@@ -55,12 +55,12 @@ namespace OpenSim.Region.Framework.Tests
         [Test]
         public void TestRezObjectFromInventoryItem()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneSetupHelpers.SetupScene();
+            Scene scene = SceneHelpers.SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
-            SceneObjectGroup sog1 = SceneSetupHelpers.CreateSceneObject(1, user1.PrincipalID);
+            SceneObjectGroup sog1 = SceneHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
 
             // Create an object embedded inside the first
@@ -98,12 +98,12 @@ namespace OpenSim.Region.Framework.Tests
         [Test]
         public void TestMoveTaskInventoryItem()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneSetupHelpers.SetupScene();
+            Scene scene = SceneHelpers.SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
-            SceneObjectGroup sog1 = SceneSetupHelpers.CreateSceneObject(1, user1.PrincipalID);
+            SceneObjectGroup sog1 = SceneHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
             TaskInventoryItem sopItem1 = TaskInventoryHelpers.AddNotecard(scene, sop1);
 
@@ -125,12 +125,12 @@ namespace OpenSim.Region.Framework.Tests
         [Test]
         public void TestMoveTaskInventoryItemNoParent()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneSetupHelpers.SetupScene();
+            Scene scene = SceneHelpers.SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
-            SceneObjectGroup sog1 = SceneSetupHelpers.CreateSceneObject(1, user1.PrincipalID);
+            SceneObjectGroup sog1 = SceneHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
             TaskInventoryItem sopItem1 = TaskInventoryHelpers.AddNotecard(scene, sop1);
             
diff --git a/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs b/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
index abca792..55fc1e7 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
@@ -55,12 +55,12 @@ namespace OpenSim.Region.Framework.Tests
         [Test]
         public void TestGiveInventoryItem()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = SceneSetupHelpers.SetupScene();
-            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, 1001);
-            UserAccount user2 = UserAccountHelpers.CreateUserWithInventory(scene, 1002);
+            Scene scene = 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);
 
             scene.GiveInventoryItem(user2.PrincipalID, user1.PrincipalID, item1.ID);
@@ -82,12 +82,12 @@ namespace OpenSim.Region.Framework.Tests
         [Test]
         public void TestGiveInventoryFolder()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            Scene scene = SceneSetupHelpers.SetupScene();
-            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, 1001);
-            UserAccount user2 = UserAccountHelpers.CreateUserWithInventory(scene, 1002);
+            Scene scene = SceneHelpers.SetupScene();
+            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1001));
+            UserAccount user2 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1002));
             InventoryFolderBase folder1
                 = UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, user1.PrincipalID, "folder1");
 
diff --git a/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs b/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs
index 4da8df1..24de56e 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 = SceneSetupHelpers.SetupScene();
+            Scene scene = SceneHelpers.SetupScene();
             m_assetService = scene.AssetService;
             m_uuidGatherer = new UuidGatherer(m_assetService);
         }
@@ -55,7 +55,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestCorruptAsset()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             UUID corruptAssetUuid = UUID.Parse("00000000-0000-0000-0000-000000000666");
             AssetBase corruptAsset 
@@ -75,7 +75,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         [Test]
         public void TestMissingAsset()
         {
-            TestHelper.InMethod();
+            TestHelpers.InMethod();
             
             UUID missingAssetUuid = UUID.Parse("00000000-0000-0000-0000-000000000666");
             IDictionary<UUID, AssetType> foundAssetUuids = new Dictionary<UUID, AssetType>();
diff --git a/OpenSim/Region/Framework/Scenes/UndoState.cs b/OpenSim/Region/Framework/Scenes/UndoState.cs
index f71b507..81f41db 100644
--- a/OpenSim/Region/Framework/Scenes/UndoState.cs
+++ b/OpenSim/Region/Framework/Scenes/UndoState.cs
@@ -25,6 +25,9 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System;
+using System.Reflection;
+using log4net;
 using OpenMetaverse;
 using OpenSim.Region.Framework.Interfaces;
 using System;
@@ -47,6 +50,8 @@ namespace OpenSim.Region.Framework.Scenes
 
     public class UndoState
     {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         public Vector3 Position = Vector3.Zero;
         public Vector3 Scale = Vector3.Zero;
         public Quaternion Rotation = Quaternion.Identity;
@@ -56,13 +61,23 @@ namespace OpenSim.Region.Framework.Scenes
         public DateTime LastUpdated = DateTime.Now;
         public UndoType Type;
 
-        public UndoState(SceneObjectPart part, UndoType type)
+        /// <summary>
+        /// Is this undo state for an entire group?
+        /// </summary>
+        public bool ForGroup;
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="part"></param>
+        /// <param name="forGroup">True if the undo is for an entire group</param>
+        public UndoState(SceneObjectPart part, bool forGroup)
         {
-            Type = type;
-            if (part != null)
+            if (part.ParentID == 0)
             {
-                if (part.ParentID == 0)
-                {
+                ForGroup = forGroup;
+
+//                    if (ForGroup)
                     GroupScale = part.ParentGroup.RootPart.Shape.Scale;
 
                     //FUBAR WARNING: Do NOT get the group's absoluteposition here 
@@ -70,23 +85,35 @@ namespace OpenSim.Region.Framework.Scenes
                     GroupPosition = part.ParentGroup.RootPart.AbsolutePosition;
                     GroupRotation = part.ParentGroup.GroupRotation;
                     Position = part.ParentGroup.RootPart.AbsolutePosition;
-                    Rotation = part.RotationOffset;
-                    Scale = part.Shape.Scale;
-                    LastUpdated = DateTime.Now;
-                }
-                else
-                {
-                    GroupScale = part.Shape.Scale;
+//                    else
+//                        Position = part.OffsetPosition;
 
-                    //FUBAR WARNING: Do NOT get the group's absoluteposition here 
-                    //or you'll experience a loop and/or a stack issue
-                    GroupPosition = part.ParentGroup.RootPart.AbsolutePosition;
-                    GroupRotation = part.ParentGroup.Rotation;
-                    Position = part.OffsetPosition;
-                    Rotation = part.RotationOffset;
-                    Scale = part.Shape.Scale;
-                    LastUpdated = DateTime.Now;
-                }
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Storing undo position {0} for root part", Position);
+
+                Rotation = part.RotationOffset;
+
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Storing undo rotation {0} for root part", Rotation);
+
+                Scale = part.Shape.Scale;
+
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Storing undo scale {0} for root part", Scale);
+            }
+            else
+            {
+                Position = part.OffsetPosition;
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Storing undo position {0} for child part", Position);
+
+                Rotation = part.RotationOffset;
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Storing undo rotation {0} for child part", Rotation);
+
+                Scale = part.Shape.Scale;
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Storing undo scale {0} for child part", Scale);
             }
         }
         public void Merge(UndoState last)
@@ -132,95 +159,143 @@ namespace OpenSim.Region.Framework.Scenes
                 return false;
             }
         }
+        /// <summary>
+        /// Compare the relevant state in the given part to this state.
+        /// </summary>
+        /// <param name="part"></param>
+        /// <returns>true if both the part's position, rotation and scale match those in this undo state.  False otherwise.</returns>
         public bool Compare(SceneObjectPart part)
         {
             if (part != null)
             {
                 if (part.ParentID == 0)
-                {
-                    if (Position == part.ParentGroup.RootPart.AbsolutePosition && Rotation == part.ParentGroup.Rotation && GroupPosition == part.ParentGroup.RootPart.AbsolutePosition && part.ParentGroup.Rotation == GroupRotation && part.Shape.Scale == GroupScale)
-                        return true;
-                    else
-                        return false;
-                }
+                    return
+                        Position == part.ParentGroup.AbsolutePosition
+                            && Rotation == part.RotationOffset
+                            && Scale == part.Shape.Scale;
                 else
-                {
-                    if (Position == part.OffsetPosition && Rotation == part.RotationOffset && Scale == part.Shape.Scale && GroupPosition == part.ParentGroup.RootPart.AbsolutePosition && part.ParentGroup.Rotation == GroupRotation && part.Shape.Scale == GroupScale)
-                        return true;
-                    else
-                        return false;
-
-                }
+                    return
+                        Position == part.OffsetPosition
+                            && Rotation == part.RotationOffset
+                            && Scale == part.Shape.Scale;
             }
+
             return false;
         }
 
         private void RestoreState(SceneObjectPart part)
         {
-            bool GroupChange = false;
-            if ((Type & UndoType.STATE_GROUP_POSITION) != 0
-                || (Type & UndoType.STATE_GROUP_ROTATION) != 0
-                || (Type & UndoType.STATE_GROUP_SCALE) != 0)
-            {
-                GroupChange = true;
-            }
+            part.Undoing = true;
 
-            if (part != null)
+            if (part.ParentID == 0)
             {
-                part.Undoing = true;
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Undoing position to {0} for root part {1} {2}",
+//                        Position, part.Name, part.LocalId);
 
-                if (part.ParentID == 0 && GroupChange == false)
+                if (Position != Vector3.Zero)
                 {
-                    if (Position != Vector3.Zero)
-
-                    part.ParentGroup.UpdateSinglePosition(Position, part.LocalId);
-                    part.ParentGroup.UpdateSingleRotation(Rotation, part.LocalId);
-                    if (Scale != Vector3.Zero)
-                        part.Resize(Scale);
-                    part.ParentGroup.ScheduleGroupForTerseUpdate();
+                    if (ForGroup)
+                        part.ParentGroup.AbsolutePosition = Position;
+                    else
+                        part.ParentGroup.UpdateRootPosition(Position);
                 }
+
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Undoing rotation {0} to {1} for root part {2} {3}",
+//                        part.RotationOffset, Rotation, part.Name, part.LocalId);
+
+                if (ForGroup)
+                    part.UpdateRotation(Rotation);
                 else
+                    part.ParentGroup.UpdateRootRotation(Rotation);
+
+                if (Scale != Vector3.Zero)
                 {
-                    if (GroupChange)
-                    {
-                        part.ParentGroup.RootPart.Undoing = true;
-                        if (GroupPosition != Vector3.Zero)
-                        {
-                            //Calculate the scale...
-                            Vector3 gs = part.Shape.Scale;
-                            float scale = GroupScale.Z / gs.Z;
-
-                            //Scale first since it can affect our position
-                            part.ParentGroup.GroupResize(gs * scale, part.LocalId);
-                            part.ParentGroup.AbsolutePosition = GroupPosition;
-                            part.ParentGroup.UpdateGroupRotationR(GroupRotation);
-
-                        }
-                        part.ParentGroup.RootPart.Undoing = false;
-                    }
+//                        m_log.DebugFormat(
+//                            "[UNDO STATE]: Undoing scale {0} to {1} for root part {2} {3}",
+//                            part.Shape.Scale, Scale, part.Name, part.LocalId);
+
+                    if (ForGroup)
+                        part.ParentGroup.GroupResize(Scale);
                     else
-                    {
-                        if (Position != Vector3.Zero) //We can use this for all the updates since all are set
-                        {
-                            part.OffsetPosition = Position;
-                            part.UpdateRotation(Rotation);
-                            part.Resize(Scale); part.ScheduleTerseUpdate();
-                        }
-                    }
+                        part.Resize(Scale);
                 }
-                part.Undoing = false;
 
+                part.ParentGroup.ScheduleGroupForTerseUpdate();
             }
+            else
+            {
+                if (Position != Vector3.Zero)
+                {
+//                        m_log.DebugFormat(
+//                            "[UNDO STATE]: Undoing position {0} to {1} for child part {2} {3}",
+//                            part.OffsetPosition, Position, part.Name, part.LocalId);
+
+                    part.OffsetPosition = Position;
+                }
+
+//                    m_log.DebugFormat(
+//                        "[UNDO STATE]: Undoing rotation {0} to {1} for child part {2} {3}",
+//                        part.RotationOffset, Rotation, part.Name, part.LocalId);
+
+                part.UpdateRotation(Rotation);
+
+                if (Scale != Vector3.Zero)
+                {
+//                        m_log.DebugFormat(
+//                            "[UNDO STATE]: Undoing scale {0} to {1} for child part {2} {3}",
+//                            part.Shape.Scale, Scale, part.Name, part.LocalId);
+
+                    part.Resize(Scale);
+                }
+
+                part.ScheduleTerseUpdate();
+            }
+
+            part.Undoing = false;
         }
-        public void PlaybackState(SceneObjectPart part)
-        {
-            RestoreState(part);
-        }
+
         public void PlayfwdState(SceneObjectPart part)
         {
-            RestoreState(part);
+            part.Undoing = true;
+
+            if (part.ParentID == 0)
+            {
+                if (Position != Vector3.Zero)
+                    part.ParentGroup.AbsolutePosition = Position;
+
+                if (Rotation != Quaternion.Identity)
+                    part.UpdateRotation(Rotation);
+
+                if (Scale != Vector3.Zero)
+                {
+                    if (ForGroup)
+                        part.ParentGroup.GroupResize(Scale);
+                    else
+                        part.Resize(Scale);
+                }
+
+                part.ParentGroup.ScheduleGroupForTerseUpdate();
+            }
+            else
+            {
+                if (Position != Vector3.Zero)
+                    part.OffsetPosition = Position;
+
+                if (Rotation != Quaternion.Identity)
+                    part.UpdateRotation(Rotation);
+
+                if (Scale != Vector3.Zero)
+                    part.Resize(Scale);
+
+                part.ScheduleTerseUpdate();
+            }
+
+            part.Undoing = false;
         }
     }
+
     public class LandUndoState
     {
         public ITerrainModule m_terrainModule;
@@ -234,10 +309,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool Compare(ITerrainChannel terrainChannel)
         {
-            if (m_terrainChannel != terrainChannel)
-                return false;
-            else
-                return false;
+            return m_terrainChannel == terrainChannel;
         }
 
         public void PlaybackState()
@@ -246,4 +318,3 @@ namespace OpenSim.Region.Framework.Scenes
         }
     }
 }
-