27 files changed, 6322 insertions, 2309 deletions

diff --git a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
index 3b5a5bd..5529a25 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
@@ -80,12 +80,13 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             m_scenePresence = sp;
             CurrentMovementAnimation = "CROUCH";
         }
-        
+
         public void AddAnimation(UUID animID, UUID objectID)
         {
             if (m_scenePresence.IsChildAgent)
                 return;
 
+            //            m_log.DebugFormat("[SCENE PRESENCE ANIMATOR]: Adding animation {0} for {1}", animID, m_scenePresence.Name);
             if (m_scenePresence.Scene.DebugAnimations)
                 m_log.DebugFormat(
                     "[SCENE PRESENCE ANIMATOR]: Adding animation {0} {1} for {2}", 
@@ -140,6 +141,22 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             }
         }
 
+        public void avnChangeAnim(UUID animID, bool addRemove, bool sendPack)
+        {
+            if (m_scenePresence.IsChildAgent)
+                return;
+
+            if (animID != UUID.Zero)
+            {
+                if (addRemove)
+                    m_animations.Add(animID, m_scenePresence.ControllingClient.NextAnimationSequenceNumber, UUID.Zero);
+                else
+                    m_animations.Remove(animID, true);
+            }
+            if(sendPack)
+                SendAnimPack();
+        }
+
         // Called from scripts
         public void RemoveAnimation(string name)
         {
diff --git a/OpenSim/Region/Framework/Scenes/CollisionSounds.cs b/OpenSim/Region/Framework/Scenes/CollisionSounds.cs
new file mode 100644
index 0000000..075724e
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/CollisionSounds.cs
@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+// Ubit 2012
+
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+using OpenMetaverse;
+using OpenSim.Framework;
+using log4net;
+
+namespace OpenSim.Region.Framework.Scenes
+{
+    public struct CollisionForSoundInfo
+    {
+        public uint colliderID;
+        public Vector3 position;
+        public float relativeVel;
+    }
+
+    public static class CollisionSounds
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private const int MaxMaterials = 7;
+        // part part
+
+        private static UUID snd_StoneStone = new UUID("be7295c0-a158-11e1-b3dd-0800200c9a66");
+        private static UUID snd_StoneMetal = new UUID("be7295c0-a158-11e1-b3dd-0800201c9a66");
+        private static UUID snd_StoneGlass = new UUID("be7295c0-a158-11e1-b3dd-0800202c9a66");
+        private static UUID snd_StoneWood = new UUID("be7295c0-a158-11e1-b3dd-0800203c9a66");
+        private static UUID snd_StoneFlesh = new UUID("be7295c0-a158-11e1-b3dd-0800204c9a66");
+        private static UUID snd_StonePlastic = new UUID("be7295c0-a158-11e1-b3dd-0800205c9a66");
+        private static UUID snd_StoneRubber = new UUID("be7295c0-a158-11e1-b3dd-0800206c9a66");
+
+        private static UUID snd_MetalMetal = new UUID("be7295c0-a158-11e1-b3dd-0801201c9a66");
+        private static UUID snd_MetalGlass = new UUID("be7295c0-a158-11e1-b3dd-0801202c9a66");
+        private static UUID snd_MetalWood  = new UUID("be7295c0-a158-11e1-b3dd-0801203c9a66");
+        private static UUID snd_MetalFlesh = new UUID("be7295c0-a158-11e1-b3dd-0801204c9a66");
+        private static UUID snd_MetalPlastic = new UUID("be7295c0-a158-11e1-b3dd-0801205c9a66");
+        private static UUID snd_MetalRubber = new UUID("be7295c0-a158-11e1-b3dd-0801206c9a66");
+
+        private static UUID snd_GlassGlass = new UUID("be7295c0-a158-11e1-b3dd-0802202c9a66");
+        private static UUID snd_GlassWood = new UUID("be7295c0-a158-11e1-b3dd-0802203c9a66");
+        private static UUID snd_GlassFlesh = new UUID("be7295c0-a158-11e1-b3dd-0802204c9a66");
+        private static UUID snd_GlassPlastic = new UUID("be7295c0-a158-11e1-b3dd-0802205c9a66");
+        private static UUID snd_GlassRubber = new UUID("be7295c0-a158-11e1-b3dd-0802206c9a66");
+
+        private static UUID snd_WoodWood = new UUID("be7295c0-a158-11e1-b3dd-0803203c9a66");
+        private static UUID snd_WoodFlesh = new UUID("be7295c0-a158-11e1-b3dd-0803204c9a66");
+        private static UUID snd_WoodPlastic = new UUID("be7295c0-a158-11e1-b3dd-0803205c9a66");
+        private static UUID snd_WoodRubber = new UUID("be7295c0-a158-11e1-b3dd-0803206c9a66");
+
+        private static UUID snd_FleshFlesh = new UUID("be7295c0-a158-11e1-b3dd-0804204c9a66");
+        private static UUID snd_FleshPlastic = new UUID("be7295c0-a158-11e1-b3dd-0804205c9a66");
+        private static UUID snd_FleshRubber = new UUID("be7295c0-a158-11e1-b3dd-0804206c9a66");
+
+        private static UUID snd_PlasticPlastic = new UUID("be7295c0-a158-11e1-b3dd-0805205c9a66");
+        private static UUID snd_PlasticRubber = new UUID("be7295c0-a158-11e1-b3dd-0805206c9a66");
+
+        private static UUID snd_RubberRubber = new UUID("be7295c0-a158-11e1-b3dd-0806206c9a66");
+
+        // terrain part
+        private static UUID snd_TerrainStone = new UUID("be7295c0-a158-11e1-b3dd-0807200c9a66");
+        private static UUID snd_TerrainMetal = new UUID("be7295c0-a158-11e1-b3dd-0807200c9a66");
+        private static UUID snd_TerrainGlass = new UUID("be7295c0-a158-11e1-b3dd-0807200c9a66");
+        private static UUID snd_TerrainWood = new UUID("be7295c0-a158-11e1-b3dd-0807200c9a66");
+        private static UUID snd_TerrainFlesh = new UUID("be7295c0-a158-11e1-b3dd-0807200c9a66");
+        private static UUID snd_TerrainPlastic = new UUID("be7295c0-a158-11e1-b3dd-0807200c9a66");
+        private static UUID snd_TerrainRubber = new UUID("be7295c0-a158-11e1-b3dd-0807200c9a66");
+
+        public static UUID[] m_TerrainPart = {
+            snd_TerrainStone,
+            snd_TerrainMetal,
+            snd_TerrainGlass,
+            snd_TerrainWood,
+            snd_TerrainFlesh,
+            snd_TerrainPlastic,
+            snd_TerrainRubber
+            };
+
+        // simetric sounds
+        public static UUID[] m_PartPart = {
+            snd_StoneStone, snd_StoneMetal, snd_StoneGlass, snd_StoneWood, snd_StoneFlesh, snd_StonePlastic, snd_StoneRubber,
+            snd_StoneMetal, snd_MetalMetal, snd_MetalGlass, snd_MetalWood, snd_MetalFlesh, snd_MetalPlastic, snd_MetalRubber,
+            snd_StoneGlass, snd_MetalGlass, snd_GlassGlass, snd_GlassWood, snd_GlassFlesh, snd_GlassPlastic, snd_GlassRubber,
+            snd_StoneWood, snd_MetalWood, snd_GlassWood, snd_WoodWood, snd_WoodFlesh, snd_WoodPlastic, snd_WoodRubber,
+            snd_StoneFlesh, snd_MetalFlesh, snd_GlassFlesh, snd_WoodFlesh, snd_FleshFlesh, snd_FleshPlastic, snd_FleshRubber,
+            snd_StonePlastic, snd_MetalPlastic, snd_GlassPlastic, snd_WoodPlastic, snd_FleshPlastic, snd_PlasticPlastic, snd_PlasticRubber,
+            snd_StoneRubber, snd_MetalRubber, snd_GlassRubber, snd_WoodRubber, snd_FleshRubber, snd_PlasticRubber, snd_RubberRubber
+            };
+        
+        public static void PartCollisionSound(SceneObjectPart part, List<CollisionForSoundInfo> collidersinfolist)
+        {
+            if (collidersinfolist.Count == 0 || part == null)
+                return;
+
+            if (part.VolumeDetectActive || (part.Flags & PrimFlags.Physics) == 0)
+                return;
+
+            if (part.ParentGroup == null)
+                return;
+
+            if (part.CollisionSoundType < 0)
+                return;
+
+            float volume = 0.0f;
+            bool HaveSound = false;
+
+            UUID soundID = part.CollisionSound;
+
+            if (part.CollisionSoundType > 0)
+            {
+                //                soundID = part.CollisionSound;
+                volume = part.CollisionSoundVolume;
+                if (volume == 0.0f)
+                    return;
+                HaveSound = true;
+            }
+
+            bool doneownsound = false;
+
+            int thisMaterial = (int)part.Material;
+            if (thisMaterial >= MaxMaterials)
+                thisMaterial = 3;
+            int thisMatScaled = thisMaterial * MaxMaterials;
+
+            CollisionForSoundInfo colInfo;
+            uint id;
+
+            for(int i = 0; i< collidersinfolist.Count; i++)
+            {
+                colInfo = collidersinfolist[i];
+
+                id = colInfo.colliderID;
+                if (id == 0) // terrain collision
+                    {
+                        if (!doneownsound)
+                        {
+                            if (!HaveSound)
+                            {
+                                volume = Math.Abs(colInfo.relativeVel);
+                                if (volume < 0.2f)
+                                    continue;
+
+                                volume *= volume * .0625f; // 4m/s == full volume
+                                if (volume > 1.0f)
+                                    volume = 1.0f;
+
+                                soundID = m_TerrainPart[thisMaterial];
+                            }
+                            part.SendCollisionSound(soundID, volume, colInfo.position);
+                            doneownsound = true;
+                        }
+                        continue;
+                    }
+
+                SceneObjectPart otherPart = part.ParentGroup.Scene.GetSceneObjectPart(id);
+                if (otherPart != null)
+                {
+                    if (otherPart.CollisionSoundType < 0 || otherPart.VolumeDetectActive)
+                        continue;
+
+                    if (!HaveSound)
+                    {
+                        if (otherPart.CollisionSoundType > 0)
+                        {
+                            soundID = otherPart.CollisionSound;
+                            volume = otherPart.CollisionSoundVolume;
+                            if (volume == 0.0f)
+                                continue;
+                        }
+                        else
+                        {
+                            volume = Math.Abs(colInfo.relativeVel);
+                            if (volume < 0.2f)
+                                continue;
+
+                            volume *= volume * .0625f; // 4m/s == full volume
+                            if (volume > 1.0f)
+                                volume = 1.0f;
+
+                            int otherMaterial = (int)otherPart.Material;
+                            if (otherMaterial >= MaxMaterials)
+                                otherMaterial = 3;
+
+                            soundID = m_PartPart[thisMatScaled + otherMaterial];
+                        }
+                    }
+
+                    if (doneownsound)
+                        otherPart.SendCollisionSound(soundID, volume, colInfo.position);
+                    else
+                    {
+                        part.SendCollisionSound(soundID, volume, colInfo.position);
+                        doneownsound = true;
+                    }
+                }
+            }
+        }
+
+        public static void AvatarCollisionSound(ScenePresence av, List<CollisionForSoundInfo> collidersinfolist)
+         {
+            if (collidersinfolist.Count == 0 || av == null)
+                return;
+
+            UUID soundID;
+            int otherMaterial;
+
+            int thisMaterial = 4; // flesh
+
+            int thisMatScaled = thisMaterial * MaxMaterials;
+
+            //            bool doneownsound = false;
+
+            CollisionForSoundInfo colInfo;
+            uint id;
+            float volume;
+
+            for(int i = 0; i< collidersinfolist.Count; i++)
+            {
+                colInfo = collidersinfolist[i];
+
+                id = colInfo.colliderID;
+
+                if (id == 0) // no terrain collision sounds for now
+                {
+                    continue;
+//                    volume = Math.Abs(colInfo.relativeVel);
+//                    if (volume < 0.2f)
+//                        continue;
+
+                }
+
+                SceneObjectPart otherPart = av.Scene.GetSceneObjectPart(id);
+                if (otherPart != null)
+                {
+                    if (otherPart.CollisionSoundType < 0)
+                        continue;
+                    if (otherPart.CollisionSoundType > 0 && otherPart.CollisionSoundVolume > 0f)
+                        otherPart.SendCollisionSound(otherPart.CollisionSound, otherPart.CollisionSoundVolume, colInfo.position);
+                    else
+                    {
+                        volume = Math.Abs(colInfo.relativeVel);
+                        // Most noral collisions (running into walls, stairs)
+                        // should never be heard.
+                        if (volume < 3.2f)
+                            continue;
+//                        m_log.DebugFormat("Collision speed was {0}", volume);
+
+                        // Cap to 0.2 times volume because climbing stairs should not be noisy
+                        // Also changed scaling
+                        volume *= volume * .0125f; // 4m/s == volume 0.2
+                        if (volume > 0.2f)
+                            volume = 0.2f;
+                        otherMaterial = (int)otherPart.Material;
+                        if (otherMaterial >= MaxMaterials)
+                            otherMaterial = 3;
+
+                        soundID = m_PartPart[thisMatScaled + otherMaterial];
+                        otherPart.SendCollisionSound(soundID, volume, colInfo.position);
+                    }
+                    continue;
+                }
+/*
+                else if (!doneownsound)
+                {
+                    ScenePresence otherav = av.Scene.GetScenePresence(Id);
+                    if (otherav != null && (!otherav.IsChildAgent))
+                    {
+                        soundID = snd_FleshFlesh;
+                        av.SendCollisionSound(soundID, 1.0);
+                        doneownsound = true;
+                    }
+                }
+ */
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 61b0ebd..1018b54 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -90,6 +90,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// </remarks>
         public event OnTerrainTickDelegate OnTerrainTick;
 
+        public delegate void OnTerrainUpdateDelegate();
+
+        public event OnTerrainUpdateDelegate OnTerrainUpdate;
+
         public delegate void OnBackupDelegate(ISimulationDataService datastore, bool forceBackup);
 
         /// <summary>
@@ -339,8 +343,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// in <see cref="Scene.SetScriptRunning"/>
         /// via <see cref="OpenSim.Framework.IClientAPI.OnSetScriptRunning"/>,
         /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.HandleSetScriptRunning"/>
-        /// XXX: This is only triggered when it is the client that starts the script, not in other situations where
-        /// a script is started, unlike OnStopScript!
         /// </remarks>
         public event StartScript OnStartScript;
 
@@ -354,7 +356,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// in <see cref="SceneObjectPartInventory.CreateScriptInstance"/>,
         /// <see cref="SceneObjectPartInventory.StopScriptInstance"/>,
         /// <see cref="Scene.SetScriptRunning"/>
-        /// XXX: This is triggered when a sciprt is stopped for any reason, unlike OnStartScript!
         /// </remarks>
         public event StopScript OnStopScript;
 
@@ -842,6 +843,10 @@ namespace OpenSim.Region.Framework.Scenes
         public event ParcelPrimCountTainted OnParcelPrimCountTainted;
         public event GetScriptRunning OnGetScriptRunning;
 
+        public delegate void ThrottleUpdate(ScenePresence scenePresence);
+
+        public event ThrottleUpdate OnThrottleUpdate;
+
         /// <summary>
         /// RegisterCapsEvent is called by Scene after the Caps object
         /// has been instantiated and before it is return to the
@@ -1435,6 +1440,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()
         {
@@ -1767,6 +1792,7 @@ namespace OpenSim.Region.Framework.Scenes
                         m_log.ErrorFormat(
                             "[EVENT MANAGER]: Delegate for TriggerRemoveScript failed - continuing.  {0} {1}", 
                             e.Message, e.StackTrace);
+                        m_log.ErrorFormat(Environment.StackTrace);
                     }
                 }
             }
@@ -3045,6 +3071,7 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 foreach (Action<Scene> d in handler.GetInvocationList())
                 {
+                    m_log.InfoFormat("[EVENT MANAGER]: TriggerSceneShuttingDown invoque {0}", d.Method.Name.ToString());
                     try
                     {
                         d(s);
@@ -3057,6 +3084,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
             }
+            m_log.Info("[EVENT MANAGER]: TriggerSceneShuttingDown done");
         }
 
         public void TriggerOnRegionStarted(Scene scene)
@@ -3248,6 +3276,15 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public void TriggerThrottleUpdate(ScenePresence scenePresence)
+        {
+            ThrottleUpdate handler = OnThrottleUpdate;
+            if (handler != null)
+            {
+                handler(scenePresence);
+            }
+        }
+
 //        public void TriggerGatherUuids(SceneObjectPart sop, IDictionary<UUID, AssetType> assetUuids)
 //        {
 //            GatherUuids handler = OnGatherUuids;
diff --git a/OpenSim/Region/Framework/Scenes/Prioritizer.cs b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
index 1b10e3c..ddae073 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)
@@ -212,9 +212,15 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             // Use the camera position for local agents and avatar position for remote agents
-            Vector3 presencePos = (presence.IsChildAgent) ?
-                presence.AbsolutePosition :
-                presence.CameraPosition;
+            // Why would I want that? They could be camming but I still see them at the
+            // avatar position, so why should I update them as if they were at their
+            // camera positions? Makes no sense!
+            // TODO: Fix this mess
+            //Vector3 presencePos = (presence.IsChildAgent) ?
+            //    presence.AbsolutePosition :
+            //    presence.CameraPosition;
+
+            Vector3 presencePos = presence.AbsolutePosition;
 
             // Compute the distance... 
             double distance = Vector3.Distance(presencePos, entityPos);
@@ -226,7 +232,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/SOPMaterial.cs b/OpenSim/Region/Framework/Scenes/SOPMaterial.cs
new file mode 100644
index 0000000..10ac37c
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/SOPMaterial.cs
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.Framework.Scenes
+{
+    public static class SOPMaterialData
+    {
+        public enum SopMaterial : int // redundante and not in use for now 
+        {
+            Stone = 0,
+            Metal = 1,
+            Glass = 2,
+            Wood = 3,
+            Flesh = 4,
+            Plastic = 5,
+            Rubber = 6,
+            light = 7 // compatibility with old viewers
+        }
+
+        private struct MaterialData
+        {
+            public float friction;
+            public float bounce;
+            public MaterialData(float f, float b)
+            {
+                friction = f;
+                bounce = b;
+            }
+        }
+
+        private static MaterialData[] m_materialdata = {
+            new MaterialData(0.8f,0.4f), // Stone
+            new MaterialData(0.3f,0.4f), // Metal
+            new MaterialData(0.2f,0.7f), // Glass
+            new MaterialData(0.6f,0.5f), // Wood
+            new MaterialData(0.9f,0.3f), // Flesh
+            new MaterialData(0.4f,0.7f), // Plastic
+            new MaterialData(0.9f,0.95f), // Rubber
+            new MaterialData(0.0f,0.0f) // light ??
+        };
+
+        public static Material MaxMaterial
+        {
+            get { return (Material)(m_materialdata.Length - 1); }
+        }
+
+        public static float friction(Material material)
+        {
+            int indx = (int)material;
+            if (indx < m_materialdata.Length)
+                return (m_materialdata[indx].friction);
+            else
+                return 0;
+        }
+
+        public static float bounce(Material material)
+        {
+            int indx = (int)material;
+            if (indx < m_materialdata.Length)
+                return (m_materialdata[indx].bounce);
+            else
+                return 0;
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/SOPVehicle.cs b/OpenSim/Region/Framework/Scenes/SOPVehicle.cs
new file mode 100644
index 0000000..9cb901a
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/SOPVehicle.cs
@@ -0,0 +1,791 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Physics.Manager;
+using System.Text;
+using System.IO;
+using System.Xml;
+using OpenSim.Framework.Serialization;
+using OpenSim.Framework.Serialization.External;
+using OpenSim.Region.Framework.Scenes.Serialization;
+
+namespace OpenSim.Region.Framework.Scenes
+{
+    public class SOPVehicle
+    {
+        public VehicleData vd;
+
+        public Vehicle Type
+        {
+            get { return vd.m_type; }
+        }
+
+        public SOPVehicle()
+        {
+            vd = new VehicleData();
+            ProcessTypeChange(Vehicle.TYPE_NONE); // is needed?
+        }
+
+        public void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
+        {
+            float len;
+            float timestep = 0.01f;
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    vd.m_angularDeflectionEfficiency = pValue;
+                    break;
+                case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_angularDeflectionTimescale = pValue;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    else if (pValue > 120) pValue = 120;
+                    vd.m_angularMotorDecayTimescale = pValue;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_angularMotorTimescale = pValue;
+                    break;
+                case Vehicle.BANKING_EFFICIENCY:
+                    if (pValue < -1f) pValue = -1f;
+                    if (pValue > 1f) pValue = 1f;
+                    vd.m_bankingEfficiency = pValue;
+                    break;
+                case Vehicle.BANKING_MIX:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    vd.m_bankingMix = pValue;
+                    break;
+                case Vehicle.BANKING_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_bankingTimescale = pValue;
+                    break;
+                case Vehicle.BUOYANCY:
+                    if (pValue < -1f) pValue = -1f;
+                    if (pValue > 1f) pValue = 1f;
+                    vd.m_VehicleBuoyancy = pValue;
+                    break;
+                case Vehicle.HOVER_EFFICIENCY:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    vd.m_VhoverEfficiency = pValue;
+                    break;
+                case Vehicle.HOVER_HEIGHT:
+                    vd.m_VhoverHeight = pValue;
+                    break;
+                case Vehicle.HOVER_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_VhoverTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    vd.m_linearDeflectionEfficiency = pValue;
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_linearDeflectionTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    else if (pValue > 120) pValue = 120;
+                    vd.m_linearMotorDecayTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_MOTOR_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_linearMotorTimescale = pValue;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    vd.m_verticalAttractionEfficiency = pValue;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_verticalAttractionTimescale = pValue;
+                    break;
+
+                // These are vector properties but the engine lets you use a single float value to
+                // set all of the components to the same value
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    vd.m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
+                    len = vd.m_angularMotorDirection.Length();
+                    if (len > 12.566f)
+                        vd.m_angularMotorDirection *= (12.566f / len);
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    if (pValue < timestep) pValue = timestep;
+                    vd.m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    vd.m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
+                    len = vd.m_linearMotorDirection.Length();
+                    if (len > 30.0f)
+                        vd.m_linearMotorDirection *= (30.0f / len);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    vd.m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
+                    len = vd.m_linearMotorOffset.Length();
+                    if (len > 100.0f)
+                        vd.m_linearMotorOffset *= (100.0f / len);
+                    break;
+            }
+        }//end ProcessFloatVehicleParam
+
+        public void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
+        {
+            float len;
+            float timestep = 0.01f;
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    if (pValue.X < timestep) pValue.X = timestep;
+                    if (pValue.Y < timestep) pValue.Y = timestep;
+                    if (pValue.Z < timestep) pValue.Z = timestep;
+
+                    vd.m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    vd.m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    // Limit requested angular speed to 2 rps= 4 pi rads/sec
+                    len = vd.m_angularMotorDirection.Length();
+                    if (len > 12.566f)
+                        vd.m_angularMotorDirection *= (12.566f / len);
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    if (pValue.X < timestep) pValue.X = timestep;
+                    if (pValue.Y < timestep) pValue.Y = timestep;
+                    if (pValue.Z < timestep) pValue.Z = timestep;
+                    vd.m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    vd.m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    len = vd.m_linearMotorDirection.Length();
+                    if (len > 30.0f)
+                        vd.m_linearMotorDirection *= (30.0f / len);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    vd.m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    len = vd.m_linearMotorOffset.Length();
+                    if (len > 100.0f)
+                        vd.m_linearMotorOffset *= (100.0f / len);
+                    break;
+            }
+        }//end ProcessVectorVehicleParam
+
+        public void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
+        {
+            switch (pParam)
+            {
+                case Vehicle.REFERENCE_FRAME:
+                    vd.m_referenceFrame = pValue;
+                    break;
+            }
+        }//end ProcessRotationVehicleParam
+
+        public void ProcessVehicleFlags(int pParam, bool remove)
+        {
+            if (remove)
+            {
+                vd.m_flags &= ~((VehicleFlag)pParam);
+            }
+            else
+            {
+                vd.m_flags |= (VehicleFlag)pParam;
+            }
+        }//end ProcessVehicleFlags
+
+        public void ProcessTypeChange(Vehicle pType)
+        {
+            vd.m_linearMotorDirection = Vector3.Zero;
+            vd.m_angularMotorDirection = Vector3.Zero;
+            vd.m_linearMotorOffset = Vector3.Zero;
+            vd.m_referenceFrame = Quaternion.Identity;
+
+            // Set Defaults For Type
+            vd.m_type = pType;
+            switch (pType)
+            {
+                case Vehicle.TYPE_NONE:
+                    vd.m_linearFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    vd.m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    vd.m_linearMotorTimescale = 1000;
+                    vd.m_linearMotorDecayTimescale = 120;
+                    vd.m_angularMotorTimescale = 1000;
+                    vd.m_angularMotorDecayTimescale = 1000;
+                    vd.m_VhoverHeight = 0;
+                    vd.m_VhoverEfficiency = 1;
+                    vd.m_VhoverTimescale = 1000;
+                    vd.m_VehicleBuoyancy = 0;
+                    vd.m_linearDeflectionEfficiency = 0;
+                    vd.m_linearDeflectionTimescale = 1000;
+                    vd.m_angularDeflectionEfficiency = 0;
+                    vd.m_angularDeflectionTimescale = 1000;
+                    vd.m_bankingEfficiency = 0;
+                    vd.m_bankingMix = 1;
+                    vd.m_bankingTimescale = 1000;
+                    vd.m_verticalAttractionEfficiency = 0;
+                    vd.m_verticalAttractionTimescale = 1000;
+
+                    vd.m_flags = (VehicleFlag)0;
+                    break;
+
+                case Vehicle.TYPE_SLED:
+                    vd.m_linearFrictionTimescale = new Vector3(30, 1, 1000);
+                    vd.m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    vd.m_linearMotorTimescale = 1000;
+                    vd.m_linearMotorDecayTimescale = 120;
+                    vd.m_angularMotorTimescale = 1000;
+                    vd.m_angularMotorDecayTimescale = 120;
+                    vd.m_VhoverHeight = 0;
+                    vd.m_VhoverEfficiency = 1;
+                    vd.m_VhoverTimescale = 10;
+                    vd.m_VehicleBuoyancy = 0;
+                    vd.m_linearDeflectionEfficiency = 1;
+                    vd.m_linearDeflectionTimescale = 1;
+                    vd.m_angularDeflectionEfficiency = 0;
+                    vd.m_angularDeflectionTimescale = 1000;
+                    vd.m_bankingEfficiency = 0;
+                    vd.m_bankingMix = 1;
+                    vd.m_bankingTimescale = 10;
+                    vd.m_flags &=
+                         ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                           VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    vd.m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
+                    break;
+                case Vehicle.TYPE_CAR:
+                    vd.m_linearFrictionTimescale = new Vector3(100, 2, 1000);
+                    vd.m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    vd.m_linearMotorTimescale = 1;
+                    vd.m_linearMotorDecayTimescale = 60;
+                    vd.m_angularMotorTimescale = 1;
+                    vd.m_angularMotorDecayTimescale = 0.8f;
+                    vd.m_VhoverHeight = 0;
+                    vd.m_VhoverEfficiency = 0;
+                    vd.m_VhoverTimescale = 1000;
+                    vd.m_VehicleBuoyancy = 0;
+                    vd.m_linearDeflectionEfficiency = 1;
+                    vd.m_linearDeflectionTimescale = 2;
+                    vd.m_angularDeflectionEfficiency = 0;
+                    vd.m_angularDeflectionTimescale = 10;
+                    vd.m_verticalAttractionEfficiency = 1f;
+                    vd.m_verticalAttractionTimescale = 10f;
+                    vd.m_bankingEfficiency = -0.2f;
+                    vd.m_bankingMix = 1;
+                    vd.m_bankingTimescale = 1;
+                    vd.m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    vd.m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY |
+                                VehicleFlag.LIMIT_MOTOR_UP | VehicleFlag.HOVER_UP_ONLY);
+                    break;
+                case Vehicle.TYPE_BOAT:
+                    vd.m_linearFrictionTimescale = new Vector3(10, 3, 2);
+                    vd.m_angularFrictionTimescale = new Vector3(10, 10, 10);
+                    vd.m_linearMotorTimescale = 5;
+                    vd.m_linearMotorDecayTimescale = 60;
+                    vd.m_angularMotorTimescale = 4;
+                    vd.m_angularMotorDecayTimescale = 4;
+                    vd.m_VhoverHeight = 0;
+                    vd.m_VhoverEfficiency = 0.5f;
+                    vd.m_VhoverTimescale = 2;
+                    vd.m_VehicleBuoyancy = 1;
+                    vd.m_linearDeflectionEfficiency = 0.5f;
+                    vd.m_linearDeflectionTimescale = 3;
+                    vd.m_angularDeflectionEfficiency = 0.5f;
+                    vd.m_angularDeflectionTimescale = 5;
+                    vd.m_verticalAttractionEfficiency = 0.5f;
+                    vd.m_verticalAttractionTimescale = 5f;
+                    vd.m_bankingEfficiency = -0.3f;
+                    vd.m_bankingMix = 0.8f;
+                    vd.m_bankingTimescale = 1;
+                    vd.m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY |
+                            VehicleFlag.HOVER_GLOBAL_HEIGHT |
+                            VehicleFlag.HOVER_UP_ONLY |
+                            VehicleFlag.LIMIT_ROLL_ONLY);
+                    vd.m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
+                                VehicleFlag.LIMIT_MOTOR_UP |
+                                VehicleFlag.HOVER_WATER_ONLY);
+                    break;
+                case Vehicle.TYPE_AIRPLANE:
+                    vd.m_linearFrictionTimescale = new Vector3(200, 10, 5);
+                    vd.m_angularFrictionTimescale = new Vector3(20, 20, 20);
+                    vd.m_linearMotorTimescale = 2;
+                    vd.m_linearMotorDecayTimescale = 60;
+                    vd.m_angularMotorTimescale = 4;
+                    vd.m_angularMotorDecayTimescale = 8;
+                    vd.m_VhoverHeight = 0;
+                    vd.m_VhoverEfficiency = 0.5f;
+                    vd.m_VhoverTimescale = 1000;
+                    vd.m_VehicleBuoyancy = 0;
+                    vd.m_linearDeflectionEfficiency = 0.5f;
+                    vd.m_linearDeflectionTimescale = 0.5f;
+                    vd.m_angularDeflectionEfficiency = 1;
+                    vd.m_angularDeflectionTimescale = 2;
+                    vd.m_verticalAttractionEfficiency = 0.9f;
+                    vd.m_verticalAttractionTimescale = 2f;
+                    vd.m_bankingEfficiency = 1;
+                    vd.m_bankingMix = 0.7f;
+                    vd.m_bankingTimescale = 2;
+                    vd.m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
+                        VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_GLOBAL_HEIGHT |
+                        VehicleFlag.HOVER_UP_ONLY |
+                        VehicleFlag.NO_DEFLECTION_UP |
+                        VehicleFlag.LIMIT_MOTOR_UP);
+                    vd.m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
+                    break;
+                case Vehicle.TYPE_BALLOON:
+                    vd.m_linearFrictionTimescale = new Vector3(5, 5, 5);
+                    vd.m_angularFrictionTimescale = new Vector3(10, 10, 10);
+                    vd.m_linearMotorTimescale = 5;
+                    vd.m_linearMotorDecayTimescale = 60;
+                    vd.m_angularMotorTimescale = 6;
+                    vd.m_angularMotorDecayTimescale = 10;
+                    vd.m_VhoverHeight = 5;
+                    vd.m_VhoverEfficiency = 0.8f;
+                    vd.m_VhoverTimescale = 10;
+                    vd.m_VehicleBuoyancy = 1;
+                    vd.m_linearDeflectionEfficiency = 0;
+                    vd.m_linearDeflectionTimescale = 5;
+                    vd.m_angularDeflectionEfficiency = 0;
+                    vd.m_angularDeflectionTimescale = 5;
+                    vd.m_verticalAttractionEfficiency = 0f;
+                    vd.m_verticalAttractionTimescale = 1000f;
+                    vd.m_bankingEfficiency = 0;
+                    vd.m_bankingMix = 0.7f;
+                    vd.m_bankingTimescale = 5;
+                    vd.m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
+                        VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_UP_ONLY |
+                        VehicleFlag.NO_DEFLECTION_UP |
+                        VehicleFlag.LIMIT_MOTOR_UP);
+                    vd.m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY |
+                        VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    break;
+            }
+        }
+        public void SetVehicle(PhysicsActor ph)
+        {
+            if (ph == null)
+                return;
+            ph.SetVehicle(vd);
+        }
+
+        private XmlTextWriter writer;
+
+        private void XWint(string name, int i)
+        {
+            writer.WriteElementString(name, i.ToString());
+        }
+
+        private void XWfloat(string name, float f)
+        {
+            writer.WriteElementString(name, f.ToString(Utils.EnUsCulture));
+        }
+
+        private void XWVector(string name, Vector3 vec)
+        {
+            writer.WriteStartElement(name);
+            writer.WriteElementString("X", vec.X.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("Y", vec.Y.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("Z", vec.Z.ToString(Utils.EnUsCulture));
+            writer.WriteEndElement();
+        }
+
+        private void XWQuat(string name, Quaternion quat)
+        {
+            writer.WriteStartElement(name);
+            writer.WriteElementString("X", quat.X.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("Y", quat.Y.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("Z", quat.Z.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("W", quat.W.ToString(Utils.EnUsCulture));
+            writer.WriteEndElement();
+        }
+
+        public void ToXml2(XmlTextWriter twriter)
+        {
+            writer = twriter;
+            writer.WriteStartElement("Vehicle");
+
+            XWint("TYPE", (int)vd.m_type);
+            XWint("FLAGS", (int)vd.m_flags);
+
+            // Linear properties
+            XWVector("LMDIR", vd.m_linearMotorDirection);
+            XWVector("LMFTIME", vd.m_linearFrictionTimescale);
+            XWfloat("LMDTIME", vd.m_linearMotorDecayTimescale);
+            XWfloat("LMTIME", vd.m_linearMotorTimescale);
+            XWVector("LMOFF", vd.m_linearMotorOffset);
+
+            //Angular properties
+            XWVector("AMDIR", vd.m_angularMotorDirection);
+            XWfloat("AMTIME", vd.m_angularMotorTimescale);
+            XWfloat("AMDTIME", vd.m_angularMotorDecayTimescale);
+            XWVector("AMFTIME", vd.m_angularFrictionTimescale);
+
+            //Deflection properties
+            XWfloat("ADEFF", vd.m_angularDeflectionEfficiency);
+            XWfloat("ADTIME", vd.m_angularDeflectionTimescale);
+            XWfloat("LDEFF", vd.m_linearDeflectionEfficiency);
+            XWfloat("LDTIME", vd.m_linearDeflectionTimescale);
+
+            //Banking properties
+            XWfloat("BEFF", vd.m_bankingEfficiency);
+            XWfloat("BMIX", vd.m_bankingMix);
+            XWfloat("BTIME", vd.m_bankingTimescale);
+
+            //Hover and Buoyancy properties
+            XWfloat("HHEI", vd.m_VhoverHeight);
+            XWfloat("HEFF", vd.m_VhoverEfficiency);
+            XWfloat("HTIME", vd.m_VhoverTimescale);
+            XWfloat("VBUO", vd.m_VehicleBuoyancy);
+
+            //Attractor properties
+            XWfloat("VAEFF", vd.m_verticalAttractionEfficiency);
+            XWfloat("VATIME", vd.m_verticalAttractionTimescale);
+
+            XWQuat("REF_FRAME", vd.m_referenceFrame);
+
+            writer.WriteEndElement();
+            writer = null;
+        }
+
+
+
+        XmlTextReader reader;
+
+        private int XRint()
+        {
+            return reader.ReadElementContentAsInt();
+        }
+
+        private float XRfloat()
+        {
+            return reader.ReadElementContentAsFloat();
+        }
+
+        public Vector3 XRvector()
+        {
+            Vector3 vec;
+            reader.ReadStartElement();
+            vec.X = reader.ReadElementContentAsFloat();
+            vec.Y = reader.ReadElementContentAsFloat();
+            vec.Z = reader.ReadElementContentAsFloat();
+            reader.ReadEndElement();
+            return vec;
+        }
+
+        public Quaternion XRquat()
+        {
+            Quaternion q;
+            reader.ReadStartElement();
+            q.X = reader.ReadElementContentAsFloat();
+            q.Y = reader.ReadElementContentAsFloat();
+            q.Z = reader.ReadElementContentAsFloat();
+            q.W = reader.ReadElementContentAsFloat();
+            reader.ReadEndElement();
+            return q;
+        }
+
+        public static bool EReadProcessors(
+            Dictionary<string, Action> processors,
+            XmlTextReader xtr)
+        {
+            bool errors = false;
+
+            string nodeName = string.Empty;
+            while (xtr.NodeType != XmlNodeType.EndElement)
+            {
+                nodeName = xtr.Name;
+
+                //                        m_log.DebugFormat("[ExternalRepresentationUtils]: Processing: {0}", nodeName);
+
+                Action p = null;
+                if (processors.TryGetValue(xtr.Name, out p))
+                {
+                    //                            m_log.DebugFormat("[ExternalRepresentationUtils]: Found {0} processor, nodeName);
+
+                    try
+                    {
+                        p();
+                    }
+                    catch (Exception e)
+                    {
+                        errors = true;
+                        if (xtr.NodeType == XmlNodeType.EndElement)
+                            xtr.Read();
+                    }
+                }
+                else
+                {
+                    // m_log.DebugFormat("[LandDataSerializer]: caught unknown element {0}", nodeName);
+                    xtr.ReadOuterXml(); // ignore
+                }
+            }
+
+            return errors;
+        }
+
+        
+        public string ToXml2()
+        {
+            MemoryStream ms = new MemoryStream(512);
+            UTF8Encoding enc = new UTF8Encoding();
+            XmlTextWriter xwriter = new XmlTextWriter(ms, enc);
+            ToXml2(xwriter);
+            xwriter.Flush();
+            string s = ms.GetStreamString();
+            xwriter.Close();
+            return s;
+        }
+
+        public static SOPVehicle FromXml2(string text)
+        {
+            if (text == String.Empty)
+                return null;
+
+            UTF8Encoding enc = new UTF8Encoding();
+            MemoryStream ms = new MemoryStream(enc.GetBytes(text));
+            XmlTextReader xreader = new XmlTextReader(ms);
+
+            SOPVehicle v = new SOPVehicle();
+            bool error;
+
+            v.FromXml2(xreader, out error);
+
+            xreader.Close();
+
+            if (error)
+            {
+                v = null;
+                return null;
+            }
+            return v;
+        }
+
+        public static SOPVehicle FromXml2(XmlTextReader reader)
+        {
+            SOPVehicle vehicle = new SOPVehicle();
+
+            bool errors = false;
+
+            vehicle.FromXml2(reader, out errors);
+            if (errors)
+                return null;
+
+            return vehicle;
+        }
+
+        private void FromXml2(XmlTextReader _reader, out bool errors)
+        {
+            errors = false;
+            reader = _reader;
+
+            Dictionary<string, Action> m_VehicleXmlProcessors
+            = new Dictionary<string, Action>();
+
+            m_VehicleXmlProcessors.Add("TYPE", ProcessXR_type);
+            m_VehicleXmlProcessors.Add("FLAGS", ProcessXR_flags);
+
+            // Linear properties
+            m_VehicleXmlProcessors.Add("LMDIR", ProcessXR_linearMotorDirection);
+            m_VehicleXmlProcessors.Add("LMFTIME", ProcessXR_linearFrictionTimescale);
+            m_VehicleXmlProcessors.Add("LMDTIME", ProcessXR_linearMotorDecayTimescale);
+            m_VehicleXmlProcessors.Add("LMTIME", ProcessXR_linearMotorTimescale);
+            m_VehicleXmlProcessors.Add("LMOFF", ProcessXR_linearMotorOffset);
+
+            //Angular properties
+            m_VehicleXmlProcessors.Add("AMDIR", ProcessXR_angularMotorDirection);
+            m_VehicleXmlProcessors.Add("AMTIME", ProcessXR_angularMotorTimescale);
+            m_VehicleXmlProcessors.Add("AMDTIME", ProcessXR_angularMotorDecayTimescale);
+            m_VehicleXmlProcessors.Add("AMFTIME", ProcessXR_angularFrictionTimescale);
+
+            //Deflection properties
+            m_VehicleXmlProcessors.Add("ADEFF", ProcessXR_angularDeflectionEfficiency);
+            m_VehicleXmlProcessors.Add("ADTIME", ProcessXR_angularDeflectionTimescale);
+            m_VehicleXmlProcessors.Add("LDEFF", ProcessXR_linearDeflectionEfficiency);
+            m_VehicleXmlProcessors.Add("LDTIME", ProcessXR_linearDeflectionTimescale);
+
+            //Banking properties
+            m_VehicleXmlProcessors.Add("BEFF", ProcessXR_bankingEfficiency);
+            m_VehicleXmlProcessors.Add("BMIX", ProcessXR_bankingMix);
+            m_VehicleXmlProcessors.Add("BTIME", ProcessXR_bankingTimescale);
+
+            //Hover and Buoyancy properties
+            m_VehicleXmlProcessors.Add("HHEI", ProcessXR_VhoverHeight);
+            m_VehicleXmlProcessors.Add("HEFF", ProcessXR_VhoverEfficiency);
+            m_VehicleXmlProcessors.Add("HTIME", ProcessXR_VhoverTimescale);
+
+            m_VehicleXmlProcessors.Add("VBUO", ProcessXR_VehicleBuoyancy);
+
+            //Attractor properties
+            m_VehicleXmlProcessors.Add("VAEFF", ProcessXR_verticalAttractionEfficiency);
+            m_VehicleXmlProcessors.Add("VATIME", ProcessXR_verticalAttractionTimescale);
+
+            m_VehicleXmlProcessors.Add("REF_FRAME", ProcessXR_referenceFrame);
+
+            vd = new VehicleData();
+
+            reader.ReadStartElement("Vehicle", String.Empty);
+
+            errors = EReadProcessors(
+                m_VehicleXmlProcessors,
+                reader);
+
+            reader.ReadEndElement();
+            reader = null;
+        }
+
+        private void ProcessXR_type()
+        {
+            vd.m_type = (Vehicle)XRint();
+        }
+        private void ProcessXR_flags()
+        {
+            vd.m_flags = (VehicleFlag)XRint();
+        }
+        // Linear properties
+        private void ProcessXR_linearMotorDirection()
+        {
+            vd.m_linearMotorDirection = XRvector();
+        }
+
+        private void ProcessXR_linearFrictionTimescale()
+        {
+            vd.m_linearFrictionTimescale = XRvector();
+        }
+
+        private void ProcessXR_linearMotorDecayTimescale()
+        {
+            vd.m_linearMotorDecayTimescale = XRfloat();
+        }
+        private void ProcessXR_linearMotorTimescale()
+        {
+            vd.m_linearMotorTimescale = XRfloat();
+        }
+        private void ProcessXR_linearMotorOffset()
+        {
+            vd.m_linearMotorOffset = XRvector();
+        }
+
+
+        //Angular properties
+        private void ProcessXR_angularMotorDirection()
+        {
+            vd.m_angularMotorDirection = XRvector();
+        }
+        private void ProcessXR_angularMotorTimescale()
+        {
+            vd.m_angularMotorTimescale = XRfloat();
+        }
+        private void ProcessXR_angularMotorDecayTimescale()
+        {
+            vd.m_angularMotorDecayTimescale = XRfloat();
+        }
+        private void ProcessXR_angularFrictionTimescale()
+        {
+            vd.m_angularFrictionTimescale = XRvector();
+        }
+
+        //Deflection properties
+        private void ProcessXR_angularDeflectionEfficiency()
+        {
+            vd.m_angularDeflectionEfficiency = XRfloat();
+        }
+        private void ProcessXR_angularDeflectionTimescale()
+        {
+            vd.m_angularDeflectionTimescale = XRfloat();
+        }
+        private void ProcessXR_linearDeflectionEfficiency()
+        {
+            vd.m_linearDeflectionEfficiency = XRfloat();
+        }
+        private void ProcessXR_linearDeflectionTimescale()
+        {
+            vd.m_linearDeflectionTimescale = XRfloat();
+        }
+
+        //Banking properties
+        private void ProcessXR_bankingEfficiency()
+        {
+            vd.m_bankingEfficiency = XRfloat();
+        }
+        private void ProcessXR_bankingMix()
+        {
+            vd.m_bankingMix = XRfloat();
+        }
+        private void ProcessXR_bankingTimescale()
+        {
+            vd.m_bankingTimescale = XRfloat();
+        }
+
+        //Hover and Buoyancy properties
+        private void ProcessXR_VhoverHeight()
+        {
+            vd.m_VhoverHeight = XRfloat();
+        }
+        private void ProcessXR_VhoverEfficiency()
+        {
+            vd.m_VhoverEfficiency = XRfloat();
+        }
+        private void ProcessXR_VhoverTimescale()
+        {
+            vd.m_VhoverTimescale = XRfloat();
+        }
+
+        private void ProcessXR_VehicleBuoyancy()
+        {
+            vd.m_VehicleBuoyancy = XRfloat();
+        }
+
+        //Attractor properties
+        private void ProcessXR_verticalAttractionEfficiency()
+        {
+            vd.m_verticalAttractionEfficiency = XRfloat();
+        }
+        private void ProcessXR_verticalAttractionTimescale()
+        {
+            vd.m_verticalAttractionTimescale = XRfloat();
+        }
+
+        private void ProcessXR_referenceFrame()
+        {
+            vd.m_referenceFrame = XRquat();
+        }
+    }
+}
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 1e4d558..70018c8 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -102,12 +102,12 @@ namespace OpenSim.Region.Framework.Scenes
                 engine.StartProcessing();
         }
 
-        public void AddUploadedInventoryItem(UUID agentID, InventoryItemBase item)
+        public void AddUploadedInventoryItem(UUID agentID, InventoryItemBase item, uint cost)
         {
             IMoneyModule money = RequestModuleInterface<IMoneyModule>();
             if (money != null)
             {
-                money.ApplyUploadCharge(agentID, money.UploadCharge, "Asset upload");
+                money.ApplyUploadCharge(agentID, (int)cost, "Asset upload");
             }
 
             AddInventoryItem(item);
@@ -170,7 +170,7 @@ namespace OpenSim.Region.Framework.Scenes
                     return false;
                 }
             }
-            
+
             if (InventoryService.AddItem(item))
             {
                 int userlevel = 0;
@@ -325,8 +325,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             // Update item with new asset
             item.AssetID = asset.FullID;
-            if (group.UpdateInventoryItem(item))
-                remoteClient.SendAlertMessage("Script saved");
+            group.UpdateInventoryItem(item);
             
             part.SendPropertiesToClient(remoteClient);
 
@@ -337,12 +336,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.SendAlertMessage("Script saved");
+                errors = part.Inventory.CreateScriptInstanceEr(item.ItemID, 0, false, DefaultScriptEngine, 1);
             }
 
             // Tell anyone managing scripts that a script has been reloaded/changed
@@ -408,6 +402,7 @@ namespace OpenSim.Region.Framework.Scenes
                 if (item.Owner != remoteClient.AgentId)
                     return;
 
+                item.Flags = (item.Flags & ~(uint)255) | (itemUpd.Flags & (uint)255);
                 item.Name = itemUpd.Name;
                 item.Description = itemUpd.Description;
 
@@ -838,6 +833,8 @@ namespace OpenSim.Region.Framework.Scenes
                     return;
             }
 
+            if (newName == null) newName = item.Name;
+
             AssetBase asset = AssetService.Get(item.AssetID.ToString());
 
             if (asset != null)
@@ -898,6 +895,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>
@@ -932,11 +947,22 @@ namespace OpenSim.Region.Framework.Scenes
         public void CreateNewInventoryItem(
             IClientAPI remoteClient, string creatorID, string creatorData, UUID folderID,
             string name, string description, uint flags, uint callbackID,
-            AssetBase asset, sbyte invType, uint nextOwnerMask, int creationDate)
+            AssetBase asset, sbyte invType, uint nextOwnerMask, int creationDate, UUID transationID)
         {
             CreateNewInventoryItem(
                 remoteClient, creatorID, creatorData, folderID, name, description, flags, callbackID, asset, invType,
-                (uint)PermissionMask.All | (uint)PermissionMask.Export, (uint)PermissionMask.All | (uint)PermissionMask.Export, 0, nextOwnerMask, 0, creationDate);
+                (uint)PermissionMask.All | (uint)PermissionMask.Export, (uint)PermissionMask.All | (uint)PermissionMask.Export, 0, nextOwnerMask, 0, creationDate, transationID);
+        }
+
+
+        private void CreateNewInventoryItem(
+            IClientAPI remoteClient, string creatorID, string creatorData, UUID folderID,
+            string name, string description, uint flags, uint callbackID, AssetBase asset, sbyte invType,
+            uint baseMask, uint currentMask, uint everyoneMask, uint nextOwnerMask, uint groupMask, int creationDate)
+        {
+            CreateNewInventoryItem(remoteClient, creatorID, creatorData, folderID,
+                name, description, flags, callbackID, asset, invType,
+                baseMask, currentMask, everyoneMask, nextOwnerMask, groupMask, creationDate, UUID.Zero);
         }
 
         /// <summary>
@@ -961,7 +987,7 @@ namespace OpenSim.Region.Framework.Scenes
         private void CreateNewInventoryItem(
             IClientAPI remoteClient, string creatorID, string creatorData, UUID folderID,
             string name, string description, uint flags, uint callbackID, AssetBase asset, sbyte invType,
-            uint baseMask, uint currentMask, uint everyoneMask, uint nextOwnerMask, uint groupMask, int creationDate)
+            uint baseMask, uint currentMask, uint everyoneMask, uint nextOwnerMask, uint groupMask, int creationDate,UUID transationID)
         {
             InventoryItemBase item = new InventoryItemBase();
             item.Owner = remoteClient.AgentId;
@@ -984,7 +1010,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (AddInventoryItem(item))
             {
-                remoteClient.SendInventoryItemCreateUpdate(item, callbackID);
+                remoteClient.SendInventoryItemCreateUpdate(item, transationID, callbackID);
             }
             else
             {
@@ -1259,6 +1285,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(
@@ -1363,21 +1393,28 @@ namespace OpenSim.Region.Framework.Scenes
                 return;
             }
 
-            if (part.OwnerID != destPart.OwnerID)
+            // Can't transfer this
+            //
+            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 && (destPart.GetEffectiveObjectFlags() & (uint)PrimFlags.AllowInventoryDrop) == 0)
             {
-                // Source must have transfer permissions
-                if ((srcTaskItem.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
-                    return;
+                // object cannot copy items to an object owned by a different owner
+                // unless llAllowInventoryDrop has been called
 
-                // Object cannot copy items to an object owned by a different owner
-                // unless llAllowInventoryDrop has been called on the destination
-                if ((destPart.GetEffectiveObjectFlags() & (uint)PrimFlags.AllowInventoryDrop) == 0)
-                    return;
+                return;
             }
 
             // 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;
+            }
 
             TaskInventoryItem destTaskItem = new TaskInventoryItem();
 
@@ -1433,6 +1470,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();
@@ -1615,12 +1660,12 @@ namespace OpenSim.Region.Framework.Scenes
                         AgentTransactionsModule.HandleTaskItemUpdateFromTransaction(
                             remoteClient, part, transactionID, currentItem);
 
-                        if ((InventoryType)itemInfo.InvType == InventoryType.Notecard)
-                            remoteClient.SendAlertMessage("Notecard saved");
-                        else if ((InventoryType)itemInfo.InvType == InventoryType.LSL)
-                            remoteClient.SendAlertMessage("Script saved");
-                        else
-                            remoteClient.SendAlertMessage("Item saved");
+//                        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
@@ -1990,23 +2035,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)
@@ -2014,8 +2068,8 @@ namespace OpenSim.Region.Framework.Scenes
 
                 SceneObjectGroup grp = part.ParentGroup;
 
-                deleteIDs.Add(localID);
-                deleteGroups.Add(grp);
+                // If child prims have invalid perms, fix them
+                grp.AdjustChildPrimPermissions();
 
                 // If child prims have invalid perms, fix them
                 grp.AdjustChildPrimPermissions();
@@ -2036,81 +2090,193 @@ 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,
+                                        new List<SceneObjectGroup>() {grp}))
                         {
-                            AddReturn(g.OwnerID == g.GroupID ? g.LastOwnerID : g.OwnerID, g.Name, g.AbsolutePosition, "parcel owner return");
+                            permissionToTake = true;
+                            permissionToDelete = true;
+
+                            AddReturn(grp.OwnerID == grp.GroupID ? grp.LastOwnerID : 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 && (action != DeRezAction.Delete || this.m_useTrashOnDelete))
+            SendKillObject(deleteIDs);
+
+            if (deleteGroups.Count > 0)
             {
+                foreach (SceneObjectGroup g in deleteGroups)
+                    deleteIDs.Remove(g.LocalId);
+
                 m_asyncSceneObjectDeleter.DeleteToInventory(
                         action, destinationID, deleteGroups, remoteClient,
-                        permissionToDelete);
+                        true);
+            }
+            if (takeGroups.Count > 0)
+            {
+                m_asyncSceneObjectDeleter.DeleteToInventory(
+                        action, destinationID, takeGroups, remoteClient,
+                        false);
             }
-            else if (permissionToDelete)
+            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.FromItemID = 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>
@@ -2240,6 +2406,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;
@@ -2296,7 +2465,10 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 else
                 {
-                    if (!Permissions.CanEditObject(sog.UUID, remoteClient.AgentId))
+                    if (!Permissions.IsGod(remoteClient.AgentId) && sog.OwnerID != remoteClient.AgentId)
+                        continue;
+
+                    if (!Permissions.CanTransferObject(sog.UUID, groupID))
                         continue;
 
                     if (sog.GroupID != groupID)
@@ -2408,6 +2580,12 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             m_sceneGraph.LinkObjects(root, children);
+
+            ScenePresence sp;
+            if (TryGetScenePresence(agentId, out sp))
+            {
+                root.SendPropertiesToClient(sp.ControllingClient);
+            }
         }
 
         private string PermissionString(uint permissions)
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index df43271..ce6415a 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -50,7 +50,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name='targetID'></param>
         /// <param name='fromAgent'></param>
         /// <param name='broadcast'></param>
-        protected void SimChat(byte[] message, ChatTypeEnum type, int channel, Vector3 fromPos, string fromName,
+        public void SimChat(byte[] message, ChatTypeEnum type, int channel, Vector3 fromPos, string fromName,
                                UUID fromID, UUID targetID, bool fromAgent, bool broadcast)
         {
             OSChatMessage args = new OSChatMessage();
@@ -61,6 +61,7 @@ namespace OpenSim.Region.Framework.Scenes
             args.Position = fromPos;
             args.SenderUUID = fromID;
             args.Scene = this;
+            args.Destination = targetID;
 
             if (fromAgent)
             {
@@ -75,7 +76,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             args.From = fromName;
-            args.TargetUUID = targetID;
+            //args.
 
 //            m_log.DebugFormat(
 //                "[SCENE]: Sending message {0} on channel {1}, type {2} from {3}, broadcast {4}",
@@ -86,7 +87,7 @@ namespace OpenSim.Region.Framework.Scenes
             else
                 EventManager.TriggerOnChatFromWorld(this, args);
         }
-
+        
         protected void SimChat(byte[] message, ChatTypeEnum type, int channel, Vector3 fromPos, string fromName,
                                UUID fromID, bool fromAgent, bool broadcast)
         {
@@ -130,19 +131,6 @@ namespace OpenSim.Region.Framework.Scenes
         {
             SimChat(message, type, channel, fromPos, fromName, fromID, fromAgent, true);
         }
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="message"></param>
-        /// <param name="type"></param>
-        /// <param name="fromPos"></param>
-        /// <param name="fromName"></param>
-        /// <param name="fromAgentID"></param>
-        /// <param name="targetID"></param>
-        public void SimChatToAgent(UUID targetID, byte[] message, Vector3 fromPos, string fromName, UUID fromID, bool fromAgent)
-        {
-            SimChat(message, ChatTypeEnum.Say, 0, fromPos, fromName, fromID, targetID, fromAgent, false);
-        }
 
         /// <summary>
         /// Invoked when the client requests a prim.
@@ -164,27 +152,47 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="remoteClient"></param>
         public void SelectPrim(uint primLocalID, IClientAPI remoteClient)
         {
+            /*
+                        SceneObjectPart part = GetSceneObjectPart(primLocalID);
+
+                        if (null == part)
+                            return;
+
+                        if (part.IsRoot)
+                        {
+                            SceneObjectGroup sog = part.ParentGroup;
+                            sog.SendPropertiesToClient(remoteClient);
+
+                            // A prim is only tainted if it's allowed to be edited by the person clicking it.
+                            if (Permissions.CanEditObject(sog.UUID, remoteClient.AgentId)
+                                || Permissions.CanMoveObject(sog.UUID, remoteClient.AgentId))
+                            {
+                                sog.IsSelected = true;
+                                EventManager.TriggerParcelPrimCountTainted();
+                            }
+                        }
+                        else
+                        {
+                             part.SendPropertiesToClient(remoteClient);
+                        }
+             */
             SceneObjectPart part = GetSceneObjectPart(primLocalID);
 
             if (null == part)
                 return;
 
-            if (part.IsRoot)
-            {
-                SceneObjectGroup sog = part.ParentGroup;
-                sog.SendPropertiesToClient(remoteClient);
-                sog.IsSelected = true;
+            SceneObjectGroup sog = part.ParentGroup;
+            if (sog == null)
+                return;
 
-                // A prim is only tainted if it's allowed to be edited by the person clicking it.
-                if (Permissions.CanEditObject(sog.UUID, remoteClient.AgentId)
-                    || Permissions.CanMoveObject(sog.UUID, remoteClient.AgentId))
-                {
-                    EventManager.TriggerParcelPrimCountTainted();
-                }
-            }
-            else
+            part.SendPropertiesToClient(remoteClient);
+
+            // A prim is only tainted if it's allowed to be edited by the person clicking it.
+            if (Permissions.CanEditObject(sog.UUID, remoteClient.AgentId)
+                || Permissions.CanMoveObject(sog.UUID, remoteClient.AgentId))
             {
-                 part.SendPropertiesToClient(remoteClient);
+                part.IsSelected = true;
+                EventManager.TriggerParcelPrimCountTainted();
             }
         }
 
@@ -237,7 +245,7 @@ namespace OpenSim.Region.Framework.Scenes
             SceneObjectPart part = GetSceneObjectPart(primLocalID);
             if (part == null)
                 return;
-            
+ /*           
             // A deselect packet contains all the local prims being deselected.  However, since selection is still
             // group based we only want the root prim to trigger a full update - otherwise on objects with many prims
             // we end up sending many duplicate ObjectUpdates
@@ -250,7 +258,9 @@ namespace OpenSim.Region.Framework.Scenes
             // handled by group, but by prim. Legacy cruft.
             // TODO: Make selection flagging per prim!
             //
-            part.ParentGroup.IsSelected = false;
+            if (Permissions.CanEditObject(part.ParentGroup.UUID, remoteClient.AgentId)
+                || Permissions.CanMoveObject(part.ParentGroup.UUID, remoteClient.AgentId))
+                part.ParentGroup.IsSelected = false;
             
             if (part.ParentGroup.IsAttachment)
                 isAttachment = true;
@@ -270,6 +280,22 @@ namespace OpenSim.Region.Framework.Scenes
                         part.UUID, remoteClient.AgentId))
                     EventManager.TriggerParcelPrimCountTainted();
             }
+  */
+
+            bool oldgprSelect = part.ParentGroup.IsSelected;
+
+            // This is wrong, wrong, wrong. Selection should not be
+            // handled by group, but by prim. Legacy cruft.
+            // TODO: Make selection flagging per prim!
+            //
+            if (Permissions.CanEditObject(part.ParentGroup.UUID, remoteClient.AgentId)
+                || Permissions.CanMoveObject(part.ParentGroup.UUID, remoteClient.AgentId))
+            {
+                part.IsSelected = false;
+                if (!part.ParentGroup.IsAttachment && oldgprSelect != part.ParentGroup.IsSelected)
+                    EventManager.TriggerParcelPrimCountTainted();
+            }
+
         }
 
         public virtual void ProcessMoneyTransferRequest(UUID source, UUID destination, int amount, 
@@ -412,6 +438,20 @@ namespace OpenSim.Region.Framework.Scenes
             );
         }
         
+        private class DescendentsRequestData
+        {
+            public IClientAPI RemoteClient;
+            public UUID FolderID;
+            public UUID OwnerID;
+            public bool FetchFolders;
+            public bool FetchItems;
+            public int SortOrder;
+        }
+
+        private Queue<DescendentsRequestData> m_descendentsRequestQueue = new Queue<DescendentsRequestData>();
+        private Object m_descendentsRequestLock = new Object();
+        private bool m_descendentsRequestProcessing = false;
+
         /// <summary>
         /// Tell the client about the various child items and folders contained in the requested folder.
         /// </summary>
@@ -448,17 +488,38 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
 
-            // We're going to send the reply async, because there may be
-            // an enormous quantity of packets -- basically the entire inventory!
-            // We don't want to block the client thread while all that is happening.
-            SendInventoryDelegate d = SendInventoryAsync;
-            d.BeginInvoke(remoteClient, folderID, ownerID, fetchFolders, fetchItems, sortOrder, SendInventoryComplete, d);
+            lock (m_descendentsRequestLock)
+            {
+                if (!m_descendentsRequestProcessing)
+                {
+                    m_descendentsRequestProcessing = true;
+
+                    // We're going to send the reply async, because there may be
+                    // an enormous quantity of packets -- basically the entire inventory!
+                    // We don't want to block the client thread while all that is happening.
+                    SendInventoryDelegate d = SendInventoryAsync;
+                    d.BeginInvoke(remoteClient, folderID, ownerID, fetchFolders, fetchItems, sortOrder, SendInventoryComplete, d);
+
+                    return;
+                }
+
+                DescendentsRequestData req = new DescendentsRequestData();
+                req.RemoteClient = remoteClient;
+                req.FolderID = folderID;
+                req.OwnerID = ownerID;
+                req.FetchFolders = fetchFolders;
+                req.FetchItems = fetchItems;
+                req.SortOrder = sortOrder;
+
+                m_descendentsRequestQueue.Enqueue(req);
+            }
         }
 
         delegate void SendInventoryDelegate(IClientAPI remoteClient, UUID folderID, UUID ownerID, bool fetchFolders, bool fetchItems, int sortOrder);
 
         void SendInventoryAsync(IClientAPI remoteClient, UUID folderID, UUID ownerID, bool fetchFolders, bool fetchItems, int sortOrder)
         {
+            Thread.Sleep(20);
             SendInventoryUpdate(remoteClient, new InventoryFolderBase(folderID), fetchFolders, fetchItems);
         }
 
@@ -466,6 +527,21 @@ namespace OpenSim.Region.Framework.Scenes
         {
             SendInventoryDelegate d = (SendInventoryDelegate)iar.AsyncState;
             d.EndInvoke(iar);
+
+            lock (m_descendentsRequestLock)
+            {
+                if (m_descendentsRequestQueue.Count > 0)
+                {
+                    DescendentsRequestData req = m_descendentsRequestQueue.Dequeue();
+
+                    d = SendInventoryAsync;
+                    d.BeginInvoke(req.RemoteClient, req.FolderID, req.OwnerID, req.FetchFolders, req.FetchItems, req.SortOrder, SendInventoryComplete, d);
+
+                    return;
+                }
+
+                m_descendentsRequestProcessing = false;
+            }
         }
         
         /// <summary>
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 9cfe869..c132c5d 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -227,8 +227,8 @@ 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 int MaxUndoCount { get; set; }
+        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;
@@ -244,11 +244,13 @@ 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 AgentCircuitManager m_authenticateHandler;
         protected SceneCommunicationService m_sceneGridService;
+        protected ISnmpModule m_snmpService = null;
 
         protected ISimulationDataService m_SimulationDataService;
         protected IEstateDataService m_EstateDataService;
@@ -311,8 +313,8 @@ namespace OpenSim.Region.Framework.Scenes
         private int m_update_presences = 1; // Update scene presence movements
         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_terrain = 1000;
+        private int m_update_land = 10;
         private int m_update_coarse_locations = 50;
 
         private int agentMS;
@@ -325,13 +327,13 @@ namespace OpenSim.Region.Framework.Scenes
         private int backupMS;
         private int terrainMS;
         private int landMS;
-        private int spareMS;
 
         /// <summary>
         /// Tick at which the last frame was processed.
         /// </summary>
         private int m_lastFrameTick;
 
+        public bool CombineRegions = false;
         /// <summary>
         /// Tick at which the last maintenance run occurred.
         /// </summary>
@@ -351,7 +353,7 @@ namespace OpenSim.Region.Framework.Scenes
         private readonly Timer m_restartTimer = new Timer(15000); // Wait before firing
         private volatile bool m_backingup;
         private Dictionary<UUID, ReturnInfo> m_returns = new Dictionary<UUID, ReturnInfo>();
-        private Dictionary<UUID, SceneObjectGroup> m_groupsWithTargets = new Dictionary<UUID, SceneObjectGroup>();
+        private Dictionary<UUID, int> m_groupsWithTargets = new Dictionary<UUID, int>();
 
         private string m_defaultScriptEngine;
 
@@ -360,6 +362,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         private int m_LastLogin;
 
+        private int m_lastIncoming;
+        private int m_lastOutgoing;
+        private int m_hbRestarts = 0;
+
+
         /// <summary>
         /// Thread that runs the scene loop.
         /// </summary>
@@ -402,7 +409,7 @@ namespace OpenSim.Region.Framework.Scenes
         private volatile bool m_active;
 
 //        private int m_lastUpdate;
-//        private bool m_firstHeartbeat = true;
+        private bool m_firstHeartbeat = true;
         
         private UpdatePrioritizationSchemes m_priorityScheme = UpdatePrioritizationSchemes.Time;
         private bool m_reprioritizationEnabled = true;
@@ -446,6 +453,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
@@ -738,6 +758,8 @@ namespace OpenSim.Region.Framework.Scenes
             m_SimulationDataService = simDataService;
             m_EstateDataService = estateDataService;
             m_regionHandle = RegionInfo.RegionHandle;
+            m_lastIncoming = 0;
+            m_lastOutgoing = 0;
 
             m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this);
             m_asyncSceneObjectDeleter.Enabled = true;
@@ -831,7 +853,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                 StartDisabled = startupConfig.GetBoolean("StartDisabled", false);
 
-                m_defaultDrawDistance = startupConfig.GetFloat("DefaultDrawDistance", m_defaultDrawDistance);
+                m_defaultDrawDistance = startupConfig.GetFloat("DefaultDrawDistance",m_defaultDrawDistance);
                 UseBackup = startupConfig.GetBoolean("UseSceneBackup", UseBackup);
                 if (!UseBackup)
                     m_log.InfoFormat("[SCENE]: Backup has been disabled for {0}", RegionInfo.RegionName);
@@ -839,10 +861,8 @@ namespace OpenSim.Region.Framework.Scenes
                 //Animation states
                 m_useFlySlow = startupConfig.GetBoolean("enableflyslow", false);
 
-                MaxUndoCount = startupConfig.GetInt("MaxPrimUndos", 20);
-
-                PhysicalPrims = startupConfig.GetBoolean("physical_prim", PhysicalPrims);
-                CollidablePrims = startupConfig.GetBoolean("collidable_prim", CollidablePrims);
+                PhysicalPrims = startupConfig.GetBoolean("physical_prim", true);
+                CollidablePrims = startupConfig.GetBoolean("collidable_prim", true);
 
                 m_minNonphys = startupConfig.GetFloat("NonPhysicalPrimMin", m_minNonphys);
                 if (RegionInfo.NonphysPrimMin > 0)
@@ -863,11 +883,21 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
                 m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", m_maxPhys);
+
                 if (RegionInfo.PhysPrimMax > 0)
                 {
                     m_maxPhys = RegionInfo.PhysPrimMax;
                 }
 
+                m_linksetCapacity = startupConfig.GetInt("LinksetPrims", m_linksetCapacity);
+                if (RegionInfo.LinksetCapacity > 0)
+                {
+                    m_linksetCapacity = RegionInfo.LinksetCapacity;
+                }
+
+                SpawnPointRouting = startupConfig.GetString("SpawnPointRouting", "closest");
+                TelehubAllowLandmarks = startupConfig.GetBoolean("TelehubAllowLandmark", false);
+
                 // Here, if clamping is requested in either global or
                 // local config, it will be used
                 //
@@ -877,13 +907,7 @@ namespace OpenSim.Region.Framework.Scenes
                     m_clampPrimSize = true;
                 }
 
-                m_linksetCapacity = startupConfig.GetInt("LinksetPrims", m_linksetCapacity);
-                if (RegionInfo.LinksetCapacity > 0)
-                {
-                    m_linksetCapacity = RegionInfo.LinksetCapacity;
-                }
-
-                m_useTrashOnDelete = startupConfig.GetBoolean("UseTrashOnDelete", m_useTrashOnDelete);
+                m_useTrashOnDelete = startupConfig.GetBoolean("UseTrashOnDelete",m_useTrashOnDelete);
                 m_trustBinaries = startupConfig.GetBoolean("TrustBinaries", m_trustBinaries);
                 m_allowScriptCrossings = startupConfig.GetBoolean("AllowScriptCrossing", m_allowScriptCrossings);
                 m_dontPersistBefore =
@@ -894,11 +918,11 @@ namespace OpenSim.Region.Framework.Scenes
                 m_persistAfter *= 10000000;
 
                 m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "XEngine");
-
-                SpawnPointRouting = startupConfig.GetString("SpawnPointRouting", "closest");
-                TelehubAllowLandmarks = startupConfig.GetBoolean("TelehubAllowLandmark", false);
+                m_log.InfoFormat("[SCENE]: Default script engine {0}", m_defaultScriptEngine);
 
                 m_strictAccessControl = startupConfig.GetBoolean("StrictAccessControl", m_strictAccessControl);
+                m_seeIntoBannedRegion = startupConfig.GetBoolean("SeeIntoBannedRegion", m_seeIntoBannedRegion);
+                CombineRegions = startupConfig.GetBoolean("CombineContiguousRegions", false);
 
                 string[] possibleMapConfigSections = new string[] { "Map", "Startup" };
 
@@ -943,7 +967,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (grant.Length > 0)
                 {
-                    foreach (string viewer in grant.Split('|'))
+                    foreach (string viewer in grant.Split(','))
                     {
                         m_AllowedViewers.Add(viewer.Trim().ToLower());
                     }
@@ -955,7 +979,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (grant.Length > 0)
                 {
-                    foreach (string viewer in grant.Split('|'))
+                    foreach (string viewer in grant.Split(','))
                     {
                         m_BannedViewers.Add(viewer.Trim().ToLower());
                     }
@@ -1015,6 +1039,8 @@ namespace OpenSim.Region.Framework.Scenes
             StatsReporter = new SimStatsReporter(this);
             StatsReporter.OnSendStatsResult += SendSimStatsPackets;
             StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats;
+
+            MainConsole.Instance.Commands.AddCommand("scene", false, "gc collect", "gc collect", "gc collect", "Cause the garbage collector to make a single pass", HandleGcCollect);
         }
 
         public Scene(RegionInfo regInfo) : base(regInfo)
@@ -1310,8 +1336,11 @@ namespace OpenSim.Region.Framework.Scenes
             // Stop all client threads.
             ForEachScenePresence(delegate(ScenePresence avatar) { avatar.ControllingClient.Close(); });
 
-            m_log.Debug("[SCENE]: Persisting changed objects");
+            m_log.Debug("[SCENE]: TriggerSceneShuttingDown");
             EventManager.TriggerSceneShuttingDown(this);
+
+            m_log.Debug("[SCENE]: Persisting changed objects");
+
             Backup(false);
             m_sceneGraph.Close();
 
@@ -1325,6 +1354,7 @@ namespace OpenSim.Region.Framework.Scenes
             // attempt to reference a null or disposed physics scene.
             if (PhysicsScene != null)
             {
+                m_log.Debug("[SCENE]: Dispose Physics");
                 PhysicsScene phys = PhysicsScene;
                 // remove the physics engine from both Scene and SceneGraph
                 PhysicsScene = null;
@@ -1355,11 +1385,29 @@ namespace OpenSim.Region.Framework.Scenes
             //m_heartbeatTimer.Elapsed += new ElapsedEventHandler(Heartbeat);
             if (m_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);
                 m_heartbeatThread.Abort();
+                Watchdog.AbortThread(m_heartbeatThread.ManagedThreadId);
                 m_heartbeatThread = null;
             }
 //            m_lastUpdate = Util.EnvironmentTickCount();
 
+//            m_sceneGraph.PreparePhysicsSimulation();
+
+
             m_heartbeatThread
                 = Watchdog.StartThread(
                     Heartbeat, string.Format("Heartbeat ({0})", RegionInfo.RegionName), ThreadPriority.Normal, false, false);
@@ -1504,16 +1552,20 @@ namespace OpenSim.Region.Framework.Scenes
                 endFrame = Frame + frames;
 
             float physicsFPS = 0f;
-            int previousFrameTick, tmpMS;
-            int maintc = Util.EnvironmentTickCount();
+            int tmpMS;
+            int previousFrameTick;
+            int maintc;
+            int sleepMS;
+            int framestart;
 
             while (!m_shuttingDown && ((endFrame == null && Active) || Frame < endFrame))
             {
+                framestart = Util.EnvironmentTickCount();
                 ++Frame;
 
 //            m_log.DebugFormat("[SCENE]: Processing frame {0} in {1}", Frame, RegionInfo.RegionName);
 
-                agentMS = tempOnRezMS = eventMS = backupMS = terrainMS = landMS = spareMS = 0;
+                agentMS = tempOnRezMS = eventMS = backupMS = terrainMS = landMS = 0;
 
                 try
                 {
@@ -1567,6 +1619,7 @@ namespace OpenSim.Region.Framework.Scenes
                         m_sceneGraph.UpdatePresences();
     
                     agentMS += Util.EnvironmentTickCountSubtract(tmpMS);
+
     
                     // Delete temp-on-rez stuff
                     if (Frame % m_update_temp_cleaning == 0 && !m_cleaningTemps)
@@ -1648,34 +1701,37 @@ namespace OpenSim.Region.Framework.Scenes
 
                 Watchdog.UpdateThread();
 
+                otherMS = tempOnRezMS + eventMS + backupMS + terrainMS + landMS;
+
+                StatsReporter.AddPhysicsFPS(physicsFPS);
+                StatsReporter.AddTimeDilation(TimeDilation);
+                StatsReporter.AddFPS(1);
+
+                StatsReporter.addAgentMS(agentMS);
+                StatsReporter.addPhysicsMS(physicsMS + physicsMS2);
+                StatsReporter.addOtherMS(otherMS);
+                StatsReporter.addScriptLines(m_sceneGraph.GetScriptLPS());
+
                 previousFrameTick = m_lastFrameTick;
                 m_lastFrameTick = Util.EnvironmentTickCount();
-                tmpMS = Util.EnvironmentTickCountSubtract(m_lastFrameTick, maintc);
+                tmpMS = Util.EnvironmentTickCountSubtract(m_lastFrameTick, framestart);
                 tmpMS = (int)(MinFrameTime * 1000) - tmpMS;
 
+                m_firstHeartbeat = false;
+
+                sleepMS = Util.EnvironmentTickCount();
+
                 if (tmpMS > 0)
-                {
                     Thread.Sleep(tmpMS);
-                    spareMS += tmpMS;
-                }
-
-                frameMS = Util.EnvironmentTickCountSubtract(maintc);
-                maintc = Util.EnvironmentTickCount();
 
-                otherMS = tempOnRezMS + eventMS + backupMS + terrainMS + landMS;
+                sleepMS = Util.EnvironmentTickCountSubtract(sleepMS);
+                frameMS = Util.EnvironmentTickCountSubtract(framestart);
+                StatsReporter.addSleepMS(sleepMS);
+                StatsReporter.addFrameMS(frameMS);
 
                 // if (Frame%m_update_avatars == 0)
                 //   UpdateInWorldTime();
-                StatsReporter.AddPhysicsFPS(physicsFPS);
-                StatsReporter.AddTimeDilation(TimeDilation);
-                StatsReporter.AddFPS(1);
 
-                StatsReporter.addFrameMS(frameMS);
-                StatsReporter.addAgentMS(agentMS);
-                StatsReporter.addPhysicsMS(physicsMS + physicsMS2);
-                StatsReporter.addOtherMS(otherMS);
-                StatsReporter.AddSpareMS(spareMS);
-                StatsReporter.addScriptLines(m_sceneGraph.GetScriptLPS());
 
                // Optionally warn if a frame takes double the amount of time that it should.
                 if (DebugUpdates
@@ -1692,7 +1748,7 @@ namespace OpenSim.Region.Framework.Scenes
         public void AddGroupTarget(SceneObjectGroup grp)
         {
             lock (m_groupsWithTargets)
-                m_groupsWithTargets[grp.UUID] = grp;
+                m_groupsWithTargets[grp.UUID] = 0;
         }
 
         public void RemoveGroupTarget(SceneObjectGroup grp)
@@ -1703,18 +1759,24 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void CheckAtTargets()
         {
-            List<SceneObjectGroup> objs = null;
+            List<UUID> objs = null;
 
             lock (m_groupsWithTargets)
             {
                 if (m_groupsWithTargets.Count != 0)
-                    objs = new List<SceneObjectGroup>(m_groupsWithTargets.Values);
+                    objs = new List<UUID>(m_groupsWithTargets.Keys);
             }
 
             if (objs != null)
             {
-                foreach (SceneObjectGroup entry in objs)
-                    entry.checkAtTargets();
+                foreach (UUID entry in objs)
+                {
+                    SceneObjectGroup grp = GetSceneObjectGroup(entry);
+                    if (grp == null)
+                        m_groupsWithTargets.Remove(entry);
+                    else
+                        grp.checkAtTargets();
+                }
             }
         }
 
@@ -1793,7 +1855,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;
@@ -2022,7 +2084,7 @@ namespace OpenSim.Region.Framework.Scenes
             return PhysicsScene.SupportsRaycastWorldFiltered();
         }
 
-        public object RayCastFiltered(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)
+        public object RayCastFiltered(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)      
         {
             if (PhysicsScene == null)
                 return null;
@@ -2044,14 +2106,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);
 
@@ -2073,7 +2145,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
@@ -2096,13 +2168,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.
@@ -2111,13 +2180,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
@@ -2128,8 +2196,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;
         }
 
 
@@ -2220,12 +2292,12 @@ namespace OpenSim.Region.Framework.Scenes
         {
             if (m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates))
             {
+                sceneObject.IsDeleted = false;
                 EventManager.TriggerObjectAddedToScene(sceneObject);
                 return true;
             }
 
             return false;
-
         }
         
         /// <summary>
@@ -2317,6 +2389,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();
@@ -2325,11 +2406,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>
@@ -2360,6 +2454,14 @@ namespace OpenSim.Region.Framework.Scenes
             else
                 group.StopScriptInstances();
 
+            List<UUID> avatars = group.GetSittingAvatars();
+            foreach (UUID av in avatars)
+            {
+                ScenePresence p = GetScenePresence(av);
+                if (p != null)
+                    p.StandUp();
+            }
+
             SceneObjectPart[] partList = group.Parts;
 
             foreach (SceneObjectPart part in partList)
@@ -2387,6 +2489,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);            
         }
@@ -2676,7 +2780,7 @@ namespace OpenSim.Region.Framework.Scenes
             // If the user is banned, we won't let any of their objects
             // enter. Period.
             //
-            if (RegionInfo.EstateSettings.IsBanned(newObject.OwnerID))
+            if (RegionInfo.EstateSettings.IsBanned(newObject.OwnerID, 36))
             {
                 m_log.InfoFormat("[INTERREGION]: Denied prim crossing for banned avatar {0}", newObject.OwnerID);
                 return false;
@@ -2731,6 +2835,23 @@ 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.
+            //
+            int flags = GetUserFlags(sceneObject.OwnerID);
+            if (RegionInfo.EstateSettings.IsBanned(sceneObject.OwnerID, flags))
+            {
+                m_log.InfoFormat("[INTERREGION]: Denied prim crossing for banned avatar {0}", sceneObject.OwnerID);
+
+                return false;
+            }
+
             // Force allocation of new LocalId
             //
             SceneObjectPart[] parts = sceneObject.Parts;
@@ -2767,16 +2888,27 @@ namespace OpenSim.Region.Framework.Scenes
                     // information that this is due to a teleport/border cross rather than an ordinary attachment.
                     // We currently do this in Scene.MakeRootAgent() instead.
                     if (AttachmentsModule != null)
-                        AttachmentsModule.AttachObject(sp, grp, 0, false, false, true);
+                        AttachmentsModule.AttachObject(sp, grp, 0, false, false, false, true);
                 }
                 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);
             }
 
@@ -2793,6 +2925,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
@@ -2825,7 +2975,7 @@ namespace OpenSim.Region.Framework.Scenes
                     = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
                         || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
     
-    //            CheckHeartbeat();
+                CheckHeartbeat();
     
                 sp = GetScenePresence(client.AgentId);
 
@@ -2843,6 +2993,13 @@ namespace OpenSim.Region.Framework.Scenes
                     SubscribeToClientEvents(client);
     
                     sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
+                    InventoryFolderBase cof = InventoryService.GetFolderForType(client.AgentId, (AssetType)46);
+                    if (cof == null)
+                        sp.COF = UUID.Zero;
+                    else
+                        sp.COF = cof.ID;
+
+                    m_log.DebugFormat("[SCENE]: COF for {0} is {1}", client.AgentId, sp.COF);
                     m_eventManager.TriggerOnNewPresence(sp);
     
                     sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;
@@ -2957,19 +3114,14 @@ 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);
+
                         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);
 
@@ -3014,6 +3166,8 @@ namespace OpenSim.Region.Framework.Scenes
             client.OnUpdatePrimGroupPosition += m_sceneGraph.UpdatePrimGroupPosition;
             client.OnUpdatePrimSinglePosition += m_sceneGraph.UpdatePrimSinglePosition;
 
+            client.onClientChangeObject += m_sceneGraph.ClientChangeObject;
+
             client.OnUpdatePrimGroupRotation += m_sceneGraph.UpdatePrimGroupRotation;
             client.OnUpdatePrimGroupMouseRotation += m_sceneGraph.UpdatePrimGroupRotation;
             client.OnUpdatePrimSingleRotation += m_sceneGraph.UpdatePrimSingleRotation;
@@ -3070,6 +3224,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;
@@ -3139,6 +3294,8 @@ namespace OpenSim.Region.Framework.Scenes
             client.OnUpdatePrimGroupPosition -= m_sceneGraph.UpdatePrimGroupPosition;
             client.OnUpdatePrimSinglePosition -= m_sceneGraph.UpdatePrimSinglePosition;
 
+            client.onClientChangeObject -= m_sceneGraph.ClientChangeObject;
+
             client.OnUpdatePrimGroupRotation -= m_sceneGraph.UpdatePrimGroupRotation;
             client.OnUpdatePrimGroupMouseRotation -= m_sceneGraph.UpdatePrimGroupRotation;
             client.OnUpdatePrimSingleRotation -= m_sceneGraph.UpdatePrimSingleRotation;
@@ -3444,7 +3601,7 @@ namespace OpenSim.Region.Framework.Scenes
                     // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
                     // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
                     if (closeChildAgents && CapsModule != null)
-                        CapsModule.RemoveCaps(agentID);
+                        CapsModule.RemoveCaps(agentID, avatar.ControllingClient.CircuitCode);
     
                     if (closeChildAgents && !isChildAgent)
                     {
@@ -3477,6 +3634,7 @@ namespace OpenSim.Region.Framework.Scenes
                     // It's possible for child agents to have transactions if changes are being made cross-border.
                     if (AgentTransactionsModule != null)
                         AgentTransactionsModule.RemoveAgentAssetTransactions(agentID);
+                    m_log.Debug("[Scene] The avatar has left the building");
                 }
                 catch (Exception e)
                 {
@@ -3670,15 +3828,27 @@ namespace OpenSim.Region.Framework.Scenes
                     agent.firstname, agent.lastname, agent.Viewer);
                 reason = "Access denied, your viewer is banned by the region owner";
                 return false;
-            }
+            }           
 
-            ILandObject land;
+            ScenePresence sp = GetScenePresence(agent.AgentID);
 
-            lock (agent)
+            // If we have noo presence here or if that presence is a zombie root
+            // presence that will be kicled, we need a new CAPS object.
+            if (sp == null || (sp != null && !sp.IsChildAgent))
             {
-                ScenePresence sp = GetScenePresence(agent.AgentID);
-    
-                if (sp != null && !sp.IsChildAgent)
+                if (CapsModule != null)
+                {
+                    lock (agent)
+                    {
+                        CapsModule.SetAgentCapsSeeds(agent);
+                        CapsModule.CreateCaps(agent.AgentID, agent.circuitcode);
+                    }
+                }
+            }
+
+            if (sp != null)
+            {
+                if (!sp.IsChildAgent)
                 {
                     // We have a zombie from a crashed session. 
                     // Or the same user is trying to be root twice here, won't work.
@@ -3688,29 +3858,34 @@ namespace OpenSim.Region.Framework.Scenes
                         sp.Name, sp.UUID, RegionInfo.RegionName);
     
                     if (sp.ControllingClient != null)
-                        sp.ControllingClient.Close(true);
+                        sp.ControllingClient.Close(true, true);
 
                     sp = null;
                 }
+            }
 
+            lock (agent)
+            {
                 // Optimistic: add or update the circuit data with the new agent circuit data and teleport flags.
                 // We need the circuit data here for some of the subsequent checks. (groups, for example)
                 // If the checks fail, we remove the circuit.
                 agent.teleportFlags = teleportFlags;
                 m_authenticateHandler.AddNewCircuit(agent.circuitcode, agent);
 
-                land = LandChannel.GetLandObject(agent.startpos.X, agent.startpos.Y);
-    
                 // On login test land permisions
                 if (vialogin)
                 {
-                    if (land != null && !TestLandRestrictions(agent.AgentID, out reason, ref agent.startpos.X, ref agent.startpos.Y))
+                    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());
                         m_authenticateHandler.RemoveCircuit(agent.circuitcode);
                         return false;
                     }
                 }
-    
+
                 if (sp == null) // We don't have an [child] agent here already
                 {
                     if (requirePresenceLookup)
@@ -3732,13 +3907,18 @@ namespace OpenSim.Region.Framework.Scenes
                             return false;
                         }
                     }
-    
+
                     try
                     {
-                        if (!AuthorizeUser(agent, out reason))
+                        // Always check estate if this is a login. Always
+                        // check if banned regions are to be blacked out.
+                        if (vialogin || (!m_seeIntoBannedRegion))
                         {
-                            m_authenticateHandler.RemoveCircuit(agent.circuitcode);
-                            return false;
+                            if (!AuthorizeUser(agent, out reason))
+                            {
+                                m_authenticateHandler.RemoveCircuit(agent.circuitcode);
+                                return false;
+                            }
                         }
                     }
                     catch (Exception e)
@@ -3749,32 +3929,27 @@ namespace OpenSim.Region.Framework.Scenes
                         m_authenticateHandler.RemoveCircuit(agent.circuitcode);
                         return false;
                     }
-    
+
                     m_log.InfoFormat(
                         "[SCENE]: Region {0} authenticated and authorized incoming {1} agent {2} {3} {4} (circuit code {5})",
                         RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
                         agent.AgentID, agent.circuitcode);
-    
-                    if (CapsModule != null)
-                    {
-                        CapsModule.SetAgentCapsSeeds(agent);
-                        CapsModule.CreateCaps(agent.AgentID);
-                    }
+
                 }
                 else
                 {
                     // Let the SP know how we got here. This has a lot of interesting
                     // uses down the line.
                     sp.TeleportFlags = (TPFlags)teleportFlags;
-    
+
                     if (sp.IsChildAgent)
                     {
                         m_log.DebugFormat(
                             "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
                             agent.AgentID, RegionInfo.RegionName);
-    
+
                         sp.AdjustKnownSeeds();
-                        
+
                         if (CapsModule != null)
                             CapsModule.SetAgentCapsSeeds(agent);
                     }
@@ -3786,6 +3961,11 @@ namespace OpenSim.Region.Framework.Scenes
                 CacheUserName(null, agent);
             }
 
+            if (CapsModule != null)
+            {
+                CapsModule.ActivateCaps(agent.circuitcode);
+            }
+
             if (vialogin)
             {
 //                CleanDroppedAttachments();
@@ -3877,6 +4057,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)
@@ -3884,6 +4066,7 @@ namespace OpenSim.Region.Framework.Scenes
                         agent.startpos = land.LandData.UserLocation;
                     }
                 }
+                */// This is now handled properly in ScenePresence.MakeRootAgent
             }
 
             return true;
@@ -3981,7 +4164,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (!m_strictAccessControl) return true;
             if (Permissions.IsGod(agent.AgentID)) return true;
-                      
+
             if (AuthorizationService != null)
             {
                 if (!AuthorizationService.IsAuthorizedForRegion(
@@ -3996,7 +4179,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (RegionInfo.EstateSettings != null)
             {
-                if (RegionInfo.EstateSettings.IsBanned(agent.AgentID))
+                if (RegionInfo.EstateSettings.IsBanned(agent.AgentID, 0))
                 {
                     m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user is on the banlist",
                                      agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
@@ -4184,6 +4367,15 @@ namespace OpenSim.Region.Framework.Scenes
             m_log.DebugFormat(
                 "[SCENE]: Incoming child agent update for {0} in {1}", cAgentData.AgentID, RegionInfo.RegionName);
 
+            // 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 (RegionInfo.EstateSettings.IsBanned(cAgentData.AgentID, flags))
+            {
+                m_log.DebugFormat("[SCENE]: Denying root agent entry to {0}: banned", cAgentData.AgentID);
+                return false;
+            }
+
             // TODO: This check should probably be in QueryAccess().
             ILandObject nearestParcel = GetNearestAllowedParcel(cAgentData.AgentID, Constants.RegionSize / 2, Constants.RegionSize / 2);
             if (nearestParcel == null)
@@ -4258,7 +4450,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name='agentID'></param>
         protected virtual ScenePresence WaitGetScenePresence(UUID agentID)
         {
-            int ntimes = 10;
+            int ntimes = 30;
             ScenePresence sp = null;
             while ((sp = GetScenePresence(agentID)) == null && (ntimes-- > 0))
                 Thread.Sleep(1000);
@@ -4307,6 +4499,16 @@ 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>
@@ -4321,7 +4523,7 @@ namespace OpenSim.Region.Framework.Scenes
             ScenePresence presence = m_sceneGraph.GetScenePresence(agentID);
             if (presence != null)
             {
-                presence.ControllingClient.Close(force);
+                presence.ControllingClient.Close(force, force);
                 return true;
             }
 
@@ -4939,7 +5141,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if ((grp.RootPart.Flags & PrimFlags.TemporaryOnRez) != 0)
                         {
-                            if (grp.RootPart.Expires <= DateTime.Now)
+                            if (grp.GetSittingAvatarsCount() == 0 && grp.RootPart.Expires <= DateTime.Now)
                                 DeleteSceneObject(grp, false);
                         }
                     }
@@ -4953,35 +5155,81 @@ namespace OpenSim.Region.Framework.Scenes
             SimulationDataService.RemoveObject(uuid, RegionInfo.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
             //
-            // 3 = We have seen a new user enter within the past 4 minutes
+            // 4 = Sim is up and both packet threads are running. Sim is
+            // likely usable
+            //
+            // 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_lastFrameTick)) < 1000)
-                health += 1;
+            {
+                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;
         }
 
@@ -5069,7 +5317,7 @@ namespace OpenSim.Region.Framework.Scenes
             bool wasUsingPhysics = ((jointProxyObject.Flags & PrimFlags.Physics) != 0);
             if (wasUsingPhysics)
             {
-                jointProxyObject.UpdatePrimFlags(false, false, true, false); // FIXME: possible deadlock here; check to make sure all the scene alterations set into motion here won't deadlock
+                jointProxyObject.UpdatePrimFlags(false, false, true, false,false); // FIXME: possible deadlock here; check to make sure all the scene alterations set into motion here won't deadlock
             }
         }
 
@@ -5168,14 +5416,14 @@ namespace OpenSim.Region.Framework.Scenes
             return (((vsn.X * xdiff) + (vsn.Y * ydiff)) / (-1 * vsn.Z)) + p0.Z;
         }
 
-//        private void CheckHeartbeat()
-//        {
-//            if (m_firstHeartbeat)
-//                return;
-//
-//            if (Util.EnvironmentTickCountSubtract(m_lastFrameTick) > 2000)
-//                StartTimer();
-//        }
+        private void CheckHeartbeat()
+        {
+            if (m_firstHeartbeat)
+                return;
+
+            if ((Util.EnvironmentTickCountSubtract(m_lastFrameTick)) > 5000)
+                Start();
+        }
 
         public override ISceneObject DeserializeObject(string representation)
         {
@@ -5233,7 +5481,7 @@ namespace OpenSim.Region.Framework.Scenes
             Vector3 nearestRegionEdgePoint = GetNearestRegionEdgePosition(avatar);
 
             //Debug.WriteLine("They are really in a place they don't belong, sending them to: " + nearestRegionEdgePoint.ToString());
-
+            
             return nearestRegionEdgePoint;
         }
 
@@ -5487,7 +5735,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();
 
@@ -5649,7 +5945,19 @@ namespace OpenSim.Region.Framework.Scenes
             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>
@@ -5728,6 +6036,11 @@ namespace OpenSim.Region.Framework.Scenes
             return m_SpawnPoint - 1;
         }
 
+        private void HandleGcCollect(string module, string[] args)
+        {
+            GC.Collect();
+        }
+
         /// <summary>
         /// Wrappers to get physics modules retrieve assets. 
         /// </summary>
diff --git a/OpenSim/Region/Framework/Scenes/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index d2097ea..4eef162 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -143,7 +143,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         protected ulong m_regionHandle;
         protected string m_regionName;
-        protected RegionInfo m_regInfo;
 
         public ITerrainChannel Heightmap;
 
@@ -168,6 +167,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 77889fa..52f46f2 100644
--- a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
@@ -194,8 +194,11 @@ 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, string auth_token)
         {
@@ -223,16 +226,14 @@ namespace OpenSim.Region.Framework.Scenes
         {
             foreach (ulong handle in regionslst)
             {
-                // We must take a copy here since handle is acts like a reference when used in an iterator.
-                // This leads to race conditions if directly passed to SendCloseChildAgent with more than one neighbour region.
                 ulong handleCopy = handle;
                 Util.FireAndForget((o) => { SendCloseChildAgent(agentID, handleCopy, auth_code); });
             }
         }
-       
+
         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 bb7ae7f..e599e90 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -41,6 +41,12 @@ namespace OpenSim.Region.Framework.Scenes
 {
     public delegate void PhysicsCrash();
 
+    public delegate void AttachToBackupDelegate(SceneObjectGroup sog);
+
+    public delegate void DetachFromBackupDelegate(SceneObjectGroup sog);
+
+    public delegate void ChangedBackupDelegate(SceneObjectGroup sog);
+
     /// <summary>
     /// This class used to be called InnerScene and may not yet truly be a SceneGraph.  The non scene graph components
     /// should be migrated out over time.
@@ -54,11 +60,15 @@ namespace OpenSim.Region.Framework.Scenes
         protected internal event PhysicsCrash UnRecoverableError;
         private PhysicsCrash handlerPhysicsCrash = null;
 
+        public event AttachToBackupDelegate OnAttachToBackup;
+        public event DetachFromBackupDelegate OnDetachFromBackup;
+        public event ChangedBackupDelegate OnChangeBackup;
+
         #endregion
 
         #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>();
 
@@ -127,13 +137,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();
@@ -254,6 +269,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();
@@ -317,9 +359,8 @@ namespace OpenSim.Region.Framework.Scenes
             if (pa != null && pa.IsPhysical && vel != Vector3.Zero)
             {
                 sceneObject.RootPart.ApplyImpulse((vel * sceneObject.GetMass()), false);
-                sceneObject.Velocity = vel;
             }
-        
+
             return true;
         }
 
@@ -344,6 +385,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// </returns>
         protected bool AddSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, bool sendClientUpdates)
         {
+            if (sceneObject == null)
+            {
+                m_log.ErrorFormat("[SCENEGRAPH]: Tried to add null scene object");
+                return false;
+            }
             if (sceneObject.UUID == UUID.Zero)
             {
                 m_log.ErrorFormat(
@@ -475,6 +521,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>
@@ -519,12 +589,12 @@ namespace OpenSim.Region.Framework.Scenes
 
         protected internal void AddPhysicalPrim(int number)
         {
-            m_physicalPrim++;
+            m_physicalPrim += number;
         }
 
         protected internal void RemovePhysicalPrim(int number)
         {
-            m_physicalPrim--;
+            m_physicalPrim -= number;
         }
 
         protected internal void AddToScriptLPS(int number)
@@ -592,7 +662,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);
@@ -616,6 +687,10 @@ namespace OpenSim.Region.Framework.Scenes
                 m_scenePresenceMap = newmap;
                 m_scenePresenceArray = newlist;
             }
+            finally
+            {
+                m_scenePresencesLock.ExitWriteLock();
+            }
         }
 
         /// <summary>
@@ -630,7 +705,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);
@@ -652,6 +728,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)
@@ -1205,6 +1285,52 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region Client Event handlers
 
+        protected internal void ClientChangeObject(uint localID, object odata, IClientAPI remoteClient)
+        {
+            SceneObjectPart part = GetSceneObjectPart(localID);
+            ObjectChangeData data = (ObjectChangeData)odata;
+
+            if (part != null)
+            {
+                SceneObjectGroup grp = part.ParentGroup;
+                if (grp != null)
+                {
+                    if (m_parentScene.Permissions.CanEditObject(grp.UUID, remoteClient.AgentId))
+                    {
+                        // These two are exceptions SL makes in the interpretation
+                        // of the change flags. Must check them here because otherwise
+                        // the group flag (see below) would be lost
+                        if (data.change == ObjectChangeType.groupS)
+                            data.change = ObjectChangeType.primS;
+                        if (data.change == ObjectChangeType.groupPS)
+                            data.change = ObjectChangeType.primPS;
+                        part.StoreUndoState(data.change); // lets test only saving what we changed
+                        grp.doChangeObject(part, (ObjectChangeData)data);
+                    }
+                    else
+                    {
+                        // Is this any kind of group operation?
+                        if ((data.change & ObjectChangeType.Group) != 0)
+                        {
+                            // Is a move and/or rotation requested?
+                            if ((data.change & (ObjectChangeType.Position | ObjectChangeType.Rotation)) != 0)
+                            {
+                                // Are we allowed to move it?
+                                if (m_parentScene.Permissions.CanMoveObject(grp.UUID, remoteClient.AgentId))
+                                {
+                                    // Strip all but move and rotation from request
+                                    data.change &= (ObjectChangeType.Group | ObjectChangeType.Position | ObjectChangeType.Rotation);
+
+                                    part.StoreUndoState(data.change);
+                                    grp.doChangeObject(part, (ObjectChangeData)data);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Update the scale of an individual prim.
         /// </summary>
@@ -1219,7 +1345,17 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_parentScene.Permissions.CanEditObject(part.ParentGroup.UUID, remoteClient.AgentId))
                 {
+                    bool physbuild = false;
+                    if (part.ParentGroup.RootPart.PhysActor != null)
+                    {
+                        part.ParentGroup.RootPart.PhysActor.Building = true;
+                        physbuild = true;
+                    }
+
                     part.Resize(scale);
+
+                    if (physbuild)
+                        part.ParentGroup.RootPart.PhysActor.Building = false;
                 }
             }
         }
@@ -1231,7 +1367,17 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
+                    bool physbuild = false;
+                    if (group.RootPart.PhysActor != null)
+                    {
+                        group.RootPart.PhysActor.Building = true;
+                        physbuild = true;
+                    }
+
                     group.GroupResize(scale);
+
+                    if (physbuild)
+                        group.RootPart.PhysActor.Building = false;
                 }
             }
         }
@@ -1359,8 +1505,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
                 {
@@ -1581,6 +1732,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         part.Material = Convert.ToByte(material);
                         group.HasGroupChanged = true;
+                        remoteClient.SendPartPhysicsProprieties(part);
                     }
                 }
             }
@@ -1659,8 +1811,10 @@ namespace OpenSim.Region.Framework.Scenes
                 return;
 
             Monitor.Enter(m_updateLock);
+
             try
             {
+
                 List<SceneObjectGroup> childGroups = new List<SceneObjectGroup>();
 
                 // We do this in reverse to get the link order of the prims correct
@@ -1675,9 +1829,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)
@@ -1706,6 +1864,16 @@ namespace OpenSim.Region.Framework.Scenes
             }
             finally
             {
+                lock (SceneObjectGroupsByLocalPartID)
+                {
+                    foreach (SceneObjectPart part in parentGroup.Parts)
+                        SceneObjectGroupsByLocalPartID[part.LocalId] = parentGroup;
+                }
+
+                parentGroup.AdjustChildPrimPermissions();
+                parentGroup.HasGroupChanged = true;
+                parentGroup.ProcessBackup(m_parentScene.SimulationDataService, true);
+                parentGroup.ScheduleGroupForFullUpdate();
                 Monitor.Exit(m_updateLock);
             }
         }
@@ -1747,21 +1915,23 @@ namespace OpenSim.Region.Framework.Scenes
 
                             SceneObjectGroup group = part.ParentGroup;
                             if (!affectedGroups.Contains(group))
+                            {
                                 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)
@@ -1775,52 +1945,61 @@ namespace OpenSim.Region.Framework.Scenes
                     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)
+                            {
+                            }
+                            else
+                            {
+                                p.ParentGroup.HasGroupChanged = true;
+                                p.ParentGroup.ScheduleGroupForFullUpdate();
+                            }
                         }
+                    }
 
-                        // If there is more than one prim remaining, we
-                        // need to re-link
+                    // If there is more than one prim remaining, we
+                    // need to re-link
+                    //
+                    if (numChildren > 2)
+                    {
+                        // Remove old root
                         //
-                        if (numChildren > 2)
+                        if (newSet.Contains(root))
+                            newSet.Remove(root);
+
+                        // Preserve link ordering
+                        //
+                        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);
-                        }
+                        LinkObjects(newRoot, newSet);
+                        if (!affectedGroups.Contains(newRoot.ParentGroup))
+                            affectedGroups.Add(newRoot.ParentGroup);
                     }
                 }
 
@@ -1828,6 +2007,12 @@ 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.
+                    g.AdjustChildPrimPermissions();
+                    m_parentScene.SimulationDataService.RemoveObject(g.UUID, m_parentScene.RegionInfo.RegionID);
                     g.TriggerScriptChangedEvent(Changed.LINK);
                     g.HasGroupChanged = true; // Persist
                     g.ScheduleGroupForFullUpdate();
@@ -1901,108 +2086,96 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="GroupID"></param>
         /// <param name="rot"></param>
         /// <returns>null if duplication fails, otherwise the duplicated object</returns>
-        public SceneObjectGroup DuplicateObject(
-            uint originalPrimID, Vector3 offset, uint flags, UUID AgentID, UUID GroupID, Quaternion rot)
+        /// <summary>
+        public SceneObjectGroup DuplicateObject(uint originalPrimID, Vector3 offset, uint flags, UUID AgentID, UUID GroupID, Quaternion rot)
         {
-            Monitor.Enter(m_updateLock);
+//            m_log.DebugFormat(
+//                "[SCENE]: Duplication of object {0} at offset {1} requested by agent {2}", 
+//                originalPrimID, offset, AgentID);
 
-            try
+            SceneObjectGroup original = GetGroupByPrim(originalPrimID);
+            if (original != null)
             {
-    //            m_log.DebugFormat(
-    //                "[SCENE]: Duplication of object {0} at offset {1} requested by agent {2}",
-    //                originalPrimID, offset, AgentID);
-
-                SceneObjectGroup original = GetGroupByPrim(originalPrimID);
-                if (original == null)
+                if (m_parentScene.Permissions.CanDuplicateObject(
+                    original.PrimCount, original.UUID, AgentID, original.AbsolutePosition))
                 {
-                    m_log.WarnFormat(
-                        "[SCENEGRAPH]: Attempt to duplicate nonexistant prim id {0} by {1}", originalPrimID, AgentID);
+                    SceneObjectGroup copy = original.Copy(true);
+                    copy.AbsolutePosition = copy.AbsolutePosition + offset;
 
-                    return null;
-                }
+                    if (original.OwnerID != AgentID)
+                    {
+                        copy.SetOwnerId(AgentID);
+                        copy.SetRootPartOwner(copy.RootPart, AgentID, GroupID);
 
-                if (!m_parentScene.Permissions.CanDuplicateObject(
-                    original.PrimCount, original.UUID, AgentID, original.AbsolutePosition))
-                    return null;
+                        SceneObjectPart[] partList = copy.Parts;
+
+                        if (m_parentScene.Permissions.PropagatePermissions())
+                        {
+                            foreach (SceneObjectPart child in partList)
+                            {
+                                child.Inventory.ChangeInventoryOwner(AgentID);
+                                child.TriggerScriptChangedEvent(Changed.OWNER);
+                                child.ApplyNextOwnerPermissions();
+                            }
+                        }
+                    }
 
-                SceneObjectGroup copy = original.Copy(true);
-                copy.AbsolutePosition = copy.AbsolutePosition + offset;
+                    // FIXME: This section needs to be refactored so that it just calls AddSceneObject()
+                    Entities.Add(copy);
 
-                if (original.OwnerID != AgentID)
-                {
-                    copy.SetOwnerId(AgentID);
-                    copy.SetRootPartOwner(copy.RootPart, AgentID, GroupID);
+                    lock (SceneObjectGroupsByFullID)
+                        SceneObjectGroupsByFullID[copy.UUID] = copy;
 
-                    SceneObjectPart[] partList = copy.Parts;
+                    SceneObjectPart[] children = copy.Parts;
 
-                    if (m_parentScene.Permissions.PropagatePermissions())
+                    lock (SceneObjectGroupsByFullPartID)
                     {
-                        foreach (SceneObjectPart child in partList)
-                        {
-                            child.Inventory.ChangeInventoryOwner(AgentID);
-                            child.TriggerScriptChangedEvent(Changed.OWNER);
-                            child.ApplyNextOwnerPermissions();
-                        }
+                        SceneObjectGroupsByFullPartID[copy.UUID] = copy;
+                        foreach (SceneObjectPart part in children)
+                            SceneObjectGroupsByFullPartID[part.UUID] = copy;
                     }
 
-                    copy.RootPart.ObjectSaleType = 0;
-                    copy.RootPart.SalePrice = 10;
-                }
+                    lock (SceneObjectGroupsByLocalPartID)
+                    {
+                        SceneObjectGroupsByLocalPartID[copy.LocalId] = copy;
+                        foreach (SceneObjectPart part in children)
+                            SceneObjectGroupsByLocalPartID[part.LocalId] = copy;
+                    }
+                    // PROBABLE END OF FIXME
 
-                // FIXME: This section needs to be refactored so that it just calls AddSceneObject()
-                Entities.Add(copy);
-                
-                lock (SceneObjectGroupsByFullID)
-                    SceneObjectGroupsByFullID[copy.UUID] = copy;
-                
-                SceneObjectPart[] children = copy.Parts;
-                
-                lock (SceneObjectGroupsByFullPartID)
-                {
-                    SceneObjectGroupsByFullPartID[copy.UUID] = copy;
-                    foreach (SceneObjectPart part in children)
-                        SceneObjectGroupsByFullPartID[part.UUID] = copy;
-                }
-    
-                lock (SceneObjectGroupsByLocalPartID)
-                {
-                    SceneObjectGroupsByLocalPartID[copy.LocalId] = copy;
-                    foreach (SceneObjectPart part in children)
-                        SceneObjectGroupsByLocalPartID[part.LocalId] = copy;
-                }   
-                // PROBABLE END OF FIXME
-
-                // Since we copy from a source group that is in selected
-                // state, but the copy is shown deselected in the viewer,
-                // We need to clear the selection flag here, else that
-                // prim never gets persisted at all. The client doesn't
-                // think it's selected, so it will never send a deselect...
-                copy.IsSelected = false;
-
-                m_numPrim += copy.Parts.Length;
-
-                if (rot != Quaternion.Identity)
-                {
-                    copy.UpdateGroupRotationR(rot);
-                }
+                    // Since we copy from a source group that is in selected
+                    // state, but the copy is shown deselected in the viewer,
+                    // We need to clear the selection flag here, else that
+                    // prim never gets persisted at all. The client doesn't
+                    // think it's selected, so it will never send a deselect...
+                    copy.IsSelected = false;
+
+                    m_numPrim += copy.Parts.Length;
+
+                    if (rot != Quaternion.Identity)
+                    {
+                        copy.UpdateGroupRotationR(rot);
+                    }
 
-                copy.CreateScriptInstances(0, false, m_parentScene.DefaultScriptEngine, 1);
-                copy.HasGroupChanged = true;
-                copy.ScheduleGroupForFullUpdate();
-                copy.ResumeScripts();
+                    copy.CreateScriptInstances(0, false, m_parentScene.DefaultScriptEngine, 1);
+                    copy.HasGroupChanged = true;
+                    copy.ScheduleGroupForFullUpdate();
+                    copy.ResumeScripts();
 
-                // required for physics to update it's position
-                copy.AbsolutePosition = copy.AbsolutePosition;
+                    // required for physics to update it's position
+                    copy.AbsolutePosition = copy.AbsolutePosition;
 
-                return copy;
+                    return copy;
+                }
             }
-            finally
+            else
             {
-                Monitor.Exit(m_updateLock);
+                m_log.WarnFormat("[SCENE]: Attempted to duplicate nonexistant prim id {0}", GroupID);
             }
+
+            return null;
         }
-        
-        /// <summary>
+
         /// Calculates the distance between two Vector3s
         /// </summary>
         /// <param name="v1"></param>
diff --git a/OpenSim/Region/Framework/Scenes/SceneManager.cs b/OpenSim/Region/Framework/Scenes/SceneManager.cs
index 28f7896..c5c083a 100644
--- a/OpenSim/Region/Framework/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneManager.cs
@@ -99,11 +99,11 @@ namespace OpenSim.Region.Framework.Scenes
             } 
         }
 
-        private readonly List<Scene> m_localScenes = new List<Scene>();
+        private readonly DoubleDictionary<UUID, string, Scene> m_localScenes = new DoubleDictionary<UUID, string, Scene>();
 
         public List<Scene> Scenes
         {
-            get { return new List<Scene>(m_localScenes); }
+            get { return new List<Scene>(m_localScenes.FindAll(delegate(Scene s) { return true; })); }
         }
 
         /// <summary>
@@ -120,13 +120,10 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (CurrentScene == null)
                 {
-                    lock (m_localScenes)
-                    {
-                        if (m_localScenes.Count > 0)
-                            return m_localScenes[0];
-                        else
-                            return null;
-                    }
+                    List<Scene> sceneList = Scenes;
+                    if (sceneList.Count == 0)
+                        return null;
+                    return sceneList[0];
                 }
                 else
                 {
@@ -138,41 +135,35 @@ namespace OpenSim.Region.Framework.Scenes
         public SceneManager()
         {
             m_instance = this;
-            m_localScenes = new List<Scene>();
+            m_localScenes = new DoubleDictionary<UUID, string, Scene>();
         }
 
         public void Close()
         {
+            List<Scene> localScenes = null;
+
             lock (m_localScenes)
             {
-                for (int i = 0; i < m_localScenes.Count; i++)
-                {
-                    m_localScenes[i].Close();
-                }
+                localScenes = Scenes;
+            }
+
+            for (int i = 0; i < localScenes.Count; i++)
+            {
+                localScenes[i].Close();
             }
         }
 
         public void Close(Scene cscene)
         {
-            lock (m_localScenes)
-            {
-                if (m_localScenes.Contains(cscene))
-                {
-                    for (int i = 0; i < m_localScenes.Count; i++)
-                    {
-                        if (m_localScenes[i].Equals(cscene))
-                        {
-                            m_localScenes[i].Close();
-                        }
-                    }
-                }
-            }
+            if (!m_localScenes.ContainsKey(cscene.RegionInfo.RegionID))
+                return;
+            cscene.Close();
         }
 
         public void Add(Scene scene)
         {
             lock (m_localScenes)
-                m_localScenes.Add(scene);
+                m_localScenes.Add(scene.RegionInfo.RegionID, scene.RegionInfo.RegionName, scene);
 
             scene.OnRestart += HandleRestart;
             scene.EventManager.OnRegionReadyStatusChange += HandleRegionReadyStatusChange;
@@ -184,15 +175,8 @@ namespace OpenSim.Region.Framework.Scenes
 
             lock (m_localScenes)
             {
-                for (int i = 0; i < m_localScenes.Count; i++)
-                {
-                    if (rdata.RegionName == m_localScenes[i].RegionInfo.RegionName)
-                    {
-                        restartedScene = m_localScenes[i];
-                        m_localScenes.RemoveAt(i);
-                        break;
-                    }
-                }
+                m_localScenes.TryGetValue(rdata.RegionID, out restartedScene);
+                m_localScenes.Remove(rdata.RegionID);
             }
 
             // If the currently selected scene has been restarted, then we can't reselect here since we the scene
@@ -207,39 +191,36 @@ namespace OpenSim.Region.Framework.Scenes
         private void HandleRegionReadyStatusChange(IScene scene)
         {
             lock (m_localScenes)
-                AllRegionsReady = m_localScenes.TrueForAll(s => s.Ready);
+                AllRegionsReady = m_localScenes.FindAll(s => !s.Ready).Count == 0;
         }
 
         public void SendSimOnlineNotification(ulong regionHandle)
         {
             RegionInfo Result = null;
 
-            lock (m_localScenes)
-            {
-                for (int i = 0; i < m_localScenes.Count; i++)
-                {
-                    if (m_localScenes[i].RegionInfo.RegionHandle == regionHandle)
+            Scene s = m_localScenes.FindValue(delegate(Scene x)
                     {
-                        // Inform other regions to tell their avatar about me
-                        Result = m_localScenes[i].RegionInfo;
-                    }
-                }
+                        if (x.RegionInfo.RegionHandle == regionHandle)
+                            return true;
+                        return false;
+                    });
+
+            if (s != null)
+            {
+                List<Scene> sceneList = Scenes;
 
-                if (Result != null)
+                for (int i = 0; i < sceneList.Count; i++)
                 {
-                    for (int i = 0; i < m_localScenes.Count; i++)
+                    if (sceneList[i]!= s)
                     {
-                        if (m_localScenes[i].RegionInfo.RegionHandle != regionHandle)
-                        {
-                            // Inform other regions to tell their avatar about me
-                            //m_localScenes[i].OtherRegionUp(Result);
-                        }
+                        // Inform other regions to tell their avatar about me
+                        //sceneList[i].OtherRegionUp(Result);
                     }
                 }
-                else
-                {
-                    m_log.Error("[REGION]: Unable to notify Other regions of this Region coming up");
-                }
+            }
+            else
+            {
+                m_log.Error("[REGION]: Unable to notify Other regions of this Region coming up");
             }
         }
 
@@ -368,16 +349,12 @@ namespace OpenSim.Region.Framework.Scenes
             }
             else
             {
-                lock (m_localScenes)
+                Scene s;
+
+                if (m_localScenes.TryGetValue(regionName, out s))
                 {
-                    foreach (Scene scene in m_localScenes)
-                    {
-                        if (String.Compare(scene.RegionInfo.RegionName, regionName, true) == 0)
-                        {
-                            CurrentScene = scene;
-                            return true;
-                        }
-                    }
+                    CurrentScene = s;
+                    return true;
                 }
 
                 return false;
@@ -386,18 +363,14 @@ 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)
+            Scene s;
+
+            if (m_localScenes.TryGetValue(regionID, out s))
             {
-                foreach (Scene scene in m_localScenes)
-                {
-                    if (scene.RegionInfo.RegionID == regionID)
-                    {
-                        CurrentScene = scene;
-                        return true;
-                    }
-                }
+                CurrentScene = s;
+                return true;
             }
 
             return false;
@@ -405,52 +378,24 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetScene(string regionName, out Scene scene)
         {
-            lock (m_localScenes)
-            {
-                foreach (Scene mscene in m_localScenes)
-                {
-                    if (String.Compare(mscene.RegionInfo.RegionName, regionName, true) == 0)
-                    {
-                        scene = mscene;
-                        return true;
-                    }
-                }
-            }
-
-            scene = null;
-            return false;
+            return m_localScenes.TryGetValue(regionName, out scene);
         }
 
         public bool TryGetScene(UUID regionID, out Scene scene)
         {
-            lock (m_localScenes)
-            {
-                foreach (Scene mscene in m_localScenes)
-                {
-                    if (mscene.RegionInfo.RegionID == regionID)
-                    {
-                        scene = mscene;
-                        return true;
-                    }
-                }
-            }
-            
-            scene = null;
-            return false;
+            return m_localScenes.TryGetValue(regionID, out scene);
         }
 
         public bool TryGetScene(uint locX, uint locY, out Scene scene)
         {
-            lock (m_localScenes)
+            List<Scene> sceneList = Scenes;
+            foreach (Scene mscene in sceneList)
             {
-                foreach (Scene mscene in m_localScenes)
+                if (mscene.RegionInfo.RegionLocX == locX &&
+                    mscene.RegionInfo.RegionLocY == locY)
                 {
-                    if (mscene.RegionInfo.RegionLocX == locX &&
-                        mscene.RegionInfo.RegionLocY == locY)
-                    {
-                        scene = mscene;
-                        return true;
-                    }
+                    scene = mscene;
+                    return true;
                 }
             }
             
@@ -460,16 +405,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetScene(IPEndPoint ipEndPoint, out Scene scene)
         {
-            lock (m_localScenes)
+            List<Scene> sceneList = Scenes;
+            foreach (Scene mscene in sceneList)
             {
-                foreach (Scene mscene in m_localScenes)
+                if ((mscene.RegionInfo.InternalEndPoint.Equals(ipEndPoint.Address)) &&
+                    (mscene.RegionInfo.InternalEndPoint.Port == ipEndPoint.Port))
                 {
-                    if ((mscene.RegionInfo.InternalEndPoint.Equals(ipEndPoint.Address)) &&
-                        (mscene.RegionInfo.InternalEndPoint.Port == ipEndPoint.Port))
-                    {
-                        scene = mscene;
-                        return true;
-                    }
+                    scene = mscene;
+                    return true;
                 }
             }
             
@@ -511,15 +454,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         public RegionInfo GetRegionInfo(UUID regionID)
         {
-            lock (m_localScenes)
+            Scene s;
+            if (m_localScenes.TryGetValue(regionID, out s))
             {
-                foreach (Scene scene in m_localScenes)
-                {
-                    if (scene.RegionInfo.RegionID == regionID)
-                    {
-                        return scene.RegionInfo;
-                    }
-                }
+                return s.RegionInfo;
             }
 
             return null;
@@ -537,14 +475,12 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetScenePresence(UUID avatarId, out ScenePresence avatar)
         {
-            lock (m_localScenes)
+            List<Scene> sceneList = Scenes;
+            foreach (Scene scene in sceneList)
             {
-                foreach (Scene scene in m_localScenes)
+                if (scene.TryGetScenePresence(avatarId, out avatar))
                 {
-                    if (scene.TryGetScenePresence(avatarId, out avatar))
-                    {
-                        return true;
-                    }
+                    return true;
                 }
             }
 
@@ -554,15 +490,13 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetRootScenePresence(UUID avatarId, out ScenePresence avatar)
         {
-            lock (m_localScenes)
+            List<Scene> sceneList = Scenes;
+            foreach (Scene scene in sceneList)
             {
-                foreach (Scene scene in m_localScenes)
-                {
-                    avatar = scene.GetScenePresence(avatarId);
+                avatar = scene.GetScenePresence(avatarId);
 
-                    if (avatar != null && !avatar.IsChildAgent)
-                        return true;
-                }
+                if (avatar != null && !avatar.IsChildAgent)
+                    return true;
             }
 
             avatar = null;
@@ -572,21 +506,19 @@ namespace OpenSim.Region.Framework.Scenes
         public void CloseScene(Scene scene)
         {
             lock (m_localScenes)
-                m_localScenes.Remove(scene);
+                m_localScenes.Remove(scene.RegionInfo.RegionID);
 
             scene.Close();
         }
 
         public bool TryGetAvatarByName(string avatarName, out ScenePresence avatar)
         {
-            lock (m_localScenes)
+            List<Scene> sceneList = Scenes;
+            foreach (Scene scene in sceneList)
             {
-                foreach (Scene scene in m_localScenes)
+                if (scene.TryGetAvatarByName(avatarName, out avatar))
                 {
-                    if (scene.TryGetAvatarByName(avatarName, out avatar))
-                    {
-                        return true;
-                    }
+                    return true;
                 }
             }
 
@@ -596,14 +528,12 @@ namespace OpenSim.Region.Framework.Scenes
 
         public bool TryGetRootScenePresenceByName(string firstName, string lastName, out ScenePresence sp)
         {
-            lock (m_localScenes)
+            List<Scene> sceneList = Scenes;
+            foreach (Scene scene in sceneList)
             {
-                foreach (Scene scene in m_localScenes)
-                {
-                    sp = scene.GetScenePresence(firstName, lastName);
-                    if (sp != null && !sp.IsChildAgent)
-                        return true;
-                }
+                sp = scene.GetScenePresence(firstName, lastName);
+                if (sp != null && !sp.IsChildAgent)
+                    return true;
             }
 
             sp = null;
@@ -612,8 +542,8 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void ForEachScene(Action<Scene> action)
         {
-            lock (m_localScenes)
-                m_localScenes.ForEach(action);
+            List<Scene> sceneList = Scenes;
+            sceneList.ForEach(action);
         }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
index 527ca35..8c50a81 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
@@ -88,10 +88,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Stop and remove 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();
@@ -254,6 +250,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 |
@@ -265,7 +266,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();
             }
 
@@ -407,6 +411,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 4b4e4ba..9e3d875 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -24,12 +24,13 @@
  * (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.ComponentModel;
 using System.Collections.Generic;
 using System.Drawing;
 using System.IO;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Xml;
@@ -44,6 +45,7 @@ using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.Framework.Scenes
 {
+    
     [Flags]
     public enum scriptEvents
     {
@@ -78,14 +80,14 @@ namespace OpenSim.Region.Framework.Scenes
         object_rez = 4194304
     }
 
-    struct scriptPosTarget
+    public struct scriptPosTarget
     {
         public Vector3 targetPos;
         public float tolerance;
         public uint handle;
     }
 
-    struct scriptRotTarget
+    public struct scriptRotTarget
     {
         public Quaternion targetRot;
         public float tolerance;
@@ -116,8 +118,12 @@ 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 List<ScenePresence> m_linkedAvatars = new List<ScenePresence>();
 
         /// <summary>
         /// This indicates whether the object has changed such that it needs to be repersisted to permenant storage
@@ -134,9 +140,44 @@ 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());
+                            float factor = 2.0f;
+                            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_maxPersistTime = m_scene.m_persistAfter;
+                            m_minPersistTime = m_scene.m_dontPersistBefore;
+                        }
+                    }
                 }
                 m_hasGroupChanged = value;
                 
@@ -151,7 +192,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()
         {
@@ -161,8 +202,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;
         }
@@ -220,6 +272,11 @@ namespace OpenSim.Region.Framework.Scenes
         {
             AttachmentPoint = 0;
 
+            // Don't zap trees
+            if (RootPart.Shape.PCode == (byte)PCode.Tree ||
+                RootPart.Shape.PCode == (byte)PCode.NewTree)
+                return;
+
             // Even though we don't use child part state parameters for attachments any more, we still need to set
             // these to zero since having them non-zero in rezzed scene objects will crash some clients.  Even if
             // we store them correctly, scene objects that we receive from elsewhere might not.
@@ -265,26 +322,38 @@ namespace OpenSim.Region.Framework.Scenes
             get { return RootPart.VolumeDetectActive; }
         }
 
-        private Vector3 lastPhysGroupPos;
-        private Quaternion lastPhysGroupRot;
-
         private bool m_isBackedUp;
 
+        public bool IsBackedUp
+        {
+            get { return m_isBackedUp; }
+        }
+
         protected MapAndArray<UUID, SceneObjectPart> m_parts = new MapAndArray<UUID, SceneObjectPart>();
 
         protected ulong m_regionHandle;
         protected SceneObjectPart m_rootPart;
         // private Dictionary<UUID, scriptEvents> m_scriptEvents = new Dictionary<UUID, scriptEvents>();
 
-        private Dictionary<uint, scriptPosTarget> m_targets = new Dictionary<uint, scriptPosTarget>();
-        private Dictionary<uint, scriptRotTarget> m_rotTargets = new Dictionary<uint, scriptRotTarget>();
+        private SortedDictionary<uint, scriptPosTarget> m_targets = new SortedDictionary<uint, scriptPosTarget>();
+        private SortedDictionary<uint, scriptRotTarget> m_rotTargets = new SortedDictionary<uint, scriptRotTarget>();
+
+        public SortedDictionary<uint, scriptPosTarget> AtTargets
+        {
+            get { return m_targets; }
+        }
+
+        public SortedDictionary<uint, scriptRotTarget> RotTargets
+        {
+            get { return m_rotTargets; }
+        }
 
         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
@@ -321,6 +390,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; }
@@ -427,7 +506,15 @@ namespace OpenSim.Region.Framework.Scenes
         {
             return (IsAttachment || (m_rootPart.Shape.PCode == 9 && m_rootPart.Shape.State != 0));
         }
-        
+
+
+
+        private struct avtocrossInfo
+        {
+            public ScenePresence av;
+            public uint ParentID;
+        }
+
         /// <summary>
         /// The absolute position of this scene object in the scene
         /// </summary>
@@ -455,13 +542,129 @@ namespace OpenSim.Region.Framework.Scenes
                             || Scene.TestBorderCross(val, Cardinals.S))
                         && !IsAttachmentCheckFull() && (!Scene.LoadingPrims))
                     {
+                        IEntityTransferModule entityTransfer = m_scene.RequestModuleInterface<IEntityTransferModule>();
+                        uint x = 0;
+                        uint y = 0;
+                        string version = String.Empty;
+                        Vector3 newpos = Vector3.Zero;
+                        OpenSim.Services.Interfaces.GridRegion destination = null;
+
                         if (m_rootPart.KeyframeMotion != null)
                             m_rootPart.KeyframeMotion.StartCrossingCheck();
 
-                        m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
+                        bool canCross = true;
+                        foreach (ScenePresence av in m_linkedAvatars)
+                        {
+                            // We need to cross these agents. First, let's find
+                            // out if any of them can't cross for some reason.
+                            // We have to deny the crossing entirely if any
+                            // of them are banned. Alternatively, we could
+                            // unsit banned agents....
+
+
+                            // We set the avatar position as being the object
+                            // position to get the region to send to
+                            if ((destination = entityTransfer.GetDestination(m_scene, av.UUID, val, out x, out y, out version, out newpos)) == null)
+                            {
+                                canCross = false;
+                                break;
+                            }
+
+                            m_log.DebugFormat("[SCENE OBJECT]: Avatar {0} needs to be crossed to {1}", av.Name, destination.RegionName);
+                        }
+
+                        if (canCross)
+                        {
+                            // We unparent the SP quietly so that it won't
+                            // be made to stand up
+
+                            List<avtocrossInfo> avsToCross = new List<avtocrossInfo>();
+
+                            foreach (ScenePresence av in m_linkedAvatars)
+                            {
+                                avtocrossInfo avinfo = new avtocrossInfo();
+                                SceneObjectPart parentPart = m_scene.GetSceneObjectPart(av.ParentID);
+                                if (parentPart != null)
+                                    av.ParentUUID = parentPart.UUID;
+
+                                avinfo.av = av;
+                                avinfo.ParentID = av.ParentID;
+                                avsToCross.Add(avinfo);
+
+                                av.ParentID = 0;
+                            }
+
+                            //                            m_linkedAvatars.Clear();
+                            m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
+
+                            // Normalize
+                            if (val.X >= Constants.RegionSize)
+                                val.X -= Constants.RegionSize;
+                            if (val.Y >= Constants.RegionSize)
+                                val.Y -= Constants.RegionSize;
+                            if (val.X < 0)
+                                val.X += Constants.RegionSize;
+                            if (val.Y < 0)
+                                val.Y += Constants.RegionSize;
+
+                            // If it's deleted, crossing was successful
+                            if (IsDeleted)
+                            {
+                                //                                foreach (ScenePresence av in m_linkedAvatars)
+                                foreach (avtocrossInfo avinfo in avsToCross)
+                                {
+                                    ScenePresence av = avinfo.av;
+                                    if (!av.IsInTransit) // just in case...
+                                    {
+                                        m_log.DebugFormat("[SCENE OBJECT]: Crossing avatar {0} to {1}", av.Name, val);
+
+                                        av.IsInTransit = true;
+
+                                        CrossAgentToNewRegionDelegate d = entityTransfer.CrossAgentToNewRegionAsync;
+                                        d.BeginInvoke(av, val, destination, av.Flying, version, CrossAgentToNewRegionCompleted, d);
+                                    }
+                                    else
+                                        m_log.DebugFormat("[SCENE OBJECT]: Crossing avatar alreasy in transit {0} to {1}", av.Name, val);
+                                }
+                                avsToCross.Clear();
+                                return;
+                            }
+                            else // cross failed, put avas back ??
+                            {
+                                foreach (avtocrossInfo avinfo in avsToCross)
+                                {
+                                    ScenePresence av = avinfo.av;
+                                    av.ParentUUID = UUID.Zero;
+                                    av.ParentID = avinfo.ParentID;
+//                                    m_linkedAvatars.Add(av);
+                                }
+                            }
+                            avsToCross.Clear();
+
+                        }
+                        else
+                        {
+                            if (m_rootPart.KeyframeMotion != null)
+                                m_rootPart.KeyframeMotion.CrossingFailure();
+
+                            if (RootPart.PhysActor != null)
+                            {
+                                RootPart.PhysActor.CrossingFailure();
+                            }
+                        }
+                        Vector3 oldp = AbsolutePosition;
+                        val.X = Util.Clamp<float>(oldp.X, 0.5f, (float)Constants.RegionSize - 0.5f);
+                        val.Y = Util.Clamp<float>(oldp.Y, 0.5f, (float)Constants.RegionSize - 0.5f);
+                        val.Z = Util.Clamp<float>(oldp.Z, 0.5f, 4096.0f);
                     }
                 }
-                
+
+/* don't see the need but worse don't see where is restored to false if things stay in
+                foreach (SceneObjectPart part in m_parts.GetArray())
+                {
+                    part.IgnoreUndoUpdate = true;
+                }
+ */
                 if (RootPart.GetStatusSandbox())
                 {
                     if (Util.GetDistanceTo(RootPart.StatusSandboxPos, value) > 10)
@@ -479,9 +682,38 @@ namespace OpenSim.Region.Framework.Scenes
                 // Restuff the new GroupPosition into each SOP of the linkset.
                 //    This has the affect of resetting and tainting the physics actors.
                 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);
+                }
 
+/*
+    This seems not needed and should not be needed:
+    sp absolute position depends on sit part absolute position fixed above.
+    sp ParentPosition is not used anywhere.
+    Since presence is sitting, viewer considers it 'linked' to root prim, so it will move/rotate it
+    Sending a extra packet with avatar position is not only bandwidth waste, but may cause jitter in viewers due to UPD nature.
+ 
+                if (!m_dupeInProgress)
+                {
+                    foreach (ScenePresence av in m_linkedAvatars)
+                    {
+                        SceneObjectPart p = m_scene.GetSceneObjectPart(av.ParentID);
+                        if (p != null && 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)
                 //{
                 //m_rootPart.PhysActor.Position =
@@ -495,6 +727,40 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public override Vector3 Velocity
+        {
+            get { return RootPart.Velocity; }
+            set { RootPart.Velocity = value; }
+        }
+
+        private void CrossAgentToNewRegionCompleted(IAsyncResult iar)
+        {
+            CrossAgentToNewRegionDelegate icon = (CrossAgentToNewRegionDelegate)iar.AsyncState;
+            ScenePresence agent = icon.EndInvoke(iar);
+
+            //// If the cross was successful, this agent is a child agent
+            if (agent.IsChildAgent)
+            {
+                if (agent.ParentUUID != UUID.Zero)
+                {
+                    agent.ParentPart = null;
+//                    agent.ParentPosition = Vector3.Zero;
+//                    agent.ParentUUID = UUID.Zero;
+                }
+            }
+
+            agent.ParentUUID = UUID.Zero;
+
+//                agent.Reset();
+//            else // Not successful
+//                agent.RestoreInCurrentScene();
+
+            // In any case
+            agent.IsInTransit = false;
+
+            m_log.DebugFormat("[SCENE OBJECT]: Crossing agent {0} {1} completed.", agent.Firstname, agent.Lastname);
+        }
+
         public override uint LocalId
         {
             get { return m_rootPart.LocalId; }
@@ -565,6 +831,11 @@ namespace OpenSim.Region.Framework.Scenes
                 m_isSelected = value;
                 // Tell physics engine that group is selected
 
+                // this is not right
+                // but ode engines should only really need to know about root part
+                // so they can put entire object simulation on hold and not colliding
+                // keep as was for now
+                
                 PhysicsActor pa = m_rootPart.PhysActor;
                 if (pa != null)
                 {
@@ -586,6 +857,40 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public void PartSelectChanged(bool partSelect)
+        {
+            // any part selected makes group selected
+            if (m_isSelected == partSelect)
+                return;
+
+            if (partSelect)
+            {
+                IsSelected = partSelect;
+//                if (!IsAttachment)
+//                    ScheduleGroupForFullUpdate();
+            }
+            else
+            {
+                // bad bad bad 2 heavy for large linksets
+                // since viewer does send lot of (un)selects
+                // this needs to be replaced by a specific list or count ?
+                // but that will require extra code in several places
+
+                SceneObjectPart[] parts = m_parts.GetArray();
+                for (int i = 0; i < parts.Length; i++)
+                {
+                    SceneObjectPart part = parts[i];
+                    if (part.IsSelected)
+                        return;
+                }
+                IsSelected = partSelect;
+                if (!IsAttachment)
+                {
+                    ScheduleGroupForFullUpdate();
+                }
+            }
+        }
+
         private SceneObjectPart m_PlaySoundMasterPrim = null;
         public SceneObjectPart PlaySoundMasterPrim
         {
@@ -680,6 +985,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public SceneObjectGroup()
         {
+            
         }
 
         /// <summary>
@@ -697,8 +1003,8 @@ 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)
-            :this(new SceneObjectPart(ownerID, shape, pos, rot, Vector3.Zero))
-        { 
+        {
+            SetRootPart(new SceneObjectPart(ownerID, shape, pos, rot, Vector3.Zero));
         }
 
         /// <summary>
@@ -733,6 +1039,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public virtual void AttachToBackup()
         {
+            if (IsAttachment) return;
+            m_scene.SceneGraph.FireAttachToBackup(this);
+
             if (InSceneBackup)
             {
                 //m_log.DebugFormat(
@@ -780,6 +1089,13 @@ namespace OpenSim.Region.Framework.Scenes
 
             ApplyPhysics();
 
+            if (RootPart.PhysActor != null)
+                RootPart.Force = RootPart.Force;
+            if (RootPart.PhysActor != null)
+                RootPart.Torque = RootPart.Torque;
+            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();
@@ -795,6 +1111,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];
@@ -809,11 +1129,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
@@ -824,10 +1139,11 @@ namespace OpenSim.Region.Framework.Scenes
                         result.obj = part;
                         result.normal = inter.normal;
                         result.distance = inter.distance;
+
+                        idist = inter.distance;
                     }
                 }
             }
-
             return result;
         }
 
@@ -839,25 +1155,27 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public void GetAxisAlignedBoundingBoxRaw(out float minX, out float maxX, out float minY, out float maxY, out float minZ, out float maxZ)
         {
-            maxX = -256f;
-            maxY = -256f;
-            maxZ = -256f;
-            minX = 256f;
-            minY = 256f;
-            minZ = 8192f;
+            maxX = float.MinValue;
+            maxY = float.MinValue;
+            maxZ = float.MinValue;
+            minX = float.MaxValue;
+            minY = float.MaxValue;
+            minZ = float.MaxValue;
 
             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;
@@ -869,6 +1187,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);
@@ -903,6 +1223,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;
@@ -924,6 +1276,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)
@@ -1067,17 +1428,118 @@ namespace OpenSim.Region.Framework.Scenes
 
         #endregion
 
+        public void GetResourcesCosts(SceneObjectPart apart,
+            out float linksetResCost, out float linksetPhysCost, out float partCost, out float partPhysCost)
+        {
+            // this information may need to be cached
+
+            float cost;
+            float tmpcost;
+
+            bool ComplexCost = false;
+
+            SceneObjectPart p;
+            SceneObjectPart[] parts;
+
+            lock (m_parts)
+            {
+                parts = m_parts.GetArray();
+            }
+
+            int nparts = parts.Length;
+          
+
+            for (int i = 0; i < nparts; i++)
+            {
+                p = parts[i];
+
+                if (p.UsesComplexCost)
+                {
+                    ComplexCost = true;
+                    break;
+                }
+            }
+
+            if (ComplexCost)
+            {
+                linksetResCost = 0;
+                linksetPhysCost = 0;
+                partCost = 0; 
+                partPhysCost = 0;
+
+                for (int i = 0; i < nparts; i++)
+                {
+                    p = parts[i];
+
+                    cost = p.StreamingCost;
+                    tmpcost = p.SimulationCost;
+                    if (tmpcost > cost)
+                        cost = tmpcost;
+                    tmpcost = p.PhysicsCost;
+                    if (tmpcost > cost)
+                        cost = tmpcost;
+
+                    linksetPhysCost += tmpcost;
+                    linksetResCost += cost;
+
+                    if (p == apart)
+                    {
+                        partCost = cost;
+                        partPhysCost = tmpcost;
+                    }
+                }
+            }
+            else
+            {
+                partPhysCost = 1.0f;
+                partCost = 1.0f;
+                linksetResCost = (float)nparts;
+                linksetPhysCost = linksetResCost;
+            }
+        }
+
+        public void GetSelectedCosts(out float PhysCost, out float StreamCost, out float SimulCost)
+        {
+            SceneObjectPart p;
+            SceneObjectPart[] parts;
+
+            lock (m_parts)
+            {
+                parts = m_parts.GetArray();
+            }
+
+            int nparts = parts.Length;
+
+            PhysCost = 0;
+            StreamCost = 0;
+            SimulCost = 0;
+
+            for (int i = 0; i < nparts; i++)
+            {
+                p = parts[i];
+
+                StreamCost += p.StreamingCost;
+                SimulCost += p.SimulationCost;
+                PhysCost += p.PhysicsCost;
+            }
+        }
+
         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)
@@ -1097,6 +1559,169 @@ 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;
+            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;
+            // must check if buildind should be true or false here
+            m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive,false);
+            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>
@@ -1136,7 +1761,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;
         }
@@ -1162,6 +1790,14 @@ namespace OpenSim.Region.Framework.Scenes
                 parts[i].UUID = UUID.Random();
         }
 
+        // helper provided for parts.
+        public int GetSceneMaxUndo()
+        {
+            if (m_scene != null)
+                return m_scene.MaxUndoCount;
+            return 5;
+        }
+
         // justincc: I don't believe this hack is needed any longer, especially since the physics
         // parts of set AbsolutePosition were already commented out.  By changing HasGroupChanged to false
         // this method was preventing proper reload of scene objects.
@@ -1219,7 +1855,7 @@ namespace OpenSim.Region.Framework.Scenes
 //                "[SCENE OBJECT GROUP]: Processing OnGrabPart for {0} on {1} {2}, offsetPos {3}",
 //                remoteClient.Name, part.Name, part.LocalId, offsetPos);
 
-            part.StoreUndoState();
+//            part.StoreUndoState();
             part.OnGrab(offsetPos, remoteClient);
         }
 
@@ -1239,6 +1875,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++)
             {
@@ -1262,6 +1903,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 });
             }
+
         }
 
         public void AddScriptLPS(int count)
@@ -1331,28 +1973,43 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void ApplyPhysics()
         {
-            // Apply physics to the root prim
-            m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive);
-            
-            // Apply physics to child prims
             SceneObjectPart[] parts = m_parts.GetArray();
             if (parts.Length > 1)
             {
+                ResetChildPrimPhysicsPositions();
+
+                // Apply physics to the root prim
+                m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, true);
+
+
                 for (int i = 0; i < parts.Length; i++)
                 {
                     SceneObjectPart part = parts[i];
                     if (part.LocalId != m_rootPart.LocalId)
-                        part.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), part.VolumeDetectActive);
+                        part.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), part.VolumeDetectActive, true);
                 }
-
                 // Hack to get the physics scene geometries in the right spot
-                ResetChildPrimPhysicsPositions();
+//                ResetChildPrimPhysicsPositions();
+                if (m_rootPart.PhysActor != null)
+                {
+                    m_rootPart.PhysActor.Building = false;
+                }
+                        }
+                        else
+                        {
+                // Apply physics to the root prim
+                m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, false);
             }
         }
 
         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)
@@ -1384,11 +2041,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.LoginsEnabled || // 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);
@@ -1415,6 +2078,7 @@ namespace OpenSim.Region.Framework.Scenes
                             }
                         }
                     }
+
                 }
 
                 if (m_scene.UseBackup && HasGroupChanged)
@@ -1422,10 +2086,30 @@ 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);
 
+                        if (RootPart.Shape.PCode == 9 && RootPart.Shape.State != 0)
+                        {
+                            RootPart.Shape.State = 0;
+                            ScheduleGroupForFullUpdate();
+                        }
+
                         SceneObjectGroup backup_group = Copy(false);
                         backup_group.RootPart.Velocity = RootPart.Velocity;
                         backup_group.RootPart.Acceleration = RootPart.Acceleration;
@@ -1435,6 +2119,16 @@ namespace OpenSim.Region.Framework.Scenes
                         HasGroupChangedDueToDelink = false;
 
                         m_scene.EventManager.TriggerOnSceneObjectPreSave(backup_group, this);
+/*
+                        backup_group.ForEachPart(delegate(SceneObjectPart part) 
+                        { 
+                            if (part.KeyframeMotion != null)
+                            {
+                                part.KeyframeMotion = KeyframeMotion.FromData(backup_group, part.KeyframeMotion.Serialize());
+//                                part.KeyframeMotion.UpdateSceneObject(this);
+                            }
+                        });
+*/
                         datastore.StoreObject(backup_group, m_scene.RegionInfo.RegionID);
 
                         backup_group.ForEachPart(delegate(SceneObjectPart part) 
@@ -1491,10 +2185,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public SceneObjectGroup Copy(bool userExposed)
         {
+            m_dupeInProgress = true;
             SceneObjectGroup dupe = (SceneObjectGroup)MemberwiseClone();
             dupe.m_isBackedUp = false;
             dupe.m_parts = new MapAndArray<OpenMetaverse.UUID, SceneObjectPart>();
 
+            // new group as no sitting avatars            
+            dupe.m_linkedAvatars = new List<ScenePresence>();
+
             // Warning, The following code related to previousAttachmentStatus is needed so that clones of 
             // attachments do not bordercross while they're being duplicated.  This is hacktastic!
             // Normally, setting AbsolutePosition will bordercross a prim if it's outside the region!
@@ -1505,7 +2203,7 @@ namespace OpenSim.Region.Framework.Scenes
             // This is only necessary when userExposed is false!
 
             bool previousAttachmentStatus = dupe.IsAttachment;
-            
+
             if (!userExposed)
                 dupe.IsAttachment = true;
 
@@ -1518,16 +2216,17 @@ namespace OpenSim.Region.Framework.Scenes
 
             dupe.CopyRootPart(m_rootPart, OwnerID, GroupID, userExposed);
             dupe.m_rootPart.LinkNum = m_rootPart.LinkNum;
+            
 
             if (userExposed)
                 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)
@@ -1537,43 +2236,56 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     newPart = dupe.CopyPart(part, OwnerID, GroupID, userExposed);
                     newPart.LinkNum = part.LinkNum;
-                }
+                    if (userExposed)
+                        newPart.ParentID = dupe.m_rootPart.LocalId;
+                 }
                 else
                 {
                     newPart = dupe.m_rootPart;
                 }
+/*
+                bool isphys = ((newPart.Flags & PrimFlags.Physics) != 0);
+                bool isphan = ((newPart.Flags & PrimFlags.Phantom) != 0);
 
                 // Need to duplicate the physics actor as well
-                PhysicsActor originalPartPa = part.PhysActor;
-                if (originalPartPa != null && userExposed)
+                if (userExposed && (isphys || !isphan || newPart.VolumeDetectActive))
                 {
                     PrimitiveBaseShape pbs = newPart.Shape;
-    
                     newPart.PhysActor
                         = m_scene.PhysicsScene.AddPrimShape(
                             string.Format("{0}/{1}", newPart.Name, newPart.UUID),
                             pbs,
                             newPart.AbsolutePosition,
                             newPart.Scale,
-                            newPart.RotationOffset,
-                            originalPartPa.IsPhysical,
+                            newPart.GetWorldRotation(),
+                            isphys,
+                            isphan,
                             newPart.LocalId);
-    
-                    newPart.DoPhysicsPropertyUpdate(originalPartPa.IsPhysical, true);
-                }
+
+                    newPart.DoPhysicsPropertyUpdate(isphys, true);
+ */
+                if (userExposed)
+                    newPart.ApplyPhysics((uint)newPart.Flags,newPart.VolumeDetectActive,true);
+//                }
+                // copy keyframemotion
                 if (part.KeyframeMotion != null)
                     newPart.KeyframeMotion = part.KeyframeMotion.Copy(dupe);
             }
-            
+
             if (userExposed)
             {
-                dupe.UpdateParentIDs();
+// done above                dupe.UpdateParentIDs();
+
+                if (dupe.m_rootPart.PhysActor != null)
+                    dupe.m_rootPart.PhysActor.Building = false; // tell physics to finish building
+
                 dupe.HasGroupChanged = true;
                 dupe.AttachToBackup();
 
                 ScheduleGroupForFullUpdate();
             }
 
+            m_dupeInProgress = false;
             return dupe;
         }
 
@@ -1585,7 +2297,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="cGroupID"></param>
         public void CopyRootPart(SceneObjectPart part, UUID cAgentID, UUID cGroupID, bool userExposed)
         {
-            SetRootPart(part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, 0, userExposed));
+            //            SetRootPart(part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, 0, userExposed));
+            // give newpart a new local ID lettng old part keep same
+            SceneObjectPart newpart = part.Copy(part.LocalId, OwnerID, GroupID, 0, userExposed);
+            newpart.LocalId = m_scene.AllocateLocalId();
+
+            SetRootPart(newpart);
+            if (userExposed)
+                RootPart.Velocity = Vector3.Zero; // In case source is moving
         }
 
         public void ScriptSetPhysicsStatus(bool usePhysics)
@@ -1643,27 +2362,14 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (pa != null)
                 {
-                    pa.AddForce(impulse, true);
-                    m_scene.PhysicsScene.AddPhysicsActorTaint(pa);
-                }
-            }
-        }
-
-        public void applyAngularImpulse(Vector3 impulse)
-        {
-            PhysicsActor pa = RootPart.PhysActor;
-
-            if (pa != null)
-            {
-                if (!IsAttachment)
-                {
-                    pa.AddAngularForce(impulse, true);
+                    // false to be applied as a impulse 
+                    pa.AddForce(impulse, false);
                     m_scene.PhysicsScene.AddPhysicsActorTaint(pa);
                 }
             }
         }
 
-        public void setAngularImpulse(Vector3 impulse)
+        public void ApplyAngularImpulse(Vector3 impulse)
         {
             PhysicsActor pa = RootPart.PhysActor;
 
@@ -1671,7 +2377,8 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (!IsAttachment)
                 {
-                    pa.Torque = impulse;
+                    // false to be applied as a impulse
+                    pa.AddAngularForce(impulse, false);
                     m_scene.PhysicsScene.AddPhysicsActorTaint(pa);
                 }
             }
@@ -1679,20 +2386,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         public Vector3 GetTorque()
         {
-            PhysicsActor pa = RootPart.PhysActor;
-
-            if (pa != null)
-            {
-                if (!IsAttachment)
-                {
-                    Vector3 torque = pa.Torque;
-                    return torque;
-                }
-            }
-
-            return Vector3.Zero;
+            return RootPart.Torque;
         }
 
+         // This is used by both Double-Click Auto-Pilot and llMoveToTarget() in an attached object
         public void moveToTarget(Vector3 target, float tau)
         {
             if (IsAttachment)
@@ -1722,8 +2419,50 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (pa != null)
                 pa.PIDActive = false;
+
+            RootPart.ScheduleTerseUpdate(); // send a stop information
+        }
+        
+        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()
+        {
+            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>
         /// Uses a PID to attempt to clamp the object on the Z axis at the given height over tau seconds.
         /// </summary>
@@ -1740,7 +2479,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     pa.PIDHoverHeight = height;
                     pa.PIDHoverType = hoverType;
-                    pa.PIDTau = tau;
+                    pa.PIDHoverTau = tau;
                     pa.PIDHoverActive = true;
                 }
                 else
@@ -1780,7 +2519,12 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="cGroupID"></param>
         public SceneObjectPart CopyPart(SceneObjectPart part, UUID cAgentID, UUID cGroupID, bool userExposed)
         {
-            SceneObjectPart newPart = part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, m_parts.Count, userExposed);
+            // give new ID to the new part, letting old keep original
+            //            SceneObjectPart newPart = part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, m_parts.Count, userExposed);
+            SceneObjectPart newPart = part.Copy(part.LocalId, OwnerID, GroupID, m_parts.Count, userExposed);
+            newPart.LocalId = m_scene.AllocateLocalId();
+            newPart.SetParent(this);
+
             AddPart(newPart);
 
             SetPartAsNonRoot(newPart);
@@ -1830,6 +2574,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         #endregion
 
+
         public override void Update()
         {
             // Check that the group was not deleted before the scheduled update
@@ -1848,19 +2593,8 @@ namespace OpenSim.Region.Framework.Scenes
             // check to see if the physical position or rotation warrant an update. 
             if (m_rootPart.UpdateFlag == UpdateRequired.NONE)
             {
-                bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
-
-                if (UsePhysics && !AbsolutePosition.ApproxEquals(lastPhysGroupPos, 0.02f))
-                {
-                    m_rootPart.UpdateFlag = UpdateRequired.TERSE;
-                    lastPhysGroupPos = AbsolutePosition;
-                }
-
-                if (UsePhysics && !GroupRotation.ApproxEquals(lastPhysGroupRot, 0.1f))
-                {
-                    m_rootPart.UpdateFlag = UpdateRequired.TERSE;
-                    lastPhysGroupRot = GroupRotation;
-                }
+                // rootpart SendScheduledUpdates will check if a update is needed
+                m_rootPart.UpdateFlag = UpdateRequired.TERSE;
             }
 
             SceneObjectPart[] parts = m_parts.GetArray();
@@ -1919,11 +2653,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();
 
@@ -2079,6 +2813,11 @@ namespace OpenSim.Region.Framework.Scenes
             // 'linkPart' == the root of the group being linked into this group
             SceneObjectPart linkPart = objectGroup.m_rootPart;
 
+            if (m_rootPart.PhysActor != null)
+                m_rootPart.PhysActor.Building = true;
+            if (linkPart.PhysActor != null)
+                linkPart.PhysActor.Building = true;
+
             // physics flags from group to be applied to linked parts
             bool grpusephys = UsesPhysics;
             bool grptemporary = IsTemporary;
@@ -2104,12 +2843,12 @@ namespace OpenSim.Region.Framework.Scenes
             Vector3 axPos = linkPart.OffsetPosition;
             // Rotate the linking root SOP's position to be relative to the new root prim
             Quaternion parentRot = m_rootPart.RotationOffset;
-            axPos *= Quaternion.Inverse(parentRot);
+            axPos *= Quaternion.Conjugate(parentRot);
             linkPart.OffsetPosition = axPos;
 
             // Make the linking root SOP's rotation relative to the new root prim
             Quaternion oldRot = linkPart.RotationOffset;
-            Quaternion newRot = Quaternion.Inverse(parentRot) * oldRot;
+            Quaternion newRot = Quaternion.Conjugate(parentRot) * oldRot;
             linkPart.RotationOffset = newRot;
 
             // If there is only one SOP in a SOG, the LinkNum is zero. I.e., not a linkset.
@@ -2143,7 +2882,7 @@ namespace OpenSim.Region.Framework.Scenes
                 linkPart.CreateSelected = true;
 
                 // let physics know preserve part volume dtc messy since UpdatePrimFlags doesn't look to parent changes for now
-                linkPart.UpdatePrimFlags(grpusephys, grptemporary, (IsPhantom || (linkPart.Flags & PrimFlags.Phantom) != 0), linkPart.VolumeDetectActive);
+                linkPart.UpdatePrimFlags(grpusephys, grptemporary, (IsPhantom || (linkPart.Flags & PrimFlags.Phantom) != 0), linkPart.VolumeDetectActive, true);
 
                 // If the added SOP is physical, also tell the physics engine about the link relationship.
                 if (linkPart.PhysActor != null && m_rootPart.PhysActor != null && m_rootPart.PhysActor.IsPhysical)
@@ -2153,6 +2892,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
                 linkPart.LinkNum = linkNum++;
+                linkPart.UpdatePrimFlags(UsesPhysics, IsTemporary, IsPhantom, IsVolumeDetect, false);
 
                 // Get a list of the SOP's in the old group in order of their linknum's.
                 SceneObjectPart[] ogParts = objectGroup.Parts;
@@ -2171,7 +2911,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                         // Update the physics flags for the newly added SOP
                         // (Is this necessary? LinkNonRootPart() has already called UpdatePrimFlags but with different flags!??)
-                        part.UpdatePrimFlags(grpusephys, grptemporary, (IsPhantom || (part.Flags & PrimFlags.Phantom) != 0), part.VolumeDetectActive);
+                        part.UpdatePrimFlags(grpusephys, grptemporary, (IsPhantom || (part.Flags & PrimFlags.Phantom) != 0), part.VolumeDetectActive, true);
 
                         // If the added SOP is physical, also tell the physics engine about the link relationship.
                         if (part.PhysActor != null && m_rootPart.PhysActor != null && m_rootPart.PhysActor.IsPhysical)
@@ -2189,7 +2929,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;
 
@@ -2203,6 +2943,9 @@ namespace OpenSim.Region.Framework.Scenes
             // unmoved prims!
             ResetChildPrimPhysicsPositions();
 
+            if (m_rootPart.PhysActor != null)
+                m_rootPart.PhysActor.Building = false;
+
             //HasGroupChanged = true;
             //ScheduleGroupForFullUpdate();
         }
@@ -2270,7 +3013,10 @@ namespace OpenSim.Region.Framework.Scenes
 //                m_log.DebugFormat(
 //                    "[SCENE OBJECT GROUP]: Delinking part {0}, {1} from group with root part {2}, {3}",
 //                    linkPart.Name, linkPart.UUID, RootPart.Name, RootPart.UUID);
-            
+
+            if (m_rootPart.PhysActor != null)
+                m_rootPart.PhysActor.Building = true;
+
             linkPart.ClearUndoState();
 
             Vector3 worldPos = linkPart.GetWorldPosition();
@@ -2341,6 +3087,14 @@ namespace OpenSim.Region.Framework.Scenes
 
             // When we delete a group, we currently have to force persist to the database if the object id has changed
             // (since delete works by deleting all rows which have a given object id)
+
+            // this is as it seems to be in sl now
+            if(linkPart.PhysicsShapeType == (byte)PhysShapeType.none)
+                linkPart.PhysicsShapeType = linkPart.DefaultPhysicsShapeType(); // root prims can't have type none for now
+
+            if (m_rootPart.PhysActor != null)
+                m_rootPart.PhysActor.Building = false;
+
             objectGroup.HasGroupChangedDueToDelink = true;
 
             return objectGroup;
@@ -2352,6 +3106,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="objectGroup"></param>
         public virtual void DetachFromBackup()
         {
+            if (m_scene != null)
+                m_scene.SceneGraph.FireDetachFromBackup(this);
             if (m_isBackedUp && Scene != null)
                 m_scene.EventManager.OnBackup -= ProcessBackup;
             
@@ -2372,7 +3128,8 @@ namespace OpenSim.Region.Framework.Scenes
             Vector3 axPos = part.OffsetPosition;
             axPos *= parentRot;
             part.OffsetPosition = axPos;
-            part.GroupPosition = oldGroupPosition + part.OffsetPosition;
+            Vector3 newPos = oldGroupPosition + part.OffsetPosition;
+            part.GroupPosition = newPos;
             part.OffsetPosition = Vector3.Zero;
 
             // Compution our rotation to be not relative to the old parent
@@ -2387,7 +3144,7 @@ namespace OpenSim.Region.Framework.Scenes
             part.LinkNum = linkNum;
 
             // Compute the new position of this SOP relative to the group position
-            part.OffsetPosition = part.GroupPosition - AbsolutePosition;
+            part.OffsetPosition = newPos - AbsolutePosition;
 
             // (radams1 20120711: I don't know why part.OffsetPosition is set multiple times.
             //   It would have the affect of setting the physics engine position multiple 
@@ -2397,18 +3154,19 @@ namespace OpenSim.Region.Framework.Scenes
             // Rotate the relative position by the rotation of the group
             Quaternion rootRotation = m_rootPart.RotationOffset;
             Vector3 pos = part.OffsetPosition;
-            pos *= Quaternion.Inverse(rootRotation);
+            pos *= Quaternion.Conjugate(rootRotation);
             part.OffsetPosition = pos;
 
             // Compute the SOP's rotation relative to the rotation of the group.
             parentRot = m_rootPart.RotationOffset;
             oldRot = part.RotationOffset;
-            Quaternion newRot = Quaternion.Inverse(parentRot) * oldRot;
+            Quaternion newRot = Quaternion.Conjugate(parentRot) * worldRot;
             part.RotationOffset = newRot;
 
             // Since this SOP's state has changed, push those changes into the physics engine
             //    and the simulator.
-            part.UpdatePrimFlags(UsesPhysics, IsTemporary, IsPhantom, IsVolumeDetect);
+            // done on caller
+//            part.UpdatePrimFlags(UsesPhysics, IsTemporary, IsPhantom, IsVolumeDetect, false);
         }
 
         /// <summary>
@@ -2430,10 +3188,14 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if (!m_rootPart.BlockGrab)
                         {
-                            Vector3 llmoveforce = pos - AbsolutePosition;
+/*                            Vector3 llmoveforce = pos - AbsolutePosition;
                             Vector3 grabforce = llmoveforce;
                             grabforce = (grabforce / 10) * pa.Mass;
-                            pa.AddForce(grabforce, true);
+ */
+                            // empirically convert distance diference to a impulse
+                            Vector3 grabforce = pos - AbsolutePosition;
+                            grabforce = grabforce * (pa.Mass/ 10.0f);
+                            pa.AddForce(grabforce, false);
                             m_scene.PhysicsScene.AddPhysicsActorTaint(pa);
                         }
                     }
@@ -2629,6 +3391,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="SetVolumeDetect"></param>
         public void UpdatePrimFlags(uint localID, bool UsePhysics, bool SetTemporary, bool SetPhantom, bool SetVolumeDetect)
         {
+            HasGroupChanged = true;
+
             SceneObjectPart selectionPart = GetPart(localID);
 
             if (SetTemporary && Scene != null)
@@ -2659,8 +3423,22 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
 
-                for (int i = 0; i < parts.Length; i++)
-                    parts[i].UpdatePrimFlags(UsePhysics, SetTemporary, SetPhantom, SetVolumeDetect);
+                if (parts.Length > 1)
+                {
+                    m_rootPart.UpdatePrimFlags(UsePhysics, SetTemporary, SetPhantom, SetVolumeDetect, true);
+
+                    for (int i = 0; i < parts.Length; i++)
+                    {
+
+                        if (parts[i].UUID != m_rootPart.UUID)
+                            parts[i].UpdatePrimFlags(UsePhysics, SetTemporary, SetPhantom, SetVolumeDetect, true);
+                    }
+
+                    if (m_rootPart.PhysActor != null)
+                        m_rootPart.PhysActor.Building = false;
+                }
+                else
+                    m_rootPart.UpdatePrimFlags(UsePhysics, SetTemporary, SetPhantom, SetVolumeDetect, false);
             }
         }
 
@@ -2673,6 +3451,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>
@@ -2710,8 +3499,24 @@ namespace OpenSim.Region.Framework.Scenes
         {
             RootPart.UpdatePermissions(AgentID, field, localID, mask, addRemTF);
 
+            bool god = Scene.Permissions.IsGod(AgentID);
+
+            if (field == 1 && god)
+            {
+                ForEachPart(part =>
+                {
+                    part.BaseMask = RootPart.BaseMask;
+                });
+            }
+
             AdjustChildPrimPermissions();
 
+            if (field == 1 && god) // Base mask was set. Update all child part inventories
+            {
+                foreach (SceneObjectPart part in Parts)
+                    part.Inventory.ApplyGodPermissions(RootPart.BaseMask);
+            }
+
             HasGroupChanged = true;
 
             // Send the group's properties to all clients once all parts are updated
@@ -2757,8 +3562,6 @@ namespace OpenSim.Region.Framework.Scenes
 
             PhysicsActor pa = m_rootPart.PhysActor;
 
-            RootPart.StoreUndoState(true);
-
             if (Scene != null)
             {
                 scale.X = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.X));
@@ -2786,7 +3589,6 @@ namespace OpenSim.Region.Framework.Scenes
                     SceneObjectPart obPart = parts[i];
                     if (obPart.UUID != m_rootPart.UUID)
                     {
-//                        obPart.IgnoreUndoUpdate = true;
                         Vector3 oldSize = new Vector3(obPart.Scale);
 
                         float f = 1.0f;
@@ -2898,8 +3700,6 @@ namespace OpenSim.Region.Framework.Scenes
                                 z *= a;
                             }
                         }
-
-//                        obPart.IgnoreUndoUpdate = false;
                     }
                 }
             }
@@ -2909,9 +3709,7 @@ namespace OpenSim.Region.Framework.Scenes
             prevScale.Y *= y;
             prevScale.Z *= z;
 
-//            RootPart.IgnoreUndoUpdate = true;
             RootPart.Resize(prevScale);
-//            RootPart.IgnoreUndoUpdate = false;
 
             for (int i = 0; i < parts.Length; i++)
             {
@@ -2919,8 +3717,6 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (obPart.UUID != m_rootPart.UUID)
                 {
-                    obPart.IgnoreUndoUpdate = true;
-
                     Vector3 currentpos = new Vector3(obPart.OffsetPosition);
                     currentpos.X *= x;
                     currentpos.Y *= y;
@@ -2933,16 +3729,12 @@ namespace OpenSim.Region.Framework.Scenes
 
                     obPart.Resize(newSize);
                     obPart.UpdateOffSet(currentpos);
-
-                    obPart.IgnoreUndoUpdate = false;                    
                 }
 
-//                obPart.IgnoreUndoUpdate = false;
-//                obPart.StoreUndoState();
+                HasGroupChanged = true;
+                m_rootPart.TriggerScriptChangedEvent(Changed.SCALE);
+                ScheduleGroupForTerseUpdate();
             }
-
-//            m_log.DebugFormat(
-//                "[SCENE OBJECT GROUP]: Finished group resizing {0} {1} to {2}", Name, LocalId, RootPart.Scale);
         }
 
         #endregion
@@ -2955,14 +3747,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="pos"></param>
         public void UpdateGroupPosition(Vector3 pos)
         {
-//            m_log.DebugFormat("[SCENE OBJECT GROUP]: Updating group position on {0} {1} to {2}", Name, LocalId, pos);
-
-            RootPart.StoreUndoState(true);
-
-//            SceneObjectPart[] parts = m_parts.GetArray();
-//            for (int i = 0; i < parts.Length; i++)
-//                parts[i].StoreUndoState();
-
             if (m_scene.EventManager.TriggerGroupMove(UUID, pos))
             {
                 if (IsAttachment)
@@ -2995,21 +3779,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="pos"></param>
         /// <param name="localID"></param>
+        /// 
+
         public void UpdateSinglePosition(Vector3 pos, uint localID)
         {
             SceneObjectPart part = GetPart(localID);
 
-//            SceneObjectPart[] parts = m_parts.GetArray();
-//            for (int i = 0; i < parts.Length; i++)
-//                parts[i].StoreUndoState();
-
             if (part != null)
             {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT GROUP]: Updating single position of {0} {1} to {2}", part.Name, part.LocalId, pos);
-
-                part.StoreUndoState(false);
-                part.IgnoreUndoUpdate = true;
+// unlock parts position change
+                if (m_rootPart.PhysActor != null)
+                    m_rootPart.PhysActor.Building = true;
 
                 if (part.UUID == m_rootPart.UUID)
                 {
@@ -3020,8 +3800,10 @@ namespace OpenSim.Region.Framework.Scenes
                     part.UpdateOffSet(pos);
                 }
 
+                if (m_rootPart.PhysActor != null)
+                    m_rootPart.PhysActor.Building = false;
+
                 HasGroupChanged = true;
-                part.IgnoreUndoUpdate = false;
             }
         }
 
@@ -3031,13 +3813,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="newPos"></param>
         public void UpdateRootPosition(Vector3 newPos)
         {
-//            m_log.DebugFormat(
-//                "[SCENE OBJECT GROUP]: Updating root position of {0} {1} to {2}", Name, LocalId, pos);
-
-//            SceneObjectPart[] parts = m_parts.GetArray();
-//            for (int i = 0; i < parts.Length; i++)
-//                parts[i].StoreUndoState();
-
+            // needs to be called with phys building true
             Vector3 oldPos;
 
             // FIXME: This improves the situation where editing just the root prim of an attached object would send
@@ -3063,7 +3839,14 @@ namespace OpenSim.Region.Framework.Scenes
             AbsolutePosition = newPos;
 
             HasGroupChanged = true;
-            ScheduleGroupForTerseUpdate();
+            if (m_rootPart.Undoing)
+            {
+                ScheduleGroupForFullUpdate();
+            }
+            else
+            {
+                ScheduleGroupForTerseUpdate();
+            }
         }
 
         #endregion
@@ -3076,24 +3859,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="rot"></param>
         public void UpdateGroupRotationR(Quaternion rot)
         {
-//            m_log.DebugFormat(
-//                "[SCENE OBJECT GROUP]: Updating group rotation R of {0} {1} to {2}", Name, LocalId, rot);
-
-//            SceneObjectPart[] parts = m_parts.GetArray();
-//            for (int i = 0; i < parts.Length; i++)
-//                parts[i].StoreUndoState();
-
-            m_rootPart.StoreUndoState(true);
-
             m_rootPart.UpdateRotation(rot);
-
+        
+/* this is done by rootpart RotationOffset set called by UpdateRotation
             PhysicsActor actor = m_rootPart.PhysActor;
             if (actor != null)
             {
                 actor.Orientation = m_rootPart.RotationOffset;
                 m_scene.PhysicsScene.AddPhysicsActorTaint(actor);
             }
-
+*/
             HasGroupChanged = true;
             ScheduleGroupForTerseUpdate();
         }
@@ -3105,16 +3880,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="rot"></param>
         public void UpdateGroupRotationPR(Vector3 pos, Quaternion rot)
         {
-//            m_log.DebugFormat(
-//                "[SCENE OBJECT GROUP]: Updating group rotation PR of {0} {1} to {2}", Name, LocalId, rot);
-
-//            SceneObjectPart[] parts = m_parts.GetArray();
-//            for (int i = 0; i < parts.Length; i++)
-//                parts[i].StoreUndoState();
-
-            RootPart.StoreUndoState(true);
-            RootPart.IgnoreUndoUpdate = true;
-
             m_rootPart.UpdateRotation(rot);
 
             PhysicsActor actor = m_rootPart.PhysActor;
@@ -3133,8 +3898,6 @@ namespace OpenSim.Region.Framework.Scenes
 
             HasGroupChanged = true;
             ScheduleGroupForTerseUpdate();
-
-            RootPart.IgnoreUndoUpdate = false;
         }
 
         /// <summary>
@@ -3147,13 +3910,11 @@ namespace OpenSim.Region.Framework.Scenes
             SceneObjectPart part = GetPart(localID);
 
             SceneObjectPart[] parts = m_parts.GetArray();
-            for (int i = 0; i < parts.Length; i++)
-                parts[i].StoreUndoState();
 
             if (part != null)
             {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT GROUP]: Updating single rotation of {0} {1} to {2}", part.Name, part.LocalId, rot);
+                if (m_rootPart.PhysActor != null)
+                    m_rootPart.PhysActor.Building = true;
 
                 if (part.UUID == m_rootPart.UUID)
                 {
@@ -3163,6 +3924,9 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     part.UpdateRotation(rot);
                 }
+
+                if (m_rootPart.PhysActor != null)
+                    m_rootPart.PhysActor.Building = false;
             }
         }
 
@@ -3176,12 +3940,8 @@ namespace OpenSim.Region.Framework.Scenes
             SceneObjectPart part = GetPart(localID);
             if (part != null)
             {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT GROUP]: Updating single position and rotation of {0} {1} to {2}",
-//                    part.Name, part.LocalId, rot);
-
-                part.StoreUndoState();
-                part.IgnoreUndoUpdate = true;
+                if (m_rootPart.PhysActor != null)
+                    m_rootPart.PhysActor.Building = true;
 
                 if (part.UUID == m_rootPart.UUID)
                 {
@@ -3194,7 +3954,8 @@ namespace OpenSim.Region.Framework.Scenes
                     part.OffsetPosition = pos;
                 }
 
-                part.IgnoreUndoUpdate = false;
+                if (m_rootPart.PhysActor != null)
+                    m_rootPart.PhysActor.Building = false;
             }
         }
 
@@ -3204,15 +3965,12 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="rot"></param>
         public void UpdateRootRotation(Quaternion rot)
         {
-//            m_log.DebugFormat(
-//                "[SCENE OBJECT GROUP]: Updating root rotation of {0} {1} to {2}",
-//                Name, LocalId, rot);
-
+            // needs to be called with phys building true
             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;
 
             PhysicsActor pa = m_rootPart.PhysActor;
 
@@ -3228,35 +3986,145 @@ namespace OpenSim.Region.Framework.Scenes
                 SceneObjectPart prim = parts[i];
                 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;
-                }
-            }
-
-//            for (int i = 0; i < parts.Length; i++)
-//            {
-//                SceneObjectPart childpart = parts[i];
-//                if (childpart != m_rootPart)
-//                {
-////                    childpart.IgnoreUndoUpdate = false;
-////                    childpart.StoreUndoState();
-//                }
-//            }
+                }
+            }
 
-            m_rootPart.ScheduleTerseUpdate();
+            HasGroupChanged = true;
+            ScheduleGroupForFullUpdate();
+        }
 
-//            m_log.DebugFormat(
-//                "[SCENE OBJECT GROUP]: Updated root rotation of {0} {1} to {2}",
-//                Name, LocalId, rot);
+        private enum updatetype :int
+        {
+            none = 0,
+            partterse = 1,
+            partfull = 2,
+            groupterse = 3,
+            groupfull = 4
+        }
+
+        public void doChangeObject(SceneObjectPart part, ObjectChangeData data)
+        {
+            // TODO  this still as excessive *.Schedule*Update()s
+
+            if (part != null && part.ParentGroup != null)
+            {
+                ObjectChangeType change = data.change;
+                bool togroup = ((change & ObjectChangeType.Group) != 0);
+                //                bool uniform = ((what & ObjectChangeType.UniformScale) != 0);  not in use
+
+                SceneObjectGroup group = part.ParentGroup;
+                PhysicsActor pha = group.RootPart.PhysActor;
+
+                updatetype updateType = updatetype.none;
+
+                if (togroup)
+                {
+                    // related to group
+                    if ((change & (ObjectChangeType.Rotation | ObjectChangeType.Position)) != 0)
+                    {
+                        if ((change & ObjectChangeType.Rotation) != 0)
+                        {
+                            group.RootPart.UpdateRotation(data.rotation);
+                            updateType = updatetype.none;
+                        }
+                        if ((change & ObjectChangeType.Position) != 0)
+                        {
+                            if (IsAttachment || m_scene.Permissions.CanObjectEntry(group.UUID, false, data.position))
+                                UpdateGroupPosition(data.position);
+                            updateType = updatetype.groupterse;
+                        }
+                        else
+                        // ugly rotation update of all parts
+                        {
+                            group.ResetChildPrimPhysicsPositions();
+                        }
+
+                    }
+                    if ((change & ObjectChangeType.Scale) != 0)
+                    {
+                        if (pha != null)
+                            pha.Building = true;
+
+                        group.GroupResize(data.scale);
+                        updateType = updatetype.none;
+
+                        if (pha != null)
+                            pha.Building = false;
+                    }
+                }
+                else
+                {
+                    // related to single prim in a link-set ( ie group)
+                    if (pha != null)
+                        pha.Building = true;
+
+                    // root part is special
+                    // parts offset positions or rotations need to change also
+
+                    if (part == group.RootPart)
+                    {
+                        if ((change & ObjectChangeType.Rotation) != 0)
+                            group.UpdateRootRotation(data.rotation);
+                        if ((change & ObjectChangeType.Position) != 0)
+                            group.UpdateRootPosition(data.position);
+                        if ((change & ObjectChangeType.Scale) != 0)
+                            part.Resize(data.scale);
+                    }
+                    else
+                    {
+                        if ((change & ObjectChangeType.Position) != 0)
+                        {
+                            part.OffsetPosition = data.position;
+                            updateType = updatetype.partterse;
+                        }
+                        if ((change & ObjectChangeType.Rotation) != 0)
+                        {
+                            part.UpdateRotation(data.rotation);
+                            updateType = updatetype.none;
+                        }
+                        if ((change & ObjectChangeType.Scale) != 0)
+                        {
+                            part.Resize(data.scale);
+                            updateType = updatetype.none;
+                        }
+                    }
+
+                    if (pha != null)
+                        pha.Building = false;
+                }
+
+                if (updateType != updatetype.none)
+                {
+                    group.HasGroupChanged = true;
+
+                    switch (updateType)
+                    {
+                        case updatetype.partterse:
+                            part.ScheduleTerseUpdate();
+                            break;
+                        case updatetype.partfull:
+                            part.ScheduleFullUpdate();
+                            break;
+                        case updatetype.groupterse:
+                            group.ScheduleGroupForTerseUpdate();
+                            break;
+                        case updatetype.groupfull:
+                            group.ScheduleGroupForFullUpdate();
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
         }
 
         #endregion
@@ -3297,6 +4165,8 @@ namespace OpenSim.Region.Framework.Scenes
             waypoint.handle = handle;
             lock (m_rotTargets)
             {
+                if (m_rotTargets.Count >= 8)
+                    m_rotTargets.Remove(m_rotTargets.ElementAt(0).Key);
                 m_rotTargets.Add(handle, waypoint);
             }
             m_scene.AddGroupTarget(this);
@@ -3322,6 +4192,8 @@ namespace OpenSim.Region.Framework.Scenes
             waypoint.handle = handle;
             lock (m_targets)
             {
+                if (m_targets.Count >= 8)
+                    m_targets.Remove(m_targets.ElementAt(0).Key);
                 m_targets.Add(handle, waypoint);
             }
             m_scene.AddGroupTarget(this);
@@ -3355,10 +4227,11 @@ namespace OpenSim.Region.Framework.Scenes
                             scriptPosTarget target = m_targets[idx];
                             if (Util.GetDistanceTo(target.targetPos, m_rootPart.GroupPosition) <= target.tolerance)
                             {
+                                at_target = true;
+
                                 // trigger at_target
                                 if (m_scriptListens_atTarget)
                                 {
-                                    at_target = true;
                                     scriptPosTarget att = new scriptPosTarget();
                                     att.targetPos = target.targetPos;
                                     att.tolerance = target.tolerance;
@@ -3476,11 +4349,50 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
         }
-        
+
+        public Vector3 GetGeometricCenter()
+        {
+            // this is not real geometric center but a average of positions relative to root prim acording to
+            // http://wiki.secondlife.com/wiki/llGetGeometricCenter
+            // ignoring tortured prims details since sl also seems to ignore
+            // so no real use in doing it on physics
+            
+            Vector3 gc = Vector3.Zero;
+
+            int nparts = m_parts.Count;
+            if (nparts <= 1)
+                return gc;
+
+            SceneObjectPart[] parts = m_parts.GetArray();
+            nparts = parts.Length; // just in case it changed
+            if (nparts <= 1)
+                return gc;
+
+            Quaternion parentRot = RootPart.RotationOffset;
+            Vector3 pPos;
+
+            // average all parts positions
+            for (int i = 0; i < nparts; i++)
+            {
+                // do it directly
+                //                gc += parts[i].GetWorldPosition();
+                if (parts[i] != RootPart)
+                {
+                    pPos = parts[i].OffsetPosition;
+                    gc += pPos;
+                }
+
+            }
+            gc /= nparts;
+
+            // relative to root:
+//            gc -= AbsolutePosition;
+            return gc;
+        }
+
         public float GetMass()
         {
             float retmass = 0f;
-
             SceneObjectPart[] parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
                 retmass += parts[i].GetMass();
@@ -3488,6 +4400,39 @@ namespace OpenSim.Region.Framework.Scenes
             return retmass;
         }
 
+        // center of mass of full object
+        public Vector3 GetCenterOfMass()
+        {
+            PhysicsActor pa = RootPart.PhysActor;
+
+            if(((RootPart.Flags & PrimFlags.Physics) !=0) && pa !=null)
+            {
+                // physics knows better about center of mass of physical prims
+                Vector3 tmp = pa.CenterOfMass;
+                return tmp;
+            }
+            
+            Vector3 Ptot = Vector3.Zero;
+            float totmass = 0f;
+            float m;
+
+            SceneObjectPart[] parts = m_parts.GetArray();
+            for (int i = 0; i < parts.Length; i++)
+            {
+                m = parts[i].GetMass();
+                Ptot += parts[i].GetPartCenterOfMass() * m;
+                totmass += m;
+            }
+
+            if (totmass == 0)
+                totmass = 0;
+            else
+                totmass = 1 / totmass;
+            Ptot *= totmass;
+
+            return Ptot;
+        }
+
         /// <summary>
         /// If the object is a sculpt/mesh, retrieve the mesh data for each part and reinsert it into each shape so that
         /// the physics engine can use it.
@@ -3667,6 +4612,14 @@ namespace OpenSim.Region.Framework.Scenes
             FromItemID = 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 eb3af42..95ffc77 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -64,7 +64,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.
@@ -123,7 +124,18 @@ namespace OpenSim.Region.Framework.Scenes
         /// Denote all sides of the prim
         /// </value>
         public const int ALL_SIDES = -1;
-        
+
+        private const scriptEvents PhysicsNeededSubsEvents = (
+                    scriptEvents.collision | scriptEvents.collision_start | scriptEvents.collision_end |
+                    scriptEvents.land_collision | scriptEvents.land_collision_start | scriptEvents.land_collision_end
+                    );
+        private const scriptEvents PhyscicsPhantonSubsEvents = (
+                    scriptEvents.land_collision | scriptEvents.land_collision_start | scriptEvents.land_collision_end
+                    );
+        private const scriptEvents PhyscicsVolumeDtcSubsEvents = (
+                    scriptEvents.collision_start | scriptEvents.collision_end
+                    );      
+
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         /// <summary>
@@ -160,7 +172,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </remarks>
         public bool IsRoot 
         {
-            get { return ParentGroup.RootPart == this; } 
+            get { return Object.ReferenceEquals(ParentGroup.RootPart, this); } 
         }
 
         /// <summary>
@@ -233,6 +245,18 @@ namespace OpenSim.Region.Framework.Scenes
 
         public uint TimeStampTerse;
 
+        // 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 Quaternion AttachRotation = Quaternion.Identity;
+
+        [XmlIgnore]
         public int STATUS_ROTATE_X;
 
         public int STATUS_ROTATE_Y;
@@ -259,8 +283,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;
 
@@ -300,10 +323,10 @@ 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 List<UndoState> m_undo = new List<UndoState>(5);
-        private readonly List<UndoState> m_redo = new List<UndoState>(5);
+        private UndoRedoState m_UndoRedo = null;
 
         private bool m_passTouches = false;
         private bool m_passCollisions = false;
@@ -331,14 +354,20 @@ namespace OpenSim.Region.Framework.Scenes
         protected Vector3 m_lastVelocity;
         protected Vector3 m_lastAcceleration;
         protected Vector3 m_lastAngularVelocity;
-        protected int m_lastTerseSent;
+        protected int m_lastUpdateSentTime;
+        protected float m_buoyancy = 0.0f;
+        protected Vector3 m_force;
+        protected Vector3 m_torque;
 
         protected byte m_physicsShapeType = (byte)PhysShapeType.prim;
         protected float m_density = 1000.0f; // in kg/m^3
         protected float m_gravitymod = 1.0f;
         protected float m_friction = 0.6f; // wood
         protected float m_bounce = 0.5f; // wood
-        
+
+
+        protected bool m_isSelected = false;
+
         /// <summary>
         /// Stores media texture data
         /// </summary>
@@ -350,15 +379,25 @@ namespace OpenSim.Region.Framework.Scenes
         private Vector3 m_cameraAtOffset;
         private bool m_forceMouselook;
 
-        // TODO: Collision sound should have default.
+
+        // 0 for default collision sounds, -1 for script disabled sound 1 for script defined sound
+        private sbyte m_collisionSoundType;
         private UUID m_collisionSound;
         private float m_collisionSoundVolume;
 
+        private int LastColSoundSentTime; 
+
+
+        private SOPVehicle m_vehicleParams = null;
+
+        private KeyframeMotion m_keyframeMotion = null;
+
         public KeyframeMotion KeyframeMotion
         {
             get; set;
         }
 
+
         #endregion Fields
 
 //        ~SceneObjectPart()
@@ -388,6 +427,7 @@ namespace OpenSim.Region.Framework.Scenes
             // this appears to have the same UUID (!) as the prim.  If this isn't the case, one can't drag items from
             // the prim into an agent inventory (Linden client reports that the "Object not found for drop" in its log
             m_inventory = new SceneObjectPartInventory(this);
+            LastColSoundSentTime = Util.EnvironmentTickCount();
         }
 
         /// <summary>
@@ -402,7 +442,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;
@@ -441,7 +481,7 @@ namespace OpenSim.Region.Framework.Scenes
         private uint _ownerMask = (uint)(PermissionMask.All | PermissionMask.Export);
         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;
@@ -539,12 +579,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>
@@ -594,20 +638,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public byte Material
-        {
-            get { return (byte) m_material; }
-            set
-            {
-                m_material = (Material)value;
-
-                PhysicsActor pa = PhysActor;
-
-                if (pa != null)
-                    pa.SetMaterial((int)value);
-            }
-        }
-
         [XmlIgnore]
         public bool PassTouches
         {
@@ -633,6 +663,18 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public bool IsSelected
+        {
+            get { return m_isSelected; }
+            set
+            {
+                m_isSelected = value;
+                if (ParentGroup != null)
+                    ParentGroup.PartSelectChanged(value);
+            }
+        }
+        
+        
         public Dictionary<int, string> CollisionFilter
         {
             get { return m_CollisionFilter; }
@@ -701,14 +743,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; }
@@ -745,9 +785,12 @@ 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 physical and the root prim of a linkset, the position of the group is what physics thinks.
-                if (actor != null && ParentID == 0)
-                    m_groupPosition = actor.Position;
+                if (ParentID == 0)
+                {
+                    if (actor != null)
+                        m_groupPosition = actor.Position;
+                    return m_groupPosition;
+                }
 
                 // If I'm an attachment, my position is reported as the position of who I'm attached to
                 if (ParentGroup.IsAttachment)
@@ -757,14 +800,16 @@ 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)
+                if (actor != null && ParentGroup.Scene.PhysicsScene != null)
                 {
                     try
                     {
@@ -789,16 +834,6 @@ namespace OpenSim.Region.Framework.Scenes
                         m_log.ErrorFormat("[SCENEOBJECTPART]: GROUP POSITION. {0}", e);
                     }
                 }
-                
-                // 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();
-                    }
-                }
             }
         }
 
@@ -807,7 +842,7 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_offsetPosition; }
             set
             {
-//                StoreUndoState();
+                Vector3 oldpos = m_offsetPosition;
                 m_offsetPosition = value;
 
                 if (ParentGroup != null && !ParentGroup.IsDeleted)
@@ -819,10 +854,25 @@ namespace OpenSim.Region.Framework.Scenes
                         actor.Orientation = GetWorldRotation();
 
                         // Tell the physics engines that this prim changed.
-                        if (ParentGroup.Scene != null)
+                        if (ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene != 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);
             }
         }
 
@@ -873,7 +923,7 @@ namespace OpenSim.Region.Framework.Scenes
             
             set
             {
-                StoreUndoState();
+//                StoreUndoState();
                 m_rotationOffset = value;
 
                 PhysicsActor actor = PhysActor;
@@ -961,19 +1011,36 @@ namespace OpenSim.Region.Framework.Scenes
             get
             {
                 PhysicsActor actor = PhysActor;
-                if ((actor != null) && actor.IsPhysical)
+                if ((actor != null) && actor.IsPhysical && ParentGroup.RootPart == this)
                 {
                     m_angularVelocity = actor.RotationalVelocity;
                 }
                 return m_angularVelocity;
             }
-            set { m_angularVelocity = value; }
+            set
+            {
+                m_angularVelocity = value;
+                PhysicsActor actor = PhysActor;
+                if ((actor != null) && actor.IsPhysical && ParentGroup.RootPart == this && VehicleType == (int)Vehicle.TYPE_NONE)
+                {
+                    actor.RotationalVelocity = m_angularVelocity;
+                }                       
+            }
         }
 
         /// <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; }
         }
 
@@ -1041,7 +1108,10 @@ namespace OpenSim.Region.Framework.Scenes
         public PrimitiveBaseShape Shape
         {
             get { return m_shape; }
-            set { m_shape = value;}
+            set
+            {
+                m_shape = value;
+            }
         }
 
         /// <summary>
@@ -1054,7 +1124,6 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_shape != null)
                 {
-                    StoreUndoState();
 
                     m_shape.Scale = value;
 
@@ -1122,10 +1191,7 @@ namespace OpenSim.Region.Framework.Scenes
         {
             get
             {
-                if (ParentGroup.IsAttachment)
-                    return GroupPosition;
-
-                return m_offsetPosition + m_groupPosition;
+                return GroupPosition + (m_offsetPosition * ParentGroup.RootPart.RotationOffset);
             }
         }
 
@@ -1294,6 +1360,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 we have a sit target.  If there is no such avatar then is UUID.Zero
@@ -1344,12 +1417,41 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_sitAnimation = value; }
         }
 
+        public UUID invalidCollisionSoundUUID = new UUID("ffffffff-ffff-ffff-ffff-ffffffffffff");
+
+        // 0 for default collision sounds, -1 for script disabled sound 1 for script defined sound
+        // runtime thing.. do not persist
+        [XmlIgnore]
+        public sbyte CollisionSoundType
+        {
+            get
+            {
+                return m_collisionSoundType;
+            }
+            set
+            {
+                m_collisionSoundType = value;
+                if (value == -1)
+                    m_collisionSound = invalidCollisionSoundUUID;
+                else if (value == 0)
+                    m_collisionSound = UUID.Zero;
+            }
+        }
+
         public UUID CollisionSound
         {
             get { return m_collisionSound; }
             set
-            {
+            {           
                 m_collisionSound = value;
+
+                if (value == invalidCollisionSoundUUID)
+                    m_collisionSoundType = -1;
+                else if (value == UUID.Zero)
+                    m_collisionSoundType = 0;
+                else
+                    m_collisionSoundType = 1;
+
                 aggregateScriptEvents();
             }
         }
@@ -1360,6 +1462,125 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_collisionSoundVolume = value; }
         }
 
+        public float Buoyancy
+        {
+            get
+            {
+                if (ParentGroup.RootPart == this)
+                    return m_buoyancy;
+
+                return ParentGroup.RootPart.Buoyancy;
+            }
+            set
+            {
+                if (ParentGroup != null && ParentGroup.RootPart != null && ParentGroup.RootPart != this)
+                {
+                    ParentGroup.RootPart.Buoyancy = value;
+                    return;
+                }
+                m_buoyancy = value;
+                if (PhysActor != null)
+                    PhysActor.Buoyancy = value;
+            }
+        }
+
+        public Vector3 Force
+        {
+            get
+            {
+                if (ParentGroup.RootPart == this)
+                    return m_force;
+
+                return ParentGroup.RootPart.Force;
+            }
+
+            set
+            {
+                if (ParentGroup != null && ParentGroup.RootPart != null && ParentGroup.RootPart != this)
+                {
+                    ParentGroup.RootPart.Force = value;
+                    return;
+                }
+                m_force = value;
+                if (PhysActor != null)
+                    PhysActor.Force = value;
+            }
+        }
+
+        public Vector3 Torque
+        {
+            get
+            {
+                if (ParentGroup.RootPart == this)
+                    return m_torque;
+                
+                return ParentGroup.RootPart.Torque;
+            }
+
+            set
+            {
+                if (ParentGroup != null && ParentGroup.RootPart != null && ParentGroup.RootPart != this)
+                {
+                    ParentGroup.RootPart.Torque = value;
+                    return;
+                }
+                m_torque = value;
+                if (PhysActor != null)
+                    PhysActor.Torque = value;
+            }
+        }
+
+        public byte Material
+        {
+            get { return (byte)m_material; }
+            set
+            {
+                if (value >= 0 && value <= (byte)SOPMaterialData.MaxMaterial)
+                {
+                    bool update = false;
+
+                    if (m_material != (Material)value)
+                    {
+                        update = true;
+                        m_material = (Material)value;
+                    }
+
+                    if (m_friction != SOPMaterialData.friction(m_material))
+                    {
+                        update = true;
+                        m_friction = SOPMaterialData.friction(m_material);
+                    }
+
+                    if (m_bounce != SOPMaterialData.bounce(m_material))
+                    {
+                        update = true;
+                        m_bounce = SOPMaterialData.bounce(m_material);
+                    }
+
+                    if (update)
+                    {
+                        if (PhysActor != null)
+                        {
+                            PhysActor.SetMaterial((int)value);
+                        }
+                        if(ParentGroup != null)
+                            ParentGroup.HasGroupChanged = true;
+                        ScheduleFullUpdateIfNone();
+                        UpdatePhysRequired = true;
+                    }
+                }
+            }
+        }
+
+        // not a propriety to move to methods place later
+        private bool HasMesh()
+        {
+            if (Shape != null && (Shape.SculptType == (byte)SculptType.Mesh))
+                return true;
+            return false;
+        }
+
+        // not a propriety to move to methods place later
         public byte DefaultPhysicsShapeType()
         {
             byte type;
@@ -1372,6 +1593,65 @@ namespace OpenSim.Region.Framework.Scenes
             return type;
         }
 
+        [XmlIgnore]
+        public bool UsesComplexCost
+        {
+            get
+            {
+                byte pst = PhysicsShapeType;
+                if(pst == (byte) PhysShapeType.none || pst == (byte) PhysShapeType.convex || HasMesh())
+                    return true;
+                return false;
+            }
+        }
+
+        [XmlIgnore]
+        public float PhysicsCost
+        {
+            get
+            {
+                if(PhysicsShapeType == (byte)PhysShapeType.none)
+                    return 0;
+
+                float cost = 0.1f;
+                if (PhysActor != null)
+                    cost = PhysActor.PhysicsCost;
+                else
+                    cost = 0.1f;
+
+                if ((Flags & PrimFlags.Physics) != 0)
+                    cost *= (1.0f + 0.01333f * Scale.LengthSquared()); // 0.01333 == 0.04/3
+                return cost;
+            }
+        }
+
+        [XmlIgnore]
+        public float StreamingCost
+        {
+            get
+            {
+                float cost;
+                if (PhysActor != null)
+                    cost = PhysActor.StreamCost;
+                else
+                    cost = 1.0f;
+                return 1.0f;
+            }
+        }
+
+        [XmlIgnore]
+        public float SimulationCost
+        {
+            get
+            {
+                // ignoring scripts. Don't like considering them for this
+                if((Flags & PrimFlags.Physics) != 0)
+                    return 1.0f;
+
+                return 0.5f;
+            }
+        }
+
         public byte PhysicsShapeType
         {
             get { return m_physicsShapeType; }
@@ -1405,11 +1685,14 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     else if (PhysActor == null)
                     {
-                        ApplyPhysics((uint)Flags, VolumeDetectActive);
+                        ApplyPhysics((uint)Flags, VolumeDetectActive, false);
+                        UpdatePhysicsSubscribedEvents();
                     }
                     else
                     {
                         PhysActor.PhysicsShapeType = m_physicsShapeType;
+//                        if (Shape.SculptEntry)
+//                            CheckSculptAndLoad();
                     }
 
                     if (ParentGroup != null)
@@ -1511,6 +1794,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+
         #endregion Public Properties with only Get
 
         private uint ApplyMask(uint val, bool set, uint mask)
@@ -1656,6 +1940,61 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        //      SetVelocity for LSL llSetVelocity..  may need revision if having other uses in future
+        public void SetVelocity(Vector3 pVel, bool localGlobalTF)
+        {
+            if (ParentGroup == null || ParentGroup.IsDeleted)
+                return;
+
+            if (ParentGroup.IsAttachment)
+                return;                         // don't work on attachments (for now ??)
+
+            SceneObjectPart root = ParentGroup.RootPart;
+
+            if (root.VehicleType != (int)Vehicle.TYPE_NONE) // don't mess with vehicles
+                return;
+
+            PhysicsActor pa = root.PhysActor;
+
+            if (pa == null || !pa.IsPhysical)
+                return;
+
+            if (localGlobalTF)
+            {
+                pVel = pVel * GetWorldRotation();
+            }
+
+            ParentGroup.Velocity = pVel;
+        }
+
+        //      SetAngularVelocity for LSL llSetAngularVelocity..  may need revision if having other uses in future
+        public void SetAngularVelocity(Vector3 pAngVel, bool localGlobalTF)
+        {
+            if (ParentGroup == null || ParentGroup.IsDeleted)
+                return;
+
+            if (ParentGroup.IsAttachment)
+                return;                         // don't work on attachments (for now ??)
+
+            SceneObjectPart root = ParentGroup.RootPart;
+
+            if (root.VehicleType != (int)Vehicle.TYPE_NONE) // don't mess with vehicles
+                return;
+
+            PhysicsActor pa = root.PhysActor;
+
+            if (pa == null || !pa.IsPhysical)
+                return;
+
+            if (localGlobalTF)
+            {
+                pAngVel = pAngVel * GetWorldRotation();
+            }
+
+            root.AngularVelocity = pAngVel;
+        }
+        
+
         /// <summary>
         /// hook to the physics scene to apply angular impulse
         /// This is sent up to the group, which then finds the root prim
@@ -1676,7 +2015,7 @@ namespace OpenSim.Region.Framework.Scenes
                 impulse = newimpulse;
             }
 
-            ParentGroup.applyAngularImpulse(impulse);
+            ParentGroup.ApplyAngularImpulse(impulse);
         }
 
         /// <summary>
@@ -1686,20 +2025,24 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="impulsei">Vector force</param>
         /// <param name="localGlobalTF">true for the local frame, false for the global frame</param>
-        public void SetAngularImpulse(Vector3 impulsei, bool localGlobalTF)
+        
+        // this is actualy Set Torque.. keeping naming so not to edit lslapi also
+        public void SetAngularImpulse(Vector3 torquei, bool localGlobalTF)
         {
-            Vector3 impulse = impulsei;
+            Vector3 torque = torquei;
 
             if (localGlobalTF)
             {
+/*
                 Quaternion grot = GetWorldRotation();
                 Quaternion AXgrot = grot;
                 Vector3 AXimpulsei = impulsei;
                 Vector3 newimpulse = AXimpulsei * AXgrot;
-                impulse = newimpulse;
+ */
+                torque *= GetWorldRotation();
             }
 
-            ParentGroup.setAngularImpulse(impulse);
+            Torque = torque;
         }
 
         /// <summary>
@@ -1707,7 +2050,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="rootObjectFlags"></param>
         /// <param name="VolumeDetectActive"></param>
-        public void ApplyPhysics(uint rootObjectFlags, bool _VolumeDetectActive)
+        /// <param name="building"></param>
+
+                public void ApplyPhysics(uint _ObjectFlags, bool _VolumeDetectActive, bool building)
         {
             VolumeDetectActive = _VolumeDetectActive;
 
@@ -1717,8 +2062,8 @@ namespace OpenSim.Region.Framework.Scenes
             if (PhysicsShapeType == (byte)PhysShapeType.none)
                 return;
 
-            bool isPhysical = (rootObjectFlags & (uint) PrimFlags.Physics) != 0;
-            bool isPhantom = (rootObjectFlags & (uint) PrimFlags.Phantom) != 0;
+            bool isPhysical = (_ObjectFlags & (uint) PrimFlags.Physics) != 0;
+            bool isPhantom = (_ObjectFlags & (uint)PrimFlags.Phantom) != 0;
 
             if (_VolumeDetectActive)
                 isPhantom = true;
@@ -1732,7 +2077,8 @@ namespace OpenSim.Region.Framework.Scenes
                 if ((!isPhantom || isPhysical || _VolumeDetectActive) && !ParentGroup.IsAttachment
                                                 && !(Shape.PathCurve == (byte)Extrusion.Flexible))
                 {
-                    AddToPhysics(isPhysical, isPhantom, isPhysical);
+                    AddToPhysics(isPhysical, isPhantom, building, isPhysical);
+                    UpdatePhysicsSubscribedEvents(); // not sure if appliable here
                 }
                 else
                     PhysActor = null; // just to be sure
@@ -1787,6 +2133,12 @@ namespace OpenSim.Region.Framework.Scenes
             dupe.Category = Category;
             dupe.m_rezzed = m_rezzed;
 
+            dupe.m_UndoRedo = null;
+            dupe.m_isSelected = false;
+
+            dupe.IgnoreUndoUpdate = false;
+            dupe.Undoing = false;
+
             dupe.m_inventory = new SceneObjectPartInventory(dupe);
             dupe.m_inventory.Items = (TaskInventoryDictionary)m_inventory.Items.Clone();
 
@@ -1802,6 +2154,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             // Move afterwards ResetIDs as it clears the localID
             dupe.LocalId = localID;
+
             // This may be wrong...    it might have to be applied in SceneObjectGroup to the object that's being duplicated.
             dupe.LastOwnerID = OwnerID;
 
@@ -1826,8 +2179,12 @@ namespace OpenSim.Region.Framework.Scenes
 */                
                 bool UsePhysics = ((dupe.Flags & PrimFlags.Physics) != 0);
                 dupe.DoPhysicsPropertyUpdate(UsePhysics, true);
+//                dupe.UpdatePhysicsSubscribedEvents();  // not sure...
             }
             
+            if (dupe.PhysActor != null)
+                dupe.PhysActor.LocalID = localID;
+
             ParentGroup.Scene.EventManager.TriggerOnSceneObjectPartCopy(dupe, this, userExposed);
 
 //            m_log.DebugFormat("[SCENE OBJECT PART]: Clone of {0} {1} finished", Name, UUID);
@@ -1846,10 +2203,10 @@ namespace OpenSim.Region.Framework.Scenes
         {
             if (asset != null)
                 SculptTextureCallback(asset);
-            else
-                m_log.WarnFormat(
-                    "[SCENE OBJECT PART]: Part {0} {1} requested mesh/sculpt data for asset id {2} from asset service but received no data",
-                    Name, UUID, id);
+//            else
+//                m_log.WarnFormat(
+//                    "[SCENE OBJECT PART]: Part {0} {1} requested mesh/sculpt data for asset id {2} from asset service but received no data",
+//                    Name, UUID, id);
         }
 */
         /// <summary>
@@ -1948,6 +2305,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Do a physics propery update for this part.
+        /// now also updates phantom and volume detector
         /// </summary>
         /// <param name="UsePhysics"></param>
         /// <param name="isNew"></param>
@@ -1973,64 +2331,69 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if (pa.IsPhysical) // implies UsePhysics==false for this block
                         {
-                            if (!isNew)
+                            if (!isNew)  // implies UsePhysics==false for this block
+                            {
                                 ParentGroup.Scene.RemovePhysicalPrim(1);
 
-                            pa.OnRequestTerseUpdate -= PhysicsRequestingTerseUpdate;
-                            pa.OnOutOfBounds -= PhysicsOutOfBounds;
-                            pa.delink();
+                                Velocity = new Vector3(0, 0, 0);
+                                Acceleration = new Vector3(0, 0, 0);
+                                if (ParentGroup.RootPart == this)
+                                    AngularVelocity = new Vector3(0, 0, 0);
 
-                            if (ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints && (!isNew))
-                            {
-                                // destroy all joints connected to this now deactivated body
-                                ParentGroup.Scene.PhysicsScene.RemoveAllJointsConnectedToActorThreadLocked(pa);
-                            }
+                                if (pa.Phantom && !VolumeDetectActive)
+                                {
+                                    RemoveFromPhysics();
+                                    return;
+                                }
 
-                            // stop client-side interpolation of all joint proxy objects that have just been deleted
-                            // this is done because RemoveAllJointsConnectedToActor invokes the OnJointDeactivated callback,
-                            // which stops client-side interpolation of deactivated joint proxy objects.
+                                pa.IsPhysical = UsePhysics;
+                                pa.OnRequestTerseUpdate -= PhysicsRequestingTerseUpdate;
+                                pa.OnOutOfBounds -= PhysicsOutOfBounds;
+                                pa.delink();
+                                if (ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
+                                {
+                                    // destroy all joints connected to this now deactivated body
+                                    ParentGroup.Scene.PhysicsScene.RemoveAllJointsConnectedToActorThreadLocked(pa);
+                                }
+                            }
                         }
 
-                        if (!UsePhysics && !isNew)
-                        {
-                            // reset velocity to 0 on physics switch-off. Without that, the client thinks the
-                            // prim still has velocity and continues to interpolate its position along the old
-                            // velocity-vector.
-                            Velocity = new Vector3(0, 0, 0);
-                            Acceleration = new Vector3(0, 0, 0);
-                            AngularVelocity = new Vector3(0, 0, 0);
-                            //RotationalVelocity = new Vector3(0, 0, 0);
-                        }
+                        if (pa.IsPhysical != UsePhysics)
+                            pa.IsPhysical = UsePhysics;
 
-                        pa.IsPhysical = UsePhysics;
+                        if (UsePhysics)
+                        {
+                            if (ParentGroup.RootPart.KeyframeMotion != null)
+                                ParentGroup.RootPart.KeyframeMotion.Stop();
+                            ParentGroup.RootPart.KeyframeMotion = null;
+                            ParentGroup.Scene.AddPhysicalPrim(1);
 
-                        // If we're not what we're supposed to be in the physics scene, recreate ourselves.
-                        //m_parentGroup.Scene.PhysicsScene.RemovePrim(PhysActor);
-                        /// that's not wholesome.  Had to make Scene public
-                        //PhysActor = null;
+                            PhysActor.OnRequestTerseUpdate += PhysicsRequestingTerseUpdate;
+                            PhysActor.OnOutOfBounds += PhysicsOutOfBounds;
 
-                        if ((Flags & PrimFlags.Phantom) == 0)
-                        {
-                            if (UsePhysics)
+                            if (ParentID != 0 && ParentID != LocalId)
                             {
-                                if (ParentGroup.RootPart.KeyframeMotion != null)
-                                    ParentGroup.RootPart.KeyframeMotion.Stop();
-                                ParentGroup.RootPart.KeyframeMotion = null;
-                                ParentGroup.Scene.AddPhysicalPrim(1);
-
-                                pa.OnRequestTerseUpdate += PhysicsRequestingTerseUpdate;
-                                pa.OnOutOfBounds += PhysicsOutOfBounds;
-                                if (ParentID != 0 && ParentID != LocalId)
-                                {
-                                    PhysicsActor parentPa = ParentGroup.RootPart.PhysActor;
+                                PhysicsActor parentPa = ParentGroup.RootPart.PhysActor;
 
-                                    if (parentPa != null)
-                                    {
-                                        pa.link(parentPa);
-                                    }
+                                if (parentPa != null)
+                                {
+                                    pa.link(parentPa);
                                 }
                             }
-                        }
+                        }                           
+                    }
+
+                    bool phan = ((Flags & PrimFlags.Phantom) != 0);
+                    if (pa.Phantom != phan)
+                        pa.Phantom = phan;
+
+// some engines dont' have this check still
+//                    if (VolumeDetectActive != pa.IsVolumeDtc)
+                    {
+                        if (VolumeDetectActive)
+                            pa.SetVolumeDetect(1);
+                        else
+                            pa.SetVolumeDetect(0);
                     }
 
                     // If this part is a sculpt then delay the physics update until we've asynchronously loaded the
@@ -2149,42 +2512,63 @@ namespace OpenSim.Region.Framework.Scenes
 
         public Vector3 GetGeometricCenter()
         {
+            // this is not real geometric center but a average of positions relative to root prim acording to
+            // http://wiki.secondlife.com/wiki/llGetGeometricCenter
+            // ignoring tortured prims details since sl also seems to ignore
+            // so no real use in doing it on physics
+            if (ParentGroup.IsDeleted)
+                return new Vector3(0, 0, 0);
+
+            return ParentGroup.GetGeometricCenter();
+        }
+
+        public float GetMass()
+        {
             PhysicsActor pa = PhysActor;
 
             if (pa != null)
-                return pa.GeometricCenter;
+                return pa.Mass;
             else
-                return Vector3.Zero;
+                return 0;
         }
 
         public Vector3 GetCenterOfMass()
         {
+            if (ParentGroup.RootPart == this)
+            {
+                if (ParentGroup.IsDeleted)
+                    return AbsolutePosition;
+                return ParentGroup.GetCenterOfMass();
+            }
+
             PhysicsActor pa = PhysActor;
 
             if (pa != null)
-                return pa.CenterOfMass;
+            {
+                Vector3 tmp = pa.CenterOfMass;
+                return tmp;
+            }
             else
-                return Vector3.Zero;
+                return AbsolutePosition;
         }
 
-        public float GetMass()
+        public Vector3 GetPartCenterOfMass()
         {
             PhysicsActor pa = PhysActor;
 
             if (pa != null)
-                return pa.Mass;
+            {
+                Vector3 tmp = pa.CenterOfMass;
+                return tmp;
+            }
             else
-                return 0;
+                return AbsolutePosition;
         }
 
+
         public Vector3 GetForce()
         {
-            PhysicsActor pa = PhysActor;
-
-            if (pa != null)
-                return pa.Force;
-            else
-                return Vector3.Zero;
+            return Force;
         }
 
         /// <summary>
@@ -2399,15 +2783,25 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void SendLandCollisionEvent(scriptEvents ev, ScriptCollidingNotification notify)
         {
-            if ((ParentGroup.RootPart.ScriptEvents & ev) != 0)
-            {
-                ColliderArgs LandCollidingMessage = new ColliderArgs();
-                List<DetectedObject> colliding = new List<DetectedObject>();
-                    
-                colliding.Add(CreateDetObjectForGround());
-                LandCollidingMessage.Colliders = colliding;
+            bool sendToRoot = true;
 
+            ColliderArgs LandCollidingMessage = new ColliderArgs();
+            List<DetectedObject> colliding = new List<DetectedObject>();
+                
+            colliding.Add(CreateDetObjectForGround());
+            LandCollidingMessage.Colliders = colliding;
+
+            if (Inventory.ContainsScripts())
+            {
+                if (!PassCollisions)
+                    sendToRoot = false;
+            }
+            if ((ScriptEvents & ev) != 0)
                 notify(LocalId, LandCollidingMessage);
+
+            if ((ParentGroup.RootPart.ScriptEvents & ev) != 0 && sendToRoot)
+            {
+                notify(ParentGroup.RootPart.LocalId, LandCollidingMessage);
             }
         }
 
@@ -2423,57 +2817,120 @@ namespace OpenSim.Region.Framework.Scenes
             List<uint> endedColliders = new List<uint>();
             List<uint> startedColliders = new List<uint>();
 
-            // calculate things that started colliding this time
-            // and build up list of colliders this time
-            foreach (uint localid in collissionswith.Keys)
+            if (collissionswith.Count == 0)
             {
-                thisHitColliders.Add(localid);
-                if (!m_lastColliders.Contains(localid))
-                    startedColliders.Add(localid);
-            }
+                if (m_lastColliders.Count == 0)
+                    return; // nothing to do
 
-            // calculate things that ended colliding
-            foreach (uint localID in m_lastColliders)
-            {
-                if (!thisHitColliders.Contains(localID))
+                foreach (uint localID in m_lastColliders)
+                {
                     endedColliders.Add(localID);
+                }
+                m_lastColliders.Clear();
             }
 
-            //add the items that started colliding this time to the last colliders list.
-            foreach (uint localID in startedColliders)
-                m_lastColliders.Add(localID);
+            else
+            {
+                List<CollisionForSoundInfo> soundinfolist = new List<CollisionForSoundInfo>();
 
-            // remove things that ended colliding from the last colliders list
-            foreach (uint localID in endedColliders)
-                m_lastColliders.Remove(localID);
+                // calculate things that started colliding this time
+                // and build up list of colliders this time
+                if (!VolumeDetectActive && CollisionSoundType >= 0)
+                {
+                    CollisionForSoundInfo soundinfo;
+                    ContactPoint curcontact;
 
-            // play the sound.
-            if (startedColliders.Count > 0 && CollisionSound != UUID.Zero && CollisionSoundVolume > 0.0f)
-            {
-                ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
-                if (soundModule != null)
+                    foreach (uint id in collissionswith.Keys)
+                    {
+                        thisHitColliders.Add(id);
+                        if (!m_lastColliders.Contains(id))
+                        {
+                            startedColliders.Add(id);
+
+                            curcontact = collissionswith[id];
+                            if (Math.Abs(curcontact.RelativeSpeed) > 0.2)
+                            {
+                                soundinfo = new CollisionForSoundInfo();
+                                soundinfo.colliderID = id;
+                                soundinfo.position = curcontact.Position;
+                                soundinfo.relativeVel = curcontact.RelativeSpeed;
+                                soundinfolist.Add(soundinfo);
+                            }
+                        }
+                    }
+                }
+                else
                 {
-                    soundModule.SendSound(UUID, CollisionSound,
-                            CollisionSoundVolume, true, 0, 0, false,
-                            false);
+                    foreach (uint id in collissionswith.Keys)
+                    {
+                        thisHitColliders.Add(id);
+                        if (!m_lastColliders.Contains(id))
+                            startedColliders.Add(id);
+                    }
                 }
+
+                // 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);
+
+                // play sounds.
+                if (soundinfolist.Count > 0)
+                    CollisionSounds.PartCollisionSound(this, soundinfolist);
             }
 
             SendCollisionEvent(scriptEvents.collision_start, startedColliders, ParentGroup.Scene.EventManager.TriggerScriptCollidingStart);
-            SendCollisionEvent(scriptEvents.collision      , m_lastColliders , ParentGroup.Scene.EventManager.TriggerScriptColliding);
+            if (!VolumeDetectActive)
+                SendCollisionEvent(scriptEvents.collision  , m_lastColliders , ParentGroup.Scene.EventManager.TriggerScriptColliding);
             SendCollisionEvent(scriptEvents.collision_end  , endedColliders  , ParentGroup.Scene.EventManager.TriggerScriptCollidingEnd);
 
             if (startedColliders.Contains(0))
-            {
-                if (m_lastColliders.Contains(0))
-                    SendLandCollisionEvent(scriptEvents.land_collision, ParentGroup.Scene.EventManager.TriggerScriptLandColliding);
-                else
-                    SendLandCollisionEvent(scriptEvents.land_collision_start, ParentGroup.Scene.EventManager.TriggerScriptLandCollidingStart);
-            }
+                SendLandCollisionEvent(scriptEvents.land_collision_start, ParentGroup.Scene.EventManager.TriggerScriptLandCollidingStart);
+            if (m_lastColliders.Contains(0))
+                SendLandCollisionEvent(scriptEvents.land_collision, ParentGroup.Scene.EventManager.TriggerScriptLandColliding);
             if (endedColliders.Contains(0))
                 SendLandCollisionEvent(scriptEvents.land_collision_end, ParentGroup.Scene.EventManager.TriggerScriptLandCollidingEnd);
         }
 
+        // The Collision sounds code calls this
+        public void SendCollisionSound(UUID soundID, double volume, Vector3 position)
+        {
+            if (soundID == UUID.Zero)
+                return;
+
+            ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
+            if (soundModule == null)
+                return;
+
+            if (volume > 1)
+                volume = 1;
+            if (volume < 0)
+                volume = 0;
+
+            int now = Util.EnvironmentTickCount();
+            if(Util.EnvironmentTickCountSubtract(now,LastColSoundSentTime) <200)
+                return;
+
+            LastColSoundSentTime = now;
+
+            UUID ownerID = OwnerID;
+            UUID objectID = ParentGroup.RootPart.UUID;
+            UUID parentID = ParentGroup.UUID;
+            ulong regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
+
+            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, 0 );
+        }
+
         public void PhysicsOutOfBounds(Vector3 pos)
         {
             // Note: This is only being called on the root prim at this time.
@@ -2495,9 +2952,9 @@ namespace OpenSim.Region.Framework.Scenes
                 Vector3 newpos = new Vector3(pa.Position.GetBytes(), 0);
                 
                 if (ParentGroup.Scene.TestBorderCross(newpos, Cardinals.N)
-                    | ParentGroup.Scene.TestBorderCross(newpos, Cardinals.S)
-                    | ParentGroup.Scene.TestBorderCross(newpos, Cardinals.E)
-                    | ParentGroup.Scene.TestBorderCross(newpos, Cardinals.W))
+                    || ParentGroup.Scene.TestBorderCross(newpos, Cardinals.S)
+                    || ParentGroup.Scene.TestBorderCross(newpos, Cardinals.E)
+                    || ParentGroup.Scene.TestBorderCross(newpos, Cardinals.W))
                 {
                     ParentGroup.AbsolutePosition = newpos;
                     return;
@@ -2782,6 +3239,14 @@ namespace OpenSim.Region.Framework.Scenes
             if (ParentGroup == null)
                 return;
 
+            // Update the "last" values
+            m_lastPosition = OffsetPosition;
+            m_lastRotation = RotationOffset;
+            m_lastVelocity = Velocity;
+            m_lastAcceleration = Acceleration;
+            m_lastAngularVelocity = AngularVelocity;
+            m_lastUpdateSentTime = Environment.TickCount;
+
             ParentGroup.Scene.ForEachScenePresence(delegate(ScenePresence avatar)
             {
                 SendFullUpdate(avatar.ControllingClient);
@@ -2840,8 +3305,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)
             {
@@ -2855,17 +3320,10 @@ namespace OpenSim.Region.Framework.Scenes
                         Velocity.ApproxEquals(Vector3.Zero, VELOCITY_TOLERANCE) ||
                         !AngularVelocity.ApproxEquals(m_lastAngularVelocity, VELOCITY_TOLERANCE) ||
                         !OffsetPosition.ApproxEquals(m_lastPosition, POSITION_TOLERANCE) ||
-                        Environment.TickCount - m_lastTerseSent > TIME_MS_TOLERANCE)
+                        Environment.TickCount - m_lastUpdateSentTime > TIME_MS_TOLERANCE)
                     {
                         SendTerseUpdateToAllClients();
 
-                        // Update the "last" values
-                        m_lastPosition = OffsetPosition;
-                        m_lastRotation = RotationOffset;
-                        m_lastVelocity = Velocity;
-                        m_lastAcceleration = Acceleration;
-                        m_lastAngularVelocity = AngularVelocity;
-                        m_lastTerseSent = Environment.TickCount;
                     }
                     break;
                 }
@@ -2883,6 +3341,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void SendTerseUpdateToAllClients()
         {
+            if (ParentGroup == null || ParentGroup.Scene == null)
+                return;
+
+            // Update the "last" values
+            m_lastPosition = OffsetPosition;
+            m_lastRotation = RotationOffset;
+            m_lastVelocity = Velocity;
+            m_lastAcceleration = Acceleration;
+            m_lastAngularVelocity = AngularVelocity;
+            m_lastUpdateSentTime = Environment.TickCount;
+
             ParentGroup.Scene.ForEachClient(delegate(IClientAPI client)
             {
                 SendTerseUpdateToClient(client);
@@ -2906,10 +3375,13 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetBuoyancy(float fvalue)
         {
-            PhysicsActor pa = PhysActor;
-
-            if (pa != null)
-                pa.Buoyancy = fvalue;
+            Buoyancy = fvalue;
+/*            
+            if (PhysActor != null)
+            {
+                PhysActor.Buoyancy = fvalue;
+            }
+ */
         }
 
         public void SetDieAtEdge(bool p)
@@ -2925,47 +3397,111 @@ namespace OpenSim.Region.Framework.Scenes
             PhysicsActor pa = PhysActor;
 
             if (pa != null)
-                pa.FloatOnWater = floatYN == 1;
+                pa.FloatOnWater = (floatYN == 1);
         }
 
         public void SetForce(Vector3 force)
         {
-            PhysicsActor pa = PhysActor;
+            Force = force;
+        }
 
-            if (pa != null)
-                pa.Force = force;
+        public SOPVehicle VehicleParams
+        {
+            get
+            {
+                return m_vehicleParams;
+            }
+            set
+            {
+                m_vehicleParams = value;
+            }
+        }
+
+
+        public int VehicleType
+        {
+            get
+            {
+                if (m_vehicleParams == null)
+                    return (int)Vehicle.TYPE_NONE;
+                else
+                    return (int)m_vehicleParams.Type;
+            }
+            set
+            {
+                SetVehicleType(value);
+            }
         }
 
         public void SetVehicleType(int type)
         {
-            PhysicsActor pa = PhysActor;
+                m_vehicleParams = null;
+                
+                if (type == (int)Vehicle.TYPE_NONE)
+                {
+                    if (_parentID ==0 && PhysActor != null)
+                        PhysActor.VehicleType = (int)Vehicle.TYPE_NONE;
+                    return;
+                }
+                m_vehicleParams = new SOPVehicle();
+                m_vehicleParams.ProcessTypeChange((Vehicle)type);
+                {
+                    if (_parentID ==0 && PhysActor != null)
+                        PhysActor.VehicleType = type;
+                    return;
+                }
+        }
 
-            if (pa != null)
-                pa.VehicleType = type;
+        public void SetVehicleFlags(int param, bool remove)
+        {
+            if (m_vehicleParams == null)
+                return;
+
+            m_vehicleParams.ProcessVehicleFlags(param, remove);
+
+            if (_parentID ==0 && PhysActor != null)
+            {
+                PhysActor.VehicleFlags(param, remove);
+            }
         }
 
         public void SetVehicleFloatParam(int param, float value)
         {
-            PhysicsActor pa = PhysActor;
+            if (m_vehicleParams == null)
+                return;
 
-            if (pa != null)
-                pa.VehicleFloatParam(param, value);
+            m_vehicleParams.ProcessFloatVehicleParam((Vehicle)param, value);
+
+            if (_parentID == 0 && PhysActor != null)
+            {
+                PhysActor.VehicleFloatParam(param, value);
+            }
         }
 
         public void SetVehicleVectorParam(int param, Vector3 value)
         {
-            PhysicsActor pa = PhysActor;
+            if (m_vehicleParams == null)
+                return;
 
-            if (pa != null)
-                pa.VehicleVectorParam(param, value);
+            m_vehicleParams.ProcessVectorVehicleParam((Vehicle)param, value);
+
+            if (_parentID == 0 && PhysActor != null)
+            {
+                PhysActor.VehicleVectorParam(param, value);
+            }
         }
 
         public void SetVehicleRotationParam(int param, Quaternion rotation)
         {
-            PhysicsActor pa = PhysActor;
+            if (m_vehicleParams == null)
+                return;
 
-            if (pa != null)
-                pa.VehicleRotationParam(param, rotation);
+            m_vehicleParams.ProcessRotationVehicleParam((Vehicle)param, rotation);
+
+            if (_parentID == 0 && PhysActor != null)
+            {
+                PhysActor.VehicleRotationParam(param, rotation);
+            }
         }
 
         /// <summary>
@@ -3166,14 +3702,6 @@ namespace OpenSim.Region.Framework.Scenes
             hasProfileCut = hasDimple; // is it the same thing?
         }
         
-        public void SetVehicleFlags(int param, bool remove)
-        {
-            PhysicsActor pa = PhysActor;
-
-            if (pa != null)
-                pa.VehicleFlags(param, remove);
-        }
-
         public void SetGroup(UUID groupID, IClientAPI client)
         {
             // Scene.AddNewPrims() calls with client == null so can't use this.
@@ -3277,71 +3805,20 @@ namespace OpenSim.Region.Framework.Scenes
         {
             ParentGroup.stopMoveToTarget();
 
-            ParentGroup.ScheduleGroupForTerseUpdate();
+//            ParentGroup.ScheduleGroupForTerseUpdate();
             //ParentGroup.ScheduleGroupForFullUpdate();
         }
 
-        public void StoreUndoState()
-        {
-            StoreUndoState(false);
-        }
-
-        public void StoreUndoState(bool forGroup)
+        public void StoreUndoState(ObjectChangeType change)
         {
-            if (ParentGroup == null || ParentGroup.Scene == null)
-                return;
-
-            if (Undoing)
-            {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Ignoring undo store for {0} {1} since already undoing", Name, LocalId);
-                return;
-            }
-
-            if (IgnoreUndoUpdate)
-            {
-//                    m_log.DebugFormat("[SCENE OBJECT PART]: Ignoring undo store for {0} {1}", Name, LocalId);
-                return;
-            }
+            if (m_UndoRedo == null)
+                m_UndoRedo = new UndoRedoState(5);
 
-            lock (m_undo)
+            lock (m_UndoRedo)
             {
-                if (m_undo.Count > 0)
+                if (!Undoing && !IgnoreUndoUpdate && ParentGroup != null) // just to read better  - undo is in progress, or suspended
                 {
-                    UndoState last = m_undo[m_undo.Count - 1];
-                    if (last != null)
-                    {
-                        // TODO: May need to fix for group comparison
-                        if (last.Compare(this))
-                        {
-//                                        m_log.DebugFormat(
-//                                            "[SCENE OBJECT PART]: Not storing undo for {0} {1} since current state is same as last undo state, initial stack size {2}",
-//                                            Name, LocalId, m_undo.Count);
-
-                            return;
-                        }
-                    }
-                }
-
-//                                m_log.DebugFormat(
-//                                    "[SCENE OBJECT PART]: Storing undo state for {0} {1}, forGroup {2}, initial stack size {3}",
-//                                    Name, LocalId, forGroup, m_undo.Count);
-
-                if (ParentGroup.Scene.MaxUndoCount > 0)
-                {
-                    UndoState nUndo = new UndoState(this, forGroup);
-
-                    m_undo.Add(nUndo);
-
-                    if (m_undo.Count > ParentGroup.Scene.MaxUndoCount)
-                        m_undo.RemoveAt(0);
-
-                    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_UndoRedo.StoreUndo(this, change);
                 }
             }
         }
@@ -3353,88 +3830,46 @@ namespace OpenSim.Region.Framework.Scenes
         {
             get
             {
-                lock (m_undo)
-                    return m_undo.Count;
+                if (m_UndoRedo == null)
+                    return 0;
+                return m_UndoRedo.Count;
             }
         }
 
         public void Undo()
         {
-            lock (m_undo)
-            {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Handling undo request for {0} {1}, stack size {2}",
-//                    Name, LocalId, m_undo.Count);
-
-                if (m_undo.Count > 0)
-                {
-                    UndoState goback = m_undo[m_undo.Count - 1];
-                    m_undo.RemoveAt(m_undo.Count - 1);
-
-                    UndoState nUndo = null;
-    
-                    if (ParentGroup.Scene.MaxUndoCount > 0)
-                    {
-                        nUndo = new UndoState(this, goback.ForGroup);
-                    }
-
-                    goback.PlaybackState(this);
-
-                    if (nUndo != null)
-                    {
-                        m_redo.Add(nUndo);
-
-                        if (m_redo.Count > ParentGroup.Scene.MaxUndoCount)
-                            m_redo.RemoveAt(0);
-                    }
-                }
+            if (m_UndoRedo == null || Undoing || ParentGroup == null)
+                return;
 
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Handled undo request for {0} {1}, stack size now {2}",
-//                    Name, LocalId, m_undo.Count);
+            lock (m_UndoRedo)
+            {
+                Undoing = true;
+                m_UndoRedo.Undo(this);
+                Undoing = false;
             }
         }
 
         public void Redo()
         {
-            lock (m_undo)
-            {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Handling redo request for {0} {1}, stack size {2}",
-//                    Name, LocalId, m_redo.Count);
-
-                if (m_redo.Count > 0)
-                {
-                    UndoState gofwd = m_redo[m_redo.Count - 1];
-                    m_redo.RemoveAt(m_redo.Count - 1);
-
-                    if (ParentGroup.Scene.MaxUndoCount > 0)
-                    {
-                        UndoState nUndo = new UndoState(this, gofwd.ForGroup);
-
-                        m_undo.Add(nUndo);
-
-                        if (m_undo.Count > ParentGroup.Scene.MaxUndoCount)
-                            m_undo.RemoveAt(0);
-                    }
-
-                    gofwd.PlayfwdState(this);
+            if (m_UndoRedo == null || Undoing || ParentGroup == null)
+                return;
 
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Handled redo request for {0} {1}, stack size now {2}",
-//                    Name, LocalId, m_redo.Count);
-                }
+            lock (m_UndoRedo)
+            {
+                Undoing = true;
+                m_UndoRedo.Redo(this);
+                Undoing = false;
             }
         }
 
         public void ClearUndoState()
         {
-//            m_log.DebugFormat("[SCENE OBJECT PART]: Clearing undo and redo stacks in {0} {1}", Name, LocalId);
+            if (m_UndoRedo == null || Undoing)
+                return;
 
-            lock (m_undo)
+            lock (m_UndoRedo)
             {
-                m_undo.Clear();
-                m_redo.Clear();
+                m_UndoRedo.Clear();
             }
         }
 
@@ -3986,7 +4421,7 @@ namespace OpenSim.Region.Framework.Scenes
                         if (god)
                         {
                             BaseMask = ApplyMask(BaseMask, set, mask);
-                            Inventory.ApplyGodPermissions(_baseMask);
+                            Inventory.ApplyGodPermissions(BaseMask);
                         }
 
                         break;
@@ -4017,7 +4452,7 @@ namespace OpenSim.Region.Framework.Scenes
                         }
                         NextOwnerMask = ApplyMask(NextOwnerMask, set, mask) &
                                 baseMask;
-                        // Prevent the client from creating no mod, no copy
+                        // Prevent the client from creating no copy, no transfer
                         // objects
                         if ((NextOwnerMask & (uint)PermissionMask.Copy) == 0)
                             NextOwnerMask |= (uint)PermissionMask.Transfer;
@@ -4035,20 +4470,20 @@ namespace OpenSim.Region.Framework.Scenes
         {
             bool update = false;
 
-            if (BaseMask != source.BaseMask ||
-                OwnerMask != source.OwnerMask ||
-                GroupMask != source.GroupMask ||
-                EveryoneMask != source.EveryoneMask ||
-                NextOwnerMask != source.NextOwnerMask)
-                update = true;
+            uint prevOwnerMask = OwnerMask;
+            uint prevGroupMask = GroupMask;
+            uint prevEveryoneMask = EveryoneMask;
+            uint prevNextOwnerMask = NextOwnerMask;
 
-            BaseMask = source.BaseMask;
-            OwnerMask = source.OwnerMask;
-            GroupMask = source.GroupMask;
-            EveryoneMask = source.EveryoneMask;
-            NextOwnerMask = source.NextOwnerMask;
+            OwnerMask = source.OwnerMask & BaseMask;
+            GroupMask = source.GroupMask & BaseMask;
+            EveryoneMask = source.EveryoneMask & BaseMask;
+            NextOwnerMask = source.NextOwnerMask & BaseMask;
 
-            if (update)
+            if (OwnerMask != prevOwnerMask ||
+                GroupMask != prevGroupMask ||
+                EveryoneMask != prevEveryoneMask ||
+                NextOwnerMask != prevNextOwnerMask)
                 SendFullUpdateToAllClients();
         }
 
@@ -4099,6 +4534,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+
         public void UpdateExtraPhysics(ExtraPhysicsData physdata)
         {
             if (physdata.PhysShapeType == PhysShapeType.invalid || ParentGroup == null)
@@ -4126,7 +4562,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="SetTemporary"></param>
         /// <param name="SetPhantom"></param>
         /// <param name="SetVD"></param>
-        public void UpdatePrimFlags(bool UsePhysics, bool SetTemporary, bool SetPhantom, bool SetVD)
+        public void UpdatePrimFlags(bool UsePhysics, bool SetTemporary, bool SetPhantom, bool SetVD, bool building)
         {
             bool wasUsingPhysics = ((Flags & PrimFlags.Physics) != 0);
             bool wasTemporary = ((Flags & PrimFlags.TemporaryOnRez) != 0);
@@ -4136,97 +4572,98 @@ namespace OpenSim.Region.Framework.Scenes
             if ((UsePhysics == wasUsingPhysics) && (wasTemporary == SetTemporary) && (wasPhantom == SetPhantom) && (SetVD == wasVD))
                 return;
 
-            PhysicsActor pa = PhysActor;
+            VolumeDetectActive = SetVD;
 
-            // Special cases for VD. VD can only be called from a script 
-            // and can't be combined with changes to other states. So we can rely
-            // that...
-            // ... if VD is changed, all others are not.
-            // ... if one of the others is changed, VD is not.
-            if (SetVD) // VD is active, special logic applies
-            {
-                // State machine logic for VolumeDetect
-                // More logic below
-                bool phanReset = (SetPhantom != wasPhantom) && !SetPhantom;
-
-                if (phanReset) // Phantom changes from on to off switch VD off too
-                {
-                    SetVD = false;               // Switch it of for the course of this routine
-                    VolumeDetectActive = false; // and also permanently
-
-                    if (pa != null)
-                        pa.SetVolumeDetect(0);   // Let physics know about it too
-                }
-                else
-                {
-                    // If volumedetect is active we don't want phantom to be applied.
-                    // If this is a new call to VD out of the state "phantom"
-                    // this will also cause the prim to be visible to physics
-                    SetPhantom = false;
-                }
-            }
-
-            if (UsePhysics && IsJoint())
-            {
+            // volume detector implies phantom
+            if (VolumeDetectActive)
                 SetPhantom = true;
-            }
 
             if (UsePhysics)
-            {
                 AddFlag(PrimFlags.Physics);
-                if (!wasUsingPhysics)
-                {
-                    DoPhysicsPropertyUpdate(UsePhysics, false);
-                }
-            }
             else
-            {
                 RemFlag(PrimFlags.Physics);
-                if (wasUsingPhysics)
-                {
-                    DoPhysicsPropertyUpdate(UsePhysics, false);
-                }
-            }
 
-            if (SetPhantom
-                || ParentGroup.IsAttachment
-                || PhysicsShapeType == (byte)PhysShapeType.none
-                || (Shape.PathCurve == (byte)Extrusion.Flexible)) // note: this may have been changed above in the case of joints
-            {
+            if (SetPhantom)
                 AddFlag(PrimFlags.Phantom);
+            else
+                RemFlag(PrimFlags.Phantom);
 
-                if (PhysActor != null)
+            if (SetTemporary)
+                AddFlag(PrimFlags.TemporaryOnRez);
+            else
+                RemFlag(PrimFlags.TemporaryOnRez);
+
+
+            if (ParentGroup.Scene == null)
+                return;
+
+            PhysicsActor pa = PhysActor;
+
+            if (pa != null && building && pa.Building != building)
+                pa.Building = building;
+
+            if ((SetPhantom && !UsePhysics && !SetVD) ||  ParentGroup.IsAttachment || PhysicsShapeType == (byte)PhysShapeType.none
+                || (Shape.PathCurve == (byte)Extrusion.Flexible))
+            {
+                if (pa != null)
                 {
+                    if(wasUsingPhysics)
+                        ParentGroup.Scene.RemovePhysicalPrim(1);
                     RemoveFromPhysics();
-                    pa = null;
                 }
+
+                Velocity = new Vector3(0, 0, 0);
+                Acceleration = new Vector3(0, 0, 0);
+                if (ParentGroup.RootPart == this)
+                    AngularVelocity = new Vector3(0, 0, 0);
             }
-            else // Not phantom
+            
+            else 
             {
-                RemFlag(PrimFlags.Phantom);
-
-                if (ParentGroup.Scene == null)
-                    return;
-
-                if (ParentGroup.Scene.CollidablePrims && pa == null)
+                if (ParentGroup.Scene.CollidablePrims)
                 {
-                    AddToPhysics(UsePhysics, SetPhantom, false);
-                    pa = PhysActor;
-
-                    if (pa != null)
+                    if (pa == null)
+                    {
+                        AddToPhysics(UsePhysics, SetPhantom, building, false);
+                        pa = PhysActor;
+/*
+                        if (pa != null)
+                        {
+                            if (
+//                                ((AggregateScriptEvents & scriptEvents.collision) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
+                                ((AggregateScriptEvents & PhysicsNeededSubsEvents) != 0) ||
+                                ((ParentGroup.RootPart.AggregateScriptEvents & PhysicsNeededSubsEvents) != 0) ||
+                                (CollisionSound != UUID.Zero)
+                                )
+                            {
+                                pa.OnCollisionUpdate += PhysicsCollision;
+                                pa.SubscribeEvents(1000);
+                            }
+                        }
+*/
+                    }
+                    else // it already has a physical representation
                     {
-                        pa.SetMaterial(Material);
-                        DoPhysicsPropertyUpdate(UsePhysics, true);
+                        DoPhysicsPropertyUpdate(UsePhysics, false); // Update physical status.
+/* moved into DoPhysicsPropertyUpdate
+                        if(VolumeDetectActive)
+                            pa.SetVolumeDetect(1);
+                        else
+                            pa.SetVolumeDetect(0);
+*/
 
-                        SubscribeForCollisionEvents();
+                        if (pa.Building != building)
+                            pa.Building = building;
                     }
-                }
-                else // it already has a physical representation
-                {
-                    DoPhysicsPropertyUpdate(UsePhysics, false); // Update physical status. If it's phantom this will remove the prim
-                }
-            }
 
+                    UpdatePhysicsSubscribedEvents();
+                }
+            }         
             if (SetVD)
             {
                 // If the above logic worked (this is urgent candidate to unit tests!)
@@ -4240,6 +4677,7 @@ namespace OpenSim.Region.Framework.Scenes
                     AddFlag(PrimFlags.Phantom); // We set this flag also if VD is active
                     VolumeDetectActive = true;
                 }
+            //            m_log.Debug("Update:  PHY:" + UsePhysics.ToString() + ", T:" + IsTemporary.ToString() + ", PHA:" + IsPhantom.ToString() + " S:" + CastsShadows.ToString());
             }
             else if (SetVD != wasVD)
             {
@@ -4251,105 +4689,51 @@ namespace OpenSim.Region.Framework.Scenes
                 RemFlag(PrimFlags.Phantom);
                 VolumeDetectActive = false;
             }
-
-            if (SetTemporary)
-            {
-                AddFlag(PrimFlags.TemporaryOnRez);
-            }
-            else
-            {
-                RemFlag(PrimFlags.TemporaryOnRez);
-            }
-
-            //            m_log.Debug("Update:  PHY:" + UsePhysics.ToString() + ", T:" + IsTemporary.ToString() + ", PHA:" + IsPhantom.ToString() + " S:" + CastsShadows.ToString());
+           // and last in case we have a new actor and not building
 
             if (ParentGroup != null)
             {
                 ParentGroup.HasGroupChanged = true;
                 ScheduleFullUpdate();
             }
-
+            
 //            m_log.DebugFormat("[SCENE OBJECT PART]: Updated PrimFlags on {0} {1} to {2}", Name, LocalId, Flags);
         }
 
         /// <summary>
-        /// Subscribe for physics collision events if needed for scripts and sounds
-        /// </summary>
-        public void SubscribeForCollisionEvents()
-        {
-            PhysicsActor pa = PhysActor;
-
-            if (pa != null)
-            {
-                if (
-                    ((AggregateScriptEvents & scriptEvents.collision) != 0) ||
-                    ((AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
-                    ((AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
-                    ((AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
-                    ((AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
-                    ((AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
-                    ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision) != 0) ||
-                    ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
-                    ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
-                    ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
-                    ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
-                    ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
-                    (CollisionSound != UUID.Zero)
-                    )
-                {
-                    if (!pa.SubscribedEvents())
-                    {
-                        // If not already subscribed for event, set up for a collision event.
-                        pa.OnCollisionUpdate += PhysicsCollision;
-                        pa.SubscribeEvents(1000);
-                    }
-                }
-                else
-                {
-                    // There is no need to be subscribed to collisions so, if subscribed, remove subscription
-                    if (pa.SubscribedEvents())
-                    {
-                        pa.OnCollisionUpdate -= PhysicsCollision;
-                        pa.UnSubscribeEvents();
-                    }
-                }
-            }
-        }
-
-        /// <summary>
         /// Adds this part to the physics scene.
+        /// and sets the PhysActor property
         /// </summary>
-        /// <remarks>This method also sets the PhysActor property.</remarks>
-        /// <param name="rigidBody">Add this prim with a rigid body.</param>
-        /// <returns>
-        /// The physics actor.  null if there was a failure.
-        /// </returns>
-        private void AddToPhysics(bool isPhysical, bool isPhantom, bool applyDynamics)
-        {
+        /// <param name="isPhysical">Add this prim as physical.</param>
+        /// <param name="isPhantom">Add this prim as phantom.</param>
+        /// <param name="building">tells physics to delay full construction of object</param>
+        /// <param name="applyDynamics">applies velocities, force and torque</param>
+        private void AddToPhysics(bool isPhysical, bool isPhantom, bool building, bool applyDynamics)
+        {          
             PhysicsActor pa;
 
-            Vector3 velocity = Velocity;
+            Vector3 velocity = Velocity; 
             Vector3 rotationalVelocity = AngularVelocity;;
 
             try
             {
                 pa = ParentGroup.Scene.PhysicsScene.AddPrimShape(
-                        string.Format("{0}/{1}", Name, UUID),
-                        Shape,
-                        AbsolutePosition,
-                        Scale,
-                        GetWorldRotation(),
-                        isPhysical,
-                        isPhantom,
-                        PhysicsShapeType,
-                        m_localId);
+                                 string.Format("{0}/{1}", Name, UUID),
+                                 Shape,
+                                 AbsolutePosition,
+                                 Scale,
+                                 GetWorldRotation(),
+                                 isPhysical,
+                                 isPhantom,
+                                 PhysicsShapeType,
+                                 m_localId);
             }
             catch (Exception e)
             {
                 m_log.ErrorFormat("[SCENE]: caught exception meshing object {0}. Object set to phantom. e={1}", m_uuid, e);
                 pa = null;
             }
-
+          
             if (pa != null)
             {
                 pa.SOPName = this.Name; // save object into the PhysActor so ODE internals know the joint/body info
@@ -4362,9 +4746,16 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (VolumeDetectActive) // change if not the default only
                     pa.SetVolumeDetect(1);
+
+                if (m_vehicleParams != null && LocalId == ParentGroup.RootPart.LocalId)
+                    m_vehicleParams.SetVehicle(pa);
+
                 // we are going to tell rest of code about physics so better have this here
                 PhysActor = pa;
 
+                //                DoPhysicsPropertyUpdate(isPhysical, true);
+                // lets expand it here just with what it really needs to do
+
                 if (isPhysical)
                 {
                     if (ParentGroup.RootPart.KeyframeMotion != null)
@@ -4386,19 +4777,34 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
 
-                if (applyDynamics)
+                if (applyDynamics) 
                     // do independent of isphysical so parameters get setted (at least some)                   
                 {
                     Velocity = velocity;
                     AngularVelocity = rotationalVelocity;
 //                    pa.Velocity = velocity;
                     pa.RotationalVelocity = rotationalVelocity;
+
+                    // if not vehicle and root part apply force and torque
+                    if ((m_vehicleParams == null || m_vehicleParams.Type == Vehicle.TYPE_NONE)
+                            && LocalId == ParentGroup.RootPart.LocalId)
+                    {
+                        pa.Force = Force;
+                        pa.Torque = Torque;
+                    }
                 }
 
-                ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(pa);
+//                if (Shape.SculptEntry)
+//                    CheckSculptAndLoad();
+//                else
+                    ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(pa);
+
+                if (!building)
+                    pa.Building = false;
             }
 
             PhysActor = pa;
+
             ParentGroup.Scene.EventManager.TriggerObjectAddedToPhysicalScene(this);
         }
 
@@ -4407,13 +4813,21 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// This isn't the same as turning off physical, since even without being physical the prim has a physics
-        /// representation for collision detection.  Rather, this would be used in situations such as making a prim
-        /// phantom.
+        /// representation for collision detection.
         /// </remarks>
         public void RemoveFromPhysics()
         {
-            ParentGroup.Scene.EventManager.TriggerObjectRemovedFromPhysicalScene(this);
-            ParentGroup.Scene.PhysicsScene.RemovePrim(PhysActor);
+            PhysicsActor pa = PhysActor;
+            if (pa != null)
+            {
+                pa.OnCollisionUpdate -= PhysicsCollision;
+                pa.OnRequestTerseUpdate -= PhysicsRequestingTerseUpdate;
+                pa.OnOutOfBounds -= PhysicsOutOfBounds;
+
+                ParentGroup.Scene.PhysicsScene.RemovePrim(pa);
+
+                ParentGroup.Scene.EventManager.TriggerObjectRemovedFromPhysicalScene(this);
+            }
             PhysActor = null;
         }
 
@@ -4545,6 +4959,8 @@ namespace OpenSim.Region.Framework.Scenes
         {
 //            m_log.DebugFormat("Processing CheckSculptAndLoad for {0} {1}", Name, LocalId);
 
+            return;
+
             if (ParentGroup.IsDeleted)
                 return;
 
@@ -4668,6 +5084,44 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+
+        private void UpdatePhysicsSubscribedEvents()
+        {
+            PhysicsActor pa = PhysActor;
+            if (pa == null)
+                return;
+
+            pa.OnCollisionUpdate -= PhysicsCollision;
+
+            bool hassound = (!VolumeDetectActive && CollisionSoundType >= 0 && ((Flags & PrimFlags.Physics) != 0));
+
+            scriptEvents CombinedEvents = AggregateScriptEvents;
+
+            // merge with root part
+            if (ParentGroup != null && ParentGroup.RootPart != null)
+                CombinedEvents |= ParentGroup.RootPart.AggregateScriptEvents;
+
+            // submit to this part case
+            if (VolumeDetectActive)
+                CombinedEvents &= PhyscicsVolumeDtcSubsEvents;
+            else if ((Flags & PrimFlags.Phantom) != 0)
+                CombinedEvents &= PhyscicsPhantonSubsEvents;
+            else
+                CombinedEvents &= PhysicsNeededSubsEvents;
+
+            if (hassound || CombinedEvents != 0)
+            {
+                // subscribe to physics updates.
+                pa.OnCollisionUpdate += PhysicsCollision;
+                pa.SubscribeEvents(50); // 20 reports per second
+            }
+            else
+            {
+                pa.UnSubscribeEvents();
+            }
+        }
+
+
         public void aggregateScriptEvents()
         {
             if (ParentGroup == null || ParentGroup.RootPart == null)
@@ -4704,8 +5158,32 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 objectflagupdate |= (uint) PrimFlags.AllowInventoryDrop;
             }
-
-            SubscribeForCollisionEvents();
+/*
+            PhysicsActor pa = PhysActor;
+            if (pa != null)
+            {
+                if (
+//                    ((AggregateScriptEvents & scriptEvents.collision) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
+                    ((AggregateScriptEvents & PhysicsNeededSubsEvents) != 0) || ((ParentGroup.RootPart.AggregateScriptEvents & PhysicsNeededSubsEvents) != 0) || (CollisionSound != UUID.Zero)
+                    )
+                {
+                    // subscribe to physics updates.
+                    pa.OnCollisionUpdate += PhysicsCollision;
+                    pa.SubscribeEvents(1000);
+                }
+                else
+                {
+                    pa.UnSubscribeEvents();
+                    pa.OnCollisionUpdate -= PhysicsCollision;
+                }
+            }
+ */
+            UpdatePhysicsSubscribedEvents();
 
             //if ((GetEffectiveObjectFlags() & (uint)PrimFlags.Scripted) != 0)
             //{
@@ -4839,6 +5317,18 @@ namespace OpenSim.Region.Framework.Scenes
             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);
+            }
+        }
+
         /// <summary>
         /// Record an avatar sitting on this part.
         /// </summary>
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index 3f223a3..3be0623 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -49,6 +49,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.
@@ -85,7 +88,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </value>
         protected internal TaskInventoryDictionary Items
         {
-            get { return m_items; }
+            get { 
+                return m_items; 
+            }
             set
             {
                 m_items = value;
@@ -134,38 +139,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>
@@ -174,17 +186,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="ownerId"></param>
         public void ChangeInventoryOwner(UUID ownerId)
         {
-            lock (Items)
-            {
-                if (0 == Items.Count)
-                {
-                    return;
-                }
-            }
+            List<TaskInventoryItem> items = GetInventoryItems();
+
+            if (items.Count == 0)
+                return;
 
+            m_items.LockItemsForWrite(true);
             HasInventoryChanged = true;
             m_part.ParentGroup.HasGroupChanged = true;
-            List<TaskInventoryItem> items = GetInventoryItems();
             foreach (TaskInventoryItem item in items)
             {
                 if (ownerId != item.OwnerID)
@@ -195,6 +204,7 @@ namespace OpenSim.Region.Framework.Scenes
                 item.PermsGranter = UUID.Zero;
                 item.OwnerChanged = true;
             }
+            m_items.LockItemsForWrite(false);
         }
 
         /// <summary>
@@ -203,12 +213,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
@@ -220,12 +229,15 @@ 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()
@@ -233,15 +245,18 @@ namespace OpenSim.Region.Framework.Scenes
             if (m_part == null || m_part.ParentGroup == null || m_part.ParentGroup.Scene == null)
                 return;
 
-            lock (Items)
+            Items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in Items.Values)
             {
-                foreach (TaskInventoryItem item in Items.Values)
+                if (item.InvType == (int)InventoryType.LSL)
                 {
                     bool running;
                     if (TryGetScriptInstanceRunning(m_part.ParentGroup.Scene, item, out running))
                         item.ScriptRunning = running;
                 }
             }
+
+            Items.LockItemsForRead(false);
         }
 
         public bool TryGetScriptInstanceRunning(UUID itemId, out bool running)
@@ -318,7 +333,10 @@ namespace OpenSim.Region.Framework.Scenes
         {
             List<TaskInventoryItem> scripts = GetInventoryItems(InventoryType.LSL);
             foreach (TaskInventoryItem item in scripts)
+            {
                 RemoveScriptInstance(item.ItemID, sceneObjectBeingDeleted);
+                m_part.RemoveScriptEvents(item.ItemID);
+            }
         }
 
         /// <summary>
@@ -340,7 +358,10 @@ namespace OpenSim.Region.Framework.Scenes
 //                 item.Name, item.ItemID, m_part.Name, m_part.UUID, m_part.ParentGroup.Scene.RegionInfo.RegionName);
 
             if (!m_part.ParentGroup.Scene.Permissions.CanRunScript(item.ItemID, m_part.UUID, item.OwnerID))
+            {
+                StoreScriptError(item.ItemID, "no permission");
                 return false;
+            }
 
             m_part.AddFlag(PrimFlags.Scripted);
 
@@ -350,14 +371,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 true;
@@ -366,6 +386,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",
                     item.Name, item.ItemID, m_part.AbsolutePosition, 
@@ -378,16 +400,18 @@ namespace OpenSim.Region.Framework.Scenes
                 if (m_part.ParentGroup.m_savedScriptState != null)
                     item.OldItemID = RestoreSavedScriptState(item.LoadedItemID, item.OldItemID, item.ItemID);
 
-                lock (m_items)
-                {
-                    m_items[item.ItemID].OldItemID = item.OldItemID;
-                    m_items[item.ItemID].PermsMask = 0;
-                    m_items[item.ItemID].PermsGranter = UUID.Zero;
-                }
+                m_items.LockItemsForWrite(true);
+
+                m_items[item.ItemID].OldItemID = item.OldItemID;
+                m_items[item.ItemID].PermsMask = 0;
+                m_items[item.ItemID].PermsGranter = UUID.Zero;
 
+                m_items.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);
@@ -460,22 +484,149 @@ namespace OpenSim.Region.Framework.Scenes
             return stateID;
         }
 
+        /// <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 bool CreateScriptInstance(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
         {
-            TaskInventoryItem item = GetInventoryItem(itemId);
-            if (item != null)
+            lock (m_scriptErrors)
             {
-                return CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
+                // Indicate to CreateScriptInstanceInternal() we don't want it to wait for completion
+                m_scriptErrors.Remove(itemId);
+            }
+            CreateScriptInstanceInternal(itemId, startParam, postOnRez, engine, stateSource);
+            return true;
+        }
+
+        private void CreateScriptInstanceInternal(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
+        {
+            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);
+            }
+            
+        }
 
-                return false;
+        /// <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>
@@ -488,15 +639,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);
@@ -567,14 +710,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;
         }
 
@@ -616,8 +761,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)
@@ -655,14 +801,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;
@@ -678,15 +824,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>
@@ -697,23 +843,24 @@ 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;
         }
 
         public TaskInventoryItem GetInventoryItem(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 item;
+                    m_items.LockItemsForRead(false);
+                    return item;
                 }
             }
+            m_items.LockItemsForRead(false);
 
             return null;
         }
@@ -722,15 +869,16 @@ namespace OpenSim.Region.Framework.Scenes
         {
             List<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;
         }
         
@@ -749,6 +897,10 @@ 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.RootPart.AttachRotation = group.GroupRotation;
+
             group.ResetIDs();
 
             SceneObjectPart rootPart = group.GetPart(group.UUID);
@@ -823,8 +975,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);
                 
@@ -837,14 +990,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);
                 
@@ -853,7 +1002,7 @@ namespace OpenSim.Region.Framework.Scenes
                     HasInventoryChanged = true;
                     m_part.ParentGroup.HasGroupChanged = true;
                 }
-                
+                m_items.LockItemsForWrite(false);
                 return true;
             }
             else
@@ -864,8 +1013,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>
@@ -876,43 +1026,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}",
@@ -921,70 +1087,12 @@ 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);
-
-                lock (m_items)
-                {
-                    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);
-
-                        UUID ownerID = item.OwnerID;
-                        uint everyoneMask = 0;
-                        uint baseMask = item.BasePermissions;
-                        uint ownerMask = item.CurrentPermissions;
-                        uint groupMask = item.GroupPermissions;
-
-                        invString.AddItemStart();
-                        invString.AddNameValueLine("item_id", item.ItemID.ToString());
-                        invString.AddNameValueLine("parent_id", m_part.UUID.ToString());
-
-                        invString.AddPermissionsStart();
-
-                        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("creator_id", item.CreatorID.ToString());
-                        invString.AddNameValueLine("owner_id", ownerID.ToString());
-
-                        invString.AddNameValueLine("last_owner_id", item.LastOwnerID.ToString());
-
-                        invString.AddNameValueLine("group_id", item.GroupID.ToString());
-                        invString.AddSectionEnd();
-
-                        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.AddSaleStart();
-                        invString.AddNameValueLine("sale_type", "not");
-                        invString.AddNameValueLine("sale_price", "0");
-                        invString.AddSectionEnd();
-
-                        invString.AddNameValueLine("name", item.Name + "|");
-                        invString.AddNameValueLine("desc", item.Description + "|");
-
-                        invString.AddNameValueLine("creation_date", item.CreationDate.ToString());
-                        invString.AddSectionEnd();
-                    }
-                }
-
-                m_inventoryFileData = Utils.StringToBytes(invString.BuildString);
-
                 return true;
             }
 
-            // No need to recreate, the existing file is fine
             return false;
         }
 
@@ -994,43 +1102,110 @@ namespace OpenSim.Region.Framework.Scenes
         /// <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);
+            bool changed = CreateInventoryFileName();
 
-                    client.SendTaskInventory(m_part.UUID, 0, new byte[0]);
-                    return;
-                }
+            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;
+            }
 
-                CreateInventoryFile();
+                        if (m_items.Count == 0) // No inventory
+                        {
+                                client.SendTaskInventory(m_part.UUID, 0, new byte[0]);
+                Items.LockItemsForRead(false);
+                                return;
+                        }
     
-                // 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 (!changed)
+            {
                 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);
+                    xferManager.AddNewFile(m_inventoryFileName,
+                            m_inventoryFileData);
+                    client.SendTaskInventory(m_part.UUID, (short)m_inventorySerial,
+                            Util.StringToBytes256(m_inventoryFileName));
+
+                    Items.LockItemsForRead(false);
+                    return;
                 }
-    
-                // Tell the client we're ready to Xfer the file
-                client.SendTaskInventory(m_part.UUID, (short)m_inventorySerial,
-                        Util.StringToBytes256(m_inventoryFileName));
             }
+
+            m_inventoryPrivileged = includeAssets;
+
+            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.AddItemStart();
+                invString.AddNameValueLine("item_id", item.ItemID.ToString());
+                invString.AddNameValueLine("parent_id", m_part.UUID.ToString());
+
+                invString.AddPermissionsStart();
+
+                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("creator_id", item.CreatorID.ToString());
+                invString.AddNameValueLine("owner_id", ownerID.ToString());
+
+                invString.AddNameValueLine("last_owner_id", item.LastOwnerID.ToString());
+
+                invString.AddNameValueLine("group_id", item.GroupID.ToString());
+                invString.AddSectionEnd();
+
+                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.AddSaleStart();
+                invString.AddNameValueLine("sale_type", "not");
+                invString.AddNameValueLine("sale_price", "0");
+                invString.AddSectionEnd();
+
+                invString.AddNameValueLine("name", item.Name + "|");
+                invString.AddNameValueLine("desc", item.Description + "|");
+
+                invString.AddNameValueLine("creation_date", item.CreationDate.ToString());
+                invString.AddSectionEnd();
+            }
+
+            Items.LockItemsForRead(false);
+
+            m_inventoryFileData = Utils.StringToBytes(invString.BuildString);
+
+            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>
@@ -1039,13 +1214,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
@@ -1111,87 +1292,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)
                 {
-//                    m_log.DebugFormat (
-//                        "[SCENE OBJECT PART INVENTORY]: Applying next permissions {0} to {1} in {2} with current {3}, base {4}, everyone {5}",
-//                        item.NextPermissions, item.Name, m_part.Name, item.CurrentPermissions, item.BasePermissions, item.EveryonePermissions);
-
-                    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.CurrentPermissions &= item.NextPermissions;
+                item.BasePermissions &= item.NextPermissions;
+                item.EveryonePermissions &= item.NextPermissions;
+                item.OwnerChanged = true;
+                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++;
@@ -1204,14 +1361,11 @@ 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;
                 }
             }
 
@@ -1225,17 +1379,15 @@ namespace OpenSim.Region.Framework.Scenes
         public int ScriptCount()
         {
             int count = 0;
-            lock (m_items)
+            Items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (TaskInventoryItem item in m_items.Values)
+                if (item.InvType == (int)InventoryType.LSL)
                 {
-                    if (item.InvType == (int)InventoryType.LSL)
-                    {
-                        count++;
-                    }
+                    count++;
                 }
             }
-
+            Items.LockItemsForRead(false);
             return count;
         }
         /// <summary>
@@ -1271,11 +1423,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;
         }
@@ -1284,8 +1433,9 @@ namespace OpenSim.Region.Framework.Scenes
         {
             List<TaskInventoryItem> ret = new List<TaskInventoryItem>();
 
-            lock (m_items)
-                ret = new List<TaskInventoryItem>(m_items.Values);
+            Items.LockItemsForRead(true);
+            ret = new List<TaskInventoryItem>(m_items.Values);
+            Items.LockItemsForRead(false);
 
             return ret;
         }
@@ -1294,18 +1444,24 @@ namespace OpenSim.Region.Framework.Scenes
         {
             List<TaskInventoryItem> ret = new List<TaskInventoryItem>();
 
-            lock (m_items)
-            {
-                foreach (TaskInventoryItem item in m_items.Values)
-                    if (item.InvType == (int)type)
-                        ret.Add(item);
-            }
+            Items.LockItemsForRead(true);
+
+            foreach (TaskInventoryItem item in m_items.Values)
+                if (item.InvType == (int)type)
+                    ret.Add(item);
+
+            Items.LockItemsForRead(false);
 
             return ret;
         }
         
         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
@@ -1331,14 +1487,21 @@ namespace OpenSim.Region.Framework.Scenes
                         string n = e.GetXMLState(item.ItemID);
                         if (n != String.Empty)
                         {
-                            if (!ret.ContainsKey(item.ItemID))
-                                ret[item.ItemID] = n;
+                            if (oldIDs)
+                            {
+                                if (!ret.ContainsKey(item.OldItemID))
+                                    ret[item.OldItemID] = n;
+                            }
+                            else
+                            {
+                                if (!ret.ContainsKey(item.ItemID))
+                                    ret[item.ItemID] = n;
+                            }
                             break;
                         }
                     }
                 }
             }
-            
             return ret;
         }
         
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 990ef6e..6e4ac98 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -63,6 +63,7 @@ namespace OpenSim.Region.Framework.Scenes
 
     struct ScriptControllers
     {
+        public UUID objectID;
         public UUID itemID;
         public ScriptControlled ignoreControls;
         public ScriptControlled eventControls;
@@ -99,7 +100,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// rotation, prim cut, prim twist, prim taper, and prim shear. See mantis
         /// issue #1716
         /// </summary>
-        public static readonly Vector3 SIT_TARGET_ADJUSTMENT = new Vector3(0.0f, 0.0f, 0.418f);
+        public static readonly Vector3 SIT_TARGET_ADJUSTMENT = new Vector3(0.0f, 0.0f, 0.4f);
 
         /// <summary>
         /// Movement updates for agents in neighboring regions are sent directly to clients.
@@ -121,8 +122,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <remarks>
         /// TODO: For some reason, we effectively have a list both here and in Appearance.  Need to work out if this is
         /// necessary.
-        /// NOTE: To avoid deadlocks, do not lock m_attachments and then perform other tasks under that lock.  Take a copy
-        /// of the list and act on that instead.
         /// </remarks>
         private List<SceneObjectGroup> m_attachments = new List<SceneObjectGroup>();
 
@@ -141,6 +140,8 @@ namespace OpenSim.Region.Framework.Scenes
         private Vector3 m_lastPosition;
         private Quaternion m_lastRotation;
         private Vector3 m_lastVelocity;
+        private Vector3 m_lastSize = new Vector3(0.45f,0.6f,1.9f);
+
 
         private Vector3? m_forceToApply;
         private int m_userFlags;
@@ -173,6 +174,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,8 +230,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public bool LandAtTarget { get; private set; }
 
-        private bool m_followCamAuto;
-
         private int m_movementUpdateCount;
         private const int NumMovementsBetweenRayCast = 5;
 
@@ -237,6 +237,13 @@ namespace OpenSim.Region.Framework.Scenes
         //private int m_moveToPositionStateStatus;
         //*****************************************************
 
+        private bool m_collisionEventFlag = false;
+        private object m_collisionEventLock = new Object();
+
+        private int m_movementAnimationUpdateCounter = 0;
+
+        private Vector3 m_prevSitOffset;
+
         protected AvatarAppearance m_appearance;
 
         public AvatarAppearance Appearance
@@ -351,6 +358,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         protected Vector3 m_lastCameraPosition;
 
+        private Vector4 m_lastCameraCollisionPlane = new Vector4(0f, 0f, 0f, 1);
+        private bool m_doingCamRayCast = false;
+
         public Vector3 CameraPosition { get; set; }
 
         public Quaternion CameraRotation
@@ -431,7 +441,9 @@ namespace OpenSim.Region.Framework.Scenes
             get { return (IClientCore)ControllingClient; }
         }
 
-        public Vector3 ParentPosition { get; set; }
+        public UUID COF { get; set; }
+
+//        public Vector3 ParentPosition { get; set; }
 
         /// <summary>
         /// Position of this avatar relative to the region the avatar is in
@@ -492,7 +504,7 @@ namespace OpenSim.Region.Framework.Scenes
                 if (ParentID == 0)
                 {
                     m_pos = value;
-                    ParentPosition = Vector3.Zero;
+//                    ParentPosition = Vector3.Zero;
                 }
 
                 //m_log.DebugFormat(
@@ -561,7 +573,24 @@ namespace OpenSim.Region.Framework.Scenes
 //                    Scene.RegionInfo.RegionName, Name, m_velocity);
             }
         }
+/*
+        public override Vector3 AngularVelocity
+        {
+            get
+            {
+                if (PhysicsActor != null)
+                {
+                    m_rotationalvelocity = PhysicsActor.RotationalVelocity;
 
+                    //                    m_log.DebugFormat(
+                    //                        "[SCENE PRESENCE]: Set velocity {0} for {1} in {2} via getting Velocity!",
+                    //                        m_velocity, Name, Scene.RegionInfo.RegionName);
+                }
+
+                return m_rotationalvelocity;
+            }
+        }
+*/
         private Quaternion m_bodyRot = Quaternion.Identity;
 
         /// <summary>
@@ -584,8 +613,16 @@ namespace OpenSim.Region.Framework.Scenes
                 m_bodyRot = value;
 
                 if (PhysicsActor != null)
-                    PhysicsActor.Orientation = m_bodyRot;
-
+                {
+                    try
+                    {
+                        PhysicsActor.Orientation = m_bodyRot;
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Error("[SCENE PRESENCE]: Orientation " + e.Message);
+                    }
+                }
 //                m_log.DebugFormat("[SCENE PRESENCE]: Body rot for {0} set to {1}", Name, m_bodyRot);
             }
         }
@@ -599,12 +636,20 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         public bool IsChildAgent { get; set; }
+        public bool IsLoggingIn { get; set; }
 
         /// <summary>
         /// If the avatar is sitting, the local ID of the prim that it's sitting on.  If not sitting then zero.
         /// </summary>
         public uint ParentID { get; set; }
 
+        public UUID ParentUUID
+        {
+            get { return m_parentUUID; }
+            set { m_parentUUID = value; }
+        }
+        private UUID m_parentUUID = UUID.Zero;
+
         /// <summary>
         /// Are we sitting on an object?
         /// </summary>
@@ -754,6 +799,7 @@ namespace OpenSim.Region.Framework.Scenes
             AttachmentsSyncLock = new Object();
             AllowMovement = true;
             IsChildAgent = true;
+            IsLoggingIn = false;
             m_sendCoarseLocationsMethod = SendCoarseLocationsDefault;
             Animator = new ScenePresenceAnimator(this);
             PresenceType = type;
@@ -797,6 +843,33 @@ namespace OpenSim.Region.Framework.Scenes
             Appearance = appearance;
         }
 
+        private void RegionHeartbeatEnd(Scene scene)
+        {
+            if (IsChildAgent)
+                return;
+
+            m_movementAnimationUpdateCounter ++;
+            if (m_movementAnimationUpdateCounter >= 2)
+            {
+                m_movementAnimationUpdateCounter = 0;
+                if (Animator != null)
+                {
+                    // If the parentID == 0 we are not sitting
+                    // if !SitGournd then we are not sitting on the ground
+                    // Fairly straightforward, now here comes the twist
+                    // if ParentUUID is NOT UUID.Zero, we are looking to
+                    // be sat on an object that isn't there yet. Should
+                    // be treated as if sat.
+                    if(ParentID == 0 && !SitGround && ParentUUID == UUID.Zero) // skip it if sitting
+                        Animator.UpdateMovementAnimations();
+                }
+                else
+                {
+                    m_scene.EventManager.OnRegionHeartbeatEnd -= RegionHeartbeatEnd;
+                }
+            }
+        }
+
         public void RegisterToEvents()
         {
             ControllingClient.OnCompleteMovementToRegion += CompleteMovement;
@@ -806,8 +879,10 @@ namespace OpenSim.Region.Framework.Scenes
             ControllingClient.OnSetAlwaysRun += HandleSetAlwaysRun;
             ControllingClient.OnStartAnim += HandleStartAnim;
             ControllingClient.OnStopAnim += HandleStopAnim;
+            ControllingClient.OnChangeAnim += avnHandleChangeAnim;
             ControllingClient.OnForceReleaseControls += HandleForceReleaseControls;
             ControllingClient.OnAutoPilotGo += MoveToTarget;
+            ControllingClient.OnUpdateThrottles += RaiseUpdateThrottles;
 
             // ControllingClient.OnChildAgentStatus += new StatusChange(this.ChildStatusChange);
             // ControllingClient.OnStopMovement += new GenericCall2(this.StopMovement);
@@ -866,6 +941,38 @@ namespace OpenSim.Region.Framework.Scenes
                 "[SCENE]: Upgrading child to root agent for {0} in {1}",
                 Name, m_scene.RegionInfo.RegionName);
 
+            if (ParentUUID != UUID.Zero)
+            {
+                m_log.DebugFormat("[SCENE PRESENCE]: Sitting avatar back on prim {0}", ParentUUID);
+                SceneObjectPart part = m_scene.GetSceneObjectPart(ParentUUID);
+                if (part == null)
+                {
+                    m_log.ErrorFormat("[SCENE PRESENCE]: Can't find prim {0} to sit on", ParentUUID);
+                }
+                else
+                {
+                    part.ParentGroup.AddAvatar(UUID);
+                    if (part.SitTargetPosition != Vector3.Zero)
+                        part.SitTargetAvatar = UUID;
+//                    ParentPosition = part.GetWorldPosition();
+                    ParentID = part.LocalId;
+                    ParentPart = part;
+                    m_pos = m_prevSitOffset;
+//                    pos = ParentPosition;
+                    pos = part.GetWorldPosition();
+                }
+                ParentUUID = UUID.Zero;
+
+                IsChildAgent = false;
+
+//                Animator.TrySetMovementAnimation("SIT");
+            }
+            else
+            {
+                IsChildAgent = false;
+                IsLoggingIn = false;
+            }
+
             //m_log.DebugFormat("[SCENE]: known regions in {0}: {1}", Scene.RegionInfo.RegionName, KnownChildRegionHandles.Count);
 
             IsChildAgent = false;
@@ -878,70 +985,106 @@ namespace OpenSim.Region.Framework.Scenes
 
             m_scene.EventManager.TriggerSetRootAgentScene(m_uuid, m_scene);
 
-            // Moved this from SendInitialData to ensure that Appearance is initialized
-            // before the inventory is processed in MakeRootAgent. This fixes a race condition
-            // related to the handling of attachments
-            //m_scene.GetAvatarAppearance(ControllingClient, out Appearance);
+            UUID groupUUID = UUID.Zero;
+            string GroupName = string.Empty;
+            ulong groupPowers = 0;
 
-            if (m_scene.TestBorderCross(pos, Cardinals.E))
+            // ----------------------------------
+            // Previous Agent Difference - AGNI sends an unsolicited AgentDataUpdate upon root agent status
+            try
             {
-                Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.E);
-                pos.X = crossedBorder.BorderLine.Z - 1;
+                if (gm != null)
+                {
+                    groupUUID = ControllingClient.ActiveGroupId;
+                    GroupRecord record = gm.GetGroupRecord(groupUUID);
+                    if (record != null)
+                        GroupName = record.GroupName;
+                    GroupMembershipData groupMembershipData = gm.GetMembershipData(groupUUID, m_uuid);
+                    if (groupMembershipData != null)
+                        groupPowers = groupMembershipData.GroupPowers;
+                }
+                ControllingClient.SendAgentDataUpdate(m_uuid, groupUUID, Firstname, Lastname, groupPowers, GroupName,
+                                                      Grouptitle);
             }
-
-            if (m_scene.TestBorderCross(pos, Cardinals.N))
+            catch (Exception e)
             {
-                Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.N);
-                pos.Y = crossedBorder.BorderLine.Z - 1;
+                m_log.Debug("[AGENTUPDATE]: " + e.ToString());
             }
+            // ------------------------------------
 
-            CheckAndAdjustLandingPoint(ref pos);
-
-            if (pos.X < 0f || pos.Y < 0f || pos.Z < 0f)
+            if (ParentID == 0)
             {
-                m_log.WarnFormat(
-                    "[SCENE PRESENCE]: MakeRootAgent() was given an illegal position of {0} for avatar {1}, {2}. Clamping",
-                    pos, Name, UUID);
+                // Moved this from SendInitialData to ensure that Appearance is initialized
+                // before the inventory is processed in MakeRootAgent. This fixes a race condition
+                // related to the handling of attachments
+                //m_scene.GetAvatarAppearance(ControllingClient, out Appearance);
+                if (m_scene.TestBorderCross(pos, Cardinals.E))
+                {
+                    Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.E);
+                    pos.X = crossedBorder.BorderLine.Z - 1;
+                }
 
-                if (pos.X < 0f) pos.X = 0f;
-                if (pos.Y < 0f) pos.Y = 0f;
-                if (pos.Z < 0f) pos.Z = 0f;
-            }
+                if (m_scene.TestBorderCross(pos, Cardinals.N))
+                {
+                    Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.N);
+                    pos.Y = crossedBorder.BorderLine.Z - 1;
+                }
 
-            float localAVHeight = 1.56f;
-            if (Appearance.AvatarHeight > 0)
-                localAVHeight = Appearance.AvatarHeight;
+                CheckAndAdjustLandingPoint(ref pos);
 
-            float posZLimit = 0;
+                if (pos.X < 0f || pos.Y < 0f || pos.Z < 0f)
+                {
+                    m_log.WarnFormat(
+                        "[SCENE PRESENCE]: MakeRootAgent() was given an illegal position of {0} for avatar {1}, {2}. Clamping",
+                        pos, Name, UUID);
 
-            if (pos.X < Constants.RegionSize && pos.Y < Constants.RegionSize)
-                posZLimit = (float)m_scene.Heightmap[(int)pos.X, (int)pos.Y];
-            
-            float newPosZ = posZLimit + localAVHeight / 2;
-            if (posZLimit >= (pos.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
-            {
-                pos.Z = newPosZ;
-            }
-            AbsolutePosition = pos;
+                    if (pos.X < 0f) pos.X = 0f;
+                    if (pos.Y < 0f) pos.Y = 0f;
+                    if (pos.Z < 0f) pos.Z = 0f;
+                }
 
-            AddToPhysicalScene(isFlying);
+                float localAVHeight = 1.56f;
+                if (Appearance.AvatarHeight > 0)
+                    localAVHeight = Appearance.AvatarHeight;
 
-            // XXX: This is to trigger any secondary teleport needed for a megaregion when the user has teleported to a 
-            // location outside the 'root region' (the south-west 256x256 corner).  This is the earlist we can do it
-            // since it requires a physics actor to be present.  If it is left any later, then physics appears to reset
-            // the value to a negative position which does not trigger the border cross.
-            // This may not be the best location for this.
-            CheckForBorderCrossing();
+                float posZLimit = 0;
 
-            if (ForceFly)
-            {
-                Flying = true;
-            }
-            else if (FlyDisabled)
-            {
-                Flying = false;
-            }
+                if (pos.X < Constants.RegionSize && pos.Y < Constants.RegionSize)
+                    posZLimit = (float)m_scene.Heightmap[(int)pos.X, (int)pos.Y];
+                
+                float newPosZ = posZLimit + localAVHeight / 2;
+                if (posZLimit >= (pos.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
+                {
+                    pos.Z = newPosZ;
+                }
+                AbsolutePosition = pos;
+
+                if (m_teleportFlags == TeleportFlags.Default)
+                {
+                    Vector3 vel = Velocity;
+                    AddToPhysicalScene(isFlying);
+                    if (PhysicsActor != null)
+                        PhysicsActor.SetMomentum(vel);
+                }
+                else
+                    AddToPhysicalScene(isFlying);
 
+                // XXX: This is to trigger any secondary teleport needed for a megaregion when the user has teleported to a 
+                // location outside the 'root region' (the south-west 256x256 corner).  This is the earlist we can do it
+                // since it requires a physics actor to be present.  If it is left any later, then physics appears to reset
+                // the value to a negative position which does not trigger the border cross.
+                // This may not be the best location for this.
+                CheckForBorderCrossing();
+
+                if (ForceFly)
+                {
+                    Flying = true;
+                }
+                else if (FlyDisabled)
+                {
+                    Flying = false;
+                }
+            }
             // Don't send an animation pack here, since on a region crossing this will sometimes cause a flying 
             // avatar to return to the standing position in mid-air.  On login it looks like this is being sent
             // elsewhere anyway
@@ -973,31 +1116,28 @@ namespace OpenSim.Region.Framework.Scenes
                 // and CHANGED_REGION) when the attachments have been rezzed in the new region.  This cannot currently
                 // be done in AttachmentsModule.CopyAttachments(AgentData ad, IScenePresence sp) itself since we are
                 // not transporting the required data.
-                //
-                // We must take a copy of the attachments list here (rather than locking) to avoid a deadlock where a script in one of 
-                // the attachments may start processing an event (which locks ScriptInstance.m_Script) that then calls a method here
-                // which needs to lock m_attachments.  ResumeScripts() needs to take a ScriptInstance.m_Script lock to try to unset the Suspend status.
-                //
-                // FIXME: In theory, this deadlock should not arise since scripts should not be processing events until ResumeScripts().
-                // But XEngine starts all scripts unsuspended.  Starting them suspended will not currently work because script rezzing
-                // is placed in an asynchronous queue in XEngine and so the ResumeScripts() call will almost certainly execute before the 
-                // script is rezzed.  This means the ResumeScripts() does absolutely nothing when using XEngine.
-                List<SceneObjectGroup> attachments = GetAttachments();
-
-                if (attachments.Count > 0)
+                lock (m_attachments)
                 {
-                    m_log.DebugFormat(
-                        "[SCENE PRESENCE]: Restarting scripts in attachments for {0} in {1}", Name, Scene.Name);
-
-                    // Resume scripts
-                    foreach (SceneObjectGroup sog in attachments)
+                    if (HasAttachments())
                     {
-                        sog.RootPart.ParentGroup.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, GetStateSource());
-                        sog.ResumeScripts();
+                        m_log.DebugFormat(
+                            "[SCENE PRESENCE]: Restarting scripts in attachments for {0} in {1}", Name, Scene.Name);
+
+                        // Resume scripts
+                        Util.FireAndForget(delegate(object x) {
+                            foreach (SceneObjectGroup sog in m_attachments)
+                            {
+                                sog.ScheduleGroupForFullUpdate();
+                                sog.RootPart.ParentGroup.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, GetStateSource());
+                                sog.ResumeScripts();
+                            }
+                        });
                     }
                 }
             }
 
+            SendAvatarDataToAllAgents();
+
             // send the animations of the other presences to me
             m_scene.ForEachRootScenePresence(delegate(ScenePresence presence)
             {
@@ -1008,6 +1148,7 @@ namespace OpenSim.Region.Framework.Scenes
             // If we don't reset the movement flag here, an avatar that crosses to a neighbouring sim and returns will
             // stall on the border crossing since the existing child agent will still have the last movement
             // recorded, which stops the input from being processed.
+
             MovementFlag = 0;
 
             // DIVA NOTE: I moved TriggerOnMakeRootAgent out of here and into the end of
@@ -1040,12 +1181,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// </remarks>
         public void MakeChildAgent()
         {
+            m_scene.EventManager.OnRegionHeartbeatEnd -= RegionHeartbeatEnd;
+
             m_log.DebugFormat("[SCENE PRESENCE]: Making {0} a child agent in {1}", Name, Scene.RegionInfo.RegionName);
 
             // Reset these so that teleporting in and walking out isn't seen
             // as teleporting back
             TeleportFlags = TeleportFlags.Default;
 
+            MovementFlag = 0;
+
             // It looks like Animator is set to null somewhere, and MakeChild
             // is called after that. Probably in aborted teleports.
             if (Animator == null)
@@ -1053,6 +1198,7 @@ namespace OpenSim.Region.Framework.Scenes
             else
                 Animator.ResetAnimations();
 
+            
 //            m_log.DebugFormat(
 //                 "[SCENE PRESENCE]: Downgrading root agent {0}, {1} to a child agent in {2}",
 //                 Name, UUID, m_scene.RegionInfo.RegionName);
@@ -1064,6 +1210,7 @@ namespace OpenSim.Region.Framework.Scenes
             IsChildAgent = true;
             m_scene.SwapRootAgentCount(true);
             RemoveFromPhysicalScene();
+            ParentID = 0; // Child agents can't be sitting
 
             // FIXME: Set RegionHandle to the region handle of the scene this agent is moving into
             
@@ -1079,9 +1226,9 @@ namespace OpenSim.Region.Framework.Scenes
             {
 //                PhysicsActor.OnRequestTerseUpdate -= SendTerseUpdateToAllClients;
                 PhysicsActor.OnOutOfBounds -= OutOfBoundsCall;
-                m_scene.PhysicsScene.RemoveAvatar(PhysicsActor);
-                PhysicsActor.UnSubscribeEvents();
                 PhysicsActor.OnCollisionUpdate -= PhysicsCollisionUpdate;
+                PhysicsActor.UnSubscribeEvents();
+                m_scene.PhysicsScene.RemoveAvatar(PhysicsActor);
                 PhysicsActor = null;
             }
 //            else
@@ -1098,7 +1245,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="pos"></param>
         public void Teleport(Vector3 pos)
         {
-            TeleportWithMomentum(pos, null);
+            TeleportWithMomentum(pos, Vector3.Zero);
         }
 
         public void TeleportWithMomentum(Vector3 pos, Vector3? v)
@@ -1122,6 +1269,41 @@ namespace OpenSim.Region.Framework.Scenes
             SendTerseUpdateToAllClients();
         }
 
+        public void avnLocalTeleport(Vector3 newpos, Vector3? newvel, bool rotateToVelXY)
+        {
+            CheckLandingPoint(ref newpos);
+            AbsolutePosition = newpos;
+
+            if (newvel.HasValue)
+            {
+                if ((Vector3)newvel == Vector3.Zero)
+                {
+                    if (PhysicsActor != null)
+                        PhysicsActor.SetMomentum(Vector3.Zero);
+                    m_velocity = Vector3.Zero;
+                }
+                else
+                {
+                    if (PhysicsActor != null)
+                        PhysicsActor.SetMomentum((Vector3)newvel);
+                    m_velocity = (Vector3)newvel;
+
+                    if (rotateToVelXY)
+                    {
+                        Vector3 lookAt = (Vector3)newvel;
+                        lookAt.Z = 0;
+                        lookAt.Normalize();
+                        ControllingClient.SendLocalTeleport(newpos, lookAt, (uint)TeleportFlags.ViaLocation);
+                        return;
+                    }
+                }
+            }
+
+            SendTerseUpdateToAllClients();
+        }
+
+
+
         public void StopFlying()
         {
             ControllingClient.StopFlying(this);
@@ -1291,6 +1473,13 @@ namespace OpenSim.Region.Framework.Scenes
                 PhysicsActor.Size = new Vector3(0.45f, 0.6f, height);
         }
 
+        public void SetSize(Vector3 size, float feetoffset)
+        {
+            if (PhysicsActor != null && !IsChildAgent)
+                PhysicsActor.setAvatarSize(size, feetoffset);
+            
+        }
+
         /// <summary>
         /// Complete Avatar's movement into the region.
         /// </summary>
@@ -1310,7 +1499,8 @@ namespace OpenSim.Region.Framework.Scenes
 
             Vector3 look = Velocity;
 
-            if ((look.X == 0) && (look.Y == 0) && (look.Z == 0))
+            //            if ((look.X == 0) && (look.Y == 0) && (look.Z == 0))
+            if ((Math.Abs(look.X) < 0.1) && (Math.Abs(look.Y) < 0.1) && (Math.Abs(look.Z) < 0.1))
             {
                 look = new Vector3(0.99f, 0.042f, 0);
             }
@@ -1367,11 +1557,12 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 IEntityTransferModule m_agentTransfer = m_scene.RequestModuleInterface<IEntityTransferModule>();
                 if (m_agentTransfer != null)
-                    Util.FireAndForget(delegate { m_agentTransfer.EnableChildAgents(this); });
+                    m_agentTransfer.EnableChildAgents(this);
 
                 IFriendsModule friendsModule = m_scene.RequestModuleInterface<IFriendsModule>();
                 if (friendsModule != null)
                     friendsModule.SendFriendsOnlineIfNeeded(ControllingClient);
+
             }
 
             // XXX: If we force an update here, then multiple attachments do appear correctly on a destination region
@@ -1401,36 +1592,69 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="collisionPoint"></param>
         /// <param name="localid"></param>
         /// <param name="distance"></param>
+        /// 
+
+        private void UpdateCameraCollisionPlane(Vector4 plane)
+        {
+            if (m_lastCameraCollisionPlane != plane)
+            {
+                m_lastCameraCollisionPlane = plane;
+                ControllingClient.SendCameraConstraint(plane);
+            }
+        }
+
         public void RayCastCameraCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance, Vector3 pNormal)
         {
             const float POSITION_TOLERANCE = 0.02f;
-            const float VELOCITY_TOLERANCE = 0.02f;
             const float ROTATION_TOLERANCE = 0.02f;
 
-            if (m_followCamAuto)
+            m_doingCamRayCast = false;
+            if (hitYN && localid != LocalId)
             {
-                if (hitYN)
+                SceneObjectGroup group = m_scene.GetGroupByPrim(localid);
+                bool IsPrim = group != null;
+                if (IsPrim)
                 {
-                    CameraConstraintActive = true;
-                    //m_log.DebugFormat("[RAYCASTRESULT]: {0}, {1}, {2}, {3}", hitYN, collisionPoint, localid, distance);
-                    
-                    Vector3 normal = Vector3.Normalize(new Vector3(0f, 0f, collisionPoint.Z) - collisionPoint);
-                    ControllingClient.SendCameraConstraint(new Vector4(normal.X, normal.Y, normal.Z, -1 * Vector3.Distance(new Vector3(0,0,collisionPoint.Z),collisionPoint)));
+                    SceneObjectPart part = group.GetPart(localid);
+                    if (part != null && !part.VolumeDetectActive)
+                    {
+                        CameraConstraintActive = true;
+                        pNormal.X = (float) Math.Round(pNormal.X, 2);
+                        pNormal.Y = (float) Math.Round(pNormal.Y, 2);
+                        pNormal.Z = (float) Math.Round(pNormal.Z, 2);
+                        pNormal.Normalize();
+                        collisionPoint.X = (float) Math.Round(collisionPoint.X, 1);
+                        collisionPoint.Y = (float) Math.Round(collisionPoint.Y, 1);
+                        collisionPoint.Z = (float) Math.Round(collisionPoint.Z, 1);
+
+                        Vector4 plane = new Vector4(pNormal.X, pNormal.Y, pNormal.Z,
+                                                    Vector3.Dot(collisionPoint, pNormal));
+                        UpdateCameraCollisionPlane(plane);
+                    }
                 }
                 else
                 {
-                    if (!m_pos.ApproxEquals(m_lastPosition, POSITION_TOLERANCE) ||
-                        !Velocity.ApproxEquals(m_lastVelocity, VELOCITY_TOLERANCE) ||
-                        !Rotation.ApproxEquals(m_lastRotation, ROTATION_TOLERANCE))
-                    {
-                        if (CameraConstraintActive)
-                        {
-                            ControllingClient.SendCameraConstraint(new Vector4(0f, 0.5f, 0.9f, -3000f));
-                            CameraConstraintActive = false;
-                        }
-                    }
+                    CameraConstraintActive = true;
+                    pNormal.X = (float) Math.Round(pNormal.X, 2);
+                    pNormal.Y = (float) Math.Round(pNormal.Y, 2);
+                    pNormal.Z = (float) Math.Round(pNormal.Z, 2);
+                    pNormal.Normalize();
+                    collisionPoint.X = (float) Math.Round(collisionPoint.X, 1);
+                    collisionPoint.Y = (float) Math.Round(collisionPoint.Y, 1);
+                    collisionPoint.Z = (float) Math.Round(collisionPoint.Z, 1);
+
+                    Vector4 plane = new Vector4(pNormal.X, pNormal.Y, pNormal.Z,
+                                                Vector3.Dot(collisionPoint, pNormal));
+                    UpdateCameraCollisionPlane(plane);
                 }
             }
+            else if (!m_pos.ApproxEquals(m_lastPosition, POSITION_TOLERANCE) ||
+                     !Rotation.ApproxEquals(m_lastRotation, ROTATION_TOLERANCE))
+            {
+                Vector4 plane = new Vector4(0.9f, 0.0f, 0.361f, -9000f); // not right...
+                UpdateCameraCollisionPlane(plane);
+                CameraConstraintActive = false;
+            }
         }
 
         /// <summary>
@@ -1504,12 +1728,6 @@ namespace OpenSim.Region.Framework.Scenes
             // DrawDistance = agentData.Far;
             DrawDistance = Scene.DefaultDrawDistance;
 
-            // Check if Client has camera in 'follow cam' or 'build' mode.
-            Vector3 camdif = (Vector3.One * Rotation - Vector3.One * CameraRotation);
-
-            m_followCamAuto = ((CameraUpAxis.Z > 0.959f && CameraUpAxis.Z < 0.98f)
-               && (Math.Abs(camdif.X) < 0.4f && Math.Abs(camdif.Y) < 0.4f)) ? true : false;
-
             m_mouseLook = (flags & AgentManager.ControlFlags.AGENT_CONTROL_MOUSELOOK) != 0;
             m_leftButtonDown = (flags & AgentManager.ControlFlags.AGENT_CONTROL_LBUTTON_DOWN) != 0;
 
@@ -1529,14 +1747,38 @@ namespace OpenSim.Region.Framework.Scenes
                 StandUp();
             }
 
-            //m_log.DebugFormat("[FollowCam]: {0}", m_followCamAuto);
             // Raycast from the avatar's head to the camera to see if there's anything blocking the view
-            if ((m_movementUpdateCount % NumMovementsBetweenRayCast) == 0 && m_scene.PhysicsScene.SupportsRayCast())
+            // this exclude checks may not be complete
+
+            if (m_movementUpdateCount % NumMovementsBetweenRayCast == 0 && m_scene.PhysicsScene.SupportsRayCast())
             {
-                if (m_followCamAuto)
+                if (!m_doingCamRayCast && !m_mouseLook && ParentID == 0)
                 {
-                    Vector3 posAdjusted = m_pos + HEAD_ADJUSTMENT;
-                    m_scene.PhysicsScene.RaycastWorld(m_pos, Vector3.Normalize(CameraPosition - posAdjusted), Vector3.Distance(CameraPosition, posAdjusted) + 0.3f, RayCastCameraCallback);
+                    Vector3 posAdjusted = AbsolutePosition;
+//                    posAdjusted.Z += 0.5f * Appearance.AvatarSize.Z - 0.5f;
+                    posAdjusted.Z += 1.0f; // viewer current camera focus point
+                    Vector3 tocam = CameraPosition - posAdjusted;
+                    tocam.X = (float)Math.Round(tocam.X, 1);
+                    tocam.Y = (float)Math.Round(tocam.Y, 1);
+                    tocam.Z = (float)Math.Round(tocam.Z, 1);
+
+                    float distTocamlen = tocam.Length();
+                    if (distTocamlen > 0.3f)
+                    {
+                        tocam *= (1.0f / distTocamlen);
+                        posAdjusted.X = (float)Math.Round(posAdjusted.X, 1);
+                        posAdjusted.Y = (float)Math.Round(posAdjusted.Y, 1);
+                        posAdjusted.Z = (float)Math.Round(posAdjusted.Z, 1);
+
+                        m_doingCamRayCast = true;
+                        m_scene.PhysicsScene.RaycastWorld(posAdjusted, tocam, distTocamlen + 1.0f, RayCastCameraCallback);
+                    }
+                }
+                else if (CameraConstraintActive && (m_mouseLook || ParentID != 0))
+                {
+                    Vector4 plane = new Vector4(0.9f, 0.0f, 0.361f, -10000f); // not right...
+                    UpdateCameraCollisionPlane(plane);
+                    CameraConstraintActive = false;
                 }
             }
 
@@ -2001,7 +2243,8 @@ namespace OpenSim.Region.Framework.Scenes
 //            m_log.DebugFormat("[SCENE PRESENCE]: Resetting move to target for {0}", Name);
 
             MovingToTarget = false;
-            MoveToPositionTarget = Vector3.Zero;
+//            MoveToPositionTarget = Vector3.Zero;
+            m_forceToApply = null; // cancel possible last action
 
             // We need to reset the control flag as the ScenePresenceAnimator uses this to determine the correct
             // resting animation (e.g. hover or stand).  NPCs don't have a client that will quickly reset this flag.
@@ -2019,12 +2262,17 @@ namespace OpenSim.Region.Framework.Scenes
 //            m_log.DebugFormat("[SCENE PRESENCE]: StandUp() for {0}", Name);
 
             SitGround = false;
+
+/* move this down so avatar gets physical in the new position and not where it is siting
             if (PhysicsActor == null)
                 AddToPhysicalScene(false);
+ */
 
             if (ParentID != 0)
             {
                 SceneObjectPart part = ParentPart;
+                UnRegisterSeatControls(part.ParentGroup.UUID);
+
                 TaskInventoryDictionary taskIDict = part.TaskInventory;
                 if (taskIDict != null)
                 {
@@ -2040,14 +2288,22 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
 
-                ParentPosition = part.GetWorldPosition();
+                part.ParentGroup.DeleteAvatar(UUID);
+//                ParentPosition = part.GetWorldPosition();
                 ControllingClient.SendClearFollowCamProperties(part.ParentUUID);
 
-                m_pos += ParentPosition + new Vector3(0.0f, 0.0f, 2.0f * m_sitAvatarHeight);
-                ParentPosition = Vector3.Zero;
+//                m_pos += ParentPosition + new Vector3(0.0f, 0.0f, 2.0f * m_sitAvatarHeight);
+//                ParentPosition = Vector3.Zero;
+                m_pos = part.AbsolutePosition + (m_pos * part.GetWorldRotation()) + new Vector3(0.0f, 0.0f, 2.0f * m_sitAvatarHeight);
+                if (part.SitTargetAvatar == UUID)
+                    m_bodyRot = part.GetWorldRotation() * part.SitTargetOrientation;
 
                 ParentID = 0;
                 ParentPart = null;
+
+                if (PhysicsActor == null)
+                    AddToPhysicalScene(false);
+
                 SendAvatarDataToAllAgents();
                 m_requestedSitTargetID = 0;
 
@@ -2057,6 +2313,9 @@ namespace OpenSim.Region.Framework.Scenes
                     part.ParentGroup.TriggerScriptChangedEvent(Changed.LINK);
             }
 
+            else if (PhysicsActor == null)
+                AddToPhysicalScene(false);
+
             Animator.TrySetMovementAnimation("STAND");
             TriggerScenePresenceUpdated();
         }
@@ -2105,11 +2364,8 @@ namespace OpenSim.Region.Framework.Scenes
             if (part == null)
                 return;
 
-            // TODO: determine position to sit at based on scene geometry; don't trust offset from client
-            // see http://wiki.secondlife.com/wiki/User:Andrew_Linden/Office_Hours/2007_11_06 for details on how LL does it
-
             if (PhysicsActor != null)
-                m_sitAvatarHeight = PhysicsActor.Size.Z;
+                m_sitAvatarHeight = PhysicsActor.Size.Z * 0.5f;
 
             bool canSit = false;
             Vector3 pos = part.AbsolutePosition + offset;
@@ -2126,31 +2382,31 @@ namespace OpenSim.Region.Framework.Scenes
             }
             else
             {
+                if (PhysicsSit(part,offset)) // physics engine 
+                    return;
+
                 if (Util.GetDistanceTo(AbsolutePosition, pos) <= 10)
                 {
-//                    m_log.DebugFormat(
-//                        "[SCENE PRESENCE]: Sitting {0} on {1} {2} because sit target is unset and within 10m",
-//                        Name, part.Name, part.LocalId);
 
                     AbsolutePosition = pos + new Vector3(0.0f, 0.0f, m_sitAvatarHeight);
                     canSit = true;
                 }
-//                else
-//                {
-//                    m_log.DebugFormat(
-//                        "[SCENE PRESENCE]: Ignoring sit request of {0} on {1} {2} because sit target is unset and outside 10m",
-//                        Name, part.Name, part.LocalId);
-//                }
             }
 
             if (canSit)
             {
+
                 if (PhysicsActor != null)
                 {
                     // We can remove the physicsActor until they stand up.
                     RemoveFromPhysicalScene();
                 }
 
+                if (MovingToTarget)
+                    ResetMoveToTarget();
+
+                Velocity = Vector3.Zero;
+
                 part.AddSittingAvatar(UUID);
 
                 cameraAtOffset = part.GetCameraAtOffset();
@@ -2172,6 +2428,9 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void HandleAgentRequestSit(IClientAPI remoteClient, UUID agentID, UUID targetID, Vector3 offset)
         {
+            if (IsChildAgent)
+                return;
+
             if (ParentID != 0)
             {
                 if (ParentPart.UUID == targetID)
@@ -2187,14 +2446,6 @@ namespace OpenSim.Region.Framework.Scenes
                 m_requestedSitTargetID = part.LocalId;
                 m_requestedSitTargetUUID = part.UUID;
 
-//                m_log.DebugFormat("[SIT]: Client requested Sit Position: {0}", offset);
-
-                if (m_scene.PhysicsScene.SupportsRayCast())
-                {
-                    //m_scene.PhysicsScene.RaycastWorld(Vector3.Zero,Vector3.Zero, 0.01f,new RaycastCallback());
-                    //SitRayCastAvatarPosition(part);
-                    //return;
-                }
             }
             else
             {
@@ -2204,197 +2455,111 @@ namespace OpenSim.Region.Framework.Scenes
             SendSitResponse(targetID, offset, Quaternion.Identity);
         }
 
-        /*
-        public void SitRayCastAvatarPosition(SceneObjectPart part)
+        // returns  false if does not suport so older sit can be tried
+        public bool PhysicsSit(SceneObjectPart part, Vector3 offset)
         {
-            Vector3 EndRayCastPosition = part.AbsolutePosition + m_requestedSitOffset;
-            Vector3 StartRayCastPosition = AbsolutePosition;
-            Vector3 direction = Vector3.Normalize(EndRayCastPosition - StartRayCastPosition);
-            float distance = Vector3.Distance(EndRayCastPosition, StartRayCastPosition);
-            m_scene.PhysicsScene.RaycastWorld(StartRayCastPosition, direction, distance, SitRayCastAvatarPositionResponse);
-        }
-
-        public void SitRayCastAvatarPositionResponse(bool hitYN, Vector3 collisionPoint, uint localid, float pdistance, Vector3 normal)
-        {
-            SceneObjectPart part =  FindNextAvailableSitTarget(m_requestedSitTargetUUID);
-            if (part != null)
-            {
-                if (hitYN)
-                {
-                    if (collisionPoint.ApproxEquals(m_requestedSitOffset + part.AbsolutePosition, 0.2f))
-                    {
-                        SitRaycastFindEdge(collisionPoint, normal);
-                        m_log.DebugFormat("[SIT]: Raycast Avatar Position succeeded at point: {0}, normal:{1}", collisionPoint, normal);
-                    }
-                    else
-                    {
-                        SitRayCastAvatarPositionCameraZ(part);
-                    }
-                }
-                else
-                {
-                    SitRayCastAvatarPositionCameraZ(part);
-                }
-            }
-            else
+            if (part == null || part.ParentGroup.IsAttachment)
             {
-                ControllingClient.SendAlertMessage("Sit position no longer exists");
-                m_requestedSitTargetUUID = UUID.Zero;
-                m_requestedSitTargetID = 0;
-                m_requestedSitOffset = Vector3.Zero;
+                return true;
             }
 
-        }
+            if ( m_scene.PhysicsScene == null)
+                return false;
 
-        public void SitRayCastAvatarPositionCameraZ(SceneObjectPart part)
-        {
-            // Next, try to raycast from the camera Z position
-            Vector3 EndRayCastPosition = part.AbsolutePosition + m_requestedSitOffset;
-            Vector3 StartRayCastPosition = AbsolutePosition; StartRayCastPosition.Z = CameraPosition.Z;
-            Vector3 direction = Vector3.Normalize(EndRayCastPosition - StartRayCastPosition);
-            float distance = Vector3.Distance(EndRayCastPosition, StartRayCastPosition);
-            m_scene.PhysicsScene.RaycastWorld(StartRayCastPosition, direction, distance, SitRayCastAvatarPositionCameraZResponse);
-        }
-
-        public void SitRayCastAvatarPositionCameraZResponse(bool hitYN, Vector3 collisionPoint, uint localid, float pdistance, Vector3 normal)
-        {
-            SceneObjectPart part = FindNextAvailableSitTarget(m_requestedSitTargetUUID);
-            if (part != null)
+            if (part.PhysActor == null)
             {
-                if (hitYN)
-                {
-                    if (collisionPoint.ApproxEquals(m_requestedSitOffset + part.AbsolutePosition, 0.2f))
-                    {
-                        SitRaycastFindEdge(collisionPoint, normal);
-                        m_log.DebugFormat("[SIT]: Raycast Avatar Position + CameraZ succeeded at point: {0}, normal:{1}", collisionPoint, normal);
-                    }
-                    else
-                    {
-                        SitRayCastCameraPosition(part);
-                    }
-                }
+                // none physcis shape
+                if (part.PhysicsShapeType == (byte)PhysicsShapeType.None)
+                    ControllingClient.SendAlertMessage(" There is no suitable surface to sit on, try another spot.");
                 else
-                {
-                    SitRayCastCameraPosition(part);
+                { // non physical phantom  TODO
+                    ControllingClient.SendAlertMessage(" There is no suitable surface to sit on, try another spot.");
+                    return false;
                 }
-            }
-            else
-            {
-                ControllingClient.SendAlertMessage("Sit position no longer exists");
-                m_requestedSitTargetUUID = UUID.Zero;
-                m_requestedSitTargetID = 0;
-                m_requestedSitOffset = Vector3.Zero;
+                return true;
             }
 
-        }
 
-        public void SitRayCastCameraPosition(SceneObjectPart part)
-        {
-            // Next, try to raycast from the camera position
-            Vector3 EndRayCastPosition = part.AbsolutePosition + m_requestedSitOffset;
-            Vector3 StartRayCastPosition = CameraPosition;
-            Vector3 direction = Vector3.Normalize(EndRayCastPosition - StartRayCastPosition);
-            float distance = Vector3.Distance(EndRayCastPosition, StartRayCastPosition);
-            m_scene.PhysicsScene.RaycastWorld(StartRayCastPosition, direction, distance, SitRayCastCameraPositionResponse);
-        }
+            // not doing autopilot
+            m_requestedSitTargetID = 0; 
 
-        public void SitRayCastCameraPositionResponse(bool hitYN, Vector3 collisionPoint, uint localid, float pdistance, Vector3 normal)
-        {
-            SceneObjectPart part = FindNextAvailableSitTarget(m_requestedSitTargetUUID);
-            if (part != null)
-            {
-                if (hitYN)
-                {
-                    if (collisionPoint.ApproxEquals(m_requestedSitOffset + part.AbsolutePosition, 0.2f))
-                    {
-                        SitRaycastFindEdge(collisionPoint, normal);
-                        m_log.DebugFormat("[SIT]: Raycast Camera Position succeeded at point: {0}, normal:{1}", collisionPoint, normal);
-                    }
-                    else
-                    {
-                        SitRayHorizontal(part);
-                    }
-                }
-                else
-                {
-                    SitRayHorizontal(part);
-                }
-            }
-            else
-            {
-                ControllingClient.SendAlertMessage("Sit position no longer exists");
-                m_requestedSitTargetUUID = UUID.Zero;
-                m_requestedSitTargetID = 0;
-                m_requestedSitOffset = Vector3.Zero;
-            }
+            if (m_scene.PhysicsScene.SitAvatar(part.PhysActor, AbsolutePosition, CameraPosition, offset, new Vector3(0.35f, 0, 0.65f), PhysicsSitResponse) != 0)
+                return true;
 
+            return false;
         }
 
-        public void SitRayHorizontal(SceneObjectPart part)
+
+        private bool CanEnterLandPosition(Vector3 testPos)
         {
-            // Next, try to raycast from the avatar position to fwd
-            Vector3 EndRayCastPosition = part.AbsolutePosition + m_requestedSitOffset;
-            Vector3 StartRayCastPosition = CameraPosition;
-            Vector3 direction = Vector3.Normalize(EndRayCastPosition - StartRayCastPosition);
-            float distance = Vector3.Distance(EndRayCastPosition, StartRayCastPosition);
-            m_scene.PhysicsScene.RaycastWorld(StartRayCastPosition, direction, distance, SitRayCastHorizontalResponse);
+            ILandObject land = m_scene.LandChannel.GetLandObject(testPos.X, testPos.Y);
+
+            if (land == null || land.LandData.Name == "NO_LAND")
+                return true;
+
+            return land.CanBeOnThisLand(UUID,testPos.Z);
         }
 
-        public void SitRayCastHorizontalResponse(bool hitYN, Vector3 collisionPoint, uint localid, float pdistance, Vector3 normal)
+        // status
+        //          < 0 ignore
+        //          0   bad sit spot
+        public void PhysicsSitResponse(int status, uint partID, Vector3 offset, Quaternion Orientation)
         {
-            SceneObjectPart part = FindNextAvailableSitTarget(m_requestedSitTargetUUID);
-            if (part != null)
+            if (status < 0)
+                return;
+
+            if (status == 0)
             {
-                if (hitYN)
-                {
-                    if (collisionPoint.ApproxEquals(m_requestedSitOffset + part.AbsolutePosition, 0.2f))
-                    {
-                        SitRaycastFindEdge(collisionPoint, normal);
-                        m_log.DebugFormat("[SIT]: Raycast Horizontal Position succeeded at point: {0}, normal:{1}", collisionPoint, normal);
-                        // Next, try to raycast from the camera position
-                        Vector3 EndRayCastPosition = part.AbsolutePosition + m_requestedSitOffset;
-                        Vector3 StartRayCastPosition = CameraPosition;
-                        Vector3 direction = Vector3.Normalize(EndRayCastPosition - StartRayCastPosition);
-                        float distance = Vector3.Distance(EndRayCastPosition, StartRayCastPosition);
-                        //m_scene.PhysicsScene.RaycastWorld(StartRayCastPosition, direction, distance, SitRayCastResponseAvatarPosition);
-                    }
-                    else
-                    {
-                        ControllingClient.SendAlertMessage("Sit position not accessable.");
-                        m_requestedSitTargetUUID = UUID.Zero;
-                        m_requestedSitTargetID = 0;
-                        m_requestedSitOffset = Vector3.Zero;
-                    }
-                }
-                else
-                {
-                    ControllingClient.SendAlertMessage("Sit position not accessable.");
-                    m_requestedSitTargetUUID = UUID.Zero;
-                    m_requestedSitTargetID = 0;
-                    m_requestedSitOffset = Vector3.Zero;
-                }
+                ControllingClient.SendAlertMessage(" There is no suitable surface to sit on, try another spot.");
+                return;
             }
-            else
+
+            SceneObjectPart part = m_scene.GetSceneObjectPart(partID);
+            if (part == null)
+                return;
+
+            Vector3 targetPos = part.GetWorldPosition() + offset * part.GetWorldRotation();     
+            if(!CanEnterLandPosition(targetPos))
             {
-                ControllingClient.SendAlertMessage("Sit position no longer exists");
-                m_requestedSitTargetUUID = UUID.Zero;
-                m_requestedSitTargetID = 0;
-                m_requestedSitOffset = Vector3.Zero;
+                ControllingClient.SendAlertMessage(" Sit position on restricted land, try another spot");
+                return;
             }
 
-        }
+            RemoveFromPhysicalScene();
 
-        private void SitRaycastFindEdge(Vector3 collisionPoint, Vector3 collisionNormal)
-        {
-            int i = 0;
-            //throw new NotImplementedException();
-            //m_requestedSitTargetUUID = UUID.Zero;
-            //m_requestedSitTargetID = 0;
-            //m_requestedSitOffset = Vector3.Zero;
+            if (MovingToTarget)
+                ResetMoveToTarget();
+
+            Velocity = Vector3.Zero;
+
+            part.AddSittingAvatar(UUID);
 
-            SendSitResponse(ControllingClient, m_requestedSitTargetUUID, collisionPoint - m_requestedSitOffset, Quaternion.Identity);
+            Vector3 cameraAtOffset = part.GetCameraAtOffset();
+            Vector3 cameraEyeOffset = part.GetCameraEyeOffset();
+            bool forceMouselook = part.GetForceMouselook();
+
+            ControllingClient.SendSitResponse(
+                part.UUID, offset, Orientation, false, cameraAtOffset, cameraEyeOffset, forceMouselook);
+
+            // not using autopilot
+
+            Rotation = Orientation;
+            m_pos = offset;
+
+            m_requestedSitTargetID = 0;
+            part.ParentGroup.AddAvatar(UUID);
+
+            ParentPart = part;
+            ParentID = part.LocalId;
+            if(status == 3)
+                Animator.TrySetMovementAnimation("SIT_GROUND");
+            else
+                Animator.TrySetMovementAnimation("SIT");
+            SendAvatarDataToAllAgents();
+
+            part.ParentGroup.TriggerScriptChangedEvent(Changed.LINK);
         }
-        */
+
 
         public void HandleAgentSit(IClientAPI remoteClient, UUID agentID)
         {
@@ -2411,6 +2576,7 @@ namespace OpenSim.Region.Framework.Scenes
                     return;
                 }
 
+
                 if (part.SitTargetAvatar == UUID)
                 {
                     Vector3 sitTargetPos = part.SitTargetPosition;
@@ -2425,14 +2591,39 @@ namespace OpenSim.Region.Framework.Scenes
 
                     //Quaternion result = (sitTargetOrient * vq) * nq;
 
-                    m_pos = sitTargetPos + SIT_TARGET_ADJUSTMENT;
+                    double x, y, z, m;
+
+                    Quaternion r = sitTargetOrient;
+                    m = r.X * r.X + r.Y * r.Y + r.Z * r.Z + r.W * r.W;
+
+                    if (Math.Abs(1.0 - m) > 0.000001)
+                    {
+                        m = 1.0 / Math.Sqrt(m);
+                        r.X *= (float)m;
+                        r.Y *= (float)m;
+                        r.Z *= (float)m;
+                        r.W *= (float)m;
+                    }
+
+                    x = 2 * (r.X * r.Z + r.Y * r.W);
+                    y = 2 * (-r.X * r.W + r.Y * r.Z);
+                    z = -r.X * r.X - r.Y * r.Y + r.Z * r.Z + r.W * r.W;
+
+                    Vector3 up = new Vector3((float)x, (float)y, (float)z);
+                    Vector3 sitOffset = up * Appearance.AvatarHeight * 0.02638f;
+
+                    m_pos = sitTargetPos + sitOffset + SIT_TARGET_ADJUSTMENT;
+
+//                    m_pos = sitTargetPos + SIT_TARGET_ADJUSTMENT - sitOffset;
                     Rotation = sitTargetOrient;
-                    ParentPosition = part.AbsolutePosition;
+//                    ParentPosition = part.AbsolutePosition;
+                    part.ParentGroup.AddAvatar(UUID);
                 }
                 else
                 {
                     m_pos -= part.AbsolutePosition;
-                    ParentPosition = 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",
@@ -2487,6 +2678,13 @@ namespace OpenSim.Region.Framework.Scenes
             TriggerScenePresenceUpdated();
         }
 
+        public void avnHandleChangeAnim(UUID animID, bool addRemove,bool sendPack)
+        {
+            Animator.avnChangeAnim(animID, addRemove, sendPack);
+        }
+
+
+
         /// <summary>
         /// Rotate the avatar to the given rotation and apply a movement in the given relative vector
         /// </summary>
@@ -2543,8 +2741,8 @@ namespace OpenSim.Region.Framework.Scenes
                         direc.Z *= 2.6f;
 
                         // TODO: PreJump and jump happen too quickly.  Many times prejump gets ignored.
-                        Animator.TrySetMovementAnimation("PREJUMP");
-                        Animator.TrySetMovementAnimation("JUMP");
+//                        Animator.TrySetMovementAnimation("PREJUMP");
+//                        Animator.TrySetMovementAnimation("JUMP");
                     }
                 }
             }
@@ -2553,6 +2751,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             // TODO: Add the force instead of only setting it to support multiple forces per frame?
             m_forceToApply = direc;
+            Animator.UpdateMovementAnimations();
         }
 
         #endregion
@@ -2570,16 +2769,12 @@ namespace OpenSim.Region.Framework.Scenes
                 // NOTE: Velocity is not the same as m_velocity. Velocity will attempt to
                 // grab the latest PhysicsActor velocity, whereas m_velocity is often
                 // storing a requested force instead of an actual traveling velocity
+                if (Appearance.AvatarSize != m_lastSize && !IsLoggingIn)
+                    SendAvatarDataToAllAgents();
 
-                // Throw away duplicate or insignificant updates
-                if (
-                    // If the velocity has become zero, send it no matter what.
-                       (Velocity != m_lastVelocity && Velocity == Vector3.Zero)
-                    // otherwise, if things have changed reasonably, send the update
-                    || (!Rotation.ApproxEquals(m_lastRotation, ROTATION_TOLERANCE)
-                        || !Velocity.ApproxEquals(m_lastVelocity, VELOCITY_TOLERANCE)
-                        || !m_pos.ApproxEquals(m_lastPosition, POSITION_TOLERANCE)))
-
+                if (!Rotation.ApproxEquals(m_lastRotation, ROTATION_TOLERANCE) ||
+                    !Velocity.ApproxEquals(m_lastVelocity, VELOCITY_TOLERANCE) ||
+                    !m_pos.ApproxEquals(m_lastPosition, POSITION_TOLERANCE))
                 {
                     SendTerseUpdateToAllClients();
 
@@ -2738,9 +2933,7 @@ namespace OpenSim.Region.Framework.Scenes
             // again here... this comes after the cached appearance check because the avatars
             // appearance goes into the avatar update packet
             SendAvatarDataToAllAgents();
-
-            // This invocation always shows up in the viewer logs as an error.
-            // SendAppearanceToAgent(this);
+            SendAppearanceToAgent(this);
 
             // If we are using the the cached appearance then send it out to everyone
             if (cachedappearance)
@@ -2771,6 +2964,8 @@ namespace OpenSim.Region.Framework.Scenes
                 return;
             }
 
+            m_lastSize = Appearance.AvatarSize;
+
             int count = 0;
             m_scene.ForEachScenePresence(delegate(ScenePresence scenePresence)
                                          {
@@ -2878,6 +3073,8 @@ namespace OpenSim.Region.Framework.Scenes
 
             avatar.ControllingClient.SendAppearance(
                 UUID, Appearance.VisualParams, Appearance.Texture.GetBytes());
+
+            
         }
 
         #endregion
@@ -2952,8 +3149,9 @@ namespace OpenSim.Region.Framework.Scenes
 
             // If we don't have a PhysActor, we can't cross anyway
             // Also don't do this while sat, sitting avatars cross with the
-            // object they sit on.
-            if (ParentID != 0 || PhysicsActor == null)
+            // object they sit on. ParentUUID denoted a pending sit, don't
+            // interfere with it.
+            if (ParentID != 0 || PhysicsActor == null || ParentUUID != UUID.Zero)
                 return;
 
             if (!IsInTransit)
@@ -3220,6 +3418,10 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         private static Vector3 marker = new Vector3(-1f, -1f, -1f);
+        private void RaiseUpdateThrottles()
+        {
+            m_scene.EventManager.TriggerThrottleUpdate(this);
+        }
         /// <summary>
         /// This updates important decision making data about a child agent
         /// The main purpose is to figure out what objects to send to a child agent that's in a neighboring region
@@ -3301,6 +3503,9 @@ namespace OpenSim.Region.Framework.Scenes
             cAgent.AlwaysRun = SetAlwaysRun;
 
             cAgent.Appearance = new AvatarAppearance(Appearance);
+
+            cAgent.ParentPart = ParentUUID;
+            cAgent.SitOffset = m_pos;
             
             lock (scriptedcontrols)
             {
@@ -3309,7 +3514,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                 foreach (ScriptControllers c in scriptedcontrols.Values)
                 {
-                    controls[i++] = new ControllerData(c.itemID, (uint)c.ignoreControls, (uint)c.eventControls);
+                    controls[i++] = new ControllerData(c.objectID, c.itemID, (uint)c.ignoreControls, (uint)c.eventControls);
                 }
                 cAgent.Controllers = controls;
             }
@@ -3342,6 +3547,8 @@ namespace OpenSim.Region.Framework.Scenes
             CameraAtAxis = cAgent.AtAxis;
             CameraLeftAxis = cAgent.LeftAxis;
             CameraUpAxis = cAgent.UpAxis;
+            ParentUUID = cAgent.ParentPart;
+            m_prevSitOffset = cAgent.SitOffset;
 
             // When we get to the point of re-computing neighbors everytime this
             // changes, then start using the agent's drawdistance rather than the 
@@ -3379,6 +3586,7 @@ namespace OpenSim.Region.Framework.Scenes
                         foreach (ControllerData c in cAgent.Controllers)
                         {
                             ScriptControllers sc = new ScriptControllers();
+                            sc.objectID = c.ObjectID;
                             sc.itemID = c.ItemID;
                             sc.ignoreControls = (ScriptControlled)c.IgnoreControls;
                             sc.eventControls = (ScriptControlled)c.EventControls;
@@ -3446,20 +3654,27 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             if (Appearance.AvatarHeight == 0)
-                Appearance.SetHeight();
+//                Appearance.SetHeight();
+                Appearance.SetSize(new Vector3(0.45f,0.6f,1.9f));
 
             PhysicsScene scene = m_scene.PhysicsScene;
 
             Vector3 pVec = AbsolutePosition;
 
+/*
             PhysicsActor = scene.AddAvatar(
                 LocalId, Firstname + "." + Lastname, pVec,
-                new Vector3(0f, 0f, Appearance.AvatarHeight), isFlying);
+                new Vector3(0.45f, 0.6f, Appearance.AvatarHeight), isFlying);
+*/
+
+            PhysicsActor = scene.AddAvatar(
+                LocalId, Firstname + "." + Lastname, pVec,
+                Appearance.AvatarBoxSize,Appearance.AvatarFeetOffset, isFlying);
 
             //PhysicsActor.OnRequestTerseUpdate += SendTerseUpdateToAllClients;
             PhysicsActor.OnCollisionUpdate += PhysicsCollisionUpdate;
             PhysicsActor.OnOutOfBounds += OutOfBoundsCall; // Called for PhysicsActors when there's something wrong
-            PhysicsActor.SubscribeEvents(500);
+            PhysicsActor.SubscribeEvents(100);
             PhysicsActor.LocalID = LocalId;
         }
 
@@ -3473,6 +3688,7 @@ namespace OpenSim.Region.Framework.Scenes
                 ControllingClient.SendAgentAlertMessage("Physics is having a problem with your avatar.  You may not be able to move until you relog.", true);
         }
 
+
         /// <summary>
         /// Event called by the physics plugin to tell the avatar about a collision.
         /// </summary>
@@ -3486,7 +3702,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="e"></param>
         public void PhysicsCollisionUpdate(EventArgs e)
         {
-            if (IsChildAgent)
+            if (IsChildAgent || Animator == null)
                 return;
             
             //if ((Math.Abs(Velocity.X) > 0.1e-9f) || (Math.Abs(Velocity.Y) > 0.1e-9f))
@@ -3503,7 +3719,6 @@ namespace OpenSim.Region.Framework.Scenes
             CollisionEventUpdate collisionData = (CollisionEventUpdate)e;
             Dictionary<uint, ContactPoint> coldata = collisionData.m_objCollisionList;
 
-            CollisionPlane = Vector4.UnitW;
 
 //            // No collisions at all means we may be flying. Update always
 //            // to make falling work
@@ -3515,6 +3730,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (coldata.Count != 0)
             {
+/*
                 switch (Animator.CurrentMovementAnimation)
                 {
                     case "STAND":
@@ -3523,24 +3739,38 @@ namespace OpenSim.Region.Framework.Scenes
                     case "CROUCH":
                     case "CROUCHWALK":
                         {
+ */
                             ContactPoint lowest;
                             lowest.SurfaceNormal = Vector3.Zero;
                             lowest.Position = Vector3.Zero;
-                            lowest.Position.Z = Single.NaN;
+                            lowest.Position.Z = float.MaxValue;
 
                             foreach (ContactPoint contact in coldata.Values)
                             {
-                                if (Single.IsNaN(lowest.Position.Z) || contact.Position.Z < lowest.Position.Z)
+                                
+                                if (contact.CharacterFeet && contact.Position.Z < lowest.Position.Z)
                                 {
                                     lowest = contact;
                                 }
                             }
 
-                            CollisionPlane = new Vector4(-lowest.SurfaceNormal, -Vector3.Dot(lowest.Position, lowest.SurfaceNormal));
+                            if (lowest.Position.Z != float.MaxValue)
+                            {
+                                lowest.SurfaceNormal = -lowest.SurfaceNormal;
+                                CollisionPlane = new Vector4(lowest.SurfaceNormal, Vector3.Dot(lowest.Position, lowest.SurfaceNormal));
+                            }
+                            else
+                                CollisionPlane = Vector4.UnitW;
+/*
                         }
                         break;
                 }
+*/
             }
+            else
+                CollisionPlane = Vector4.UnitW;
+
+            RaiseCollisionScriptEvents(coldata);
 
             // Gods do not take damage and Invulnerable is set depending on parcel/region flags
             if (Invulnerable || GodLevel > 0)
@@ -3639,6 +3869,13 @@ namespace OpenSim.Region.Framework.Scenes
             // m_reprioritizationTimer.Dispose(); 
 
             RemoveFromPhysicalScene();
+          
+            m_scene.EventManager.OnRegionHeartbeatEnd -= RegionHeartbeatEnd;
+
+//            if (Animator != null)
+//                Animator.Close();
+            Animator = null;
+
         }
 
         public void AddAttachment(SceneObjectGroup gobj)
@@ -3872,10 +4109,18 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void RegisterControlEventsToScript(int controls, int accept, int pass_on, uint Obj_localID, UUID Script_item_UUID)
         {
+            SceneObjectPart p = m_scene.GetSceneObjectPart(Obj_localID);
+            if (p == null)
+                return;
+
+            ControllingClient.SendTakeControls(controls, false, false);
+            ControllingClient.SendTakeControls(controls, true, false);
+
             ScriptControllers obj = new ScriptControllers();
             obj.ignoreControls = ScriptControlled.CONTROL_ZERO;
             obj.eventControls = ScriptControlled.CONTROL_ZERO;
 
+            obj.objectID = p.ParentGroup.UUID;
             obj.itemID = Script_item_UUID;
             if (pass_on == 0 && accept == 0)
             {
@@ -3924,6 +4169,21 @@ namespace OpenSim.Region.Framework.Scenes
             ControllingClient.SendTakeControls(int.MaxValue, false, false);
         }
 
+        private void UnRegisterSeatControls(UUID obj)
+        {
+            List<UUID> takers = new List<UUID>();
+
+            foreach (ScriptControllers c in scriptedcontrols.Values)
+            {
+                if (c.objectID == obj)
+                    takers.Add(c.itemID);
+            }
+            foreach (UUID t in takers)
+            {
+                UnRegisterControlEventsToScript(0, t);
+            }
+        }
+
         public void UnRegisterControlEventsToScript(uint Obj_localID, UUID Script_item_UUID)
         {
             ScriptControllers takecontrols;
@@ -4253,6 +4513,12 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void CheckAndAdjustLandingPoint(ref Vector3 pos)
         {
+            string reason;
+
+            // Honor bans
+            if (!m_scene.TestLandRestrictions(UUID, out reason, ref pos.X, ref pos.Y))
+                return;
+
             SceneObjectGroup telehub = null;
             if (m_scene.RegionInfo.RegionSettings.TelehubObject != UUID.Zero && (telehub = m_scene.GetSceneObjectGroup(m_scene.RegionInfo.RegionSettings.TelehubObject)) != null)
             {
@@ -4292,11 +4558,206 @@ namespace OpenSim.Region.Framework.Scenes
                         pos = land.LandData.UserLocation;
                     }
                 }
-
+                
                 land.SendLandUpdateToClient(ControllingClient);
             }
         }
 
+        private DetectedObject CreateDetObject(SceneObjectPart obj)
+        {
+            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;
+
+            return detobj;
+        }
+
+        private DetectedObject CreateDetObject(ScenePresence av)
+        {
+            DetectedObject detobj = new DetectedObject();
+            detobj.keyUUID = av.UUID;
+            detobj.nameStr = av.ControllingClient.Name;
+            detobj.ownerUUID = av.UUID;
+            detobj.posVector = av.AbsolutePosition;
+            detobj.rotQuat = av.Rotation;
+            detobj.velVector = av.Velocity;
+            detobj.colliderType = 0;
+            detobj.groupUUID = av.ControllingClient.ActiveGroupId;
+
+            return detobj;
+        }
+
+        private DetectedObject CreateDetObjectForGround()
+        {
+            DetectedObject detobj = new DetectedObject();
+            detobj.keyUUID = UUID.Zero;
+            detobj.nameStr = "";
+            detobj.ownerUUID = UUID.Zero;
+            detobj.posVector = AbsolutePosition;
+            detobj.rotQuat = Quaternion.Identity;
+            detobj.velVector = Vector3.Zero;
+            detobj.colliderType = 0;
+            detobj.groupUUID = UUID.Zero;
+
+            return detobj;
+        }
+
+        private ColliderArgs CreateColliderArgs(SceneObjectPart dest, List<uint> colliders)
+        {
+            ColliderArgs colliderArgs = new ColliderArgs();
+            List<DetectedObject> colliding = new List<DetectedObject>();
+            foreach (uint localId in colliders)
+            {
+                if (localId == 0)
+                    continue;
+
+                SceneObjectPart obj = m_scene.GetSceneObjectPart(localId);
+                if (obj != null)
+                {
+                    if (!dest.CollisionFilteredOut(obj.UUID, obj.Name))
+                        colliding.Add(CreateDetObject(obj));
+                }
+                else
+                {
+                    ScenePresence av = m_scene.GetScenePresence(localId);
+                    if (av != null && (!av.IsChildAgent))
+                    {
+                        if (!dest.CollisionFilteredOut(av.UUID, av.Name))
+                            colliding.Add(CreateDetObject(av));
+                    }
+                }
+            }
+
+            colliderArgs.Colliders = colliding;
+
+            return colliderArgs;
+        }
+
+        private delegate void ScriptCollidingNotification(uint localID, ColliderArgs message);
+
+        private void SendCollisionEvent(SceneObjectGroup dest, scriptEvents ev, List<uint> colliders, ScriptCollidingNotification notify)
+        {
+            ColliderArgs CollidingMessage;
+
+            if (colliders.Count > 0)
+            {
+                if ((dest.RootPart.ScriptEvents & ev) != 0)
+                {
+                    CollidingMessage = CreateColliderArgs(dest.RootPart, colliders);
+
+                    if (CollidingMessage.Colliders.Count > 0)
+                        notify(dest.RootPart.LocalId, CollidingMessage);
+                }
+            }
+        }
+
+        private void SendLandCollisionEvent(SceneObjectGroup dest, scriptEvents ev, ScriptCollidingNotification notify)
+        {
+            if ((dest.RootPart.ScriptEvents & ev) != 0)
+            {
+                ColliderArgs LandCollidingMessage = new ColliderArgs();
+                List<DetectedObject> colliding = new List<DetectedObject>();
+
+                colliding.Add(CreateDetObjectForGround());
+                LandCollidingMessage.Colliders = colliding;
+
+                notify(dest.RootPart.LocalId, LandCollidingMessage);
+            }
+        }
+
+        private void RaiseCollisionScriptEvents(Dictionary<uint, ContactPoint> coldata)
+        {
+            try
+            {
+                List<uint> thisHitColliders = new List<uint>();
+                List<uint> endedColliders = new List<uint>();
+                List<uint> startedColliders = new List<uint>();
+                List<CollisionForSoundInfo> soundinfolist = new List<CollisionForSoundInfo>();
+                CollisionForSoundInfo soundinfo;
+                ContactPoint curcontact;
+
+                if (coldata.Count == 0)
+                {
+                    if (m_lastColliders.Count == 0)
+                        return; // nothing to do
+
+                    foreach (uint localID in m_lastColliders)
+                    {
+                        endedColliders.Add(localID);
+                    }
+                    m_lastColliders.Clear();
+                }
+
+                else
+                {
+                    foreach (uint id in coldata.Keys)
+                    {
+                        thisHitColliders.Add(id);
+                        if (!m_lastColliders.Contains(id))
+                        {
+                            startedColliders.Add(id);
+                            curcontact = coldata[id];
+                            if (Math.Abs(curcontact.RelativeSpeed) > 0.2)
+                            {
+                                soundinfo = new CollisionForSoundInfo();
+                                soundinfo.colliderID = id;
+                                soundinfo.position = curcontact.Position;
+                                soundinfo.relativeVel = curcontact.RelativeSpeed;
+                                soundinfolist.Add(soundinfo);
+                            }
+                        }
+                        //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);
+                    }
+
+                    if (soundinfolist.Count > 0)
+                        CollisionSounds.AvatarCollisionSound(this, soundinfolist);
+                }
+
+                foreach (SceneObjectGroup att in GetAttachments())
+                {
+                    SendCollisionEvent(att, scriptEvents.collision_start, startedColliders, m_scene.EventManager.TriggerScriptCollidingStart);
+                    SendCollisionEvent(att, scriptEvents.collision      , m_lastColliders , m_scene.EventManager.TriggerScriptColliding);
+                    SendCollisionEvent(att, scriptEvents.collision_end  , endedColliders  , m_scene.EventManager.TriggerScriptCollidingEnd);
+
+                    if (startedColliders.Contains(0))
+                        SendLandCollisionEvent(att, scriptEvents.land_collision_start, m_scene.EventManager.TriggerScriptLandCollidingStart);
+                    if (m_lastColliders.Contains(0))
+                        SendLandCollisionEvent(att, scriptEvents.land_collision, m_scene.EventManager.TriggerScriptLandColliding);
+                    if (endedColliders.Contains(0))
+                        SendLandCollisionEvent(att, scriptEvents.land_collision_end, m_scene.EventManager.TriggerScriptLandCollidingEnd);
+                }
+            }
+            finally
+            {
+                m_collisionEventFlag = false;
+            }
+        }
+
         private void TeleportFlagsDebug() {
     
             // Some temporary debugging help to show all the TeleportFlags we have...
@@ -4321,6 +4782,5 @@ namespace OpenSim.Region.Framework.Scenes
             m_log.InfoFormat("[SCENE PRESENCE]: TELEPORT ******************");
     
         }
-
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index 945745e..68918d3 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -374,11 +374,21 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             m_SOPXmlProcessors.Add("PayPrice3", ProcessPayPrice3);
             m_SOPXmlProcessors.Add("PayPrice4", ProcessPayPrice4);
 
+            m_SOPXmlProcessors.Add("Buoyancy", ProcessBuoyancy);
+            m_SOPXmlProcessors.Add("Force", ProcessForce);
+            m_SOPXmlProcessors.Add("Torque", ProcessTorque);
+            m_SOPXmlProcessors.Add("VolumeDetectActive", ProcessVolumeDetectActive);
+
+
+            m_SOPXmlProcessors.Add("Vehicle", ProcessVehicle);
+
             m_SOPXmlProcessors.Add("PhysicsShapeType", ProcessPhysicsShapeType);
             m_SOPXmlProcessors.Add("Density", ProcessDensity);
             m_SOPXmlProcessors.Add("Friction", ProcessFriction);
             m_SOPXmlProcessors.Add("Bounce", ProcessBounce);
             m_SOPXmlProcessors.Add("GravityModifier", ProcessGravityModifier);
+            m_SOPXmlProcessors.Add("CameraEyeOffset", ProcessCameraEyeOffset);
+            m_SOPXmlProcessors.Add("CameraAtOffset", ProcessCameraAtOffset);
 
             #endregion
 
@@ -407,7 +417,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             m_TaskInventoryXmlProcessors.Add("PermsMask", ProcessTIPermsMask);
             m_TaskInventoryXmlProcessors.Add("Type", ProcessTIType);
             m_TaskInventoryXmlProcessors.Add("OwnerChanged", ProcessTIOwnerChanged);
-            
+
             #endregion
 
             #region ShapeXmlProcessors initialization
@@ -632,6 +642,33 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             obj.GravityModifier = reader.ReadElementContentAsFloat("GravityModifier", String.Empty);
         }
 
+        private static void ProcessCameraEyeOffset(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.SetCameraEyeOffset(Util.ReadVector(reader, "CameraEyeOffset"));
+        }
+
+        private static void ProcessCameraAtOffset(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.SetCameraAtOffset(Util.ReadVector(reader, "CameraAtOffset"));
+        }
+
+        private static void ProcessVehicle(SceneObjectPart obj, XmlTextReader reader)
+        {
+            SOPVehicle vehicle = SOPVehicle.FromXml2(reader);
+
+            if (vehicle == null)
+            {
+                obj.VehicleParams = null;
+                m_log.DebugFormat(
+                    "[SceneObjectSerializer]: Parsing Vehicle for object part {0} {1} encountered errors.  Please see earlier log entries.",
+                    obj.Name, obj.UUID);
+            }
+            else
+            {
+                obj.VehicleParams = vehicle;
+            }
+        }
+                   
         private static void ProcessShape(SceneObjectPart obj, XmlTextReader reader)
         {
             List<string> errorNodeNames;
@@ -801,6 +838,25 @@ 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 = (float)reader.ReadElementContentAsFloat("Buoyancy", String.Empty);
+        }
+
+        private static void ProcessForce(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Force = Util.ReadVector(reader, "Force");
+        }
+        private static void ProcessTorque(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Torque = Util.ReadVector(reader, "Torque");
+        }
+
+        private static void ProcessVolumeDetectActive(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.VolumeDetectActive = Util.ReadBoolean(reader);
+        }
+
         #endregion
 
         #region TaskInventoryXmlProcessors
@@ -1191,7 +1247,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
             if (sog.RootPart.KeyframeMotion != null)
             {
-                Byte[] data = sog.RootPart.KeyframeMotion.Serialize();
+                Byte[] data = sog.RootPart.KeyframeMotion.Serialize();               
 
                 writer.WriteStartElement(String.Empty, "KeyframeMotion", String.Empty);
                 writer.WriteBase64(data, 0, data.Length);
@@ -1305,6 +1361,16 @@ 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());
+
+            WriteVector(writer, "Force", sop.Force);
+            WriteVector(writer, "Torque", sop.Torque);
+
+            writer.WriteElementString("VolumeDetectActive", sop.VolumeDetectActive.ToString().ToLower());
+
+            if (sop.VehicleParams != null)
+                sop.VehicleParams.ToXml2(writer);
+
             if(sop.PhysicsShapeType != sop.DefaultPhysicsShapeType())
                 writer.WriteElementString("PhysicsShapeType", sop.PhysicsShapeType.ToString().ToLower());
             if (sop.Density != 1000.0f)
@@ -1315,6 +1381,8 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                 writer.WriteElementString("Bounce", sop.Restitution.ToString().ToLower());
             if (sop.GravityModifier != 1.0f)
                 writer.WriteElementString("GravityModifier", sop.GravityModifier.ToString().ToLower());
+            WriteVector(writer, "CameraEyeOffset", sop.GetCameraEyeOffset());
+            WriteVector(writer, "CameraAtOffset", sop.GetCameraAtOffset());
 
             writer.WriteEndElement();
         }
@@ -1540,12 +1608,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")
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index 95f9caf..bf32251 100644
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -175,7 +175,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         // saved last reported value so there is something available for llGetRegionFPS 
         private float lastReportedSimFPS;
-        private float[] lastReportedSimStats = new float[22];
+        private float[] lastReportedSimStats = new float[23];
         private float m_pfps;
 
         /// <summary>
@@ -189,12 +189,13 @@ namespace OpenSim.Region.Framework.Scenes
         private int m_objectUpdates;
 
         private int m_frameMS;
-        private int m_spareMS;
+
         private int m_netMS;
         private int m_agentMS;
         private int m_physicsMS;
         private int m_imageMS;
         private int m_otherMS;
+        private int m_sleeptimeMS;
 
 //Ckrinke: (3-21-08) Comment out to remove a compiler warning. Bring back into play when needed.
 //Ckrinke        private int m_scriptMS = 0;
@@ -292,7 +293,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (!m_scene.Active)
                 return;
 
-            SimStatsPacket.StatBlock[] sb = new SimStatsPacket.StatBlock[22];
+            SimStatsPacket.StatBlock[] sb = new SimStatsPacket.StatBlock[23];
             SimStatsPacket.RegionBlock rb = new SimStatsPacket.RegionBlock();
             
             // Know what's not thread safe in Mono... modifying timers.
@@ -330,6 +331,35 @@ namespace OpenSim.Region.Framework.Scenes
                     physfps = 0;
 
 #endregion
+                float factor = 1 / m_statsUpdateFactor;
+
+                if (reportedFPS <= 0)
+                    reportedFPS = 1;
+
+                float perframe = 1.0f / (float)reportedFPS;
+
+                float TotalFrameTime = m_frameMS * perframe;
+
+                float targetframetime = 1100.0f / (float)m_nominalReportedFps;
+
+                float sparetime;
+                float sleeptime;
+
+                if (TotalFrameTime > targetframetime)
+                {
+                    sparetime = 0;
+                    sleeptime = 0;
+                }
+                else
+                {
+                    sparetime = m_frameMS - m_physicsMS - m_agentMS;
+                    sparetime *= perframe;
+                    if (sparetime < 0)
+                        sparetime = 0;
+                    else if (sparetime > TotalFrameTime)
+                        sparetime = TotalFrameTime;
+                    sleeptime = m_sleeptimeMS * perframe;
+                }
 
                 m_rootAgents = m_scene.SceneGraph.GetRootAgentCount();
                 m_childAgents = m_scene.SceneGraph.GetChildAgentCount();
@@ -341,25 +371,15 @@ namespace OpenSim.Region.Framework.Scenes
                 // so that stat numbers are always consistent.
                 CheckStatSanity();
                 
-                //Our time dilation is 0.91 when we're running a full speed,
-                // therefore to make sure we get an appropriate range,
-                // we have to factor in our error.   (0.10f * statsUpdateFactor)
-                // multiplies the fix for the error times the amount of times it'll occur a second
-                // / 10 divides the value by the number of times the sim heartbeat runs (10fps)
-                // Then we divide the whole amount by the amount of seconds pass in between stats updates.
-
-                // 'statsUpdateFactor' is how often stats packets are sent in seconds. Used below to change
-                // values to X-per-second values.
+                // other MS is actually simulation time
+                //                m_otherMS = m_frameMS - m_physicsMS - m_imageMS - m_netMS - m_agentMS;
+                // m_imageMS  m_netMS are not included in m_frameMS
 
-                uint thisFrame = m_scene.Frame;
-                float framesUpdated = (float)(thisFrame - m_lastUpdateFrame) * m_reportedFpsCorrectionFactor;
-                m_lastUpdateFrame = thisFrame;
+                m_otherMS = m_frameMS - m_physicsMS -  m_agentMS - m_sleeptimeMS;
+                if (m_otherMS < 0)
+                    m_otherMS = 0;
 
-                // Avoid div-by-zero if somehow we've not updated any frames.
-                if (framesUpdated == 0)
-                    framesUpdated = 1;
-
-                for (int i = 0; i < 22; i++)
+                for (int i = 0; i < 23; i++)
                 {
                     sb[i] = new SimStatsPacket.StatBlock();
                 }
@@ -389,19 +409,19 @@ namespace OpenSim.Region.Framework.Scenes
                 sb[7].StatValue = m_activePrim;
 
                 sb[8].StatID = (uint)Stats.FrameMS;
-                sb[8].StatValue = m_frameMS / framesUpdated;
+                sb[8].StatValue = TotalFrameTime;
 
                 sb[9].StatID = (uint)Stats.NetMS;
-                sb[9].StatValue = m_netMS / framesUpdated;
+                sb[9].StatValue = m_netMS * perframe;
 
                 sb[10].StatID = (uint)Stats.PhysicsMS;
-                sb[10].StatValue = m_physicsMS / framesUpdated;
+                sb[10].StatValue = m_physicsMS * perframe;
 
                 sb[11].StatID = (uint)Stats.ImageMS ;
-                sb[11].StatValue = m_imageMS / framesUpdated;
+                sb[11].StatValue = m_imageMS * perframe;
 
                 sb[12].StatID = (uint)Stats.OtherMS;
-                sb[12].StatValue = m_otherMS / framesUpdated;
+                sb[12].StatValue = m_otherMS * perframe;
 
                 sb[13].StatID = (uint)Stats.InPacketsPerSecond;
                 sb[13].StatValue = (m_inPacketsPerSecond / m_statsUpdateFactor);
@@ -413,7 +433,7 @@ namespace OpenSim.Region.Framework.Scenes
                 sb[15].StatValue = m_unAckedBytes;
 
                 sb[16].StatID = (uint)Stats.AgentMS;
-                sb[16].StatValue = m_agentMS / framesUpdated;
+                sb[16].StatValue = m_agentMS * perframe;
 
                 sb[17].StatID = (uint)Stats.PendingDownloads;
                 sb[17].StatValue = m_pendingDownloads;
@@ -428,7 +448,10 @@ namespace OpenSim.Region.Framework.Scenes
                 sb[20].StatValue = m_scriptLinesPerSecond / m_statsUpdateFactor;
 
                 sb[21].StatID = (uint)Stats.SimSpareMs;
-                sb[21].StatValue = m_spareMS / framesUpdated;
+                sb[21].StatValue = sparetime;
+
+                sb[22].StatID = (uint)Stats.SimSleepMs;
+                sb[22].StatValue = sleeptime;
 
                 for (int i = 0; i < 22; i++)
                 {
@@ -447,28 +470,32 @@ namespace OpenSim.Region.Framework.Scenes
                 }
 
                 // Extra statistics that aren't currently sent to clients
-                lock (m_lastReportedExtraSimStats)
+                if (m_scene.PhysicsScene != null)
                 {
-                    m_lastReportedExtraSimStats[LastReportedObjectUpdateStatName] = m_objectUpdates / m_statsUpdateFactor;
-                    m_lastReportedExtraSimStats[SlowFramesStat.ShortName] = (float)SlowFramesStat.Value;
-
-                    Dictionary<string, float> physicsStats = m_scene.PhysicsScene.GetStats();
-    
-                    if (physicsStats != null)
+                    lock (m_lastReportedExtraSimStats)
                     {
-                        foreach (KeyValuePair<string, float> tuple in physicsStats)
+                        m_lastReportedExtraSimStats[LastReportedObjectUpdateStatName] = m_objectUpdates / m_statsUpdateFactor;
+                        m_lastReportedExtraSimStats[SlowFramesStat.ShortName] = (float)SlowFramesStat.Value;
+
+                        Dictionary<string, float> physicsStats = m_scene.PhysicsScene.GetStats();
+        
+                        if (physicsStats != null)
                         {
-                            // FIXME: An extremely dirty hack to divide MS stats per frame rather than per second
-                            // Need to change things so that stats source can indicate whether they are per second or
-                            // per frame.
-                            if (tuple.Key.EndsWith("MS"))
-                                m_lastReportedExtraSimStats[tuple.Key] = tuple.Value / framesUpdated;
-                            else
-                                m_lastReportedExtraSimStats[tuple.Key] = tuple.Value / m_statsUpdateFactor;
+                            foreach (KeyValuePair<string, float> tuple in physicsStats)
+                            {
+                                // FIXME: An extremely dirty hack to divide MS stats per frame rather than per second
+                                // Need to change things so that stats source can indicate whether they are per second or
+                                // per frame.
+                                if (tuple.Key.EndsWith("MS"))
+                                    m_lastReportedExtraSimStats[tuple.Key] = tuple.Value * perframe;
+                                else
+                                    m_lastReportedExtraSimStats[tuple.Key] = tuple.Value / m_statsUpdateFactor;
+                            }
                         }
                     }
                 }
 
+//                LastReportedObjectUpdates = m_objectUpdates / m_statsUpdateFactor;
                 ResetValues();
             }
         }
@@ -491,7 +518,8 @@ namespace OpenSim.Region.Framework.Scenes
             m_physicsMS = 0;
             m_imageMS = 0;
             m_otherMS = 0;
-            m_spareMS = 0;
+//            m_spareMS = 0;
+            m_sleeptimeMS = 0;
 
 //Ckrinke This variable is not used, so comment to remove compiler warning until it is used.
 //Ckrinke            m_scriptMS = 0;
@@ -575,11 +603,6 @@ namespace OpenSim.Region.Framework.Scenes
                 SlowFramesStat.Value++;
         }
 
-        public void AddSpareMS(int ms)
-        {
-            m_spareMS += ms;
-        }
-
         public void addNetMS(int ms)
         {
             m_netMS += ms;
@@ -605,6 +628,11 @@ namespace OpenSim.Region.Framework.Scenes
             m_otherMS += ms;
         }
 
+        public void addSleepMS(int ms)
+        {
+            m_sleeptimeMS += ms;
+        }
+
         public void AddPendingDownloads(int count)
         {
             m_pendingDownloads += count;
diff --git a/OpenSim/Region/Framework/Scenes/TerrainChannel.cs b/OpenSim/Region/Framework/Scenes/TerrainChannel.cs
index c0ca48e..b6e0a97 100644
--- a/OpenSim/Region/Framework/Scenes/TerrainChannel.cs
+++ b/OpenSim/Region/Framework/Scenes/TerrainChannel.cs
@@ -131,7 +131,15 @@ namespace OpenSim.Region.Framework.Scenes
 
         public double this[int x, int y]
         {
-            get { return map[x, y]; }
+            get
+            {
+                if (x < 0) x = 0;
+                if (y < 0) y = 0;
+                if (x >= (int)Constants.RegionSize) x = (int)Constants.RegionSize - 1;
+                if (y >= (int)Constants.RegionSize) y = (int)Constants.RegionSize - 1;
+
+                return map[x, y];
+            }
             set
             {
                 // Will "fix" terrain hole problems. Although not fantastically.
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
index c264433..1182c96 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectResizeTests.cs
@@ -62,6 +62,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             Assert.That(g1Post.RootPart.Scale.X, Is.EqualTo(2));
             Assert.That(g1Post.RootPart.Scale.Y, Is.EqualTo(3));
             Assert.That(g1Post.RootPart.Scale.Z, Is.EqualTo(4));
+
+            Assert.That(g1Post.RootPart.UndoCount, Is.EqualTo(1));
         }
 
         /// <summary>
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUndoRedoTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUndoRedoTests.cs
deleted file mode 100644
index 4883ae7..0000000
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUndoRedoTests.cs
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-using System;
-using System.Reflection;
-using NUnit.Framework;
-using OpenMetaverse;
-using OpenSim.Framework;
-using OpenSim.Framework.Communications;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
-
-namespace OpenSim.Region.Framework.Scenes.Tests
-{
-    /// <summary>
-    /// Tests for undo/redo
-    /// </summary>
-    public class SceneObjectUndoRedoTests : OpenSimTestCase
-    {
-        [Test]
-        public void TestUndoRedoResizeSceneObject()
-        {
-            TestHelpers.InMethod();
-//            TestHelpers.EnableLogging();
-
-            Vector3 firstSize = new Vector3(2, 3, 4);
-            Vector3 secondSize = new Vector3(5, 6, 7);
-
-            Scene scene = new SceneHelpers().SetupScene();
-            scene.MaxUndoCount = 20;
-            SceneObjectGroup g1 = SceneHelpers.AddSceneObject(scene);
-
-            // TODO: It happens to be the case that we are not storing undo states for SOPs which are not yet in a SOG,
-            // which is the way that AddSceneObject() sets up the object (i.e. it creates the SOP first).  However,
-            // this is somewhat by chance.  Really, we shouldn't be storing undo states at all if the object is not
-            // in a scene.
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(0));
-
-            g1.GroupResize(firstSize);
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(1));
-
-            g1.GroupResize(secondSize);
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(2));
-
-            g1.RootPart.Undo();
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(1));
-            Assert.That(g1.GroupScale, Is.EqualTo(firstSize));
-
-            g1.RootPart.Redo();
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(2));
-            Assert.That(g1.GroupScale, Is.EqualTo(secondSize));
-        }
-
-        [Test]
-        public void TestUndoLimit()
-        {
-            TestHelpers.InMethod();
-
-            Vector3 firstSize = new Vector3(2, 3, 4);
-            Vector3 secondSize = new Vector3(5, 6, 7);
-            Vector3 thirdSize = new Vector3(8, 9, 10);
-            Vector3 fourthSize = new Vector3(11, 12, 13);
-
-            Scene scene = new SceneHelpers().SetupScene();
-            scene.MaxUndoCount = 2;
-            SceneObjectGroup g1 = SceneHelpers.AddSceneObject(scene);
-
-            g1.GroupResize(firstSize);
-            g1.GroupResize(secondSize);
-            g1.GroupResize(thirdSize);
-            g1.GroupResize(fourthSize);
-
-            g1.RootPart.Undo();
-            g1.RootPart.Undo();
-            g1.RootPart.Undo();
-
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(0));
-            Assert.That(g1.GroupScale, Is.EqualTo(secondSize));
-        }
-
-        [Test]
-        public void TestNoUndoOnObjectsNotInScene()
-        {
-            TestHelpers.InMethod();
-
-            Vector3 firstSize = new Vector3(2, 3, 4);
-            Vector3 secondSize = new Vector3(5, 6, 7);
-//            Vector3 thirdSize = new Vector3(8, 9, 10);
-//            Vector3 fourthSize = new Vector3(11, 12, 13);
-
-            Scene scene = new SceneHelpers().SetupScene();
-            scene.MaxUndoCount = 20;
-            SceneObjectGroup g1 = SceneHelpers.CreateSceneObject(1, TestHelpers.ParseTail(0x1));
-
-            g1.GroupResize(firstSize);
-            g1.GroupResize(secondSize);
-
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(0));
-
-            g1.RootPart.Undo();
-
-            Assert.That(g1.GroupScale, Is.EqualTo(secondSize));
-        }
-
-        [Test]
-        public void TestUndoBeyondAvailable()
-        {
-            TestHelpers.InMethod();
-
-            Vector3 newSize = new Vector3(2, 3, 4);
-
-            Scene scene = new SceneHelpers().SetupScene();
-            scene.MaxUndoCount = 20;
-            SceneObjectGroup g1 = SceneHelpers.AddSceneObject(scene);
-            Vector3 originalSize = g1.GroupScale;
-
-            g1.RootPart.Undo();
-
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(0));
-            Assert.That(g1.GroupScale, Is.EqualTo(originalSize));
-
-            g1.GroupResize(newSize);
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(1));
-            Assert.That(g1.GroupScale, Is.EqualTo(newSize));
-
-            g1.RootPart.Undo();
-            g1.RootPart.Undo();
-
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(0));
-            Assert.That(g1.GroupScale, Is.EqualTo(originalSize));
-        }
-
-        [Test]
-        public void TestRedoBeyondAvailable()
-        {
-            TestHelpers.InMethod();
-
-            Vector3 newSize = new Vector3(2, 3, 4);
-
-            Scene scene = new SceneHelpers().SetupScene();
-            scene.MaxUndoCount = 20;
-            SceneObjectGroup g1 = SceneHelpers.AddSceneObject(scene);
-            Vector3 originalSize = g1.GroupScale;
-
-            g1.RootPart.Redo();
-
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(0));
-            Assert.That(g1.GroupScale, Is.EqualTo(originalSize));
-
-            g1.GroupResize(newSize);
-            g1.RootPart.Undo();
-            g1.RootPart.Redo();
-            g1.RootPart.Redo();
-
-            Assert.That(g1.RootPart.UndoCount, Is.EqualTo(1));
-            Assert.That(g1.GroupScale, Is.EqualTo(newSize));
-        }
-    }
-}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
index 2b79271..c7eaff9 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
@@ -44,7 +44,7 @@ using OpenSim.Tests.Common.Mock;
 namespace OpenSim.Region.Framework.Scenes.Tests
 {
     [TestFixture]
-    public class SceneObjectUserGroupTests : OpenSimTestCase
+    public class SceneObjectUserGroupTests
     {
         /// <summary>
         /// Test share with group object functionality
@@ -54,6 +54,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
         public void TestShareWithGroup()
         {
             TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
                         
             UUID userId = UUID.Parse("10000000-0000-0000-0000-000000000001");
             
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCapabilityTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCapabilityTests.cs
index b6fb730..4ae7a8e 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCapabilityTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCapabilityTests.cs
@@ -75,14 +75,14 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             SceneHelpers.SetupSceneModules(scene, capsMod);
 
             ScenePresence sp = SceneHelpers.AddChildScenePresence(scene, spUuid);
-            Assert.That(capsMod.GetCapsForUser(spUuid), Is.Not.Null);
+            //Assert.That(capsMod.GetCapsForUser(spUuid), Is.Not.Null);
 
             // TODO: Need to add tests for other ICapabiltiesModule methods.
 
             scene.IncomingCloseAgent(sp.UUID, false);
-            Assert.That(capsMod.GetCapsForUser(spUuid), Is.Null);
+            //Assert.That(capsMod.GetCapsForUser(spUuid), Is.Null);
 
             // TODO: Need to add tests for other ICapabiltiesModule methods.
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Scenes/UndoState.cs b/OpenSim/Region/Framework/Scenes/UndoState.cs
index 860172c..7bbf1bd 100644
--- a/OpenSim/Region/Framework/Scenes/UndoState.cs
+++ b/OpenSim/Region/Framework/Scenes/UndoState.cs
@@ -27,202 +27,307 @@
 
 using System;
 using System.Reflection;
+using System.Collections.Generic;
 using log4net;
 using OpenMetaverse;
+using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 
 namespace OpenSim.Region.Framework.Scenes
 {
     public class UndoState
     {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-
-        public Vector3 Position = Vector3.Zero;
-        public Vector3 Scale = Vector3.Zero;
-        public Quaternion Rotation = Quaternion.Identity;
-
-        /// <summary>
-        /// Is this undo state for an entire group?
-        /// </summary>
-        public bool ForGroup;
+        const int UNDOEXPIRESECONDS = 300; // undo expire time   (nice to have it came from a ini later)
 
+        public ObjectChangeData data;
+        public DateTime creationtime;
         /// <summary>
         /// Constructor.
         /// </summary>
         /// <param name="part"></param>
-        /// <param name="forGroup">True if the undo is for an entire group</param>
-        public UndoState(SceneObjectPart part, bool forGroup)
+        /// <param name="change">bit field with what is changed</param>
+        /// 
+        public UndoState(SceneObjectPart part, ObjectChangeType change)
         {
-            if (part.ParentID == 0)
-            {
-                ForGroup = forGroup;
-
-//                    if (ForGroup)
-                    Position = part.ParentGroup.AbsolutePosition;
-//                    else
-//                        Position = part.OffsetPosition;
-
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Storing undo position {0} for root part", Position);
+            data = new ObjectChangeData();
+            data.change = change;
+            creationtime = DateTime.UtcNow;
 
-                Rotation = part.RotationOffset;
-
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Storing undo rotation {0} for root part", Rotation);
-
-                Scale = part.Shape.Scale;
-
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Storing undo scale {0} for root part", Scale);
+            if (part.ParentGroup.RootPart == part)
+            {
+                if ((change & ObjectChangeType.Position) != 0)
+                    data.position = part.ParentGroup.AbsolutePosition;
+                if ((change & ObjectChangeType.Rotation) != 0)
+                    data.rotation = part.RotationOffset;
+                if ((change & ObjectChangeType.Scale) != 0)
+                    data.scale = part.Shape.Scale;
             }
             else
             {
-                Position = part.OffsetPosition;
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Storing undo position {0} for child part", Position);
+                if ((change & ObjectChangeType.Position) != 0)
+                    data.position = part.OffsetPosition;
+                if ((change & ObjectChangeType.Rotation) != 0)
+                    data.rotation = part.RotationOffset;
+                if ((change & ObjectChangeType.Scale) != 0)
+                    data.scale = part.Shape.Scale;
+            }
+        }
+        /// <summary>
+        /// check if undo or redo is too old 
+        /// </summary>
 
-                Rotation = part.RotationOffset;
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Storing undo rotation {0} for child part", Rotation);
+        public bool checkExpire()
+        {
+            TimeSpan t = DateTime.UtcNow - creationtime;
+            if (t.Seconds > UNDOEXPIRESECONDS)
+                return true;
+            return false;
+        }
 
-                Scale = part.Shape.Scale;
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Storing undo scale {0} for child part", Scale);
-            }
+        /// <summary>
+        /// updates undo or redo creation time to now
+        /// </summary>
+        public void updateExpire()
+        {
+            creationtime = DateTime.UtcNow;
         }
 
         /// <summary>
         /// Compare the relevant state in the given part to this state.
         /// </summary>
         /// <param name="part"></param>
-        /// <returns>true if both the part's position, rotation and scale match those in this undo state.  False otherwise.</returns>
-        public bool Compare(SceneObjectPart part)
+        /// <returns>true what fiels and related data are equal, False otherwise.</returns>
+        /// 
+        public bool Compare(SceneObjectPart part, ObjectChangeType change)    
         {
+            if (data.change != change) // if diferent targets, then they are diferent
+                return false;
+
             if (part != null)
             {
                 if (part.ParentID == 0)
-                    return
-                        Position == part.ParentGroup.AbsolutePosition
-                            && Rotation == part.RotationOffset
-                            && Scale == part.Shape.Scale;
+                {
+                    if ((change & ObjectChangeType.Position) != 0 && data.position != part.ParentGroup.AbsolutePosition)
+                        return false;
+                }
                 else
-                    return
-                        Position == part.OffsetPosition
-                            && Rotation == part.RotationOffset
-                            && Scale == part.Shape.Scale;
-            }
+                {
+                    if ((change & ObjectChangeType.Position) != 0 && data.position != part.OffsetPosition)
+                        return false;
+                }
+
+                if ((change & ObjectChangeType.Rotation) != 0 && data.rotation != part.RotationOffset)
+                    return false;
+                if ((change & ObjectChangeType.Rotation) != 0 && data.scale == part.Shape.Scale)
+                    return false;
+                return true;
 
+            }
             return false;
         }
 
-        public void PlaybackState(SceneObjectPart part)
+        /// <summary>
+        /// executes the undo or redo to a part or its group
+        /// </summary>
+        /// <param name="part"></param>
+        /// 
+
+        public void PlayState(SceneObjectPart part)
         {
             part.Undoing = true;
 
-            if (part.ParentID == 0)
-            {
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Undoing position to {0} for root part {1} {2}",
-//                        Position, part.Name, part.LocalId);
+            SceneObjectGroup grp = part.ParentGroup;
 
-                if (Position != Vector3.Zero)
-                {
-                    if (ForGroup)
-                        part.ParentGroup.AbsolutePosition = Position;
-                    else
-                        part.ParentGroup.UpdateRootPosition(Position);
-                }
+            if (grp != null)
+            {
+                grp.doChangeObject(part, data);              
+            }
+            part.Undoing = false;
+        }
+    }
 
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Undoing rotation {0} to {1} for root part {2} {3}",
-//                        part.RotationOffset, Rotation, part.Name, part.LocalId);
+    public class UndoRedoState
+    {
+        int size;
+        public LinkedList<UndoState> m_redo = new LinkedList<UndoState>();
+        public LinkedList<UndoState> m_undo = new LinkedList<UndoState>();
 
-                if (ForGroup)
-                    part.UpdateRotation(Rotation);
-                else
-                    part.ParentGroup.UpdateRootRotation(Rotation);
+        /// <summary>
+        /// creates a new UndoRedoState with default states memory size
+        /// </summary>
 
-                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);
+        public UndoRedoState()
+        {
+            size = 5;
+        }
 
-                    if (ForGroup)
-                        part.ParentGroup.GroupResize(Scale);
-                    else
-                        part.Resize(Scale);
-                }
+        /// <summary>
+        /// creates a new UndoRedoState with states memory having indicated size
+        /// </summary>
+        /// <param name="size"></param>
 
-                part.ParentGroup.ScheduleGroupForTerseUpdate();
-            }
+        public UndoRedoState(int _size)
+        {
+            if (_size < 3)
+                size = 3;
             else
-            {
-                // 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);
+                size = _size;
+        }
 
-                    part.OffsetPosition = Position;
-                }
+        /// <summary>
+        /// returns number of undo entries in memory
+        /// </summary>
 
-//                    m_log.DebugFormat(
-//                        "[UNDO STATE]: Undoing rotation {0} to {1} for child part {2} {3}",
-//                        part.RotationOffset, Rotation, part.Name, part.LocalId);
+        public int Count
+        {
+            get { return m_undo.Count; }
+        }
 
-                part.UpdateRotation(Rotation);
+        /// <summary>
+        /// clears all undo and redo entries
+        /// </summary>
 
-                if (Scale != Vector3.Zero)
+        public void Clear()
+        {
+            m_undo.Clear();
+            m_redo.Clear();
+        }
+
+        /// <summary>
+        /// adds a new state undo to part or its group, with changes indicated by what bits
+        /// </summary>
+        /// <param name="part"></param>
+        /// <param name="change">bit field with what is changed</param>
+
+        public void StoreUndo(SceneObjectPart part, ObjectChangeType change)
+        {
+            lock (m_undo)
+            {
+                UndoState last;
+
+                if (m_redo.Count > 0) // last code seems to clear redo on every new undo
                 {
-//                        m_log.DebugFormat(
-//                            "[UNDO STATE]: Undoing scale {0} to {1} for child part {2} {3}",
-//                            part.Shape.Scale, Scale, part.Name, part.LocalId);
+                    m_redo.Clear();
+                }
 
-                    part.Resize(Scale);
+                if (m_undo.Count > 0)
+                {
+                    // check expired entry
+                    last = m_undo.First.Value;
+                    if (last != null && last.checkExpire())
+                        m_undo.Clear();
+                    else
+                    {
+                        // see if we actually have a change
+                        if (last != null)
+                        {
+                            if (last.Compare(part, change))
+                                return;
+                        }
+                    }
                 }
-            }
 
-            part.Undoing = false;
+                // limite size
+                while (m_undo.Count >= size)
+                    m_undo.RemoveLast();
+
+                UndoState nUndo = new UndoState(part, change);
+                m_undo.AddFirst(nUndo);
+            }
         }
 
-        public void PlayfwdState(SceneObjectPart part)
-        {
-            part.Undoing = true;
+        /// <summary>
+        /// executes last state undo to part or its group
+        /// current state is pushed into redo
+        /// </summary>
+        /// <param name="part"></param>
 
-            if (part.ParentID == 0)
+        public void Undo(SceneObjectPart part)
+        {
+            lock (m_undo)
             {
-                if (Position != Vector3.Zero)
-                    part.ParentGroup.AbsolutePosition = Position;
-
-                if (Rotation != Quaternion.Identity)
-                    part.UpdateRotation(Rotation);
+                UndoState nUndo;
 
-                if (Scale != Vector3.Zero)
+                // expire redo
+                if (m_redo.Count > 0)
                 {
-                    if (ForGroup)
-                        part.ParentGroup.GroupResize(Scale);
-                    else
-                        part.Resize(Scale);
+                    nUndo = m_redo.First.Value;
+                    if (nUndo != null && nUndo.checkExpire())
+                        m_redo.Clear();
                 }
 
-                part.ParentGroup.ScheduleGroupForTerseUpdate();
+                if (m_undo.Count > 0)
+                {
+                    UndoState goback = m_undo.First.Value;
+                    // check expired
+                    if (goback != null && goback.checkExpire())
+                    {
+                        m_undo.Clear();
+                        return;
+                    }
+
+                    if (goback != null)
+                    {
+                        m_undo.RemoveFirst();
+
+                        // redo limite size
+                        while (m_redo.Count >= size)
+                            m_redo.RemoveLast();
+
+                        nUndo = new UndoState(part, goback.data.change); // new value in part should it be full goback copy?
+                        m_redo.AddFirst(nUndo);
+
+                        goback.PlayState(part);
+                    }
+                }
             }
-            else
+        }
+
+        /// <summary>
+        /// executes last state redo to part or its group
+        /// current state is pushed into undo
+        /// </summary>
+        /// <param name="part"></param>
+
+        public void Redo(SceneObjectPart part)
+        {
+            lock (m_undo)
             {
-                // Note: Updating these properties on sop automatically schedules an update if needed
-                if (Position != Vector3.Zero)
-                    part.OffsetPosition = Position;
+                UndoState nUndo;
 
-                if (Rotation != Quaternion.Identity)
-                    part.UpdateRotation(Rotation);
+                // expire undo
+                if (m_undo.Count > 0)
+                {
+                    nUndo = m_undo.First.Value;
+                    if (nUndo != null && nUndo.checkExpire())
+                        m_undo.Clear();
+                }
 
-                if (Scale != Vector3.Zero)
-                    part.Resize(Scale);
+                if (m_redo.Count > 0)
+                {
+                    UndoState gofwd = m_redo.First.Value;
+                    // check expired
+                    if (gofwd != null && gofwd.checkExpire())
+                    {
+                        m_redo.Clear();
+                        return;
+                    }
+
+                    if (gofwd != null)
+                    {
+                        m_redo.RemoveFirst();
+
+                        // limite undo size
+                        while (m_undo.Count >= size)
+                            m_undo.RemoveLast();
+
+                        nUndo = new UndoState(part, gofwd.data.change);   // new value in part should it be full gofwd copy?
+                        m_undo.AddFirst(nUndo);
+
+                        gofwd.PlayState(part);
+                    }
+                }
             }
-
-            part.Undoing = false;
         }
     }
 
@@ -247,4 +352,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 8f69ce3..e60a025 100644
--- a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
+++ b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
@@ -85,10 +85,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;