18 files changed, 2284 insertions, 729 deletions

diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index fd35c62..74d9e60 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -55,8 +55,12 @@ namespace OpenSim.Region.Framework.Scenes
 
         public delegate void OnTerrainTickDelegate();
 
+        public delegate void OnTerrainUpdateDelegate();
+
         public event OnTerrainTickDelegate OnTerrainTick;
 
+        public event OnTerrainUpdateDelegate OnTerrainUpdate;
+
         public delegate void OnBackupDelegate(ISimulationDataService datastore, bool forceBackup);
 
         public event OnBackupDelegate OnBackup;
@@ -791,6 +795,26 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
         }
+        public void TriggerTerrainUpdate()
+        {
+            OnTerrainUpdateDelegate handlerTerrainUpdate = OnTerrainUpdate;
+            if (handlerTerrainUpdate != null)
+            {
+                foreach (OnTerrainUpdateDelegate d in handlerTerrainUpdate.GetInvocationList())
+                {
+                    try
+                    {
+                        d();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerTerrainUpdate failed - continuing.  {0} {1}",
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }
 
         public void TriggerTerrainTick()
         {
diff --git a/OpenSim/Region/Framework/Scenes/Prioritizer.cs b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
index 1b10e3c..0a34a4c 100644
--- a/OpenSim/Region/Framework/Scenes/Prioritizer.cs
+++ b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
@@ -157,7 +157,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         private uint GetPriorityByBestAvatarResponsiveness(IClientAPI client, ISceneEntity entity)
         {
-            uint pqueue = ComputeDistancePriority(client,entity,true);
+            uint pqueue = ComputeDistancePriority(client,entity,false);
 
             ScenePresence presence = m_scene.GetScenePresence(client.AgentId);
             if (presence != null)
@@ -226,7 +226,7 @@ namespace OpenSim.Region.Framework.Scenes
             
             for (int i = 0; i < queues - 1; i++)
             {
-                if (distance < 10 * Math.Pow(2.0,i))
+                if (distance < 30 * Math.Pow(2.0,i))
                     break;
                 pqueue++;
             }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 2444367..e005698 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -117,34 +117,22 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="item"></param>
         public bool AddInventoryItem(InventoryItemBase item)
         {
-            if (UUID.Zero == item.Folder)
+            InventoryFolderBase folder;
+
+            if (item.Folder == UUID.Zero)
             {
-                InventoryFolderBase f = InventoryService.GetFolderForType(item.Owner, (AssetType)item.AssetType);
-                if (f != null)
+                folder = InventoryService.GetFolderForType(item.Owner, (AssetType)item.AssetType);
+                if (folder == null)
                 {
-//                    m_log.DebugFormat(
-//                        "[LOCAL INVENTORY SERVICES CONNECTOR]: Found folder {0} type {1} for item {2}", 
-//                        f.Name, (AssetType)f.Type, item.Name);
-                    
-                    item.Folder = f.ID;
-                }
-                else
-                {
-                    f = InventoryService.GetRootFolder(item.Owner);
-                    if (f != null)
-                    {
-                        item.Folder = f.ID;
-                    }
-                    else
-                    {
-                        m_log.WarnFormat(
-                            "[AGENT INVENTORY]: Could not find root folder for {0} when trying to add item {1} with no parent folder specified",
-                            item.Owner, item.Name);
+                    folder = InventoryService.GetRootFolder(item.Owner);
+
+                    if (folder == null)
                         return false;
-                    }
                 }
+
+                item.Folder = folder.ID;
             }
-            
+
             if (InventoryService.AddItem(item))
             {
                 int userlevel = 0;
@@ -264,8 +252,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             // Update item with new asset
             item.AssetID = asset.FullID;
-            if (group.UpdateInventoryItem(item))
-                remoteClient.SendAgentAlertMessage("Script saved", false);
+            group.UpdateInventoryItem(item);
             
             part.SendPropertiesToClient(remoteClient);
 
@@ -276,12 +263,7 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 // Needs to determine which engine was running it and use that
                 //
-                part.Inventory.CreateScriptInstance(item.ItemID, 0, false, DefaultScriptEngine, 0);
-                errors = part.Inventory.GetScriptErrors(item.ItemID);
-            }
-            else
-            {
-                remoteClient.SendAgentAlertMessage("Script saved", false);
+                errors = part.Inventory.CreateScriptInstanceEr(item.ItemID, 0, false, DefaultScriptEngine, 0);
             }
             part.ParentGroup.ResumeScripts();
             return errors;
@@ -345,6 +327,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (UUID.Zero == transactionID)
                 {
+                    item.Flags = (item.Flags & ~(uint)255) | (itemUpd.Flags & (uint)255);
                     item.Name = itemUpd.Name;
                     item.Description = itemUpd.Description;
                     if (item.NextPermissions != (itemUpd.NextPermissions & item.BasePermissions))
@@ -723,6 +706,8 @@ namespace OpenSim.Region.Framework.Scenes
                     return;
             }
 
+            if (newName == null) newName = item.Name;
+
             AssetBase asset = AssetService.Get(item.AssetID.ToString());
 
             if (asset != null)
@@ -779,6 +764,24 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Move an item within the agent's inventory, and leave a copy (used in making a new outfit)
+        /// </summary>
+        public void MoveInventoryItemsLeaveCopy(IClientAPI remoteClient, List<InventoryItemBase> items, UUID destfolder)
+        {
+            List<InventoryItemBase> moveitems = new List<InventoryItemBase>();
+            foreach (InventoryItemBase b in items)
+            {
+                CopyInventoryItem(remoteClient, 0, remoteClient.AgentId, b.ID, b.Folder, null);
+                InventoryItemBase n = InventoryService.GetItem(b);
+                n.Folder = destfolder;
+                moveitems.Add(n);
+                remoteClient.SendInventoryItemCreateUpdate(n, 0);
+            }
+            
+            MoveInventoryItem(remoteClient, moveitems);
+        }
+
+        /// <summary>
         /// Move an item within the agent's inventory.
         /// </summary>
         /// <param name="remoteClient"></param>
@@ -1121,6 +1124,10 @@ namespace OpenSim.Region.Framework.Scenes
         {
             SceneObjectPart part = GetSceneObjectPart(primLocalId);
 
+            // Can't move a null item
+            if (itemId == UUID.Zero)
+                return;
+
             if (null == part)
             {
                 m_log.WarnFormat(
@@ -1231,6 +1238,10 @@ namespace OpenSim.Region.Framework.Scenes
             if ((part.OwnerID != destPart.OwnerID) && ((srcTaskItem.CurrentPermissions & (uint)PermissionMask.Transfer) == 0))
                 return;
 
+            bool overrideNoMod = false;
+            if ((part.GetEffectiveObjectFlags() & (uint)PrimFlags.AllowInventoryDrop) != 0)
+                overrideNoMod = true;
+
             if (part.OwnerID != destPart.OwnerID && (part.GetEffectiveObjectFlags() & (uint)PrimFlags.AllowInventoryDrop) == 0)
             {
                 // object cannot copy items to an object owned by a different owner
@@ -1240,7 +1251,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             // must have both move and modify permission to put an item in an object
-            if ((part.OwnerMask & ((uint)PermissionMask.Move | (uint)PermissionMask.Modify)) == 0)
+            if (((part.OwnerMask & (uint)PermissionMask.Modify) == 0) && (!overrideNoMod))
             {
                 return;
             }
@@ -1299,6 +1310,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         public UUID MoveTaskInventoryItems(UUID destID, string category, SceneObjectPart host, List<UUID> items)
         {
+            SceneObjectPart destPart = GetSceneObjectPart(destID);
+            if (destPart != null) // Move into a prim
+            {
+                foreach(UUID itemID in items)
+                    MoveTaskInventoryItem(destID, host, itemID);
+                return destID; // Prim folder ID == prim ID
+            }
+
             InventoryFolderBase rootFolder = InventoryService.GetRootFolder(destID);
 
             UUID newFolderID = UUID.Random();
@@ -1478,13 +1497,6 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         agentTransactions.HandleTaskItemUpdateFromTransaction(
                             remoteClient, part, transactionID, currentItem);
-
-                        if ((InventoryType)itemInfo.InvType == InventoryType.Notecard) 
-                            remoteClient.SendAgentAlertMessage("Notecard saved", false);
-                        else if ((InventoryType)itemInfo.InvType == InventoryType.LSL)
-                            remoteClient.SendAgentAlertMessage("Script saved", false);
-                        else
-                            remoteClient.SendAgentAlertMessage("Item saved", false);
                     }
 
                     // Base ALWAYS has move
@@ -1625,7 +1637,7 @@ namespace OpenSim.Region.Framework.Scenes
                     return;
 
                 AssetBase asset = CreateAsset(itemBase.Name, itemBase.Description, (sbyte)itemBase.AssetType,
-                    Encoding.ASCII.GetBytes("default\n{\n    state_entry()\n    {\n        llSay(0, \"Script running\");\n    }\n}"),
+                    Encoding.ASCII.GetBytes("default\n{\n    state_entry()\n    {\n        llSay(0, \"Script running\");\n    }\n\n    touch_start(integer num)\n    {\n    }\n}"),
                     remoteClient.AgentId);
                 AssetService.Store(asset);
 
@@ -1778,23 +1790,32 @@ namespace OpenSim.Region.Framework.Scenes
             // build a list of eligible objects
             List<uint> deleteIDs = new List<uint>();
             List<SceneObjectGroup> deleteGroups = new List<SceneObjectGroup>();
-
-            // Start with true for both, then remove the flags if objects
-            // that we can't derez are part of the selection
-            bool permissionToTake = true;
-            bool permissionToTakeCopy = true;
-            bool permissionToDelete = true;
+            List<SceneObjectGroup> takeGroups = new List<SceneObjectGroup>();
 
             foreach (uint localID in localIDs)
             {
+                // Start with true for both, then remove the flags if objects
+                // that we can't derez are part of the selection
+                bool permissionToTake = true;
+                bool permissionToTakeCopy = true;
+                bool permissionToDelete = true;
+
                 // Invalid id
                 SceneObjectPart part = GetSceneObjectPart(localID);
                 if (part == null)
+                {
+                    //Client still thinks the object exists, kill it
+                    deleteIDs.Add(localID);
                     continue;
+                }
 
                 // Already deleted by someone else
                 if (part.ParentGroup.IsDeleted)
+                {
+                    //Client still thinks the object exists, kill it
+                    deleteIDs.Add(localID);
                     continue;
+                }
 
                 // Can't delete child prims
                 if (part != part.ParentGroup.RootPart)
@@ -1802,9 +1823,6 @@ namespace OpenSim.Region.Framework.Scenes
 
                 SceneObjectGroup grp = part.ParentGroup;
 
-                deleteIDs.Add(localID);
-                deleteGroups.Add(grp);
-
                 if (remoteClient == null)
                 {
                     // Autoreturn has a null client. Nothing else does. So
@@ -1821,83 +1839,195 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 else
                 {
-                    if (!Permissions.CanTakeCopyObject(grp.UUID, remoteClient.AgentId))
+                    if (action == DeRezAction.TakeCopy)
+                    {
+                        if (!Permissions.CanTakeCopyObject(grp.UUID, remoteClient.AgentId))
+                            permissionToTakeCopy = false;
+                    }
+                    else
+                    {
                         permissionToTakeCopy = false;
-                    
+                    }
                     if (!Permissions.CanTakeObject(grp.UUID, remoteClient.AgentId))
                         permissionToTake = false;
                     
                     if (!Permissions.CanDeleteObject(grp.UUID, remoteClient.AgentId))
                         permissionToDelete = false;
                 }
-            }
 
-            // Handle god perms
-            if ((remoteClient != null) && Permissions.IsGod(remoteClient.AgentId))
-            {
-                permissionToTake = true;
-                permissionToTakeCopy = true;
-                permissionToDelete = true;
-            }
+                // Handle god perms
+                if ((remoteClient != null) && Permissions.IsGod(remoteClient.AgentId))
+                {
+                    permissionToTake = true;
+                    permissionToTakeCopy = true;
+                    permissionToDelete = true;
+                }
 
-            // If we're re-saving, we don't even want to delete
-            if (action == DeRezAction.SaveToExistingUserInventoryItem)
-                permissionToDelete = false;
+                // If we're re-saving, we don't even want to delete
+                if (action == DeRezAction.SaveToExistingUserInventoryItem)
+                    permissionToDelete = false;
 
-            // if we want to take a copy, we also don't want to delete
-            // Note: after this point, the permissionToTakeCopy flag
-            // becomes irrelevant. It already includes the permissionToTake
-            // permission and after excluding no copy items here, we can
-            // just use that.
-            if (action == DeRezAction.TakeCopy)
-            {
-                // If we don't have permission, stop right here
-                if (!permissionToTakeCopy)
-                    return;
+                // if we want to take a copy, we also don't want to delete
+                // Note: after this point, the permissionToTakeCopy flag
+                // becomes irrelevant. It already includes the permissionToTake
+                // permission and after excluding no copy items here, we can
+                // just use that.
+                if (action == DeRezAction.TakeCopy)
+                {
+                    // If we don't have permission, stop right here
+                    if (!permissionToTakeCopy)
+                        return;
 
-                permissionToTake = true;
-                // Don't delete
-                permissionToDelete = false;
-            }
+                    permissionToTake = true;
+                    // Don't delete
+                    permissionToDelete = false;
+                }
 
-            if (action == DeRezAction.Return)
-            {
-                if (remoteClient != null)
+                if (action == DeRezAction.Return)
                 {
-                    if (Permissions.CanReturnObjects(
-                                    null,
-                                    remoteClient.AgentId,
-                                    deleteGroups))
+                    if (remoteClient != null)
                     {
-                        permissionToTake = true;
-                        permissionToDelete = true;
-
-                        foreach (SceneObjectGroup g in deleteGroups)
+                        if (Permissions.CanReturnObjects(
+                                        null,
+                                        remoteClient.AgentId,
+                                        deleteGroups))
                         {
-                            AddReturn(g.OwnerID, g.Name, g.AbsolutePosition, "parcel owner return");
+                            permissionToTake = true;
+                            permissionToDelete = true;
+
+                            AddReturn(grp.OwnerID, grp.Name, grp.AbsolutePosition, "parcel owner return");
                         }
                     }
+                    else // Auto return passes through here with null agent
+                    {
+                        permissionToTake = true;
+                        permissionToDelete = true;
+                    }
                 }
-                else // Auto return passes through here with null agent
+
+                if (permissionToTake && (!permissionToDelete))
+                    takeGroups.Add(grp);
+
+                if (permissionToDelete)
                 {
-                    permissionToTake = true;
-                    permissionToDelete = true;
+                    if (permissionToTake)
+                        deleteGroups.Add(grp);
+                    deleteIDs.Add(grp.LocalId);
                 }
             }
 
-            if (permissionToTake)
+            SendKillObject(deleteIDs);
+
+            if (deleteGroups.Count > 0)
             {
+                foreach (SceneObjectGroup g in deleteGroups)
+                    deleteIDs.Remove(g.LocalId);
+
                 m_asyncSceneObjectDeleter.DeleteToInventory(
                         action, destinationID, deleteGroups, remoteClient,
-                        permissionToDelete);
+                        true);
             }
-            else if (permissionToDelete)
+            if (takeGroups.Count > 0)
+            {
+                m_asyncSceneObjectDeleter.DeleteToInventory(
+                        action, destinationID, takeGroups, remoteClient,
+                        false);
+            }
+            if (deleteIDs.Count > 0)
             {
                 foreach (SceneObjectGroup g in deleteGroups)
-                    DeleteSceneObject(g, false);
+                    DeleteSceneObject(g, true);
             }
         }
 
+        public UUID attachObjectAssetStore(IClientAPI remoteClient, SceneObjectGroup grp, UUID AgentId, out UUID itemID)
+        {
+            itemID = UUID.Zero;
+            if (grp != null)
+            {
+                Vector3 inventoryStoredPosition = new Vector3
+                       (((grp.AbsolutePosition.X > (int)Constants.RegionSize)
+                             ? 250
+                             : grp.AbsolutePosition.X)
+                        ,
+                        (grp.AbsolutePosition.X > (int)Constants.RegionSize)
+                            ? 250
+                            : grp.AbsolutePosition.X,
+                        grp.AbsolutePosition.Z);
+
+                Vector3 originalPosition = grp.AbsolutePosition;
+
+                grp.AbsolutePosition = inventoryStoredPosition;
+
+                string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(grp);
+
+                grp.AbsolutePosition = originalPosition;
+
+                AssetBase asset = CreateAsset(
+                    grp.GetPartName(grp.LocalId),
+                    grp.GetPartDescription(grp.LocalId),
+                    (sbyte)AssetType.Object,
+                    Utils.StringToBytes(sceneObjectXml),
+                    remoteClient.AgentId);
+                AssetService.Store(asset);
+
+                InventoryItemBase item = new InventoryItemBase();
+                item.CreatorId = grp.RootPart.CreatorID.ToString();
+                item.CreatorData = grp.RootPart.CreatorData;
+                item.Owner = remoteClient.AgentId;
+                item.ID = UUID.Random();
+                item.AssetID = asset.FullID;
+                item.Description = asset.Description;
+                item.Name = asset.Name;
+                item.AssetType = asset.Type;
+                item.InvType = (int)InventoryType.Object;
+
+                InventoryFolderBase folder = InventoryService.GetFolderForType(remoteClient.AgentId, AssetType.Object);
+                if (folder != null)
+                    item.Folder = folder.ID;
+                else // oopsies
+                    item.Folder = UUID.Zero;
+
+                // Set up base perms properly
+                uint permsBase = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify);
+                permsBase &= grp.RootPart.BaseMask;
+                permsBase |= (uint)PermissionMask.Move;
+
+                // Make sure we don't lock it
+                grp.RootPart.NextOwnerMask |= (uint)PermissionMask.Move;
+
+                if ((remoteClient.AgentId != grp.RootPart.OwnerID) && Permissions.PropagatePermissions())
+                {
+                    item.BasePermissions = permsBase & grp.RootPart.NextOwnerMask;
+                    item.CurrentPermissions = permsBase & grp.RootPart.NextOwnerMask;
+                    item.NextPermissions = permsBase & grp.RootPart.NextOwnerMask;
+                    item.EveryOnePermissions = permsBase & grp.RootPart.EveryoneMask & grp.RootPart.NextOwnerMask;
+                    item.GroupPermissions = permsBase & grp.RootPart.GroupMask & grp.RootPart.NextOwnerMask;
+                }
+                else
+                {
+                    item.BasePermissions = permsBase;
+                    item.CurrentPermissions = permsBase & grp.RootPart.OwnerMask;
+                    item.NextPermissions = permsBase & grp.RootPart.NextOwnerMask;
+                    item.EveryOnePermissions = permsBase & grp.RootPart.EveryoneMask;
+                    item.GroupPermissions = permsBase & grp.RootPart.GroupMask;
+                }
+                item.CreationDate = Util.UnixTimeSinceEpoch();
+
+                // sets itemID so client can show item as 'attached' in inventory
+                grp.SetFromItemID(item.ID);
+
+                if (AddInventoryItem(item))
+                    remoteClient.SendInventoryItemCreateUpdate(item, 0);
+                else
+                    m_dialogModule.SendAlertToUser(remoteClient, "Operation failed");
+
+                itemID = item.ID;
+                return item.AssetID;
+            }
+            return UUID.Zero;
+        }
+
         /// <summary>
         /// Event Handler Rez an object into a scene
         /// Calls the non-void event handler
@@ -2024,6 +2154,9 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetScriptRunning(IClientAPI controllingClient, UUID objectID, UUID itemID, bool running)
         {
+            if (!Permissions.CanEditScript(itemID, objectID, controllingClient.AgentId))
+                return;
+
             SceneObjectPart part = GetSceneObjectPart(objectID);
             if (part == null)
                 return;
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index 3355ebe..bf2e775 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -346,7 +346,10 @@ namespace OpenSim.Region.Framework.Scenes
             List<UserAccount> accounts = UserAccountService.GetUserAccounts(RegionInfo.ScopeID, query);
 
             if (accounts == null)
+            {
+                m_log.DebugFormat("[LLCIENT]: ProcessAvatarPickerRequest: returned null result");
                 return;
+            }
 
             AvatarPickerReplyPacket replyPacket = (AvatarPickerReplyPacket) PacketPool.Instance.GetPacket(PacketType.AvatarPickerReply);
             // TODO: don't create new blocks if recycling an old packet
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs b/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
index e1fedf4..48beb9c 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
@@ -49,6 +49,7 @@ namespace OpenSim.Region.Framework.Scenes
     public delegate bool DuplicateObjectHandler(int objectCount, UUID objectID, UUID owner, Scene scene, Vector3 objectPosition);
     public delegate bool EditObjectHandler(UUID objectID, UUID editorID, Scene scene);
     public delegate bool EditObjectInventoryHandler(UUID objectID, UUID editorID, Scene scene);
+    public delegate bool ViewObjectInventoryHandler(UUID objectID, UUID editorID, Scene scene);
     public delegate bool MoveObjectHandler(UUID objectID, UUID moverID, Scene scene);
     public delegate bool ObjectEntryHandler(UUID objectID, bool enteringRegion, Vector3 newPoint, Scene scene);
     public delegate bool ReturnObjectsHandler(ILandObject land, UUID user, List<SceneObjectGroup> objects, Scene scene);
@@ -116,6 +117,7 @@ namespace OpenSim.Region.Framework.Scenes
         public event DuplicateObjectHandler OnDuplicateObject;
         public event EditObjectHandler OnEditObject;
         public event EditObjectInventoryHandler OnEditObjectInventory;
+        public event ViewObjectInventoryHandler OnViewObjectInventory;
         public event MoveObjectHandler OnMoveObject;
         public event ObjectEntryHandler OnObjectEntry;
         public event ReturnObjectsHandler OnReturnObjects;
@@ -401,6 +403,21 @@ namespace OpenSim.Region.Framework.Scenes
             return true;
         }
 
+        public bool CanViewObjectInventory(UUID objectID, UUID editorID)
+        {
+            ViewObjectInventoryHandler handler = OnViewObjectInventory;
+            if (handler != null)
+            {
+                Delegate[] list = handler.GetInvocationList();
+                foreach (ViewObjectInventoryHandler h in list)
+                {
+                    if (h(objectID, editorID, m_scene) == false)
+                        return false;
+                }
+            }
+            return true;
+        }
+
         #endregion
 
         #region MOVE OBJECT
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 027ec96..4de494f 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -103,6 +103,7 @@ namespace OpenSim.Region.Framework.Scenes
         // TODO: need to figure out how allow client agents but deny
         // root agents when ACL denies access to root agent
         public bool m_strictAccessControl = true;
+        public bool m_seeIntoBannedRegion = false;
         public int MaxUndoCount = 5;
         // Using this for RegionReady module to prevent LoginsDisabled from changing under our feet;
         public bool LoginLock = false;
@@ -118,12 +119,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         protected int m_splitRegionID;
         protected Timer m_restartWaitTimer = new Timer();
+        protected Timer m_timerWatchdog = new Timer();
         protected List<RegionInfo> m_regionRestartNotifyList = new List<RegionInfo>();
         protected List<RegionInfo> m_neighbours = new List<RegionInfo>();
         protected string m_simulatorVersion = "OpenSimulator Server";
         protected ModuleLoader m_moduleLoader;
         protected AgentCircuitManager m_authenticateHandler;
         protected SceneCommunicationService m_sceneGridService;
+        protected ISnmpModule m_snmpService = null;
 
         protected ISimulationDataService m_SimulationDataService;
         protected IEstateDataService m_EstateDataService;
@@ -176,7 +179,7 @@ namespace OpenSim.Region.Framework.Scenes
         private int m_update_events = 1;
         private int m_update_backup = 200;
         private int m_update_terrain = 50;
-//        private int m_update_land = 1;
+        private int m_update_land = 10;
         private int m_update_coarse_locations = 50;
 
         private int agentMS;
@@ -191,6 +194,7 @@ namespace OpenSim.Region.Framework.Scenes
         private int landMS;
         private int lastCompletedFrame;
 
+        public bool CombineRegions = false;
         /// <summary>
         /// Signals whether temporary objects are currently being cleaned up.  Needed because this is launched
         /// asynchronously from the update loop.
@@ -213,11 +217,14 @@ namespace OpenSim.Region.Framework.Scenes
         private bool m_scripts_enabled = true;
         private string m_defaultScriptEngine;
         private int m_LastLogin;
-        private Thread HeartbeatThread;
+        private Thread HeartbeatThread = null;
         private volatile bool shuttingdown;
 
         private int m_lastUpdate;
+        private int m_lastIncoming;
+        private int m_lastOutgoing;
         private bool m_firstHeartbeat = true;
+        private int m_hbRestarts = 0;
 
         private object m_deleting_scene_object = new object();
         
@@ -264,6 +271,19 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_sceneGridService; }
         }
 
+        public ISnmpModule SnmpService
+        {
+            get
+            {
+                if (m_snmpService == null)
+                {
+                    m_snmpService = RequestModuleInterface<ISnmpModule>();
+                }
+
+                return m_snmpService;
+            }
+        }
+
         public ISimulationDataService SimulationDataService
         {
             get
@@ -545,6 +565,9 @@ namespace OpenSim.Region.Framework.Scenes
             m_EstateDataService = estateDataService;
             m_regionHandle = m_regInfo.RegionHandle;
             m_regionName = m_regInfo.RegionName;
+            m_lastUpdate = Util.EnvironmentTickCount();
+            m_lastIncoming = 0;
+            m_lastOutgoing = 0;
 
             m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this);
             m_asyncSceneObjectDeleter.Enabled = true;
@@ -662,6 +685,7 @@ namespace OpenSim.Region.Framework.Scenes
                 CollidablePrims = startupConfig.GetBoolean("collidable_prim", true);
 
                 m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", m_maxNonphys);
+
                 if (RegionInfo.NonphysPrimMax > 0)
                 {
                     m_maxNonphys = RegionInfo.NonphysPrimMax;
@@ -693,6 +717,7 @@ namespace OpenSim.Region.Framework.Scenes
                 m_persistAfter *= 10000000;
 
                 m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "XEngine");
+                m_log.InfoFormat("[SCENE]: Default script engine {0}", m_defaultScriptEngine);
 
                 IConfig packetConfig = m_config.Configs["PacketPool"];
                 if (packetConfig != null)
@@ -702,6 +727,8 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
                 m_strictAccessControl = startupConfig.GetBoolean("StrictAccessControl", m_strictAccessControl);
+                m_seeIntoBannedRegion = startupConfig.GetBoolean("SeeIntoBannedRegion", m_seeIntoBannedRegion);
+                CombineRegions = startupConfig.GetBoolean("CombineContiguousRegions", false);
 
                 m_generateMaptiles = startupConfig.GetBoolean("GenerateMaptiles", true);
                 if (m_generateMaptiles)
@@ -737,9 +764,9 @@ namespace OpenSim.Region.Framework.Scenes
                 m_update_terrain          = startupConfig.GetInt(   "UpdateTerrainEveryNFrames",         m_update_terrain);
                 m_update_temp_cleaning    = startupConfig.GetInt(   "UpdateTempCleaningEveryNFrames",    m_update_temp_cleaning);
             }
-            catch
+            catch (Exception e)
             {
-                m_log.Warn("[SCENE]: Failed to load StartupConfig");
+                m_log.Error("[SCENE]: Failed to load StartupConfig: " + e.ToString());
             }
 
             #endregion Region Config
@@ -1150,7 +1177,22 @@ namespace OpenSim.Region.Framework.Scenes
             //m_heartbeatTimer.Elapsed += new ElapsedEventHandler(Heartbeat);
             if (HeartbeatThread != null)
             {
+                m_hbRestarts++;
+                if(m_hbRestarts > 10)
+                    Environment.Exit(1);
+                m_log.ErrorFormat("[SCENE]: Restarting heartbeat thread because it hasn't reported in in region {0}", RegionInfo.RegionName);
+
+//int pid = System.Diagnostics.Process.GetCurrentProcess().Id;
+//System.Diagnostics.Process proc = new System.Diagnostics.Process();
+//proc.EnableRaisingEvents=false; 
+//proc.StartInfo.FileName = "/bin/kill";
+//proc.StartInfo.Arguments = "-QUIT " + pid.ToString();
+//proc.Start();
+//proc.WaitForExit();
+//Thread.Sleep(1000);
+//Environment.Exit(1);
                 HeartbeatThread.Abort();
+                Watchdog.AbortThread(HeartbeatThread.ManagedThreadId);
                 HeartbeatThread = null;
             }
             m_lastUpdate = Util.EnvironmentTickCount();
@@ -1197,9 +1239,6 @@ namespace OpenSim.Region.Framework.Scenes
                 m_eventManager.TriggerOnRegionStarted(this);
                 while (!shuttingdown)
                     Update();
-
-                m_lastUpdate = Util.EnvironmentTickCount();
-                m_firstHeartbeat = false;
             }
             catch (ThreadAbortException)
             {
@@ -1297,6 +1336,13 @@ namespace OpenSim.Region.Framework.Scenes
                     eventMS = Util.EnvironmentTickCountSubtract(evMS); ;
                 }
 
+                   // if (Frame % m_update_land == 0)
+                   // {
+                   //     int ldMS = Util.EnvironmentTickCount();
+                   //     UpdateLand();
+                   //     landMS = Util.EnvironmentTickCountSubtract(ldMS);
+                   // }
+
                 if (Frame % m_update_backup == 0)
                 {
                     int backMS = Util.EnvironmentTickCount();
@@ -1404,12 +1450,16 @@ namespace OpenSim.Region.Framework.Scenes
             maintc = Util.EnvironmentTickCountSubtract(maintc);
             maintc = (int)(MinFrameTime * 1000) - maintc;
 
+
+            m_lastUpdate = Util.EnvironmentTickCount();
+            m_firstHeartbeat = false;
+
             if (maintc > 0)
                 Thread.Sleep(maintc);
 
             // Tell the watchdog that this thread is still alive
             Watchdog.UpdateThread();
-        }        
+        }
 
         public void AddGroupTarget(SceneObjectGroup grp)
         {
@@ -1425,9 +1475,9 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void CheckAtTargets()
         {
-            Dictionary<UUID, SceneObjectGroup>.ValueCollection objs;
+            List<SceneObjectGroup> objs = new List<SceneObjectGroup>();
             lock (m_groupsWithTargets)
-                objs = m_groupsWithTargets.Values;
+                objs = new List<SceneObjectGroup>(m_groupsWithTargets.Values);
 
             foreach (SceneObjectGroup entry in objs)
                 entry.checkAtTargets();
@@ -1509,7 +1559,7 @@ namespace OpenSim.Region.Framework.Scenes
                     msg.fromAgentName = "Server";
                     msg.dialog = (byte)19; // Object msg
                     msg.fromGroup = false;
-                    msg.offline = (byte)0;
+                    msg.offline = (byte)1;
                     msg.ParentEstateID = RegionInfo.EstateSettings.ParentEstateID;
                     msg.Position = Vector3.Zero;
                     msg.RegionID = RegionInfo.RegionID.Guid;
@@ -1740,14 +1790,24 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public Vector3 GetNewRezLocation(Vector3 RayStart, Vector3 RayEnd, UUID RayTargetID, Quaternion rot, byte bypassRayCast, byte RayEndIsIntersection, bool frontFacesOnly, Vector3 scale, bool FaceCenter)
         {
+        
+            float wheight = (float)RegionInfo.RegionSettings.WaterHeight;
+            Vector3 wpos = Vector3.Zero;
+            // Check for water surface intersection from above
+            if ( (RayStart.Z > wheight) && (RayEnd.Z < wheight) )
+            {
+                float ratio = (RayStart.Z - wheight) / (RayStart.Z - RayEnd.Z);
+                wpos.X = RayStart.X - (ratio * (RayStart.X - RayEnd.X));
+                wpos.Y = RayStart.Y - (ratio * (RayStart.Y - RayEnd.Y));
+                wpos.Z = wheight;
+            }                
+        
             Vector3 pos = Vector3.Zero;
             if (RayEndIsIntersection == (byte)1)
             {
                 pos = RayEnd;
-                return pos;
             }
-
-            if (RayTargetID != UUID.Zero)
+            else if (RayTargetID != UUID.Zero)
             {
                 SceneObjectPart target = GetSceneObjectPart(RayTargetID);
 
@@ -1769,7 +1829,7 @@ namespace OpenSim.Region.Framework.Scenes
                     EntityIntersection ei = target.TestIntersectionOBB(NewRay, Quaternion.Identity, frontFacesOnly, FaceCenter);
 
                     // 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());
+                    // m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
                     float ScaleOffset = 0.5f;
 
                     // If we hit something
@@ -1792,13 +1852,10 @@ namespace OpenSim.Region.Framework.Scenes
                         //pos.Z -= 0.25F; 
                        
                     }
-
-                    return pos;
                 }
                 else
                 {
                     // We don't have a target here, so we're going to raytrace all the objects in the scene.
-
                     EntityIntersection ei = m_sceneGraph.GetClosestIntersectingPrim(new Ray(AXOrigin, AXdirection), true, false);
 
                     // Un-comment the following line to print the raytrace results to the console.
@@ -1807,13 +1864,12 @@ namespace OpenSim.Region.Framework.Scenes
                     if (ei.HitTF)
                     {
                         pos = new Vector3(ei.ipoint.X, ei.ipoint.Y, ei.ipoint.Z);
-                    } else
+                    } 
+                    else
                     {
                         // fall back to our stupid functionality
                         pos = RayEnd;
                     }
-
-                    return pos;
                 }
             }
             else
@@ -1824,8 +1880,12 @@ namespace OpenSim.Region.Framework.Scenes
                 //increase height so its above the ground.
                 //should be getting the normal of the ground at the rez point and using that?
                 pos.Z += scale.Z / 2f;
-                return pos;
+//                return pos;
             }
+            
+            // check against posible water intercept
+            if (wpos.Z > pos.Z) pos = wpos;
+            return pos;
         }
 
 
@@ -1909,7 +1969,10 @@ namespace OpenSim.Region.Framework.Scenes
         public bool AddRestoredSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates)
         {
-            return m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates);
+            bool result =  m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates);
+            if (result)
+                sceneObject.IsDeleted = false;
+            return result;
         }
         
         /// <summary>
@@ -1999,6 +2062,15 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void DeleteAllSceneObjects()
         {
+            DeleteAllSceneObjects(false);
+        }
+
+        /// <summary>
+        /// Delete every object from the scene.  This does not include attachments worn by avatars.
+        /// </summary>
+        public void DeleteAllSceneObjects(bool exceptNoCopy)
+        {
+            List<SceneObjectGroup> toReturn = new List<SceneObjectGroup>();
             lock (Entities)
             {
                 EntityBase[] entities = Entities.GetEntities();
@@ -2007,11 +2079,24 @@ namespace OpenSim.Region.Framework.Scenes
                     if (e is SceneObjectGroup)
                     {
                         SceneObjectGroup sog = (SceneObjectGroup)e;
-                        if (!sog.IsAttachment)
-                            DeleteSceneObject((SceneObjectGroup)e, false);
+                        if (sog != null && !sog.IsAttachment)
+                        {
+                            if (!exceptNoCopy || ((sog.GetEffectivePermissions() & (uint)PermissionMask.Copy) != 0))
+                            {
+                                DeleteSceneObject((SceneObjectGroup)e, false);
+                            }
+                            else
+                            {
+                                toReturn.Add((SceneObjectGroup)e);   
+                            }
+                        }
                     }
                 }
             }
+            if (toReturn.Count > 0)
+            {
+                returnObjects(toReturn.ToArray(), UUID.Zero);
+            }
         }
 
         /// <summary>
@@ -2059,6 +2144,8 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             group.DeleteGroupFromScene(silent);
+            if (!silent)
+                SendKillObject(new List<uint>() { group.LocalId });
 
 //            m_log.DebugFormat("[SCENE]: Exit DeleteSceneObject() for {0} {1}", group.Name, group.UUID);            
         }
@@ -2413,10 +2500,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns>True if the SceneObjectGroup was added, False if it was not</returns>
         public bool AddSceneObject(SceneObjectGroup sceneObject)
         {
+            if (sceneObject.OwnerID == UUID.Zero)
+            {
+                m_log.ErrorFormat("[SCENE]: Owner ID for {0} was zero", sceneObject.UUID);
+                return false;
+            }
+
             // If the user is banned, we won't let any of their objects
             // enter. Period.
             //
-            if (m_regInfo.EstateSettings.IsBanned(sceneObject.OwnerID))
+            int flags = GetUserFlags(sceneObject.OwnerID);
+            if (m_regInfo.EstateSettings.IsBanned(sceneObject.OwnerID, flags))
             {
                 m_log.InfoFormat("[INTERREGION]: Denied prim crossing for banned avatar {0}", sceneObject.OwnerID);
 
@@ -2462,12 +2556,23 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 else
                 {
+                    m_log.DebugFormat("[SCENE]: Attachment {0} arrived and scene presence was not found, setting to temp", sceneObject.UUID);
                     RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
                     RootPrim.AddFlag(PrimFlags.TemporaryOnRez);
                 }
+                if (sceneObject.OwnerID == UUID.Zero)
+                {
+                    m_log.ErrorFormat("[SCENE]: Owner ID for {0} was zero after attachment processing. BUG!", sceneObject.UUID);
+                    return false;
+                }
             }
             else
             {
+                if (sceneObject.OwnerID == UUID.Zero)
+                {
+                    m_log.ErrorFormat("[SCENE]: Owner ID for non-attachment {0} was zero", sceneObject.UUID);
+                    return false;
+                }
                 AddRestoredSceneObject(sceneObject, true, false);
 
                 if (!Permissions.CanObjectEntry(sceneObject.UUID,
@@ -2496,6 +2601,24 @@ namespace OpenSim.Region.Framework.Scenes
             return 2; // StateSource.PrimCrossing
         }
 
+        public int GetUserFlags(UUID user)
+        {
+            //Unfortunately the SP approach means that the value is cached until region is restarted
+            /*
+            ScenePresence sp;
+            if (TryGetScenePresence(user, out sp))
+            {
+                return sp.UserFlags;
+            }
+            else
+            {
+             */
+                UserAccount uac = UserAccountService.GetUserAccount(RegionInfo.ScopeID, user);
+                if (uac == null)
+                    return 0;
+                return uac.UserFlags;
+            //}
+        }
         #endregion
 
         #region Add/Remove Avatar Methods
@@ -2510,6 +2633,7 @@ namespace OpenSim.Region.Framework.Scenes
                     || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
 
             CheckHeartbeat();
+            ScenePresence presence;
 
             ScenePresence sp = GetScenePresence(client.AgentId);
 
@@ -2558,7 +2682,13 @@ namespace OpenSim.Region.Framework.Scenes
 
             EventManager.TriggerOnNewClient(client);
             if (vialogin)
+            {
                 EventManager.TriggerOnClientLogin(client);
+                // Send initial parcel data
+                Vector3 pos = sp.AbsolutePosition;
+                ILandObject land = LandChannel.GetLandObject(pos.X, pos.Y);
+                land.SendLandUpdateToClient(client);
+            }
 
             return sp;
         }
@@ -2648,19 +2778,12 @@ namespace OpenSim.Region.Framework.Scenes
                     // and the scene presence and the client, if they exist
                     try
                     {
-                        // We need to wait for the client to make UDP contact first.
-                        // It's the UDP contact that creates the scene presence
-                        ScenePresence sp = WaitGetScenePresence(agentID);
+                        ScenePresence sp = GetScenePresence(agentID);
+                        PresenceService.LogoutAgent(sp.ControllingClient.SessionId);
+                        
                         if (sp != null)
-                        {
-                            PresenceService.LogoutAgent(sp.ControllingClient.SessionId);
-
                             sp.ControllingClient.Close();
-                        }
-                        else
-                        {
-                            m_log.WarnFormat("[SCENE]: Could not find scene presence for {0}", agentID);
-                        }
+
                         // BANG! SLASH!
                         m_authenticateHandler.RemoveCircuit(agentID);
 
@@ -2761,6 +2884,7 @@ namespace OpenSim.Region.Framework.Scenes
             client.OnFetchInventory += m_asyncInventorySender.HandleFetchInventory;
             client.OnUpdateInventoryItem += UpdateInventoryItemAsset;
             client.OnCopyInventoryItem += CopyInventoryItem;
+            client.OnMoveItemsAndLeaveCopy += MoveInventoryItemsLeaveCopy;
             client.OnMoveInventoryItem += MoveInventoryItem;
             client.OnRemoveInventoryItem += RemoveInventoryItem;
             client.OnRemoveInventoryFolder += RemoveInventoryFolder;
@@ -2936,15 +3060,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="agentId">The avatar's Unique ID</param>
         /// <param name="client">The IClientAPI for the client</param>
-        public virtual void TeleportClientHome(UUID agentId, IClientAPI client)
+        public virtual bool TeleportClientHome(UUID agentId, IClientAPI client)
         {
             if (m_teleportModule != null)
-                m_teleportModule.TeleportHome(agentId, client);
+                return m_teleportModule.TeleportHome(agentId, client);
             else
             {
                 m_log.DebugFormat("[SCENE]: Unable to teleport user home: no AgentTransferModule is active");
                 client.SendTeleportFailed("Unable to perform teleports on this simulator.");
             }
+            return false;
         }
 
         /// <summary>
@@ -3036,6 +3161,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="flags"></param>
         public virtual void SetHomeRezPoint(IClientAPI remoteClient, ulong regionHandle, Vector3 position, Vector3 lookAt, uint flags)
         {
+            //Add half the avatar's height so that the user doesn't fall through prims
+            ScenePresence presence;
+            if (TryGetScenePresence(remoteClient.AgentId, out presence))
+            {
+                if (presence.Appearance != null)
+                {
+                    position.Z = position.Z + (presence.Appearance.AvatarHeight / 2);
+                }
+            }
+
             if (GridUserService != null && GridUserService.SetHome(remoteClient.AgentId.ToString(), RegionInfo.RegionID, position, lookAt))
                 // FUBAR ALERT: this needs to be "Home position set." so the viewer saves a home-screenshot.
                 m_dialogModule.SendAlertToUser(remoteClient, "Home position set.");
@@ -3104,8 +3239,9 @@ namespace OpenSim.Region.Framework.Scenes
                         regions.Remove(RegionInfo.RegionHandle);
                         m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
                     }
-
+                    m_log.Debug("[Scene] Beginning ClientClosed");
                     m_eventManager.TriggerClientClosed(agentID, this);
+                    m_log.Debug("[Scene] Finished ClientClosed");
                 }
                 catch (NullReferenceException)
                 {
@@ -3157,9 +3293,10 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     m_log.ErrorFormat("[SCENE] Scene.cs:RemoveClient exception {0}{1}", e.Message, e.StackTrace);
                 }
-
+                m_log.Debug("[Scene] Done. Firing RemoveCircuit");
                 m_authenticateHandler.RemoveCircuit(avatar.ControllingClient.CircuitCode);
 //                CleanDroppedAttachments();
+                m_log.Debug("[Scene] The avatar has left the building");
                 //m_log.InfoFormat("[SCENE] Memory pre  GC {0}", System.GC.GetTotalMemory(false));
                 //m_log.InfoFormat("[SCENE] Memory post GC {0}", System.GC.GetTotalMemory(true));
             }
@@ -3278,13 +3415,16 @@ namespace OpenSim.Region.Framework.Scenes
                 sp = null;
             }
 
-            ILandObject land = LandChannel.GetLandObject(agent.startpos.X, agent.startpos.Y);
 
             //On login test land permisions
             if (vialogin)
             {
-                if (land != null && !TestLandRestrictions(agent, land, out reason))
+                IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
+                if (cache != null)
+                    cache.Remove(agent.firstname + " " + agent.lastname);
+                if (!TestLandRestrictions(agent.AgentID, out reason, ref agent.startpos.X, ref agent.startpos.Y))
                 {
+                    m_log.DebugFormat("[CONNECTION BEGIN]: Denying access to {0} due to no land access", agent.AgentID.ToString());
                     return false;
                 }
             }
@@ -3308,8 +3448,13 @@ namespace OpenSim.Region.Framework.Scenes
 
                 try
                 {
-                    if (!AuthorizeUser(agent, out reason))
-                        return false;
+                    // Always check estate if this is a login. Always
+                    // check if banned regions are to be blacked out.
+                    if (vialogin || (!m_seeIntoBannedRegion))
+                    {
+                        if (!AuthorizeUser(agent, out reason))
+                            return false;
+                    }
                 }
                 catch (Exception e)
                 {
@@ -3412,6 +3557,8 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
                 // Honor parcel landing type and position.
+                /*
+                ILandObject land = LandChannel.GetLandObject(agent.startpos.X, agent.startpos.Y);
                 if (land != null)
                 {
                     if (land.LandData.LandingType == (byte)1 && land.LandData.UserLocation != Vector3.Zero)
@@ -3419,26 +3566,34 @@ namespace OpenSim.Region.Framework.Scenes
                         agent.startpos = land.LandData.UserLocation;
                     }
                 }
+                */// This is now handled properly in ScenePresence.MakeRootAgent
             }
 
             return true;
         }
 
-        private bool TestLandRestrictions(AgentCircuitData agent, ILandObject land,  out string reason)
+        private bool TestLandRestrictions(UUID agentID, out string reason, ref float posX, ref float posY)
         {
-      
-            bool banned = land.IsBannedFromLand(agent.AgentID);
-            bool restricted = land.IsRestrictedFromLand(agent.AgentID);
+            reason = String.Empty;
+            if (Permissions.IsGod(agentID))
+                return true;
+
+            ILandObject land = LandChannel.GetLandObject(posX, posY);
+            if (land == null)
+                return false;
+
+            bool banned = land.IsBannedFromLand(agentID);
+            bool restricted = land.IsRestrictedFromLand(agentID);
 
             if (banned || restricted)
             {
-                ILandObject nearestParcel = GetNearestAllowedParcel(agent.AgentID, agent.startpos.X, agent.startpos.Y);
+                ILandObject nearestParcel = GetNearestAllowedParcel(agentID, posX, posY);
                 if (nearestParcel != null)
                 {
                     //Move agent to nearest allowed
                     Vector3 newPosition = GetParcelCenterAtGround(nearestParcel);
-                    agent.startpos.X = newPosition.X;
-                    agent.startpos.Y = newPosition.Y;
+                    posX = newPosition.X;
+                    posY = newPosition.Y;
                 }
                 else
                 {
@@ -3500,7 +3655,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (!m_strictAccessControl) return true;
             if (Permissions.IsGod(agent.AgentID)) return true;
-                      
+
             if (AuthorizationService != null)
             {
                 if (!AuthorizationService.IsAuthorizedForRegion(
@@ -3508,14 +3663,14 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user does not have access to the region",
                                      agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
-                    
+
                     return false;
                 }
             }
 
             if (m_regInfo.EstateSettings != null)
             {
-                if (m_regInfo.EstateSettings.IsBanned(agent.AgentID))
+                if (m_regInfo.EstateSettings.IsBanned(agent.AgentID,0))
                 {
                     m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user is on the banlist",
                                      agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
@@ -3707,6 +3862,13 @@ namespace OpenSim.Region.Framework.Scenes
 
             // We have to wait until the viewer contacts this region after receiving EAC.
             // That calls AddNewClient, which finally creates the ScenePresence
+            int flags = GetUserFlags(cAgentData.AgentID);
+            if (m_regInfo.EstateSettings.IsBanned(cAgentData.AgentID, flags))
+            {
+                m_log.DebugFormat("[SCENE]: Denying root agent entry to {0}: banned", cAgentData.AgentID);
+                return false;
+            }
+
             ILandObject nearestParcel = GetNearestAllowedParcel(cAgentData.AgentID, Constants.RegionSize / 2, Constants.RegionSize / 2);
             if (nearestParcel == null)
             {
@@ -3788,12 +3950,22 @@ namespace OpenSim.Region.Framework.Scenes
             return false;
         }
 
+        public bool IncomingCloseAgent(UUID agentID)
+        {
+            return IncomingCloseAgent(agentID, false);
+        }
+
+        public bool IncomingCloseChildAgent(UUID agentID)
+        {
+            return IncomingCloseAgent(agentID, true);
+        }
+
         /// <summary>
         /// Tell a single agent to disconnect from the region.
         /// </summary>
-        /// <param name="regionHandle"></param>
         /// <param name="agentID"></param>
-        public bool IncomingCloseAgent(UUID agentID)
+        /// <param name="childOnly"></param>
+        public bool IncomingCloseAgent(UUID agentID, bool childOnly)
         {
             //m_log.DebugFormat("[SCENE]: Processing incoming close agent for {0}", agentID);
 
@@ -3805,7 +3977,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                    m_sceneGraph.removeUserCount(false);
                 }
-                else
+                else if (!childOnly)
                 {
                    m_sceneGraph.removeUserCount(true);
                 }
@@ -3821,9 +3993,12 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     else
                         presence.ControllingClient.SendShutdownConnectionNotice();
+                    presence.ControllingClient.Close(false);
+                }
+                else if (!childOnly)
+                {
+                    presence.ControllingClient.Close(true);
                 }
-
-                presence.ControllingClient.Close();
                 return true;
             }
 
@@ -4406,34 +4581,78 @@ namespace OpenSim.Region.Framework.Scenes
             SimulationDataService.RemoveObject(uuid, m_regInfo.RegionID);
         }
 
-        public int GetHealth()
+        public int GetHealth(out int flags, out string message)
         {
             // Returns:
             // 1 = sim is up and accepting http requests. The heartbeat has
             // stopped and the sim is probably locked up, but a remote
             // admin restart may succeed
-            //
+            // 
             // 2 = Sim is up and the heartbeat is running. The sim is likely
-            // usable for people within and logins _may_ work
+            // usable for people within
+            //
+            // 3 = Sim is up and one packet thread is running. Sim is
+            // unstable and will not accept new logins
+            //
+            // 4 = Sim is up and both packet threads are running. Sim is
+            // likely usable
             //
-            // 3 = We have seen a new user enter within the past 4 minutes
+            // 5 = We have seen a new user enter within the past 4 minutes
             // which can be seen as positive confirmation of sim health
             //
+
+            flags = 0;
+            message = String.Empty;
+
+            CheckHeartbeat();
+
+            if (m_firstHeartbeat || (m_lastIncoming == 0 && m_lastOutgoing == 0))
+            {
+                // We're still starting
+                // 0 means "in startup", it can't happen another way, since
+                // to get here, we must be able to accept http connections
+                return 0;
+            }
+
             int health=1; // Start at 1, means we're up
 
-            if ((Util.EnvironmentTickCountSubtract(m_lastUpdate)) < 1000)
+            if (Util.EnvironmentTickCountSubtract(m_lastUpdate) < 1000)
+            {
+                health+=1;
+                flags |= 1;
+            }
+
+            if (Util.EnvironmentTickCountSubtract(m_lastIncoming) < 1000)
+            {
+                health+=1;
+                flags |= 2;
+            }
+
+            if (Util.EnvironmentTickCountSubtract(m_lastOutgoing) < 1000)
+            {
                 health+=1;
+                flags |= 4;
+            }
             else
+            {
+int pid = System.Diagnostics.Process.GetCurrentProcess().Id;
+System.Diagnostics.Process proc = new System.Diagnostics.Process();
+proc.EnableRaisingEvents=false; 
+proc.StartInfo.FileName = "/bin/kill";
+proc.StartInfo.Arguments = "-QUIT " + pid.ToString();
+proc.Start();
+proc.WaitForExit();
+Thread.Sleep(1000);
+Environment.Exit(1);
+            }
+
+            if (flags != 7)
                 return health;
 
             // A login in the last 4 mins? We can't be doing too badly
             //
-            if ((Util.EnvironmentTickCountSubtract(m_LastLogin)) < 240000)
+            if (Util.EnvironmentTickCountSubtract(m_LastLogin) < 240000)
                 health++;
-            else
-                return health;
-
-            CheckHeartbeat();
 
             return health;
         }
@@ -4626,7 +4845,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (m_firstHeartbeat)
                 return;
 
-            if (Util.EnvironmentTickCountSubtract(m_lastUpdate) > 2000)
+            if (Util.EnvironmentTickCountSubtract(m_lastUpdate) > 5000)
                 StartTimer();
         }
 
@@ -5036,7 +5255,55 @@ namespace OpenSim.Region.Framework.Scenes
                 mapModule.GenerateMaptile();
         }
 
-        private void RegenerateMaptileAndReregister(object sender, ElapsedEventArgs e)
+//        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);
+//            }
+//        }
+
+        public void ThreadAlive(int threadCode)
+        {
+            switch(threadCode)
+            {
+                case 1: // Incoming
+                    m_lastIncoming = Util.EnvironmentTickCount();
+                    break;
+                case 2: // Incoming
+                    m_lastOutgoing = Util.EnvironmentTickCount();
+                    break;
+            }
+        }
+
+        public void RegenerateMaptileAndReregister(object sender, ElapsedEventArgs e)
         {
             RegenerateMaptile();
 
@@ -5055,6 +5322,14 @@ namespace OpenSim.Region.Framework.Scenes
         // child agent creation, thereby emulating the SL behavior.
         public bool QueryAccess(UUID agentID, Vector3 position, out string reason)
         {
+            reason = "You are banned from the region";
+
+            if (Permissions.IsGod(agentID))
+            {
+                reason = String.Empty;
+                return true;
+            }
+
             int num = m_sceneGraph.GetNumberOfScenePresences();
 
             if (num >= RegionInfo.RegionSettings.AgentLimit)
@@ -5066,11 +5341,82 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
 
+            ScenePresence presence = GetScenePresence(agentID);
+            IClientAPI client = null;
+            AgentCircuitData aCircuit = null;
+
+            if (presence != null)
+            {
+                client = presence.ControllingClient;
+                if (client != null)
+                    aCircuit = client.RequestClientInfo();
+            }
+
+            // We may be called before there is a presence or a client.
+            // Fake AgentCircuitData to keep IAuthorizationModule smiling
+            if (client == null)
+            {
+                aCircuit = new AgentCircuitData();
+                aCircuit.AgentID = agentID;
+                aCircuit.firstname = String.Empty;
+                aCircuit.lastname = String.Empty;
+            }
+
+            try
+            {
+                if (!AuthorizeUser(aCircuit, out reason))
+                {
+                    // m_log.DebugFormat("[SCENE]: Denying access for {0}", agentID);
+                    return false;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[SCENE]: Exception authorizing agent: {0} "+ e.StackTrace, e.Message);
+                return false;
+            }
+
+            if (position == Vector3.Zero) // Teleport
+            {
+                float posX = 128.0f;
+                float posY = 128.0f;
+
+                if (!TestLandRestrictions(agentID, out reason, ref posX, ref posY))
+                {
+                    // m_log.DebugFormat("[SCENE]: Denying {0} because they are banned on all parcels", agentID);
+                    return false;
+                }
+            }
+            else // Walking
+            {
+                ILandObject land = LandChannel.GetLandObject(position.X, position.Y);
+                if (land == null)
+                    return false;
+
+                bool banned = land.IsBannedFromLand(agentID);
+                bool restricted = land.IsRestrictedFromLand(agentID);
+
+                if (banned || restricted)
+                    return false;
+            }
+
             reason = String.Empty;
             return true;
         }
 
-        /// <summary>
+                public void StartTimerWatchdog()
+        {
+            m_timerWatchdog.Interval = 1000;
+            m_timerWatchdog.Elapsed += TimerWatchdog;
+            m_timerWatchdog.AutoReset = true;
+            m_timerWatchdog.Start();
+        }
+
+        public void TimerWatchdog(object sender, ElapsedEventArgs e)
+        {
+            CheckHeartbeat();
+                }
+
         /// This method deals with movement when an avatar is automatically moving (but this is distinct from the
         /// autopilot that moves an avatar to a sit target!.
         /// </summary>
diff --git a/OpenSim/Region/Framework/Scenes/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index 712e094..da3b4dd 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -136,6 +136,8 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_permissions; }
         }
 
+        protected string m_datastore;
+
          /* Used by the loadbalancer plugin on GForge */
         protected RegionStatus m_regStatus;
         public RegionStatus RegionStatus
diff --git a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
index 58a7b20..27833e8 100644
--- a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
@@ -88,7 +88,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (neighbour != null)
             {
-                m_log.DebugFormat("[INTERGRID]: Successfully informed neighbour {0}-{1} that I'm here", x / Constants.RegionSize, y / Constants.RegionSize);
+              //  m_log.DebugFormat("[INTERGRID]: Successfully informed neighbour {0}-{1} that I'm here", x / Constants.RegionSize, y / Constants.RegionSize);
                 m_scene.EventManager.TriggerOnRegionUp(neighbour);
             }
             else
@@ -102,7 +102,7 @@ namespace OpenSim.Region.Framework.Scenes
             //m_log.Info("[INTER]: " + debugRegionName + ": SceneCommunicationService: Sending InterRegion Notification that region is up " + region.RegionName);
 
             List<GridRegion> neighbours = m_scene.GridService.GetNeighbours(m_scene.RegionInfo.ScopeID, m_scene.RegionInfo.RegionID);
-            m_log.DebugFormat("[INTERGRID]: Informing {0} neighbours that this region is up", neighbours.Count);
+            //m_log.DebugFormat("[INTERGRID]: Informing {0} neighbours that this region is up", neighbours.Count);
             foreach (GridRegion n in neighbours)
             {
                 InformNeighbourThatRegionUpDelegate d = InformNeighboursThatRegionIsUpAsync;
@@ -176,10 +176,13 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public delegate void SendCloseChildAgentDelegate(UUID agentID, ulong regionHandle);
+
         /// <summary>
-        /// Closes a child agent on a given region
+        /// This Closes child agents on neighboring regions
+        /// Calls an asynchronous method to do so..  so it doesn't lag the sim.
         /// </summary>
-        protected void SendCloseChildAgent(UUID agentID, ulong regionHandle)
+        protected void SendCloseChildAgentAsync(UUID agentID, ulong regionHandle)
         {
             // let's do our best, but there's not much we can do if the neighbour doesn't accept.
 
@@ -188,31 +191,29 @@ namespace OpenSim.Region.Framework.Scenes
             Utils.LongToUInts(regionHandle, out x, out y);
 
             GridRegion destination = m_scene.GridService.GetRegionByPosition(m_regionInfo.ScopeID, (int)x, (int)y);
+            m_scene.SimulationService.CloseChildAgent(destination, agentID);
+        }
 
-            m_log.DebugFormat(
-                "[INTERGRID]: Sending close agent {0} to region at {1}-{2}",
-                agentID, destination.RegionCoordX, destination.RegionCoordY);
-
-            m_scene.SimulationService.CloseAgent(destination, agentID);
+        private void SendCloseChildAgentCompleted(IAsyncResult iar)
+        {
+            SendCloseChildAgentDelegate icon = (SendCloseChildAgentDelegate)iar.AsyncState;
+            icon.EndInvoke(iar);
         }
 
-        /// <summary>
-        /// Closes a child agents in a collection of regions. Does so asynchronously 
-        /// so that the caller doesn't wait.
-        /// </summary>
-        /// <param name="agentID"></param>
-        /// <param name="regionslst"></param>
         public void SendCloseChildAgentConnections(UUID agentID, List<ulong> regionslst)
         {
             foreach (ulong handle in regionslst)
             {
-                SendCloseChildAgent(agentID, handle);
+                SendCloseChildAgentDelegate d = SendCloseChildAgentAsync;
+                d.BeginInvoke(agentID, handle,
+                              SendCloseChildAgentCompleted,
+                              d);
             }
         }
-       
+
         public List<GridRegion> RequestNamedRegions(string name, int maxNumber)
         {
             return m_scene.GridService.GetRegionsByName(UUID.Zero, name, maxNumber);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index 1e2901b..6c57d57 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -43,6 +43,12 @@ namespace OpenSim.Region.Framework.Scenes
 
     public delegate void ObjectDuplicateDelegate(EntityBase original, EntityBase clone);
 
+    public delegate void AttachToBackupDelegate(SceneObjectGroup sog);
+
+    public delegate void DetachFromBackupDelegate(SceneObjectGroup sog);
+
+    public delegate void ChangedBackupDelegate(SceneObjectGroup sog);
+
     public delegate void ObjectCreateDelegate(EntityBase obj);
 
     public delegate void ObjectDeleteDelegate(EntityBase obj);
@@ -61,6 +67,9 @@ namespace OpenSim.Region.Framework.Scenes
         private PhysicsCrash handlerPhysicsCrash = null;
 
         public event ObjectDuplicateDelegate OnObjectDuplicate;
+        public event AttachToBackupDelegate OnAttachToBackup;
+        public event DetachFromBackupDelegate OnDetachFromBackup;
+        public event ChangedBackupDelegate OnChangeBackup;
         public event ObjectCreateDelegate OnObjectCreate;
         public event ObjectDeleteDelegate OnObjectRemove;
 
@@ -68,7 +77,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region Fields
 
-        protected object m_presenceLock = new object();
+        protected OpenMetaverse.ReaderWriterLockSlim m_scenePresencesLock = new OpenMetaverse.ReaderWriterLockSlim();
         protected Dictionary<UUID, ScenePresence> m_scenePresenceMap = new Dictionary<UUID, ScenePresence>();
         protected List<ScenePresence> m_scenePresenceArray = new List<ScenePresence>();
 
@@ -130,13 +139,18 @@ namespace OpenSim.Region.Framework.Scenes
 
         protected internal void Close()
         {
-            lock (m_presenceLock)
+            m_scenePresencesLock.EnterWriteLock();
+            try
             {
                 Dictionary<UUID, ScenePresence> newmap = new Dictionary<UUID, ScenePresence>();
                 List<ScenePresence> newlist = new List<ScenePresence>();
                 m_scenePresenceMap = newmap;
                 m_scenePresenceArray = newlist;
             }
+            finally
+            {
+                m_scenePresencesLock.ExitWriteLock();
+            }
 
             lock (SceneObjectGroupsByFullID)
                 SceneObjectGroupsByFullID.Clear();
@@ -275,6 +289,33 @@ namespace OpenSim.Region.Framework.Scenes
         protected internal bool AddRestoredSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates)
         {
+            if (!m_parentScene.CombineRegions)
+            {
+                // KF: Check for out-of-region, move inside and make static.
+                Vector3 npos = new Vector3(sceneObject.RootPart.GroupPosition.X,
+                                           sceneObject.RootPart.GroupPosition.Y,
+                                           sceneObject.RootPart.GroupPosition.Z);
+                if (!(((sceneObject.RootPart.Shape.PCode == (byte)PCode.Prim) && (sceneObject.RootPart.Shape.State != 0))) && (npos.X < 0.0 || npos.Y < 0.0 || npos.Z < 0.0 ||
+                    npos.X > Constants.RegionSize ||
+                    npos.Y > Constants.RegionSize))
+                {
+                    if (npos.X < 0.0) npos.X = 1.0f;
+                    if (npos.Y < 0.0) npos.Y = 1.0f;
+                    if (npos.Z < 0.0) npos.Z = 0.0f;
+                    if (npos.X > Constants.RegionSize) npos.X = Constants.RegionSize - 1.0f;
+                    if (npos.Y > Constants.RegionSize) npos.Y = Constants.RegionSize - 1.0f;
+     
+                    foreach (SceneObjectPart part in sceneObject.Parts)
+                    {
+                        part.GroupPosition = npos;
+                    }
+                    sceneObject.RootPart.Velocity = Vector3.Zero;
+                    sceneObject.RootPart.AngularVelocity = Vector3.Zero;
+                    sceneObject.RootPart.Acceleration = Vector3.Zero;
+                    sceneObject.RootPart.Velocity = Vector3.Zero;
+                }
+            }
+
             if (attachToBackup && (!alreadyPersisted))
             {
                 sceneObject.ForceInventoryPersistence();
@@ -491,6 +532,30 @@ namespace OpenSim.Region.Framework.Scenes
                 m_updateList[obj.UUID] = obj;
         }
 
+        public void FireAttachToBackup(SceneObjectGroup obj)
+        {
+            if (OnAttachToBackup != null)
+            {
+                OnAttachToBackup(obj);
+            }
+        }
+
+        public void FireDetachFromBackup(SceneObjectGroup obj)
+        {
+            if (OnDetachFromBackup != null)
+            {
+                OnDetachFromBackup(obj);
+            }
+        }
+
+        public void FireChangeBackup(SceneObjectGroup obj)
+        {
+            if (OnChangeBackup != null)
+            {
+                OnChangeBackup(obj);
+            }
+        }
+
         /// <summary>
         /// Process all pending updates
         /// </summary>
@@ -608,7 +673,8 @@ namespace OpenSim.Region.Framework.Scenes
 
             Entities[presence.UUID] = presence;
 
-            lock (m_presenceLock)
+            m_scenePresencesLock.EnterWriteLock();
+            try
             {
                 Dictionary<UUID, ScenePresence> newmap = new Dictionary<UUID, ScenePresence>(m_scenePresenceMap);
                 List<ScenePresence> newlist = new List<ScenePresence>(m_scenePresenceArray);
@@ -632,6 +698,10 @@ namespace OpenSim.Region.Framework.Scenes
                 m_scenePresenceMap = newmap;
                 m_scenePresenceArray = newlist;
             }
+            finally
+            {
+                m_scenePresencesLock.ExitWriteLock();
+            }
         }
 
         /// <summary>
@@ -646,7 +716,8 @@ namespace OpenSim.Region.Framework.Scenes
                     agentID);
             }
 
-            lock (m_presenceLock)
+            m_scenePresencesLock.EnterWriteLock();
+            try
             {
                 Dictionary<UUID, ScenePresence> newmap = new Dictionary<UUID, ScenePresence>(m_scenePresenceMap);
                 List<ScenePresence> newlist = new List<ScenePresence>(m_scenePresenceArray);
@@ -668,6 +739,10 @@ namespace OpenSim.Region.Framework.Scenes
                     m_log.WarnFormat("[SCENE GRAPH]: Tried to remove non-existent scene presence with agent ID {0} from scene ScenePresences list", agentID);
                 }
             }
+            finally
+            {
+                m_scenePresencesLock.ExitWriteLock();
+            }
         }
 
         protected internal void SwapRootChildAgent(bool direction_RC_CR_T_F)
@@ -1381,8 +1456,13 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (group.IsAttachment || (group.RootPart.Shape.PCode == 9 && group.RootPart.Shape.State != 0))
                 {
-                    if (m_parentScene.AttachmentsModule != null)
-                        m_parentScene.AttachmentsModule.UpdateAttachmentPosition(group, pos);
+                    // Set the new attachment point data in the object
+                    byte attachmentPoint = group.GetAttachmentPoint();
+                    group.UpdateGroupPosition(pos);
+                    group.IsAttachment = false;
+                    group.AbsolutePosition = group.RootPart.AttachedPos;
+                    group.AttachmentPoint = attachmentPoint;
+                    group.HasGroupChanged = true;
                 }
                 else
                 {
@@ -1654,8 +1734,11 @@ namespace OpenSim.Region.Framework.Scenes
                 return;
 
             Monitor.Enter(m_updateLock);
+
             try
             {
+                parentGroup.areUpdatesSuspended = true;
+
                 List<SceneObjectGroup> childGroups = new List<SceneObjectGroup>();
 
                 // We do this in reverse to get the link order of the prims correct
@@ -1666,9 +1749,13 @@ namespace OpenSim.Region.Framework.Scenes
                     // Make sure no child prim is set for sale
                     // So that, on delink, no prims are unwittingly
                     // left for sale and sold off
-                    child.RootPart.ObjectSaleType = 0;
-                    child.RootPart.SalePrice = 10;
-                    childGroups.Add(child);
+                   
+                    if (child != null)
+                    {
+                        child.RootPart.ObjectSaleType = 0;
+                        child.RootPart.SalePrice = 10;
+                        childGroups.Add(child);
+                    }
                 }
 
                 foreach (SceneObjectGroup child in childGroups)
@@ -1687,12 +1774,19 @@ namespace OpenSim.Region.Framework.Scenes
                 // occur on link to invoke this elsewhere (such as object selection)
                 parentGroup.RootPart.CreateSelected = true;
                 parentGroup.TriggerScriptChangedEvent(Changed.LINK);
-                parentGroup.HasGroupChanged = true;
-                parentGroup.ScheduleGroupForFullUpdate();
-                
             }
             finally
             {
+                lock (SceneObjectGroupsByLocalPartID)
+                {
+                    foreach (SceneObjectPart part in parentGroup.Parts)
+                        SceneObjectGroupsByLocalPartID[part.LocalId] = parentGroup;
+                }
+
+                parentGroup.areUpdatesSuspended = false;
+                parentGroup.HasGroupChanged = true;
+                parentGroup.ProcessBackup(m_parentScene.SimulationDataService, true);
+                parentGroup.ScheduleGroupForFullUpdate();
                 Monitor.Exit(m_updateLock);
             }
         }
@@ -1729,21 +1823,24 @@ namespace OpenSim.Region.Framework.Scenes
 
                             SceneObjectGroup group = part.ParentGroup;
                             if (!affectedGroups.Contains(group))
+                            {
+                                group.areUpdatesSuspended = true;
                                 affectedGroups.Add(group);
+                            }
                         }
                     }
                 }
 
-                foreach (SceneObjectPart child in childParts)
+                if (childParts.Count > 0)
                 {
-                    // Unlink all child parts from their groups
-                    //
-                    child.ParentGroup.DelinkFromGroup(child, true);
-
-                    // These are not in affected groups and will not be
-                    // handled further. Do the honors here.
-                    child.ParentGroup.HasGroupChanged = true;
-                    child.ParentGroup.ScheduleGroupForFullUpdate();
+                    foreach (SceneObjectPart child in childParts)
+                    {
+                        // Unlink all child parts from their groups
+                        //
+                        child.ParentGroup.DelinkFromGroup(child, true);
+                        child.ParentGroup.HasGroupChanged = true;
+                        child.ParentGroup.ScheduleGroupForFullUpdate();
+                    }
                 }
 
                 foreach (SceneObjectPart root in rootParts)
@@ -1753,56 +1850,68 @@ namespace OpenSim.Region.Framework.Scenes
                     // However, editing linked parts and unlinking may be different
                     //
                     SceneObjectGroup group = root.ParentGroup;
+                    group.areUpdatesSuspended = true;
                     
                     List<SceneObjectPart> newSet = new List<SceneObjectPart>(group.Parts);
                     int numChildren = newSet.Count;
 
+                    if (numChildren == 1)
+                        break;
+
                     // If there are prims left in a link set, but the root is
                     // slated for unlink, we need to do this
+                    // Unlink the remaining set
                     //
-                    if (numChildren != 1)
-                    {
-                        // Unlink the remaining set
-                        //
-                        bool sendEventsToRemainder = true;
-                        if (numChildren > 1)
-                            sendEventsToRemainder = false;
+                    bool sendEventsToRemainder = true;
+                    if (numChildren > 1)
+                        sendEventsToRemainder = false;
 
-                        foreach (SceneObjectPart p in newSet)
+                    foreach (SceneObjectPart p in newSet)
+                    {
+                        if (p != group.RootPart)
                         {
-                            if (p != group.RootPart)
-                                group.DelinkFromGroup(p, sendEventsToRemainder);
+                            group.DelinkFromGroup(p, sendEventsToRemainder);
+                            if (numChildren > 2)
+                            {
+                                p.ParentGroup.areUpdatesSuspended = true;
+                            }
+                            else
+                            {
+                                p.ParentGroup.HasGroupChanged = true;
+                                p.ParentGroup.ScheduleGroupForFullUpdate();
+                            }
                         }
+                    }
+
+                    // If there is more than one prim remaining, we
+                    // need to re-link
+                    //
+                    if (numChildren > 2)
+                    {
+                        // Remove old root
+                        //
+                        if (newSet.Contains(root))
+                            newSet.Remove(root);
 
-                        // If there is more than one prim remaining, we
-                        // need to re-link
+                        // Preserve link ordering
                         //
-                        if (numChildren > 2)
+                        newSet.Sort(delegate (SceneObjectPart a, SceneObjectPart b)
                         {
-                            // Remove old root
-                            //
-                            if (newSet.Contains(root))
-                                newSet.Remove(root);
-
-                            // Preserve link ordering
-                            //
-                            newSet.Sort(delegate (SceneObjectPart a, SceneObjectPart b)
-                            {
-                                return a.LinkNum.CompareTo(b.LinkNum);
-                            });
+                            return a.LinkNum.CompareTo(b.LinkNum);
+                        });
 
-                            // Determine new root
-                            //
-                            SceneObjectPart newRoot = newSet[0];
-                            newSet.RemoveAt(0);
+                        // Determine new root
+                        //
+                        SceneObjectPart newRoot = newSet[0];
+                        newSet.RemoveAt(0);
 
                             foreach (SceneObjectPart newChild in newSet)
                                 newChild.ClearUpdateSchedule();
 
-                            LinkObjects(newRoot, newSet);
-                            if (!affectedGroups.Contains(newRoot.ParentGroup))
-                                affectedGroups.Add(newRoot.ParentGroup);
-                        }
+                        newRoot.ParentGroup.areUpdatesSuspended = true;
+                        LinkObjects(newRoot, newSet);
+                        if (!affectedGroups.Contains(newRoot.ParentGroup))
+                            affectedGroups.Add(newRoot.ParentGroup);
                     }
                 }
 
@@ -1810,8 +1919,14 @@ namespace OpenSim.Region.Framework.Scenes
                 //
                 foreach (SceneObjectGroup g in affectedGroups)
                 {
+                    // Child prims that have been unlinked and deleted will
+                    // return unless the root is deleted. This will remove them
+                    // from the database. They will be rewritten immediately,
+                    // minus the rows for the unlinked child prims.
+                    m_parentScene.SimulationDataService.RemoveObject(g.UUID, m_parentScene.RegionInfo.RegionID);
                     g.TriggerScriptChangedEvent(Changed.LINK);
                     g.HasGroupChanged = true; // Persist
+                    g.areUpdatesSuspended = false;
                     g.ScheduleGroupForFullUpdate();
                 }
             }
@@ -1929,9 +2044,6 @@ namespace OpenSim.Region.Framework.Scenes
                                 child.ApplyNextOwnerPermissions();
                             }
                         }
-
-                        copy.RootPart.ObjectSaleType = 0;
-                        copy.RootPart.SalePrice = 10;
                     }
 
                     // FIXME: This section needs to be refactored so that it just calls AddSceneObject()
diff --git a/OpenSim/Region/Framework/Scenes/SceneManager.cs b/OpenSim/Region/Framework/Scenes/SceneManager.cs
index d73a959..e4eaf3a 100644
--- a/OpenSim/Region/Framework/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneManager.cs
@@ -356,7 +356,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TrySetCurrentScene(UUID regionID)
         {
-            m_log.Debug("Searching for Region: '" + regionID + "'");
+//            m_log.Debug("Searching for Region: '" + regionID + "'");
 
             lock (m_localScenes)
             {
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
index 905ecc9..c7da4f4 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
@@ -69,10 +69,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Stop the scripts contained in all the prims in this group
         /// </summary>
-        /// <param name="sceneObjectBeingDeleted">
-        /// Should be true if these scripts are being removed because the scene
-        /// object is being deleted.  This will prevent spurious updates to the client.
-        /// </param>
         public void RemoveScriptInstances(bool sceneObjectBeingDeleted)
         {
             SceneObjectPart[] parts = m_parts.GetArray();
@@ -234,6 +230,11 @@ namespace OpenSim.Region.Framework.Scenes
 
         public uint GetEffectivePermissions()
         {
+            return GetEffectivePermissions(false);
+        }
+
+        public uint GetEffectivePermissions(bool useBase)
+        {
             uint perms=(uint)(PermissionMask.Modify |
                               PermissionMask.Copy |
                               PermissionMask.Move |
@@ -245,7 +246,10 @@ namespace OpenSim.Region.Framework.Scenes
             for (int i = 0; i < parts.Length; i++)
             {
                 SceneObjectPart part = parts[i];
-                ownerMask &= part.OwnerMask;
+                if (useBase)
+                    ownerMask &= part.BaseMask;
+                else
+                    ownerMask &= part.OwnerMask;
                 perms &= part.Inventory.MaskEffectivePermissions();
             }
 
@@ -385,6 +389,9 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void ResumeScripts()
         {
+            if (m_scene.RegionInfo.RegionSettings.DisableScripts)
+                return;
+
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
                 parts[i].Inventory.ResumeScripts();
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 8860764..3b0d1cd 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -24,11 +24,12 @@
  * (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.Drawing;
 using System.IO;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Xml;
@@ -105,8 +106,29 @@ namespace OpenSim.Region.Framework.Scenes
         /// since the group's last persistent backup
         /// </summary>
         private bool m_hasGroupChanged = false;
-        private long timeFirstChanged;
-        private long timeLastChanged;
+        private long timeFirstChanged = 0;
+        private long timeLastChanged = 0;
+        private long m_maxPersistTime = 0;
+        private long m_minPersistTime = 0;
+        private Random m_rand;
+        private bool m_suspendUpdates;
+        private List<ScenePresence> m_linkedAvatars = new List<ScenePresence>();
+
+        public bool areUpdatesSuspended
+        {
+            get
+            {
+                return m_suspendUpdates;
+            }
+            set 
+            {
+                m_suspendUpdates = value;   
+                if (!value)
+                {
+                    QueueForUpdateCheck();
+                }               
+            }
+        }
 
         public bool HasGroupChanged
         {
@@ -114,9 +136,39 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (value)
                 {
+                    if (m_isBackedUp)
+                    {
+                        m_scene.SceneGraph.FireChangeBackup(this);
+                    }
                     timeLastChanged = DateTime.Now.Ticks;
                     if (!m_hasGroupChanged)
                         timeFirstChanged = DateTime.Now.Ticks;
+                    if (m_rootPart != null && m_rootPart.UUID != null && m_scene != null)
+                    {
+                        if (m_rand == null)
+                        {
+                            byte[] val = new byte[16];
+                            m_rootPart.UUID.ToBytes(val, 0);
+                            m_rand = new Random(BitConverter.ToInt32(val, 0));
+                        }
+                       
+                        if (m_scene.GetRootAgentCount() == 0)
+                        {
+                            //If the region is empty, this change has been made by an automated process
+                            //and thus we delay the persist time by a random amount between 1.5 and 2.5.
+
+                            float factor = 1.5f + (float)(m_rand.NextDouble());
+                            m_maxPersistTime = (long)((float)m_scene.m_persistAfter * factor);
+                            m_minPersistTime = (long)((float)m_scene.m_dontPersistBefore * factor);
+                        }
+                        else
+                        {
+                            //If the region is not empty, we want to obey the minimum and maximum persist times
+                            //but add a random factor so we stagger the object persistance a little
+                            m_maxPersistTime = (long)((float)m_scene.m_persistAfter * (1.0d - (m_rand.NextDouble() / 5.0d))); //Multiply by 1.0-1.5
+                            m_minPersistTime = (long)((float)m_scene.m_dontPersistBefore * (1.0d + (m_rand.NextDouble() / 2.0d))); //Multiply by 0.8-1.0
+                        }
+                    }
                 }
                 m_hasGroupChanged = value;
                 
@@ -131,7 +183,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// Has the group changed due to an unlink operation?  We record this in order to optimize deletion, since
         /// an unlinked group currently has to be persisted to the database before we can perform an unlink operation.
         /// </summary>
-        public bool HasGroupChangedDueToDelink { get; private set; }
+        public bool HasGroupChangedDueToDelink { get; set; }
 
         private bool isTimeToPersist()
         {
@@ -141,8 +193,19 @@ namespace OpenSim.Region.Framework.Scenes
                 return false;
             if (m_scene.ShuttingDown)
                 return true;
+
+            if (m_minPersistTime == 0 || m_maxPersistTime == 0)
+            {
+                m_maxPersistTime = m_scene.m_persistAfter;
+                m_minPersistTime = m_scene.m_dontPersistBefore;
+            }
+                
             long currentTime = DateTime.Now.Ticks;
-            if (currentTime - timeLastChanged > m_scene.m_dontPersistBefore || currentTime - timeFirstChanged > m_scene.m_persistAfter)
+
+            if (timeLastChanged == 0) timeLastChanged = currentTime;
+            if (timeFirstChanged == 0) timeFirstChanged = currentTime;
+
+            if (currentTime - timeLastChanged > m_minPersistTime || currentTime - timeFirstChanged > m_maxPersistTime)
                 return true;
             return false;
         }
@@ -247,10 +310,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         private bool m_scriptListens_atTarget;
         private bool m_scriptListens_notAtTarget;
-
         private bool m_scriptListens_atRotTarget;
         private bool m_scriptListens_notAtRotTarget;
 
+        public bool m_dupeInProgress = false;
         internal Dictionary<UUID, string> m_savedScriptState;
 
         #region Properties
@@ -281,6 +344,16 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_parts.Count; }
         }
 
+//        protected Quaternion m_rotation = Quaternion.Identity;
+//
+//        public virtual Quaternion Rotation
+//        {
+//            get { return m_rotation; }
+//            set {
+//                m_rotation = value; 
+//            }
+//        }
+
         public Quaternion GroupRotation
         {
             get { return m_rootPart.RotationOffset; }
@@ -389,7 +462,11 @@ namespace OpenSim.Region.Framework.Scenes
                         m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
                     }
                 }
-                
+
+                foreach (SceneObjectPart part in m_parts.GetArray())
+                {
+                    part.IgnoreUndoUpdate = true;
+                }
                 if (RootPart.GetStatusSandbox())
                 {
                     if (Util.GetDistanceTo(RootPart.StatusSandboxPos, value) > 10)
@@ -403,10 +480,30 @@ namespace OpenSim.Region.Framework.Scenes
                         return;
                     }
                 }
-
                 SceneObjectPart[] parts = m_parts.GetArray();
-                for (int i = 0; i < parts.Length; i++)
-                    parts[i].GroupPosition = val;
+                bool triggerScriptEvent = m_rootPart.GroupPosition != val;
+                if (m_dupeInProgress)
+                    triggerScriptEvent = false;
+                foreach (SceneObjectPart part in parts)
+                {
+                    part.GroupPosition = val;
+                    if (triggerScriptEvent)
+                        part.TriggerScriptChangedEvent(Changed.POSITION);
+                }
+                if (!m_dupeInProgress)
+                {
+                    foreach (ScenePresence av in m_linkedAvatars)
+                    {
+                        SceneObjectPart p = m_scene.GetSceneObjectPart(av.ParentID);
+                        if (m_parts.TryGetValue(p.UUID, out p))
+                        {
+                            Vector3 offset = p.GetWorldPosition() - av.ParentPosition;
+                            av.AbsolutePosition += offset;
+                            av.ParentPosition = p.GetWorldPosition(); //ParentPosition gets cleared by AbsolutePosition
+                            av.SendAvatarDataToAllAgents();
+                        }
+                    }
+                }
 
                 //if (m_rootPart.PhysActor != null)
                 //{
@@ -565,6 +662,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public SceneObjectGroup()
         {
+            
         }
 
         /// <summary>
@@ -581,7 +679,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// Constructor.  This object is added to the scene later via AttachToScene()
         /// </summary>
         public SceneObjectGroup(UUID ownerID, Vector3 pos, Quaternion rot, PrimitiveBaseShape shape)
-        { 
+        {
             SetRootPart(new SceneObjectPart(ownerID, shape, pos, rot, Vector3.Zero));
         }
 
@@ -629,6 +727,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public virtual void AttachToBackup()
         {
+            if (IsAttachment) return;
+            m_scene.SceneGraph.FireAttachToBackup(this);
+
             if (InSceneBackup)
             {
                 //m_log.DebugFormat(
@@ -671,6 +772,9 @@ namespace OpenSim.Region.Framework.Scenes
 
             ApplyPhysics();
 
+            if (RootPart.PhysActor != null)
+                RootPart.Buoyancy = RootPart.Buoyancy;
+
             // Don't trigger the update here - otherwise some client issues occur when multiple updates are scheduled
             // for the same object with very different properties.  The caller must schedule the update.
             //ScheduleGroupForFullUpdate();
@@ -686,6 +790,10 @@ namespace OpenSim.Region.Framework.Scenes
             EntityIntersection result = new EntityIntersection();
 
             SceneObjectPart[] parts = m_parts.GetArray();
+
+            // Find closest hit here
+            float idist = float.MaxValue;
+
             for (int i = 0; i < parts.Length; i++)
             {
                 SceneObjectPart part = parts[i];
@@ -700,11 +808,6 @@ namespace OpenSim.Region.Framework.Scenes
 
                 EntityIntersection inter = part.TestIntersectionOBB(hRay, parentrotation, frontFacesOnly, faceCenters);
 
-                // This may need to be updated to the maximum draw distance possible..
-                // We might (and probably will) be checking for prim creation from other sims
-                // when the camera crosses the border.
-                float idist = Constants.RegionSize;
-
                 if (inter.HitTF)
                 {
                     // We need to find the closest prim to return to the testcaller along the ray
@@ -715,10 +818,11 @@ namespace OpenSim.Region.Framework.Scenes
                         result.obj = part;
                         result.normal = inter.normal;
                         result.distance = inter.distance;
+
+                        idist = inter.distance;
                     }
                 }
             }
-
             return result;
         }
 
@@ -738,17 +842,19 @@ namespace OpenSim.Region.Framework.Scenes
             minZ = 8192f;
 
             SceneObjectPart[] parts = m_parts.GetArray();
-            for (int i = 0; i < parts.Length; i++)
+            foreach (SceneObjectPart part in parts)
             {
-                SceneObjectPart part = parts[i];
-
                 Vector3 worldPos = part.GetWorldPosition();
                 Vector3 offset = worldPos - AbsolutePosition;
                 Quaternion worldRot;
                 if (part.ParentID == 0)
+                {
                     worldRot = part.RotationOffset;
+                }
                 else
+                {
                     worldRot = part.GetWorldRotation();
+                }
 
                 Vector3 frontTopLeft;
                 Vector3 frontTopRight;
@@ -760,6 +866,8 @@ namespace OpenSim.Region.Framework.Scenes
                 Vector3 backBottomLeft;
                 Vector3 backBottomRight;
 
+               // Vector3[] corners = new Vector3[8];
+
                 Vector3 orig = Vector3.Zero;
 
                 frontTopLeft.X = orig.X - (part.Scale.X / 2);
@@ -794,6 +902,38 @@ namespace OpenSim.Region.Framework.Scenes
                 backBottomRight.Y = orig.Y + (part.Scale.Y / 2);
                 backBottomRight.Z = orig.Z - (part.Scale.Z / 2);
 
+                
+
+                //m_log.InfoFormat("pre corner 1 is {0} {1} {2}", frontTopLeft.X, frontTopLeft.Y, frontTopLeft.Z);
+                //m_log.InfoFormat("pre corner 2 is {0} {1} {2}", frontTopRight.X, frontTopRight.Y, frontTopRight.Z);
+                //m_log.InfoFormat("pre corner 3 is {0} {1} {2}", frontBottomRight.X, frontBottomRight.Y, frontBottomRight.Z);
+                //m_log.InfoFormat("pre corner 4 is {0} {1} {2}", frontBottomLeft.X, frontBottomLeft.Y, frontBottomLeft.Z);
+                //m_log.InfoFormat("pre corner 5 is {0} {1} {2}", backTopLeft.X, backTopLeft.Y, backTopLeft.Z);
+                //m_log.InfoFormat("pre corner 6 is {0} {1} {2}", backTopRight.X, backTopRight.Y, backTopRight.Z);
+                //m_log.InfoFormat("pre corner 7 is {0} {1} {2}", backBottomRight.X, backBottomRight.Y, backBottomRight.Z);
+                //m_log.InfoFormat("pre corner 8 is {0} {1} {2}", backBottomLeft.X, backBottomLeft.Y, backBottomLeft.Z);
+
+                //for (int i = 0; i < 8; i++)
+                //{
+                //    corners[i] = corners[i] * worldRot;
+                //    corners[i] += offset;
+
+                //    if (corners[i].X > maxX)
+                //        maxX = corners[i].X;
+                //    if (corners[i].X < minX)
+                //        minX = corners[i].X;
+
+                //    if (corners[i].Y > maxY)
+                //        maxY = corners[i].Y;
+                //    if (corners[i].Y < minY)
+                //        minY = corners[i].Y;
+
+                //    if (corners[i].Z > maxZ)
+                //        maxZ = corners[i].Y;
+                //    if (corners[i].Z < minZ)
+                //        minZ = corners[i].Z;
+                //}
+
                 frontTopLeft = frontTopLeft * worldRot;
                 frontTopRight = frontTopRight * worldRot;
                 frontBottomLeft = frontBottomLeft * worldRot;
@@ -815,6 +955,15 @@ namespace OpenSim.Region.Framework.Scenes
                 backTopLeft += offset;
                 backTopRight += offset;
 
+                //m_log.InfoFormat("corner 1 is {0} {1} {2}", frontTopLeft.X, frontTopLeft.Y, frontTopLeft.Z);
+                //m_log.InfoFormat("corner 2 is {0} {1} {2}", frontTopRight.X, frontTopRight.Y, frontTopRight.Z);
+                //m_log.InfoFormat("corner 3 is {0} {1} {2}", frontBottomRight.X, frontBottomRight.Y, frontBottomRight.Z);
+                //m_log.InfoFormat("corner 4 is {0} {1} {2}", frontBottomLeft.X, frontBottomLeft.Y, frontBottomLeft.Z);
+                //m_log.InfoFormat("corner 5 is {0} {1} {2}", backTopLeft.X, backTopLeft.Y, backTopLeft.Z);
+                //m_log.InfoFormat("corner 6 is {0} {1} {2}", backTopRight.X, backTopRight.Y, backTopRight.Z);
+                //m_log.InfoFormat("corner 7 is {0} {1} {2}", backBottomRight.X, backBottomRight.Y, backBottomRight.Z);
+                //m_log.InfoFormat("corner 8 is {0} {1} {2}", backBottomLeft.X, backBottomLeft.Y, backBottomLeft.Z);
+
                 if (frontTopRight.X > maxX)
                     maxX = frontTopRight.X;
                 if (frontTopLeft.X > maxX)
@@ -960,15 +1109,20 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SaveScriptedState(XmlTextWriter writer)
         {
+            SaveScriptedState(writer, false);
+        }
+
+        public void SaveScriptedState(XmlTextWriter writer, bool oldIDs)
+        {
             XmlDocument doc = new XmlDocument();
             Dictionary<UUID,string> states = new Dictionary<UUID,string>();
 
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
             {
-                Dictionary<UUID, string> pstates = parts[i].Inventory.GetScriptStates();
+                Dictionary<UUID, string> pstates = parts[i].Inventory.GetScriptStates(oldIDs);
                 foreach (KeyValuePair<UUID, string> kvp in pstates)
-                    states.Add(kvp.Key, kvp.Value);
+                    states[kvp.Key] = kvp.Value;
             }
 
             if (states.Count > 0)
@@ -988,6 +1142,168 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Add the avatar to this linkset (avatar is sat).
+        /// </summary>
+        /// <param name="agentID"></param>
+        public void AddAvatar(UUID agentID)
+        {
+            ScenePresence presence;
+            if (m_scene.TryGetScenePresence(agentID, out presence))
+            {
+                if (!m_linkedAvatars.Contains(presence))
+                {
+                    m_linkedAvatars.Add(presence);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Delete the avatar from this linkset (avatar is unsat).
+        /// </summary>
+        /// <param name="agentID"></param>
+        public void DeleteAvatar(UUID agentID)
+        {
+            ScenePresence presence;
+            if (m_scene.TryGetScenePresence(agentID, out presence))
+            {
+                if (m_linkedAvatars.Contains(presence))
+                {
+                    m_linkedAvatars.Remove(presence);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns the list of linked presences (avatars sat on this group)
+        /// </summary>
+        /// <param name="agentID"></param>
+        public List<ScenePresence> GetLinkedAvatars()
+        {
+            return m_linkedAvatars;
+        }
+
+        /// <summary>
+        /// Attach this scene object to the given avatar.
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="attachmentpoint"></param>
+        /// <param name="AttachOffset"></param>
+        private void AttachToAgent(
+            ScenePresence avatar, SceneObjectGroup so, uint attachmentpoint, Vector3 attachOffset, bool silent)
+        {
+            if (avatar != null)
+            {
+                // don't attach attachments to child agents
+                if (avatar.IsChildAgent) return;
+
+                // Remove from database and parcel prim count
+                m_scene.DeleteFromStorage(so.UUID);
+                m_scene.EventManager.TriggerParcelPrimCountTainted();
+
+                so.AttachedAvatar = avatar.UUID;
+
+                if (so.RootPart.PhysActor != null)
+                {
+                    m_scene.PhysicsScene.RemovePrim(so.RootPart.PhysActor);
+                    so.RootPart.PhysActor = null;
+                }
+
+                so.AbsolutePosition = attachOffset;
+                so.RootPart.AttachedPos = attachOffset;
+                so.IsAttachment = true;
+                so.RootPart.SetParentLocalId(avatar.LocalId);
+                so.AttachmentPoint = attachmentpoint;
+
+                avatar.AddAttachment(this);
+
+                if (!silent)
+                {
+                    // Killing it here will cause the client to deselect it
+                    // It then reappears on the avatar, deselected
+                    // through the full update below
+                    //
+                    if (IsSelected)
+                    {
+                        m_scene.SendKillObject(new List<uint> { m_rootPart.LocalId });
+                    }
+
+                    IsSelected = false; // fudge....
+                    ScheduleGroupForFullUpdate();
+                }
+            }
+            else
+            {
+                m_log.WarnFormat(
+                    "[SOG]: Tried to add attachment {0} to avatar with UUID {1} in region {2} but the avatar is not present", 
+                    UUID, avatar.ControllingClient.AgentId, Scene.RegionInfo.RegionName);
+            }
+        }
+
+        public byte GetAttachmentPoint()
+        {
+            return m_rootPart.Shape.State;
+        }
+
+        public void DetachToGround()
+        {
+            ScenePresence avatar = m_scene.GetScenePresence(AttachedAvatar);
+            if (avatar == null)
+                return;
+
+            avatar.RemoveAttachment(this);
+
+            Vector3 detachedpos = new Vector3(127f,127f,127f);
+            if (avatar == null)
+                return;
+
+            detachedpos = avatar.AbsolutePosition;
+            RootPart.FromItemID = UUID.Zero;
+
+            AbsolutePosition = detachedpos;
+            AttachedAvatar = UUID.Zero;
+
+            //SceneObjectPart[] parts = m_parts.GetArray();
+            //for (int i = 0; i < parts.Length; i++)
+            //    parts[i].AttachedAvatar = UUID.Zero;
+
+            m_rootPart.SetParentLocalId(0);
+            AttachmentPoint = (byte)0;
+            m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive);
+            HasGroupChanged = true;
+            RootPart.Rezzed = DateTime.Now;
+            RootPart.RemFlag(PrimFlags.TemporaryOnRez);
+            AttachToBackup();
+            m_scene.EventManager.TriggerParcelPrimCountTainted();
+            m_rootPart.ScheduleFullUpdate();
+            m_rootPart.ClearUndoState();
+        }
+
+        public void DetachToInventoryPrep()
+        {
+            ScenePresence avatar = m_scene.GetScenePresence(AttachedAvatar);
+            //Vector3 detachedpos = new Vector3(127f, 127f, 127f);
+            if (avatar != null)
+            {
+                //detachedpos = avatar.AbsolutePosition;
+                avatar.RemoveAttachment(this);
+            }
+
+            AttachedAvatar = UUID.Zero;
+
+            /*SceneObjectPart[] parts = m_parts.GetArray();
+            for (int i = 0; i < parts.Length; i++)
+                parts[i].AttachedAvatar = UUID.Zero;*/
+
+            m_rootPart.SetParentLocalId(0);
+            //m_rootPart.SetAttachmentPoint((byte)0);
+            IsAttachment = false;
+            AbsolutePosition = m_rootPart.AttachedPos;
+            //m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_scene.m_physicalPrim);
+            //AttachToBackup();
+            //m_rootPart.ScheduleFullUpdate();
+        }
+
+        /// <summary>
         ///
         /// </summary>
         /// <param name="part"></param>
@@ -1037,7 +1353,10 @@ namespace OpenSim.Region.Framework.Scenes
         public void AddPart(SceneObjectPart part)
         {
             part.SetParent(this);
-            part.LinkNum = m_parts.Add(part.UUID, part);
+            m_parts.Add(part.UUID, part);
+
+            part.LinkNum = m_parts.Count;
+
             if (part.LinkNum == 2)
                 RootPart.LinkNum = 1;
         }
@@ -1145,6 +1464,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="silent">If true then deletion is not broadcast to clients</param>
         public void DeleteGroupFromScene(bool silent)
         {
+            // We need to keep track of this state in case this group is still queued for backup.
+            IsDeleted = true;
+
+            DetachFromBackup();
+
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
             {
@@ -1167,6 +1491,8 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 });
             }
+            
+          
         }
 
         public void AddScriptLPS(int count)
@@ -1262,7 +1588,12 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetOwnerId(UUID userId)
         {
-            ForEachPart(delegate(SceneObjectPart part) { part.OwnerID = userId; });
+                ForEachPart(delegate(SceneObjectPart part) 
+                {
+                    
+                    part.OwnerID = userId;
+                    
+                });
         }
 
         public void ForEachPart(Action<SceneObjectPart> whatToDo)
@@ -1294,11 +1625,17 @@ namespace OpenSim.Region.Framework.Scenes
                 return;
             }
 
+            if ((RootPart.Flags & PrimFlags.TemporaryOnRez) != 0)
+                return;
+
             // Since this is the top of the section of call stack for backing up a particular scene object, don't let
             // any exception propogate upwards.
             try
             {
-                if (!m_scene.ShuttingDown) // if shutting down then there will be nothing to handle the return so leave till next restart
+                if (!m_scene.ShuttingDown || // if shutting down then there will be nothing to handle the return so leave till next restart
+                        m_scene.LoginsDisabled || // We're starting up or doing maintenance, don't mess with things
+                        m_scene.LoadingPrims) // Land may not be valid yet
+                
                 {
                     ILandObject parcel = m_scene.LandChannel.GetLandObject(
                             m_rootPart.GroupPosition.X, m_rootPart.GroupPosition.Y);
@@ -1325,6 +1662,7 @@ namespace OpenSim.Region.Framework.Scenes
                             }
                         }
                     }
+
                 }
 
                 if (m_scene.UseBackup && HasGroupChanged)
@@ -1332,6 +1670,20 @@ namespace OpenSim.Region.Framework.Scenes
                     // don't backup while it's selected or you're asking for changes mid stream.
                     if (isTimeToPersist() || forcedBackup)
                     {
+                        if (m_rootPart.PhysActor != null &&
+                            (!m_rootPart.PhysActor.IsPhysical))
+                        {
+                            // Possible ghost prim
+                            if (m_rootPart.PhysActor.Position != m_rootPart.GroupPosition)
+                            {
+                                foreach (SceneObjectPart part in m_parts.GetArray())
+                                {
+                                    // Re-set physics actor positions and
+                                    // orientations
+                                    part.GroupPosition = m_rootPart.GroupPosition;
+                                }
+                            }
+                        }
 //                        m_log.DebugFormat(
 //                            "[SCENE]: Storing {0}, {1} in {2}",
 //                            Name, UUID, m_scene.RegionInfo.RegionName);
@@ -1415,7 +1767,7 @@ namespace OpenSim.Region.Framework.Scenes
             // This is only necessary when userExposed is false!
 
             bool previousAttachmentStatus = dupe.IsAttachment;
-            
+
             if (!userExposed)
                 dupe.IsAttachment = true;
 
@@ -1433,11 +1785,11 @@ namespace OpenSim.Region.Framework.Scenes
                 dupe.m_rootPart.TrimPermissions();
 
             List<SceneObjectPart> partList = new List<SceneObjectPart>(m_parts.GetArray());
-            
+
             partList.Sort(delegate(SceneObjectPart p1, SceneObjectPart p2)
-                {
-                    return p1.LinkNum.CompareTo(p2.LinkNum);
-                }
+            {
+                return p1.LinkNum.CompareTo(p2.LinkNum);
+            }
             );
 
             foreach (SceneObjectPart part in partList)
@@ -1457,7 +1809,7 @@ namespace OpenSim.Region.Framework.Scenes
                 if (part.PhysActor != null && userExposed)
                 {
                     PrimitiveBaseShape pbs = newPart.Shape;
-    
+
                     newPart.PhysActor
                         = m_scene.PhysicsScene.AddPrimShape(
                             string.Format("{0}/{1}", newPart.Name, newPart.UUID),
@@ -1467,11 +1819,11 @@ namespace OpenSim.Region.Framework.Scenes
                             newPart.RotationOffset,
                             part.PhysActor.IsPhysical,
                             newPart.LocalId);
-    
+
                     newPart.DoPhysicsPropertyUpdate(part.PhysActor.IsPhysical, true);
                 }
             }
-            
+
             if (userExposed)
             {
                 dupe.UpdateParentIDs();
@@ -1586,6 +1938,7 @@ namespace OpenSim.Region.Framework.Scenes
             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)
         {
             if (IsAttachment)
@@ -1613,10 +1966,44 @@ namespace OpenSim.Region.Framework.Scenes
                 RootPart.PhysActor.PIDActive = false;
         }
         
+        public void rotLookAt(Quaternion target, float strength, float damping)
+        {
+            SceneObjectPart rootpart = m_rootPart;
+            if (rootpart != null)
+            {
+                if (IsAttachment)
+                {
+                /*
+                    ScenePresence avatar = m_scene.GetScenePresence(rootpart.AttachedAvatar);
+                    if (avatar != null)
+                    {
+                    Rotate the Av?
+                    } */
+                }
+                else
+                {
+                    if (rootpart.PhysActor != null)
+                    {                                                                   // APID must be implemented in your physics system for this to function.
+                        rootpart.PhysActor.APIDTarget = new Quaternion(target.X, target.Y, target.Z, target.W);
+                        rootpart.PhysActor.APIDStrength = strength;
+                        rootpart.PhysActor.APIDDamping = damping;
+                        rootpart.PhysActor.APIDActive = true;
+                    }
+                }
+            }
+        }
+
         public void stopLookAt()
         {
-            if (RootPart.PhysActor != null)
-                RootPart.PhysActor.APIDActive = false;
+            SceneObjectPart rootpart = m_rootPart;
+            if (rootpart != null)
+            {
+                if (rootpart.PhysActor != null)
+                {                                                       // APID must be implemented in your physics system for this to function.
+                    rootpart.PhysActor.APIDActive = false;
+                }
+            }
+        
         }
 
         /// <summary>
@@ -1674,6 +2061,8 @@ namespace OpenSim.Region.Framework.Scenes
         public SceneObjectPart CopyPart(SceneObjectPart part, UUID cAgentID, UUID cGroupID, bool userExposed)
         {
             SceneObjectPart newPart = part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, m_parts.Count, userExposed);
+            newPart.SetParent(this);
+
             AddPart(newPart);
 
             SetPartAsNonRoot(newPart);
@@ -1802,11 +2191,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// Immediately send a full update for this scene object.
         /// </summary>
         public void SendGroupFullUpdate()
-        {
+        {                       
             if (IsDeleted)
                 return;
 
-//            m_log.DebugFormat("[SOG]: Sending immediate full group update for {0} {1}", Name, UUID);
+//            m_log.DebugFormat("[SOG]: Sending immediate full group update for {0} {1}", Name, UUID);            
             
             RootPart.SendFullUpdateToAllClients();
 
@@ -2007,7 +2396,7 @@ namespace OpenSim.Region.Framework.Scenes
             objectGroup.IsDeleted = true;
 
             objectGroup.m_parts.Clear();
-
+            
             // Can't do this yet since backup still makes use of the root part without any synchronization
 //            objectGroup.m_rootPart = null;
 
@@ -2141,6 +2530,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="objectGroup"></param>
         public virtual void DetachFromBackup()
         {
+            m_scene.SceneGraph.FireDetachFromBackup(this);
             if (m_isBackedUp && Scene != null)
                 m_scene.EventManager.OnBackup -= ProcessBackup;
             
@@ -2159,7 +2549,8 @@ namespace OpenSim.Region.Framework.Scenes
 
             axPos *= parentRot;
             part.OffsetPosition = axPos;
-            part.GroupPosition = oldGroupPosition + part.OffsetPosition;
+            Vector3 newPos = oldGroupPosition + part.OffsetPosition;
+            part.GroupPosition = newPos;
             part.OffsetPosition = Vector3.Zero;
             part.RotationOffset = worldRot;
 
@@ -2170,7 +2561,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             part.LinkNum = linkNum;
 
-            part.OffsetPosition = part.GroupPosition - AbsolutePosition;
+            part.OffsetPosition = newPos - AbsolutePosition;
 
             Quaternion rootRotation = m_rootPart.RotationOffset;
 
@@ -2180,7 +2571,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             parentRot = m_rootPart.RotationOffset;
             oldRot = part.RotationOffset;
-            Quaternion newRot = Quaternion.Inverse(parentRot) * oldRot;
+            Quaternion newRot = Quaternion.Inverse(parentRot) * worldRot;
             part.RotationOffset = newRot;
         }
 
@@ -2427,8 +2818,12 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
 
+                RootPart.UpdatePrimFlags(UsePhysics, SetTemporary, SetPhantom, SetVolumeDetect);
                 for (int i = 0; i < parts.Length; i++)
-                    parts[i].UpdatePrimFlags(UsePhysics, SetTemporary, SetPhantom, SetVolumeDetect);
+                {
+                    if (parts[i] != RootPart)
+                        parts[i].UpdatePrimFlags(UsePhysics, SetTemporary, SetPhantom, SetVolumeDetect);
+                }
             }
         }
 
@@ -2441,6 +2836,17 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+
+
+        /// <summary>
+        /// Gets the number of parts
+        /// </summary>
+        /// <returns></returns>
+        public int GetPartCount()
+        {
+            return Parts.Count();
+        }
+
         /// <summary>
         /// Update the texture entry for this part
         /// </summary>
@@ -2502,7 +2908,6 @@ namespace OpenSim.Region.Framework.Scenes
         {
 //            m_log.DebugFormat(
 //                "[SCENE OBJECT GROUP]: Group resizing {0} {1} from {2} to {3}", Name, LocalId, RootPart.Scale, scale);
-
             RootPart.StoreUndoState(true);
 
             scale.X = Math.Min(scale.X, Scene.m_maxNonphys);
@@ -2603,7 +3008,6 @@ namespace OpenSim.Region.Framework.Scenes
             prevScale.X *= x;
             prevScale.Y *= y;
             prevScale.Z *= z;
-
 //            RootPart.IgnoreUndoUpdate = true;
             RootPart.Resize(prevScale);
 //            RootPart.IgnoreUndoUpdate = false;
@@ -2634,7 +3038,9 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
 //                obPart.IgnoreUndoUpdate = false;
-//                obPart.StoreUndoState();
+                HasGroupChanged = true;
+                m_rootPart.TriggerScriptChangedEvent(Changed.SCALE);
+                ScheduleGroupForTerseUpdate();
             }
 
 //            m_log.DebugFormat(
@@ -2694,9 +3100,9 @@ namespace OpenSim.Region.Framework.Scenes
         {
             SceneObjectPart part = GetChildPart(localID);
 
-//            SceneObjectPart[] parts = m_parts.GetArray();
-//            for (int i = 0; i < parts.Length; i++)
-//                parts[i].StoreUndoState();
+            SceneObjectPart[] parts = m_parts.GetArray();
+            for (int i = 0; i < parts.Length; i++)
+                parts[i].StoreUndoState();
 
             if (part != null)
             {
@@ -2752,10 +3158,27 @@ namespace OpenSim.Region.Framework.Scenes
                     obPart.OffsetPosition = obPart.OffsetPosition + diff;
             }
 
-            AbsolutePosition = newPos;
+            //We have to set undoing here because otherwise an undo state will be saved
+            if (!m_rootPart.Undoing)
+            {
+                m_rootPart.Undoing = true;
+                AbsolutePosition = newPos;
+                m_rootPart.Undoing = false;
+            }
+            else
+            {
+                AbsolutePosition = newPos;
+            }
 
             HasGroupChanged = true;
-            ScheduleGroupForTerseUpdate();
+            if (m_rootPart.Undoing)
+            {
+                ScheduleGroupForFullUpdate();
+            }
+            else
+            {
+                ScheduleGroupForTerseUpdate();
+            }
         }
 
         #endregion
@@ -2832,10 +3255,7 @@ namespace OpenSim.Region.Framework.Scenes
         public void UpdateSingleRotation(Quaternion rot, uint localID)
         {
             SceneObjectPart part = GetChildPart(localID);
-
             SceneObjectPart[] parts = m_parts.GetArray();
-            for (int i = 0; i < parts.Length; i++)
-                parts[i].StoreUndoState();
 
             if (part != null)
             {
@@ -2873,7 +3293,16 @@ namespace OpenSim.Region.Framework.Scenes
                 if (part.UUID == m_rootPart.UUID)
                 {
                     UpdateRootRotation(rot);
-                    AbsolutePosition = pos;
+                    if (!m_rootPart.Undoing)
+                    {
+                        m_rootPart.Undoing = true;
+                        AbsolutePosition = pos;
+                        m_rootPart.Undoing = false;
+                    }
+                    else
+                    {
+                        AbsolutePosition = pos;
+                    }
                 }
                 else
                 {
@@ -2897,9 +3326,10 @@ namespace OpenSim.Region.Framework.Scenes
 
             Quaternion axRot = rot;
             Quaternion oldParentRot = m_rootPart.RotationOffset;
-
             m_rootPart.StoreUndoState();
-            m_rootPart.UpdateRotation(rot);
+            
+            //Don't use UpdateRotation because it schedules an update prematurely
+            m_rootPart.RotationOffset = rot;
             if (m_rootPart.PhysActor != null)
             {
                 m_rootPart.PhysActor.Orientation = m_rootPart.RotationOffset;
@@ -2913,15 +3343,17 @@ namespace OpenSim.Region.Framework.Scenes
                 if (prim.UUID != m_rootPart.UUID)
                 {
                     prim.IgnoreUndoUpdate = true;
+
+                    Quaternion NewRot = oldParentRot * prim.RotationOffset;
+                    NewRot = Quaternion.Inverse(axRot) * NewRot;
+                    prim.RotationOffset = NewRot;
+
                     Vector3 axPos = prim.OffsetPosition;
+
                     axPos *= oldParentRot;
                     axPos *= Quaternion.Inverse(axRot);
                     prim.OffsetPosition = axPos;
-                    Quaternion primsRot = prim.RotationOffset;
-                    Quaternion newRot = oldParentRot * primsRot;
-                    newRot = Quaternion.Inverse(axRot) * newRot;
-                    prim.RotationOffset = newRot;
-                    prim.ScheduleTerseUpdate();
+
                     prim.IgnoreUndoUpdate = false;
                 }
             }
@@ -2935,8 +3367,8 @@ namespace OpenSim.Region.Framework.Scenes
 ////                    childpart.StoreUndoState();
 //                }
 //            }
-
-            m_rootPart.ScheduleTerseUpdate();
+            HasGroupChanged = true;
+            ScheduleGroupForFullUpdate();
 
 //            m_log.DebugFormat(
 //                "[SCENE OBJECT GROUP]: Updated root rotation of {0} {1} to {2}",
@@ -3164,7 +3596,6 @@ namespace OpenSim.Region.Framework.Scenes
         public float GetMass()
         {
             float retmass = 0f;
-
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
                 retmass += parts[i].GetMass();
@@ -3260,6 +3691,14 @@ namespace OpenSim.Region.Framework.Scenes
             SetFromItemID(uuid);
         }
 
+        public void ResetOwnerChangeFlag()
+        {
+            ForEachPart(delegate(SceneObjectPart part)
+            {
+                part.ResetOwnerChangeFlag();
+            });
+        }
+
         #endregion
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 51d3586..c45cfb8 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -62,7 +62,8 @@ namespace OpenSim.Region.Framework.Scenes
         TELEPORT = 512,
         REGION_RESTART = 1024,
         MEDIA = 2048,
-        ANIMATION = 16384
+        ANIMATION = 16384,
+        POSITION = 32768
     }
 
     // I don't really know where to put this except here.
@@ -184,6 +185,15 @@ namespace OpenSim.Region.Framework.Scenes
 
         public UUID FromFolderID;
 
+        // The following two are to hold the attachment data
+        // while an object is inworld
+        [XmlIgnore]
+        public byte AttachPoint = 0;
+
+        [XmlIgnore]
+        public Vector3 AttachOffset = Vector3.Zero;
+
+        [XmlIgnore]
         public int STATUS_ROTATE_X;
 
         public int STATUS_ROTATE_Y;
@@ -210,8 +220,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public Vector3 RotationAxis = Vector3.One;
 
-        public bool VolumeDetectActive; // XmlIgnore set to avoid problems with persistance until I come to care for this
-                                        // Certainly this must be a persistant setting finally
+        public bool VolumeDetectActive;
 
         public bool IsWaitingForFirstSpinUpdatePacket;
 
@@ -252,6 +261,7 @@ namespace OpenSim.Region.Framework.Scenes
         private Quaternion m_sitTargetOrientation = Quaternion.Identity;
         private Vector3 m_sitTargetPosition;
         private string m_sitAnimation = "SIT";
+        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 Stack<UndoState> m_undo = new Stack<UndoState>(5);
@@ -284,6 +294,7 @@ namespace OpenSim.Region.Framework.Scenes
         protected Vector3 m_lastAcceleration;
         protected Vector3 m_lastAngularVelocity;
         protected int m_lastTerseSent;
+        protected float m_buoyancy = 0.0f;
         
         /// <summary>
         /// Stores media texture data
@@ -339,7 +350,7 @@ namespace OpenSim.Region.Framework.Scenes
             UUID ownerID, PrimitiveBaseShape shape, Vector3 groupPosition, 
             Quaternion rotationOffset, Vector3 offsetPosition) : this()
         {
-            m_name = "Primitive";
+            m_name = "Object";
 
             CreationDate = (int)Utils.DateTimeToUnixTime(Rezzed);
             LastOwnerID = CreatorID = OwnerID = ownerID;
@@ -379,7 +390,7 @@ namespace OpenSim.Region.Framework.Scenes
         private uint _ownerMask = (uint)PermissionMask.All;
         private uint _groupMask = (uint)PermissionMask.None;
         private uint _everyoneMask = (uint)PermissionMask.None;
-        private uint _nextOwnerMask = (uint)PermissionMask.All;
+        private uint _nextOwnerMask = (uint)(PermissionMask.Move | PermissionMask.Modify | PermissionMask.Transfer);
         private PrimFlags _flags = PrimFlags.None;
         private DateTime m_expires;
         private DateTime m_rezzed;
@@ -473,12 +484,16 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <value>
-        /// Access should be via Inventory directly - this property temporarily remains for xml serialization purposes
+        /// Get the inventory list
         /// </value>
         public TaskInventoryDictionary TaskInventory
         {
-            get { return m_inventory.Items; }
-            set { m_inventory.Items = value; }
+            get {
+                return m_inventory.Items;
+            }
+            set {
+                m_inventory.Items = value;
+            }
         }
 
         /// <summary>
@@ -623,14 +638,12 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_LoopSoundSlavePrims = value; }
         }
 
-        
         public Byte[] TextureAnimation
         {
             get { return m_TextureAnimation; }
             set { m_TextureAnimation = value; }
         }
 
-        
         public Byte[] ParticleSystem
         {
             get { return m_particleSystem; }
@@ -667,9 +680,11 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 // If this is a linkset, we don't want the physics engine mucking up our group position here.
                 PhysicsActor actor = PhysActor;
-                if (actor != null && ParentID == 0)
+                if (ParentID == 0)
                 {
-                    m_groupPosition = actor.Position;
+                    if (actor != null)
+                        m_groupPosition = actor.Position;
+                    return m_groupPosition;
                 }
 
                 if (ParentGroup.IsAttachment)
@@ -679,12 +694,14 @@ namespace OpenSim.Region.Framework.Scenes
                         return sp.AbsolutePosition;
                 }
 
+                // use root prim's group position. Physics may have updated it
+                if (ParentGroup.RootPart != this)
+                    m_groupPosition = ParentGroup.RootPart.GroupPosition;
                 return m_groupPosition;
             }
             set
             {
                 m_groupPosition = value;
-
                 PhysicsActor actor = PhysActor;
                 if (actor != null)
                 {
@@ -710,16 +727,6 @@ namespace OpenSim.Region.Framework.Scenes
                         m_log.Error("[SCENEOBJECTPART]: GROUP POSITION. " + e.Message);
                     }
                 }
-                
-                // TODO if we decide to do sitting in a more SL compatible way (multiple avatars per prim), this has to be fixed, too
-                if (SitTargetAvatar != UUID.Zero)
-                {
-                    ScenePresence avatar;
-                    if (ParentGroup.Scene.TryGetScenePresence(SitTargetAvatar, out avatar))
-                    {
-                        avatar.ParentPosition = GetWorldPosition();
-                    }
-                }
             }
         }
 
@@ -728,7 +735,7 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_offsetPosition; }
             set
             {
-//                StoreUndoState();
+                Vector3 oldpos = m_offsetPosition;
                 m_offsetPosition = value;
 
                 if (ParentGroup != null && !ParentGroup.IsDeleted)
@@ -743,7 +750,22 @@ namespace OpenSim.Region.Framework.Scenes
                         if (ParentGroup.Scene != null)
                             ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(actor);
                     }
+
+                    if (!m_parentGroup.m_dupeInProgress)
+                    {
+                        List<ScenePresence> avs = ParentGroup.GetLinkedAvatars();
+                        foreach (ScenePresence av in avs)
+                        {
+                            if (av.ParentID == m_localId)
+                            {
+                                Vector3 offset = (m_offsetPosition - oldpos);
+                                av.AbsolutePosition += offset;
+                                av.SendAvatarDataToAllAgents();
+                            }
+                        }
+                    }
                 }
+                TriggerScriptChangedEvent(Changed.POSITION);
             }
         }
 
@@ -892,7 +914,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary></summary>
         public Vector3 Acceleration
         {
-            get { return m_acceleration; }
+                        get 
+                        { 
+                PhysicsActor actor = PhysActor;
+                if (actor != null)
+                                {
+                                        m_acceleration = actor.Acceleration;
+                                }
+                                return m_acceleration;
+                        } 
+            
             set { m_acceleration = value; }
         }
 
@@ -1043,10 +1074,7 @@ namespace OpenSim.Region.Framework.Scenes
         {
             get
             {
-                if (ParentGroup.IsAttachment)
-                    return GroupPosition;
-
-                return m_offsetPosition + m_groupPosition;
+                return GroupPosition + (m_offsetPosition * ParentGroup.RootPart.RotationOffset);
             }
         }
 
@@ -1216,6 +1244,13 @@ namespace OpenSim.Region.Framework.Scenes
                 _flags = value; 
             }
         }
+        
+        [XmlIgnore]
+        public bool IsOccupied                          // KF If an av is sittingon this prim
+        {
+                get { return m_occupied; }
+                set { m_occupied = value; }
+        }
 
         /// <summary>
         /// ID of the avatar that is sat on us.  If there is no such avatar then is UUID.Zero
@@ -1275,6 +1310,19 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_collisionSoundVolume = value; }
         }
 
+        public float Buoyancy
+        {
+            get { return m_buoyancy; }
+            set
+            {
+                m_buoyancy = value;
+                if (PhysActor != null)
+                {
+                    PhysActor.Buoyancy = value;
+                }
+            }
+        }
+
         #endregion Public Properties with only Get
 
         private uint ApplyMask(uint val, bool set, uint mask)
@@ -1599,6 +1647,9 @@ namespace OpenSim.Region.Framework.Scenes
 
             // Move afterwards ResetIDs as it clears the localID
             dupe.LocalId = localID;
+            if(dupe.PhysActor != null)
+                dupe.PhysActor.LocalID = localID;
+
             // This may be wrong...    it might have to be applied in SceneObjectGroup to the object that's being duplicated.
             dupe.LastOwnerID = OwnerID;
 
@@ -2604,17 +2655,18 @@ namespace OpenSim.Region.Framework.Scenes
                 //Trys to fetch sound id from prim's inventory.
                 //Prim's inventory doesn't support non script items yet
                 
-                lock (TaskInventory)
+                TaskInventory.LockItemsForRead(true);
+
+                foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
                 {
-                    foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
+                    if (item.Value.Name == sound)
                     {
-                        if (item.Value.Name == sound)
-                        {
-                            soundID = item.Value.ItemID;
-                            break;
-                        }
+                        soundID = item.Value.ItemID;
+                        break;
                     }
                 }
+
+                TaskInventory.LockItemsForRead(false);
             }
 
             ParentGroup.Scene.ForEachRootScenePresence(delegate(ScenePresence sp)
@@ -2697,7 +2749,7 @@ namespace OpenSim.Region.Framework.Scenes
         
         public void RotLookAt(Quaternion target, float strength, float damping)
         {
-            rotLookAt(target, strength, damping);
+                m_parentGroup.rotLookAt(target, strength, damping);  // This calls method in SceneObjectGroup.
         }
 
         public void rotLookAt(Quaternion target, float strength, float damping)
@@ -2923,8 +2975,8 @@ namespace OpenSim.Region.Framework.Scenes
         {
             const float ROTATION_TOLERANCE = 0.01f;
             const float VELOCITY_TOLERANCE = 0.001f;
-            const float POSITION_TOLERANCE = 0.05f;
-            const int TIME_MS_TOLERANCE = 3000;
+            const float POSITION_TOLERANCE = 0.05f; // I don't like this, but I suppose it's necessary
+            const int TIME_MS_TOLERANCE = 200; //llSetPos has a 200ms delay. This should NOT be 3 seconds.
 
             switch (UpdateFlag)
             {
@@ -2986,17 +3038,16 @@ namespace OpenSim.Region.Framework.Scenes
             if (!UUID.TryParse(sound, out soundID))
             {
                 // search sound file from inventory
-                lock (TaskInventory)
+                TaskInventory.LockItemsForRead(true);
+                foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
                 {
-                    foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
+                    if (item.Value.Name == sound && item.Value.Type == (int)AssetType.Sound)
                     {
-                        if (item.Value.Name == sound && item.Value.Type == (int)AssetType.Sound)
-                        {
-                            soundID = item.Value.ItemID;
-                            break;
-                        }
+                        soundID = item.Value.ItemID;
+                        break;
                     }
                 }
+                TaskInventory.LockItemsForRead(false);
             }
 
             if (soundID == UUID.Zero)
@@ -3470,10 +3521,10 @@ namespace OpenSim.Region.Framework.Scenes
                                     // 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);
-    
+                                        //                                        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;
                                     }
                                 }
@@ -3486,29 +3537,29 @@ namespace OpenSim.Region.Framework.Scenes
                             if (ParentGroup.GetSceneMaxUndo() > 0)
                             {
                                 UndoState nUndo = new UndoState(this, forGroup);
-    
+
                                 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);
+
+                                //                                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}", Name, LocalId);
+                //                }
             }
-//            else
-//            {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Ignoring undo store for {0} {1} since already undoing", Name, LocalId);
-//            }
+            //            else
+            //            {
+            //                m_log.DebugFormat(
+            //                    "[SCENE OBJECT PART]: Ignoring undo store for {0} {1} since already undoing", Name, LocalId);
+            //            }
         }
 
         /// <summary>
@@ -4239,6 +4290,9 @@ namespace OpenSim.Region.Framework.Scenes
             bool wasPhantom = ((Flags & PrimFlags.Phantom) != 0);
             bool wasVD = VolumeDetectActive;
 
+//            m_log.DebugFormat("[SOP]: Old states: phys: {0} temp: {1} phan: {2} vd: {3}", wasUsingPhysics, wasTemporary, wasPhantom, wasVD);
+//            m_log.DebugFormat("[SOP]: New states: phys: {0} temp: {1} phan: {2} vd: {3}", UsePhysics, SetTemporary, SetPhantom, SetVD);
+
             if ((UsePhysics == wasUsingPhysics) && (wasTemporary == SetTemporary) && (wasPhantom == SetPhantom) && (SetVD == wasVD))
                 return;
 
@@ -4268,6 +4322,11 @@ namespace OpenSim.Region.Framework.Scenes
                     SetPhantom = false;
                 }
             }
+            else if (wasVD)
+            {
+                // Correspondingly, if VD is turned off, also turn off phantom
+                SetPhantom = false;
+            }
 
             if (UsePhysics && IsJoint())
             {
@@ -4762,5 +4821,17 @@ namespace OpenSim.Region.Framework.Scenes
             Color color = Color;
             return new Color4(color.R, color.G, color.B, (byte)(0xFF - color.A));
         }
+
+        public void ResetOwnerChangeFlag()
+        {
+            List<UUID> inv = Inventory.GetInventoryList();
+
+            foreach (UUID itemID in inv)
+            {
+                TaskInventoryItem item = Inventory.GetInventoryItem(itemID);
+                item.OwnerChanged = false;
+                Inventory.UpdateInventoryItem(item, false, false);
+            }
+        }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index daddb90..2335ad5 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -48,6 +48,9 @@ namespace OpenSim.Region.Framework.Scenes
         private string m_inventoryFileName = String.Empty;
         private byte[] m_inventoryFileData = new byte[0];
         private uint m_inventoryFileNameSerial = 0;
+        private bool m_inventoryPrivileged = false;
+
+        private Dictionary<UUID, ArrayList> m_scriptErrors = new Dictionary<UUID, ArrayList>();
         
         /// <value>
         /// The part to which the inventory belongs.
@@ -84,11 +87,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// </value>
         protected internal TaskInventoryDictionary Items
         {
-            get { return m_items; }
+            get { 
+                return m_items; 
+            }
             set
             {
                 m_items = value;
                 m_inventorySerial++;
+                QueryScriptStates();
             }
         }
         
@@ -123,38 +129,45 @@ namespace OpenSim.Region.Framework.Scenes
         public void ResetInventoryIDs()
         {
             if (null == m_part)
-                return;
-            
-            lock (m_items)
+            m_items.LockItemsForWrite(true);
+
+            if (Items.Count == 0)
             {
-                if (0 == m_items.Count)
-                    return;
+                m_items.LockItemsForWrite(false);
+                return;
+            }
 
-                IList<TaskInventoryItem> items = GetInventoryItems();
-                m_items.Clear();
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            Items.Clear();
 
-                foreach (TaskInventoryItem item in items)
-                {
-                    item.ResetIDs(m_part.UUID);
-                    m_items.Add(item.ItemID, item);
-                }
+            foreach (TaskInventoryItem item in items)
+            {
+                item.ResetIDs(m_part.UUID);
+                Items.Add(item.ItemID, item);
             }
+            m_items.LockItemsForWrite(false);
         }
 
         public void ResetObjectID()
         {
-            lock (Items)
+            m_items.LockItemsForWrite(true);
+
+            if (Items.Count == 0)
             {
-                IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
-                Items.Clear();
-    
-                foreach (TaskInventoryItem item in items)
-                {
-                    item.ParentPartID = m_part.UUID;
-                    item.ParentID = m_part.UUID;
-                    Items.Add(item.ItemID, item);
-                }
+                m_items.LockItemsForWrite(false);
+                return;
             }
+
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            Items.Clear();
+
+            foreach (TaskInventoryItem item in items)
+            {
+                item.ParentPartID = m_part.UUID;
+                item.ParentID = m_part.UUID;
+                Items.Add(item.ItemID, item);
+            }
+            m_items.LockItemsForWrite(false);
         }
 
         /// <summary>
@@ -163,12 +176,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="ownerId"></param>
         public void ChangeInventoryOwner(UUID ownerId)
         {
-            lock (Items)
+            m_items.LockItemsForWrite(true);
+            if (0 == Items.Count)
             {
-                if (0 == Items.Count)
-                {
-                    return;
-                }
+                m_items.LockItemsForWrite(false);
+                return;
             }
 
             HasInventoryChanged = true;
@@ -184,6 +196,7 @@ namespace OpenSim.Region.Framework.Scenes
                 item.PermsGranter = UUID.Zero;
                 item.OwnerChanged = true;
             }
+            m_items.LockItemsForWrite(false);
         }
 
         /// <summary>
@@ -192,12 +205,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="groupID"></param>
         public void ChangeInventoryGroup(UUID groupID)
         {
-            lock (Items)
+            m_items.LockItemsForWrite(true);
+            if (0 == Items.Count)
             {
-                if (0 == Items.Count)
-                {
-                    return;
-                }
+                m_items.LockItemsForWrite(false);
+                return;
             }
 
             // Don't let this set the HasGroupChanged flag for attachments
@@ -209,12 +221,45 @@ namespace OpenSim.Region.Framework.Scenes
                 m_part.ParentGroup.HasGroupChanged = true;
             }
 
-            List<TaskInventoryItem> items = GetInventoryItems();
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
             foreach (TaskInventoryItem item in items)
             {
                 if (groupID != item.GroupID)
+                {
                     item.GroupID = groupID;
+                }
+            }
+            m_items.LockItemsForWrite(false);
+        }
+
+        private void QueryScriptStates()
+        {
+            if (m_part == null || m_part.ParentGroup == null)
+                return;
+
+            IScriptModule[] engines = m_part.ParentGroup.Scene.RequestModuleInterfaces<IScriptModule>();
+            if (engines == null) // No engine at all
+                return;
+
+            Items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in Items.Values)
+            {
+                if (item.InvType == (int)InventoryType.LSL)
+                {
+                    foreach (IScriptModule e in engines)
+                    {
+                        bool running;
+
+                        if (e.HasScript(item.ItemID, out running))
+                        {
+                            item.ScriptRunning = running;
+                            break;
+                        }
+                    }
+                }
             }
+
+            Items.LockItemsForRead(false);
         }
 
         /// <summary>
@@ -222,9 +267,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
         {
-            List<TaskInventoryItem> scripts = GetInventoryScripts();
-            foreach (TaskInventoryItem item in scripts)
-                CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
+            Items.LockItemsForRead(true);
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            Items.LockItemsForRead(false);
+            foreach (TaskInventoryItem item in items)
+            {
+                if ((int)InventoryType.LSL == item.InvType)
+                    CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
+            }
         }
 
         public ArrayList GetScriptErrors(UUID itemID)
@@ -255,9 +305,18 @@ namespace OpenSim.Region.Framework.Scenes
         /// </param>
         public void RemoveScriptInstances(bool sceneObjectBeingDeleted)
         {
-            List<TaskInventoryItem> scripts = GetInventoryScripts();
-            foreach (TaskInventoryItem item in scripts)
-                RemoveScriptInstance(item.ItemID, sceneObjectBeingDeleted);
+            Items.LockItemsForRead(true);
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            Items.LockItemsForRead(false);
+
+            foreach (TaskInventoryItem item in items)
+            {
+                if ((int)InventoryType.LSL == item.InvType)
+                {
+                    RemoveScriptInstance(item.ItemID, sceneObjectBeingDeleted);
+                    m_part.RemoveScriptEvents(item.ItemID);
+                }
+            }
         }
 
         /// <summary>
@@ -273,7 +332,10 @@ namespace OpenSim.Region.Framework.Scenes
             //     item.Name, item.ItemID, Name, UUID);
 
             if (!m_part.ParentGroup.Scene.Permissions.CanRunScript(item.ItemID, m_part.UUID, item.OwnerID))
+            {
+                StoreScriptError(item.ItemID, "no permission");
                 return;
+            }
 
             m_part.AddFlag(PrimFlags.Scripted);
 
@@ -282,14 +344,13 @@ namespace OpenSim.Region.Framework.Scenes
                 if (stateSource == 2 && // Prim crossing
                         m_part.ParentGroup.Scene.m_trustBinaries)
                 {
-                    lock (m_items)
-                    {
-                        m_items[item.ItemID].PermsMask = 0;
-                        m_items[item.ItemID].PermsGranter = UUID.Zero;
-                    }
-                    
+                    m_items.LockItemsForWrite(true);
+                    m_items[item.ItemID].PermsMask = 0;
+                    m_items[item.ItemID].PermsGranter = UUID.Zero;
+                    m_items.LockItemsForWrite(false);
                     m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
                         m_part.LocalId, item.ItemID, String.Empty, startParam, postOnRez, engine, stateSource);
+                    StoreScriptErrors(item.ItemID, null);
                     m_part.ParentGroup.AddActiveScriptCount(1);
                     m_part.ScheduleFullUpdate();
                     return;
@@ -298,6 +359,8 @@ namespace OpenSim.Region.Framework.Scenes
                 AssetBase asset = m_part.ParentGroup.Scene.AssetService.Get(item.AssetID.ToString());
                 if (null == asset)
                 {
+                    string msg = String.Format("asset ID {0} could not be found", item.AssetID);
+                    StoreScriptError(item.ItemID, msg);
                     m_log.ErrorFormat(
                         "[PRIM INVENTORY]: " +
                         "Couldn't start script {0}, {1} at {2} in {3} since asset ID {4} could not be found",
@@ -309,15 +372,20 @@ namespace OpenSim.Region.Framework.Scenes
                     if (m_part.ParentGroup.m_savedScriptState != null)
                         RestoreSavedScriptState(item.OldItemID, item.ItemID);
 
-                    lock (m_items)
-                    {
-                        m_items[item.ItemID].PermsMask = 0;
-                        m_items[item.ItemID].PermsGranter = UUID.Zero;
-                    }
+                    m_items.LockItemsForWrite(true);
+
+                    m_items[item.ItemID].PermsMask = 0;
+                    m_items[item.ItemID].PermsGranter = UUID.Zero;
+
+                    m_items.LockItemsForWrite(false);
                 
                     string script = Utils.BytesToString(asset.Data);
                     m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
                         m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
+                    StoreScriptErrors(item.ItemID, null);
+                    if (!item.ScriptRunning)
+                        m_part.ParentGroup.Scene.EventManager.TriggerStopScript(
+                            m_part.LocalId, item.ItemID);
                     m_part.ParentGroup.AddActiveScriptCount(1);
                     m_part.ScheduleFullUpdate();
                 }
@@ -383,21 +451,145 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Start a script which is in this prim's inventory.
+        /// Some processing may occur in the background, but this routine returns asap.
         /// </summary>
         /// <param name="itemId">
         /// A <see cref="UUID"/>
         /// </param>
         public void CreateScriptInstance(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
         {
-            TaskInventoryItem item = GetInventoryItem(itemId);
-            if (item != null)
-                CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
+            lock (m_scriptErrors)
+            {
+                // Indicate to CreateScriptInstanceInternal() we don't want it to wait for completion
+                m_scriptErrors.Remove(itemId);
+            }
+            CreateScriptInstanceInternal(itemId, startParam, postOnRez, engine, stateSource);
+        }
+
+        private void CreateScriptInstanceInternal(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
+        {
+            m_items.LockItemsForRead(true);
+            if (m_items.ContainsKey(itemId))
+            {
+                if (m_items.ContainsKey(itemId))
+                {
+                    m_items.LockItemsForRead(false);
+                    CreateScriptInstance(m_items[itemId], startParam, postOnRez, engine, stateSource);
+                }
+                else
+                {
+                    m_items.LockItemsForRead(false);
+                    string msg = String.Format("couldn't be found for prim {0}, {1} at {2} in {3}", m_part.Name, m_part.UUID,
+                        m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
+                    StoreScriptError(itemId, msg);
+                    m_log.ErrorFormat(
+                        "[PRIM INVENTORY]: " +
+                        "Couldn't start script with ID {0} since it {1}", itemId, msg);
+                }
+            }
             else
+            {
+                m_items.LockItemsForRead(false);
+                string msg = String.Format("couldn't be found for prim {0}, {1}", m_part.Name, m_part.UUID);
+                StoreScriptError(itemId, msg);
                 m_log.ErrorFormat(
                     "[PRIM INVENTORY]: " +
-                    "Couldn't start script with ID {0} since it couldn't be found for prim {1}, {2} at {3} in {4}",
-                    itemId, m_part.Name, m_part.UUID, 
-                    m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
+                    "Couldn't start script with ID {0} since it {1}", itemId, msg);
+            }
+            
+        }
+
+        /// <summary>
+        /// Start a script which is in this prim's inventory and return any compilation error messages.
+        /// </summary>
+        /// <param name="itemId">
+        /// A <see cref="UUID"/>
+        /// </param>
+        public ArrayList CreateScriptInstanceEr(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
+        {
+            ArrayList errors;
+
+            // Indicate to CreateScriptInstanceInternal() we want it to 
+            // post any compilation/loading error messages
+            lock (m_scriptErrors)
+            {
+                m_scriptErrors[itemId] = null;
+            }
+
+            // Perform compilation/loading
+            CreateScriptInstanceInternal(itemId, startParam, postOnRez, engine, stateSource);
+
+            // Wait for and retrieve any errors
+            lock (m_scriptErrors)
+            {
+                while ((errors = m_scriptErrors[itemId]) == null)
+                {
+                    if (!System.Threading.Monitor.Wait(m_scriptErrors, 15000))
+                    {
+                        m_log.ErrorFormat(
+                            "[PRIM INVENTORY]: " +
+                            "timedout waiting for script {0} errors", itemId);
+                        errors = m_scriptErrors[itemId];
+                        if (errors == null)
+                        {
+                            errors = new ArrayList(1);
+                            errors.Add("timedout waiting for errors");
+                        }
+                        break;
+                    }
+                }
+                m_scriptErrors.Remove(itemId);
+            }
+            return errors;
+        }
+
+        // Signal to CreateScriptInstanceEr() that compilation/loading is complete
+        private void StoreScriptErrors(UUID itemId, ArrayList errors)
+        {
+            lock (m_scriptErrors)
+            {
+                // If compilation/loading initiated via CreateScriptInstance(),
+                // it does not want the errors, so just get out
+                if (!m_scriptErrors.ContainsKey(itemId))
+                {
+                    return;
+                }
+
+                // Initiated via CreateScriptInstanceEr(), if we know what the
+                // errors are, save them and wake CreateScriptInstanceEr().
+                if (errors != null)
+                {
+                    m_scriptErrors[itemId] = errors;
+                    System.Threading.Monitor.PulseAll(m_scriptErrors);
+                    return;
+                }
+            }
+
+            // Initiated via CreateScriptInstanceEr() but we don't know what
+            // the errors are yet, so retrieve them from the script engine.
+            // This may involve some waiting internal to GetScriptErrors().
+            errors = GetScriptErrors(itemId);
+
+            // Get a default non-null value to indicate success.
+            if (errors == null)
+            {
+                errors = new ArrayList();
+            }
+
+            // Post to CreateScriptInstanceEr() and wake it up
+            lock (m_scriptErrors)
+            {
+                m_scriptErrors[itemId] = errors;
+                System.Threading.Monitor.PulseAll(m_scriptErrors);
+            }
+        }
+
+        // Like StoreScriptErrors(), but just posts a single string message
+        private void StoreScriptError(UUID itemId, string message)
+        {
+            ArrayList errors = new ArrayList(1);
+            errors.Add(message);
+            StoreScriptErrors(itemId, errors);
         }
 
         /// <summary>
@@ -410,15 +602,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </param>
         public void RemoveScriptInstance(UUID itemId, bool sceneObjectBeingDeleted)
         {
-            bool scriptPresent = false;
-
-            lock (m_items)
-            {
-                if (m_items.ContainsKey(itemId))
-                    scriptPresent = true;
-            }
-            
-            if (scriptPresent)
+            if (m_items.ContainsKey(itemId))
             {
                 if (!sceneObjectBeingDeleted)
                     m_part.RemoveScriptEvents(itemId);
@@ -443,14 +627,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         private bool InventoryContainsName(string name)
         {
-            lock (m_items)
+            m_items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (TaskInventoryItem item in m_items.Values)
+                if (item.Name == name)
                 {
-                    if (item.Name == name)
-                        return true;
+                    m_items.LockItemsForRead(false);
+                    return true;
                 }
             }
+            m_items.LockItemsForRead(false);
             return false;
         }
 
@@ -492,8 +678,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="item"></param>
         public void AddInventoryItemExclusive(TaskInventoryItem item, bool allowedDrop)
         {
-            List<TaskInventoryItem> il = GetInventoryItems();
-            
+            m_items.LockItemsForRead(true);
+            List<TaskInventoryItem> il = new List<TaskInventoryItem>(m_items.Values);
+            m_items.LockItemsForRead(false);
             foreach (TaskInventoryItem i in il)
             {
                 if (i.Name == item.Name)
@@ -531,14 +718,14 @@ namespace OpenSim.Region.Framework.Scenes
             item.Name = name;
             item.GroupID = m_part.GroupID;
 
-            lock (m_items)
-                m_items.Add(item.ItemID, item);
-
-            if (allowedDrop) 
-                m_part.TriggerScriptChangedEvent(Changed.ALLOWED_DROP);
-            else
-                m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
-
+            m_items.LockItemsForWrite(true);
+            m_items.Add(item.ItemID, item);
+            m_items.LockItemsForWrite(false);
+                if (allowedDrop) 
+                    m_part.TriggerScriptChangedEvent(Changed.ALLOWED_DROP);
+                else
+                    m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
+            
             m_inventorySerial++;
             //m_inventorySerial += 2;
             HasInventoryChanged = true;
@@ -554,15 +741,15 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="items"></param>
         public void RestoreInventoryItems(ICollection<TaskInventoryItem> items)
         {
-            lock (m_items)
+            m_items.LockItemsForWrite(true);
+            foreach (TaskInventoryItem item in items)
             {
-                foreach (TaskInventoryItem item in items)
-                {
-                    m_items.Add(item.ItemID, item);
-//                    m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
-                }
-                m_inventorySerial++;
+                m_items.Add(item.ItemID, item);
+//                m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
             }
+            m_items.LockItemsForWrite(false);
+
+            m_inventorySerial++;
         }
 
         /// <summary>
@@ -573,10 +760,9 @@ namespace OpenSim.Region.Framework.Scenes
         public TaskInventoryItem GetInventoryItem(UUID itemId)
         {
             TaskInventoryItem item;
-
-            lock (m_items)
-                m_items.TryGetValue(itemId, out item);
-
+            m_items.LockItemsForRead(true);
+            m_items.TryGetValue(itemId, out item);
+            m_items.LockItemsForRead(false);
             return item;
         }
 
@@ -592,15 +778,16 @@ namespace OpenSim.Region.Framework.Scenes
         {
             IList<TaskInventoryItem> items = new List<TaskInventoryItem>();
 
-            lock (m_items)
+            m_items.LockItemsForRead(true);
+
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (TaskInventoryItem item in m_items.Values)
-                {
-                    if (item.Name == name)
-                        items.Add(item);
-                }
+                if (item.Name == name)
+                    items.Add(item);
             }
 
+            m_items.LockItemsForRead(false);
+
             return items;
         }
         
@@ -619,6 +806,9 @@ namespace OpenSim.Region.Framework.Scenes
             string xmlData = Utils.BytesToString(rezAsset.Data);
             SceneObjectGroup group = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
 
+            group.RootPart.AttachPoint = group.RootPart.Shape.State;
+            group.RootPart.AttachOffset = group.AbsolutePosition;
+
             group.ResetIDs();
 
             SceneObjectPart rootPart = group.GetChildPart(group.UUID);
@@ -693,8 +883,9 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool UpdateInventoryItem(TaskInventoryItem item, bool fireScriptEvents, bool considerChanged)
         {
-            TaskInventoryItem it = GetInventoryItem(item.ItemID);
-            if (it != null)
+            m_items.LockItemsForWrite(true);
+
+            if (m_items.ContainsKey(item.ItemID))
             {
 //                m_log.DebugFormat("[PRIM INVENTORY]: Updating item {0} in {1}", item.Name, m_part.Name);
                 
@@ -707,14 +898,10 @@ namespace OpenSim.Region.Framework.Scenes
                     item.GroupID = m_part.GroupID;
 
                 if (item.AssetID == UUID.Zero)
-                    item.AssetID = it.AssetID;
+                    item.AssetID = m_items[item.ItemID].AssetID;
 
-                lock (m_items)
-                {
-                    m_items[item.ItemID] = item;
-                    m_inventorySerial++;
-                }
-                
+                m_items[item.ItemID] = item;
+                m_inventorySerial++;
                 if (fireScriptEvents)
                     m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
                 
@@ -723,7 +910,7 @@ namespace OpenSim.Region.Framework.Scenes
                     HasInventoryChanged = true;
                     m_part.ParentGroup.HasGroupChanged = true;
                 }
-                
+                m_items.LockItemsForWrite(false);
                 return true;
             }
             else
@@ -734,8 +921,9 @@ namespace OpenSim.Region.Framework.Scenes
                     item.ItemID, m_part.Name, m_part.UUID, 
                     m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
             }
-            return false;
+            m_items.LockItemsForWrite(false);
 
+            return false;
         }
 
         /// <summary>
@@ -746,43 +934,59 @@ namespace OpenSim.Region.Framework.Scenes
         /// in this prim's inventory.</returns>
         public int RemoveInventoryItem(UUID itemID)
         {
-            TaskInventoryItem item = GetInventoryItem(itemID);
-            if (item != null)
+            m_items.LockItemsForRead(true);
+
+            if (m_items.ContainsKey(itemID))
             {
                 int type = m_items[itemID].InvType;
+                m_items.LockItemsForRead(false);
                 if (type == 10) // Script
                 {
-                    m_part.RemoveScriptEvents(itemID);
                     m_part.ParentGroup.Scene.EventManager.TriggerRemoveScript(m_part.LocalId, itemID);
                 }
+                m_items.LockItemsForWrite(true);
                 m_items.Remove(itemID);
+                m_items.LockItemsForWrite(false);
                 m_inventorySerial++;
                 m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
 
                 HasInventoryChanged = true;
                 m_part.ParentGroup.HasGroupChanged = true;
 
-                if (!ContainsScripts())
+                int scriptcount = 0;
+                m_items.LockItemsForRead(true);
+                foreach (TaskInventoryItem item in m_items.Values)
+                {
+                    if (item.Type == 10)
+                    {
+                        scriptcount++;
+                    }
+                }
+                m_items.LockItemsForRead(false);
+                
+
+                if (scriptcount <= 0)
+                {
                     m_part.RemFlag(PrimFlags.Scripted);
+                }
 
                 m_part.ScheduleFullUpdate();
 
                 return type;
-                
             }
             else
             {
+                m_items.LockItemsForRead(false);
                 m_log.ErrorFormat(
                     "[PRIM INVENTORY]: " +
-                    "Tried to remove item ID {0} from prim {1}, {2} at {3} in {4} but the item does not exist in this inventory",
-                    itemID, m_part.Name, m_part.UUID,
-                    m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
+                    "Tried to remove item ID {0} from prim {1}, {2} but the item does not exist in this inventory",
+                    itemID, m_part.Name, m_part.UUID);
             }
 
             return -1;
         }
 
-        private bool CreateInventoryFile()
+        private bool CreateInventoryFileName()
         {
 //            m_log.DebugFormat(
 //                "[PRIM INVENTORY]: Creating inventory file for {0} {1} {2}, serial {3}",
@@ -791,116 +995,125 @@ namespace OpenSim.Region.Framework.Scenes
             if (m_inventoryFileName == String.Empty ||
                 m_inventoryFileNameSerial < m_inventorySerial)
             {
-                // Something changed, we need to create a new file
                 m_inventoryFileName = "inventory_" + UUID.Random().ToString() + ".tmp";
                 m_inventoryFileNameSerial = m_inventorySerial;
 
-                InventoryStringBuilder invString = new InventoryStringBuilder(m_part.UUID, UUID.Zero);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Serialize all the metadata for the items in this prim's inventory ready for sending to the client
+        /// </summary>
+        /// <param name="xferManager"></param>
+        public void RequestInventoryFile(IClientAPI client, IXfer xferManager)
+        {
+            bool changed = CreateInventoryFileName();
+
+            bool includeAssets = false;
+            if (m_part.ParentGroup.Scene.Permissions.CanEditObjectInventory(m_part.UUID, client.AgentId))
+                includeAssets = true;
+
+            if (m_inventoryPrivileged != includeAssets)
+                changed = true;
+
+            InventoryStringBuilder invString = new InventoryStringBuilder(m_part.UUID, UUID.Zero);
+
+            Items.LockItemsForRead(true);
+
+            if (m_inventorySerial == 0) // No inventory
+            {
+                client.SendTaskInventory(m_part.UUID, 0, new byte[0]);
+                Items.LockItemsForRead(false);
+                return;
+            }
 
-                lock (m_items)
+                        if (m_items.Count == 0) // No inventory
+                        {
+                                client.SendTaskInventory(m_part.UUID, 0, new byte[0]);
+                Items.LockItemsForRead(false);
+                                return;
+                        }
+    
+            if (!changed)
+            {
+                if (m_inventoryFileData.Length > 2)
                 {
-                    foreach (TaskInventoryItem item in m_items.Values)
-                    {
-//                        m_log.DebugFormat(
-//                            "[PRIM INVENTORY]: Adding item {0} {1} for serial {2} on prim {3} {4} {5}",
-//                            item.Name, item.ItemID, m_inventorySerial, m_part.Name, m_part.UUID, m_part.LocalId);
+                    xferManager.AddNewFile(m_inventoryFileName,
+                            m_inventoryFileData);
+                    client.SendTaskInventory(m_part.UUID, (short)m_inventorySerial,
+                            Util.StringToBytes256(m_inventoryFileName));
 
-                        UUID ownerID = item.OwnerID;
-                        uint everyoneMask = 0;
-                        uint baseMask = item.BasePermissions;
-                        uint ownerMask = item.CurrentPermissions;
-                        uint groupMask = item.GroupPermissions;
+                    Items.LockItemsForRead(false);
+                    return;
+                }
+            }
 
-                        invString.AddItemStart();
-                        invString.AddNameValueLine("item_id", item.ItemID.ToString());
-                        invString.AddNameValueLine("parent_id", m_part.UUID.ToString());
+            m_inventoryPrivileged = includeAssets;
 
-                        invString.AddPermissionsStart();
+            foreach (TaskInventoryItem item in m_items.Values)
+            {
+                UUID ownerID = item.OwnerID;
+                uint everyoneMask = 0;
+                uint baseMask = item.BasePermissions;
+                uint ownerMask = item.CurrentPermissions;
+                uint groupMask = item.GroupPermissions;
 
-                        invString.AddNameValueLine("base_mask", Utils.UIntToHexString(baseMask));
-                        invString.AddNameValueLine("owner_mask", Utils.UIntToHexString(ownerMask));
-                        invString.AddNameValueLine("group_mask", Utils.UIntToHexString(groupMask));
-                        invString.AddNameValueLine("everyone_mask", Utils.UIntToHexString(everyoneMask));
-                        invString.AddNameValueLine("next_owner_mask", Utils.UIntToHexString(item.NextPermissions));
+                invString.AddItemStart();
+                invString.AddNameValueLine("item_id", item.ItemID.ToString());
+                invString.AddNameValueLine("parent_id", m_part.UUID.ToString());
 
-                        invString.AddNameValueLine("creator_id", item.CreatorID.ToString());
-                        invString.AddNameValueLine("owner_id", ownerID.ToString());
+                invString.AddPermissionsStart();
 
-                        invString.AddNameValueLine("last_owner_id", item.LastOwnerID.ToString());
+                invString.AddNameValueLine("base_mask", Utils.UIntToHexString(baseMask));
+                invString.AddNameValueLine("owner_mask", Utils.UIntToHexString(ownerMask));
+                invString.AddNameValueLine("group_mask", Utils.UIntToHexString(groupMask));
+                invString.AddNameValueLine("everyone_mask", Utils.UIntToHexString(everyoneMask));
+                invString.AddNameValueLine("next_owner_mask", Utils.UIntToHexString(item.NextPermissions));
 
-                        invString.AddNameValueLine("group_id", item.GroupID.ToString());
-                        invString.AddSectionEnd();
+                invString.AddNameValueLine("creator_id", item.CreatorID.ToString());
+                invString.AddNameValueLine("owner_id", ownerID.ToString());
 
-                        invString.AddNameValueLine("asset_id", item.AssetID.ToString());
-                        invString.AddNameValueLine("type", Utils.AssetTypeToString((AssetType)item.Type));
-                        invString.AddNameValueLine("inv_type", Utils.InventoryTypeToString((InventoryType)item.InvType));
-                        invString.AddNameValueLine("flags", Utils.UIntToHexString(item.Flags));
+                invString.AddNameValueLine("last_owner_id", item.LastOwnerID.ToString());
 
-                        invString.AddSaleStart();
-                        invString.AddNameValueLine("sale_type", "not");
-                        invString.AddNameValueLine("sale_price", "0");
-                        invString.AddSectionEnd();
+                invString.AddNameValueLine("group_id", item.GroupID.ToString());
+                invString.AddSectionEnd();
 
-                        invString.AddNameValueLine("name", item.Name + "|");
-                        invString.AddNameValueLine("desc", item.Description + "|");
+                if (includeAssets)
+                    invString.AddNameValueLine("asset_id", item.AssetID.ToString());
+                else
+                    invString.AddNameValueLine("asset_id", UUID.Zero.ToString());
+                invString.AddNameValueLine("type", Utils.AssetTypeToString((AssetType)item.Type));
+                invString.AddNameValueLine("inv_type", Utils.InventoryTypeToString((InventoryType)item.InvType));
+                invString.AddNameValueLine("flags", Utils.UIntToHexString(item.Flags));
 
-                        invString.AddNameValueLine("creation_date", item.CreationDate.ToString());
-                        invString.AddSectionEnd();
-                    }
-                }
+                invString.AddSaleStart();
+                invString.AddNameValueLine("sale_type", "not");
+                invString.AddNameValueLine("sale_price", "0");
+                invString.AddSectionEnd();
 
-                m_inventoryFileData = Utils.StringToBytes(invString.BuildString);
+                invString.AddNameValueLine("name", item.Name + "|");
+                invString.AddNameValueLine("desc", item.Description + "|");
 
-                return true;
+                invString.AddNameValueLine("creation_date", item.CreationDate.ToString());
+                invString.AddSectionEnd();
             }
 
-            // No need to recreate, the existing file is fine
-            return false;
-        }
+            Items.LockItemsForRead(false);
 
-        /// <summary>
-        /// Serialize all the metadata for the items in this prim's inventory ready for sending to the client
-        /// </summary>
-        /// <param name="xferManager"></param>
-        public void RequestInventoryFile(IClientAPI client, IXfer xferManager)
-        {
-            lock (m_items)
-            {
-                // Don't send a inventory xfer name if there are no items.  Doing so causes viewer 3 to crash when rezzing
-                // a new script if any previous deletion has left the prim inventory empty.
-                if (m_items.Count == 0) // No inventory
-                {
-//                    m_log.DebugFormat(
-//                        "[PRIM INVENTORY]: Not sending inventory data for part {0} {1} {2} for {3} since no items",
-//                        m_part.Name, m_part.LocalId, m_part.UUID, client.Name);
+            m_inventoryFileData = Utils.StringToBytes(invString.BuildString);
 
-                    client.SendTaskInventory(m_part.UUID, 0, new byte[0]);
-                    return;
-                }
-
-                CreateInventoryFile();
-    
-                // In principle, we should only do the rest if the inventory changed;
-                // by sending m_inventorySerial to the client, it ought to know
-                // that nothing changed and that it doesn't need to request the file. 
-                // Unfortunately, it doesn't look like the client optimizes this; 
-                // the client seems to always come back and request the Xfer, 
-                // no matter what value m_inventorySerial has.
-                // FIXME: Could probably be > 0 here rather than > 2
-                if (m_inventoryFileData.Length > 2)
-                {
-                    // Add the file for Xfer
-    //                m_log.DebugFormat(
-    //                    "[PRIM INVENTORY]: Adding inventory file {0} (length {1}) for transfer on {2} {3} {4}",
-    //                    m_inventoryFileName, m_inventoryFileData.Length, m_part.Name, m_part.UUID, m_part.LocalId);
-                    
-                    xferManager.AddNewFile(m_inventoryFileName, m_inventoryFileData);
-                }
-    
-                // Tell the client we're ready to Xfer the file
-                client.SendTaskInventory(m_part.UUID, (short)m_inventorySerial,
-                        Util.StringToBytes256(m_inventoryFileName));
+            if (m_inventoryFileData.Length > 2)
+            {
+                xferManager.AddNewFile(m_inventoryFileName, m_inventoryFileData);
+                                client.SendTaskInventory(m_part.UUID, (short)m_inventorySerial,
+                                                Util.StringToBytes256(m_inventoryFileName));
+                                return;
             }
+
+                        client.SendTaskInventory(m_part.UUID, 0, new byte[0]);
         }
 
         /// <summary>
@@ -909,13 +1122,19 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="datastore"></param>
         public void ProcessInventoryBackup(ISimulationDataService datastore)
         {
-            if (HasInventoryChanged)
-            {
-                HasInventoryChanged = false;
-                List<TaskInventoryItem> items = GetInventoryItems();
-                datastore.StorePrimInventory(m_part.UUID, items);
+// Removed this because linking will cause an immediate delete of the new
+// child prim from the database and the subsequent storing of the prim sees
+// the inventory of it as unchanged and doesn't store it at all. The overhead
+// of storing prim inventory needlessly is much less than the aggravation
+// of prim inventory loss.
+//            if (HasInventoryChanged)
+//            {
+                Items.LockItemsForRead(true);
+                datastore.StorePrimInventory(m_part.UUID, Items.Values);
+                Items.LockItemsForRead(false);
 
-            }
+                HasInventoryChanged = false;
+//            }
         }
 
         public class InventoryStringBuilder
@@ -981,82 +1200,63 @@ namespace OpenSim.Region.Framework.Scenes
         {
             uint mask=0x7fffffff;
 
-            lock (m_items)
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (TaskInventoryItem item in m_items.Values)
+                if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Copy) == 0)
+                    mask &= ~((uint)PermissionMask.Copy >> 13);
+                if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Transfer) == 0)
+                    mask &= ~((uint)PermissionMask.Transfer >> 13);
+                if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Modify) == 0)
+                    mask &= ~((uint)PermissionMask.Modify >> 13);
+
+                if (item.InvType == (int)InventoryType.Object)
                 {
-                    if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Copy) == 0)
+                    if ((item.CurrentPermissions & ((uint)PermissionMask.Copy >> 13)) == 0)
                         mask &= ~((uint)PermissionMask.Copy >> 13);
-                    if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Transfer) == 0)
+                    if ((item.CurrentPermissions & ((uint)PermissionMask.Transfer >> 13)) == 0)
                         mask &= ~((uint)PermissionMask.Transfer >> 13);
-                    if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Modify) == 0)
+                    if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
                         mask &= ~((uint)PermissionMask.Modify >> 13);
-
-                    if (item.InvType != (int)InventoryType.Object)
-                    {
-                        if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Copy) == 0)
-                            mask &= ~((uint)PermissionMask.Copy >> 13);
-                        if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Transfer) == 0)
-                            mask &= ~((uint)PermissionMask.Transfer >> 13);
-                        if ((item.CurrentPermissions & item.NextPermissions & (uint)PermissionMask.Modify) == 0)
-                            mask &= ~((uint)PermissionMask.Modify >> 13);
-                    }
-                    else
-                    {
-                        if ((item.CurrentPermissions & ((uint)PermissionMask.Copy >> 13)) == 0)
-                            mask &= ~((uint)PermissionMask.Copy >> 13);
-                        if ((item.CurrentPermissions & ((uint)PermissionMask.Transfer >> 13)) == 0)
-                            mask &= ~((uint)PermissionMask.Transfer >> 13);
-                        if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
-                            mask &= ~((uint)PermissionMask.Modify >> 13);
-                    }
-    
-                    if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
-                        mask &= ~(uint)PermissionMask.Copy;
-                    if ((item.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
-                        mask &= ~(uint)PermissionMask.Transfer;
-                    if ((item.CurrentPermissions & (uint)PermissionMask.Modify) == 0)
-                        mask &= ~(uint)PermissionMask.Modify;
                 }
+
+                if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
+                    mask &= ~(uint)PermissionMask.Copy;
+                if ((item.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
+                    mask &= ~(uint)PermissionMask.Transfer;
+                if ((item.CurrentPermissions & (uint)PermissionMask.Modify) == 0)
+                    mask &= ~(uint)PermissionMask.Modify;
             }
-                
             return mask;
         }
 
         public void ApplyNextOwnerPermissions()
         {
-            lock (m_items)
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (TaskInventoryItem item in m_items.Values)
+                if (item.InvType == (int)InventoryType.Object && (item.CurrentPermissions & 7) != 0)
                 {
-                    if (item.InvType == (int)InventoryType.Object && (item.CurrentPermissions & 7) != 0)
-                    {
-                        if ((item.CurrentPermissions & ((uint)PermissionMask.Copy >> 13)) == 0)
-                            item.CurrentPermissions &= ~(uint)PermissionMask.Copy;
-                        if ((item.CurrentPermissions & ((uint)PermissionMask.Transfer >> 13)) == 0)
-                            item.CurrentPermissions &= ~(uint)PermissionMask.Transfer;
-                        if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
-                            item.CurrentPermissions &= ~(uint)PermissionMask.Modify;
-                    }
-                    item.CurrentPermissions &= item.NextPermissions;
-                    item.BasePermissions &= item.NextPermissions;
-                    item.EveryonePermissions &= item.NextPermissions;
-                    item.OwnerChanged = true;
-                    item.PermsMask = 0;
-                    item.PermsGranter = UUID.Zero;
+                    if ((item.CurrentPermissions & ((uint)PermissionMask.Copy >> 13)) == 0)
+                        item.CurrentPermissions &= ~(uint)PermissionMask.Copy;
+                    if ((item.CurrentPermissions & ((uint)PermissionMask.Transfer >> 13)) == 0)
+                        item.CurrentPermissions &= ~(uint)PermissionMask.Transfer;
+                    if ((item.CurrentPermissions & ((uint)PermissionMask.Modify >> 13)) == 0)
+                        item.CurrentPermissions &= ~(uint)PermissionMask.Modify;
                 }
+                item.OwnerChanged = true;
+                item.CurrentPermissions &= item.NextPermissions;
+                item.BasePermissions &= item.NextPermissions;
+                item.EveryonePermissions &= item.NextPermissions;
+                item.PermsMask = 0;
+                item.PermsGranter = UUID.Zero;
             }
         }
 
         public void ApplyGodPermissions(uint perms)
         {
-            lock (m_items)
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (TaskInventoryItem item in m_items.Values)
-                {
-                    item.CurrentPermissions = perms;
-                    item.BasePermissions = perms;
-                }
+                item.CurrentPermissions = perms;
+                item.BasePermissions = perms;
             }
             
             m_inventorySerial++;
@@ -1069,17 +1269,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public bool ContainsScripts()
         {
-            lock (m_items)
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (TaskInventoryItem item in m_items.Values)
+                if (item.InvType == (int)InventoryType.LSL)
                 {
-                    if (item.InvType == (int)InventoryType.LSL)
-                    {
-                        return true;
-                    }
+                    return true;
                 }
             }
-            
             return false;
         }
 
@@ -1087,11 +1283,8 @@ namespace OpenSim.Region.Framework.Scenes
         {
             List<UUID> ret = new List<UUID>();
 
-            lock (m_items)
-            {
-                foreach (TaskInventoryItem item in m_items.Values)
-                    ret.Add(item.ItemID);
-            }
+            foreach (TaskInventoryItem item in m_items.Values)
+                ret.Add(item.ItemID);
 
             return ret;
         }
@@ -1122,6 +1315,11 @@ namespace OpenSim.Region.Framework.Scenes
         
         public Dictionary<UUID, string> GetScriptStates()
         {
+            return GetScriptStates(false);
+        }
+
+        public Dictionary<UUID, string> GetScriptStates(bool oldIDs)
+        {
             Dictionary<UUID, string> ret = new Dictionary<UUID, string>();            
             
             if (m_part.ParentGroup.Scene == null) // Group not in a scene
@@ -1132,25 +1330,35 @@ namespace OpenSim.Region.Framework.Scenes
             if (engines.Length == 0) // No engine at all
                 return ret;
 
-            List<TaskInventoryItem> scripts = GetInventoryScripts();
-
-            foreach (TaskInventoryItem item in scripts)
+            Items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (IScriptModule e in engines)
+                if (item.InvType == (int)InventoryType.LSL)
                 {
-                    if (e != null)
+                    foreach (IScriptModule e in engines)
                     {
-                        string n = e.GetXMLState(item.ItemID);
-                        if (n != String.Empty)
+                        if (e != null)
                         {
-                            if (!ret.ContainsKey(item.ItemID))
-                                ret[item.ItemID] = n;
-                            break;
+                            string n = e.GetXMLState(item.ItemID);
+                            if (n != String.Empty)
+                            {
+                                if (oldIDs)
+                                {
+                                    if (!ret.ContainsKey(item.OldItemID))
+                                        ret[item.OldItemID] = n;
+                                }
+                                else
+                                {
+                                    if (!ret.ContainsKey(item.ItemID))
+                                        ret[item.ItemID] = n;
+                                }
+                                break;
+                            }
                         }
                     }
                 }
             }
-            
+            Items.LockItemsForRead(false);
             return ret;
         }
         
@@ -1160,21 +1368,27 @@ namespace OpenSim.Region.Framework.Scenes
             if (engines.Length == 0)
                 return;
 
-            List<TaskInventoryItem> scripts = GetInventoryScripts();
 
-            foreach (TaskInventoryItem item in scripts)
+            Items.LockItemsForRead(true);
+
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (IScriptModule engine in engines)
+                if (item.InvType == (int)InventoryType.LSL)
                 {
-                    if (engine != null)
+                    foreach (IScriptModule engine in engines)
                     {
-                        if (item.OwnerChanged)
-                            engine.PostScriptEvent(item.ItemID, "changed", new Object[] { (int)Changed.OWNER });
-                        item.OwnerChanged = false;
-                        engine.ResumeScript(item.ItemID);
+                        if (engine != null)
+                        {
+                            if (item.OwnerChanged)
+                                engine.PostScriptEvent(item.ItemID, "changed", new Object[] { (int)Changed.OWNER });
+                            item.OwnerChanged = false;
+                            engine.ResumeScript(item.ItemID);
+                        }
                     }
                 }
             }
+
+            Items.LockItemsForRead(false);
         }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 8a49f2c..635bca7 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -167,6 +167,7 @@ namespace OpenSim.Region.Framework.Scenes
 //        private int m_lastColCount = -1;              //KF: Look for Collision chnages
 //        private int m_updateCount = 0;                        //KF: Update Anims for a while
 //        private static readonly int UPDATE_COUNT = 10;                // how many frames to update for
+        private List<uint> m_lastColliders = new List<uint>();
 
         private TeleportFlags m_teleportFlags;
         public TeleportFlags TeleportFlags
@@ -228,6 +229,9 @@ namespace OpenSim.Region.Framework.Scenes
         //private int m_moveToPositionStateStatus;
         //*****************************************************
 
+        private bool m_collisionEventFlag = false;
+        private object m_collisionEventLock = new Object();
+
         protected AvatarAppearance m_appearance;
 
         public AvatarAppearance Appearance
@@ -1836,6 +1840,7 @@ namespace OpenSim.Region.Framework.Scenes
                     if (part.SitTargetAvatar == UUID)
                         part.SitTargetAvatar = UUID.Zero;
 
+                    part.ParentGroup.DeleteAvatar(UUID);
                     ParentPosition = part.GetWorldPosition();
                     ControllingClient.SendClearFollowCamProperties(part.ParentUUID);
                 }
@@ -1974,7 +1979,7 @@ namespace OpenSim.Region.Framework.Scenes
                 forceMouselook = part.GetForceMouselook();
 
                 ControllingClient.SendSitResponse(
-                    targetID, offset, sitOrientation, false, cameraAtOffset, cameraEyeOffset, forceMouselook);
+                    part.UUID, offset, sitOrientation, false, cameraAtOffset, cameraEyeOffset, forceMouselook);
 
                 m_requestedSitTargetUUID = targetID;
 
@@ -2259,11 +2264,13 @@ namespace OpenSim.Region.Framework.Scenes
                     m_pos = sitTargetPos + SIT_TARGET_ADJUSTMENT;
                     Rotation = sitTargetOrient;
                     ParentPosition = part.AbsolutePosition;
+                    part.ParentGroup.AddAvatar(UUID);
                 }
                 else
                 {
                     m_pos -= part.AbsolutePosition;
                     ParentPosition = part.AbsolutePosition;
+                    part.ParentGroup.AddAvatar(UUID);
 
 //                        m_log.DebugFormat(
 //                            "[SCENE PRESENCE]: Sitting {0} at position {1} ({2} + {3}) on part {4} {5} without sit target",
@@ -3369,6 +3376,8 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
 
+            RaiseCollisionScriptEvents(coldata);
+
             if (Invulnerable)
                 return;
             
@@ -3879,9 +3888,171 @@ namespace OpenSim.Region.Framework.Scenes
                         pos = land.LandData.UserLocation;
                     }
                 }
-
+                
                 land.SendLandUpdateToClient(ControllingClient);
             }
         }
+
+        private void RaiseCollisionScriptEvents(Dictionary<uint, ContactPoint> coldata)
+        {
+            lock(m_collisionEventLock)
+            {
+                if (m_collisionEventFlag)
+                    return;
+                m_collisionEventFlag = true;
+            }
+
+            Util.FireAndForget(delegate(object x)
+            {
+                try
+                {
+                    List<uint> thisHitColliders = new List<uint>();
+                    List<uint> endedColliders = new List<uint>();
+                    List<uint> startedColliders = new List<uint>();
+
+                    foreach (uint localid in coldata.Keys)
+                    {
+                        thisHitColliders.Add(localid);
+                        if (!m_lastColliders.Contains(localid))
+                        {
+                            startedColliders.Add(localid);
+                        }
+                        //m_log.Debug("[SCENE PRESENCE]: Collided with:" + localid.ToString() + " at depth of: " + collissionswith[localid].ToString());
+                    }
+                    
+                    // calculate things that ended colliding
+                    foreach (uint localID in m_lastColliders)
+                    {
+                        if (!thisHitColliders.Contains(localID))
+                        {
+                            endedColliders.Add(localID);
+                        }
+                    }
+                    //add the items that started colliding this time to the last colliders list.
+                    foreach (uint localID in startedColliders)
+                    {
+                        m_lastColliders.Add(localID);
+                    }
+                    // remove things that ended colliding from the last colliders list
+                    foreach (uint localID in endedColliders)
+                    {
+                        m_lastColliders.Remove(localID);
+                    }
+
+                    // do event notification
+                    if (startedColliders.Count > 0)
+                    {
+                        ColliderArgs StartCollidingMessage = new ColliderArgs();
+                        List<DetectedObject> colliding = new List<DetectedObject>();
+                        foreach (uint localId in startedColliders)
+                        {
+                            if (localId == 0)
+                                continue;
+
+                            SceneObjectPart obj = Scene.GetSceneObjectPart(localId);
+                            string data = "";
+                            if (obj != null)
+                            {
+                                DetectedObject detobj = new DetectedObject();
+                                detobj.keyUUID = obj.UUID;
+                                detobj.nameStr = obj.Name;
+                                detobj.ownerUUID = obj.OwnerID;
+                                detobj.posVector = obj.AbsolutePosition;
+                                detobj.rotQuat = obj.GetWorldRotation();
+                                detobj.velVector = obj.Velocity;
+                                detobj.colliderType = 0;
+                                detobj.groupUUID = obj.GroupID;
+                                colliding.Add(detobj);
+                            }
+                        }
+
+                        if (colliding.Count > 0)
+                        {
+                            StartCollidingMessage.Colliders = colliding;
+
+                            foreach (SceneObjectGroup att in GetAttachments())
+                                Scene.EventManager.TriggerScriptCollidingStart(att.LocalId, StartCollidingMessage);
+                        }
+                    }
+
+                    if (endedColliders.Count > 0)
+                    {
+                        ColliderArgs EndCollidingMessage = new ColliderArgs();
+                        List<DetectedObject> colliding = new List<DetectedObject>();
+                        foreach (uint localId in endedColliders)
+                        {
+                            if (localId == 0)
+                                continue;
+
+                            SceneObjectPart obj = Scene.GetSceneObjectPart(localId);
+                            string data = "";
+                            if (obj != null)
+                            {
+                                DetectedObject detobj = new DetectedObject();
+                                detobj.keyUUID = obj.UUID;
+                                detobj.nameStr = obj.Name;
+                                detobj.ownerUUID = obj.OwnerID;
+                                detobj.posVector = obj.AbsolutePosition;
+                                detobj.rotQuat = obj.GetWorldRotation();
+                                detobj.velVector = obj.Velocity;
+                                detobj.colliderType = 0;
+                                detobj.groupUUID = obj.GroupID;
+                                colliding.Add(detobj);
+                            }
+                        }
+
+                        if (colliding.Count > 0)
+                        {
+                            EndCollidingMessage.Colliders = colliding;
+
+                            foreach (SceneObjectGroup att in GetAttachments())
+                                Scene.EventManager.TriggerScriptCollidingEnd(att.LocalId, EndCollidingMessage);
+                        }
+                    }
+
+                    if (thisHitColliders.Count > 0)
+                    {
+                        ColliderArgs CollidingMessage = new ColliderArgs();
+                        List<DetectedObject> colliding = new List<DetectedObject>();
+                        foreach (uint localId in thisHitColliders)
+                        {
+                            if (localId == 0)
+                                continue;
+
+                            SceneObjectPart obj = Scene.GetSceneObjectPart(localId);
+                            string data = "";
+                            if (obj != null)
+                            {
+                                DetectedObject detobj = new DetectedObject();
+                                detobj.keyUUID = obj.UUID;
+                                detobj.nameStr = obj.Name;
+                                detobj.ownerUUID = obj.OwnerID;
+                                detobj.posVector = obj.AbsolutePosition;
+                                detobj.rotQuat = obj.GetWorldRotation();
+                                detobj.velVector = obj.Velocity;
+                                detobj.colliderType = 0;
+                                detobj.groupUUID = obj.GroupID;
+                                colliding.Add(detobj);
+                            }
+                        }
+
+                        if (colliding.Count > 0)
+                        {
+                            CollidingMessage.Colliders = colliding;
+
+                            lock (m_attachments)
+                            {
+                                foreach (SceneObjectGroup att in m_attachments)
+                                    Scene.EventManager.TriggerScriptColliding(att.LocalId, CollidingMessage);
+                            }
+                        }
+                    }
+                }
+                finally
+                {
+                    m_collisionEventFlag = false;
+                }
+            });
+        }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index bca49f7..3f24991 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -345,6 +345,9 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             m_SOPXmlProcessors.Add("PayPrice2", ProcessPayPrice2);
             m_SOPXmlProcessors.Add("PayPrice3", ProcessPayPrice3);
             m_SOPXmlProcessors.Add("PayPrice4", ProcessPayPrice4);
+
+            m_SOPXmlProcessors.Add("Buoyancy", ProcessBuoyancy);
+            m_SOPXmlProcessors.Add("VolumeDetectActive", ProcessVolumeDetectActive);
             #endregion
 
             #region TaskInventoryXmlProcessors initialization
@@ -729,6 +732,16 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             obj.PayPrice[4] = (int)reader.ReadElementContentAsInt("PayPrice4", String.Empty);
         }
 
+        private static void ProcessBuoyancy(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Buoyancy = (int)reader.ReadElementContentAsFloat("Buoyancy", String.Empty);
+        }
+
+        private static void ProcessVolumeDetectActive(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.VolumeDetectActive = Util.ReadBoolean(reader);
+        }
+
         #endregion
 
         #region TaskInventoryXmlProcessors
@@ -1212,6 +1225,9 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             writer.WriteElementString("PayPrice3", sop.PayPrice[3].ToString());
             writer.WriteElementString("PayPrice4", sop.PayPrice[4].ToString());
 
+            writer.WriteElementString("Buoyancy", sop.Buoyancy.ToString());
+            writer.WriteElementString("VolumeDetectActive", sop.VolumeDetectActive.ToString().ToLower());
+
             writer.WriteEndElement();
         }
 
@@ -1496,12 +1512,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         {
             TaskInventoryDictionary tinv = new TaskInventoryDictionary();
 
-            if (reader.IsEmptyElement)
-            {
-                reader.Read();
-                return tinv;
-            }
-
             reader.ReadStartElement(name, String.Empty);
 
             while (reader.Name == "TaskInventoryItem")
@@ -1544,12 +1554,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
             PrimitiveBaseShape shape = new PrimitiveBaseShape();
 
-            if (reader.IsEmptyElement)
-            {
-                reader.Read();
-                return shape;
-            }
-
             reader.ReadStartElement(name, String.Empty); // Shape
 
             string nodeName = string.Empty;
diff --git a/OpenSim/Region/Framework/Scenes/UndoState.cs b/OpenSim/Region/Framework/Scenes/UndoState.cs
index 860172c..5ed3c79 100644
--- a/OpenSim/Region/Framework/Scenes/UndoState.cs
+++ b/OpenSim/Region/Framework/Scenes/UndoState.cs
@@ -30,12 +30,27 @@ using System.Reflection;
 using log4net;
 using OpenMetaverse;
 using OpenSim.Region.Framework.Interfaces;
+using System;
 
 namespace OpenSim.Region.Framework.Scenes
 {
+    [Flags]
+    public enum UndoType
+    {
+        STATE_PRIM_POSITION = 1,
+        STATE_PRIM_ROTATION = 2,
+        STATE_PRIM_SCALE = 4,
+        STATE_PRIM_ALL = 7,
+        STATE_GROUP_POSITION = 8,
+        STATE_GROUP_ROTATION = 16,
+        STATE_GROUP_SCALE = 32,
+        STATE_GROUP_ALL = 56,
+        STATE_ALL = 63       
+    }
+
     public class UndoState
     {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         public Vector3 Position = Vector3.Zero;
         public Vector3 Scale = Vector3.Zero;
@@ -57,37 +72,37 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 ForGroup = forGroup;
 
-//                    if (ForGroup)
-                    Position = part.ParentGroup.AbsolutePosition;
-//                    else
-//                        Position = part.OffsetPosition;
+                //                    if (ForGroup)
+                Position = part.ParentGroup.AbsolutePosition;
+                //                    else
+                //                        Position = part.OffsetPosition;
 
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Storing undo position {0} for root part", Position);
+                //                    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);
+                //                    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);
+                //                    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);
+                //                    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);
+                //                    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);
+                //                    m_log.DebugFormat(
+                //                        "[UNDO STATE]: Storing undo scale {0} for child part", Scale);
             }
         }
 
@@ -121,9 +136,9 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (part.ParentID == 0)
             {
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Undoing position to {0} for root part {1} {2}",
-//                        Position, part.Name, part.LocalId);
+                //                    m_log.DebugFormat(
+                //                        "[UNDO STATE]: Undoing position to {0} for root part {1} {2}",
+                //                        Position, part.Name, part.LocalId);
 
                 if (Position != Vector3.Zero)
                 {
@@ -133,9 +148,9 @@ namespace OpenSim.Region.Framework.Scenes
                         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);
+                //                    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);
@@ -144,9 +159,9 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (Scale != Vector3.Zero)
                 {
-//                        m_log.DebugFormat(
-//                            "[UNDO STATE]: Undoing scale {0} to {1} for root part {2} {3}",
-//                            part.Shape.Scale, Scale, part.Name, part.LocalId);
+                    //                        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);
@@ -161,24 +176,24 @@ namespace OpenSim.Region.Framework.Scenes
                 // Note: Updating these properties on sop automatically schedules an update if needed
                 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);
+                    //                        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);
+                //                    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);
+                    //                        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);
                 }
@@ -247,4 +262,4 @@ namespace OpenSim.Region.Framework.Scenes
             m_terrainModule.UndoTerrain(m_terrainChannel);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
index efb68a2..411e421 100644
--- a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
+++ b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
@@ -87,10 +87,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="assetUuids">The assets gathered</param>
         public void GatherAssetUuids(UUID assetUuid, AssetType assetType, IDictionary<UUID, AssetType> assetUuids)
         {
-            // avoid infinite loops
-            if (assetUuids.ContainsKey(assetUuid))
-                return;
-
             try
             {               
                 assetUuids[assetUuid] = assetType;