8 files changed, 308 insertions, 110 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index 6df55a6..7c5aee7 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -1242,14 +1242,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             try
             {
                 // Send LayerData in typerwriter pattern
+                //for (int y = 0; y < 16; y++)
+                //{
+                //    for (int x = 0; x < 16; x++)
+                //    {
+                //        SendLayerData(x, y, map);
+                //    }
+                //}
 
-                for (int y = 0; y < 16; y++)
-                {
-                    for (int x = 0; x < 16; x++)
-                    {
-                        SendLayerData(x, y, map);
-                    }
-                }
+                // Send LayerData in a spiral pattern. Fun!
+                SendLayerTopRight(map, 0, 0, map.SizeX / Constants.TerrainPatchSize - 1, map.SizeY / Constants.TerrainPatchSize - 1);
             }
             catch (Exception e)
             {
@@ -1257,6 +1259,35 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
 
+        private void SendLayerTopRight(TerrainData map, int x1, int y1, int x2, int y2)
+        {
+            // Row
+            for (int i = x1; i <= x2; i++)
+                SendLayerData(i, y1, map);
+
+            // Column
+            for (int j = y1 + 1; j <= y2; j++)
+                SendLayerData(x2, j, map);
+
+            if (x2 - x1 > 0 && y2 - y1 > 0)
+                SendLayerBottomLeft(map, x1, y1 + 1, x2 - 1, y2);
+        }
+
+        void SendLayerBottomLeft(TerrainData map, int x1, int y1, int x2, int y2)
+        {
+            // Row in reverse
+            for (int i = x2; i >= x1; i--)
+                SendLayerData(i, y2, map);
+
+            // Column in reverse
+            for (int j = y2 - 1; j >= y1; j--)
+                SendLayerData(x1, j, map);
+
+            if (x2 - x1 > 0 && y2 - y1 > 0)
+                SendLayerTopRight(map, x1 + 1, y1, x2, y2 - 1);
+        }
+
+
         // Legacy form of invocation that passes around a bare data array.
         // Just ignore what was passed and use the real terrain info that is part of the scene.
         // As a HORRIBLE kludge in an attempt to not change the definition of IClientAPI, 
@@ -1359,7 +1390,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private void SendTheLayerPacket(LayerDataPacket layerpack)
         {
-                OutPacket(layerpack, ThrottleOutPacketType.Land);
+            OutPacket(layerpack, ThrottleOutPacketType.Land);
         }
 
         /// <summary>
diff --git a/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/LLRAW.cs b/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/LLRAW.cs
index be1fb24..59994e4 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/LLRAW.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/LLRAW.cs
@@ -57,6 +57,10 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
 
         public LLRAW()
         {
+        }
+
+        private void BuildLookupHeightTable()
+        {
             LookupHeightTable = new HeightmapLookupValue[256 * 256];
 
             for (int i = 0; i < 256; i++)
@@ -186,6 +190,9 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
 
         public void SaveStream(Stream s, ITerrainChannel map)
         {
+            if (LookupHeightTable == null)
+                BuildLookupHeightTable();
+
             using (BinaryWriter binStream = new BinaryWriter(s))
             {
                 // Output the calculated raw
@@ -241,6 +248,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
                     }
                 }
             }
+            LookupHeightTable = null;
         }
 
         public string FileExtension
diff --git a/OpenSim/Region/CoreModules/World/Terrain/TerrainModifier.cs b/OpenSim/Region/CoreModules/World/Terrain/TerrainModifier.cs
index 7ebd08e..c6e992f 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/TerrainModifier.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/TerrainModifier.cs
@@ -370,9 +370,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             }
             return mask;
         }
-
-
     }
-
 }
 
diff --git a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
index 22723fc..2f4618d 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
@@ -29,6 +29,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using System.Net;
+using System.Threading;
 
 using log4net;
 using Nini.Config;
@@ -36,7 +37,6 @@ using Nini.Config;
 using OpenMetaverse;
 using Mono.Addins;
 
-using OpenSim.Data;
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
 using OpenSim.Region.CoreModules.Framework.InterfaceCommander;
@@ -86,7 +86,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         private readonly Dictionary<string, ITerrainLoader> m_loaders = new Dictionary<string, ITerrainLoader>();
         private readonly Dictionary<StandardTerrainEffects, ITerrainPaintableEffect> m_painteffects =
             new Dictionary<StandardTerrainEffects, ITerrainPaintableEffect>();
-
+        private Dictionary<string, ITerrainModifier> m_modifyOperations =
+             new Dictionary<string, ITerrainModifier>();
         private Dictionary<string, ITerrainEffect> m_plugineffects;
         private ITerrainChannel m_channel;
         private ITerrainChannel m_baked;
@@ -106,6 +107,10 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             private bool[,] updated;    // for each patch, whether it needs to be sent to this client
             private int updateCount;    // number of patches that need to be sent
             public ScenePresence Presence;   // a reference to the client to send to
+            public bool sendAll;
+            public int sendAllcurrentX;
+            public int sendAllcurrentY;
+
 
             public PatchUpdates(TerrainData terrData, ScenePresence pPresence)
             {
@@ -149,6 +154,9 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                         updated[xx, yy] = state;
                 if (state)
                     updateCount = updated.GetLength(0) * updated.GetLength(1);
+                sendAllcurrentX = 0;
+                sendAllcurrentY = 0;
+                sendAll = true;
             }
 
             // Logically OR's the terrain data's patch taint map into this client's update map.
@@ -210,7 +218,9 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             if (terrainConfig != null)
             {
                 m_InitialTerrain = terrainConfig.GetString("InitialTerrain", m_InitialTerrain);
-                m_sendTerrainUpdatesByViewDistance = terrainConfig.GetBoolean("SendTerrainUpdatesByViewDistance", m_sendTerrainUpdatesByViewDistance);
+                m_sendTerrainUpdatesByViewDistance = 
+                    terrainConfig.GetBoolean(
+                        "SendTerrainUpdatesByViewDistance",m_sendTerrainUpdatesByViewDistance);
             }
         }
 
@@ -523,21 +533,29 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         // ITerrainModule.PushTerrain()
         public void PushTerrain(IClientAPI pClient)
         {
-            ScenePresence presence = m_scene.GetScenePresence(pClient.AgentId);
-            if (presence != null)
+            if (m_sendTerrainUpdatesByViewDistance)
             {
-                lock (m_perClientPatchUpdates)
+                ScenePresence presence = m_scene.GetScenePresence(pClient.AgentId);
+                if (presence != null)
                 {
-                    PatchUpdates pups;
-                    if (!m_perClientPatchUpdates.TryGetValue(pClient.AgentId, out pups))
+                    lock (m_perClientPatchUpdates)
                     {
-                        // There is a ScenePresence without a send patch map. Create one.
-                        pups = new PatchUpdates(m_scene.Heightmap.GetTerrainData(), presence);
-                        m_perClientPatchUpdates.Add(presence.UUID, pups);
+                        PatchUpdates pups;
+                        if (!m_perClientPatchUpdates.TryGetValue(pClient.AgentId, out pups))
+                        {
+                            // There is a ScenePresence without a send patch map. Create one.
+                            pups = new PatchUpdates(m_scene.Heightmap.GetTerrainData(), presence);
+                            m_perClientPatchUpdates.Add(presence.UUID, pups);
+                        }
+                        pups.SetAll(true);
                     }
-                    pups.SetAll(true);
                 }
             }
+            else
+            {
+                // The traditional way is to call into the protocol stack to send them all.
+                pClient.SendLayerData(new float[10]);
+            }
         }
 
         #region Plugin Loading Methods
@@ -643,7 +661,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             m_floodeffects[StandardTerrainEffects.Revert] = new RevertArea(m_baked);
 
             // Terrain Modifier operations
-/*
+
             m_modifyOperations["min"] = new MinModifier(this);
             m_modifyOperations["max"] = new MaxModifier(this);
             m_modifyOperations["raise"] = new RaiseModifier(this);
@@ -651,7 +669,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             m_modifyOperations["fill"] = new FillModifier(this);
             m_modifyOperations["smooth"] = new SmoothModifier(this);
             m_modifyOperations["noise"] = new NoiseModifier(this);
-*/
+
             // Filesystem load/save loaders
             m_loaders[".r32"] = new RAW32();
             m_loaders[".f32"] = m_loaders[".r32"];
@@ -948,19 +966,37 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         /// <param name="y">The patch corner to send</param>
         private void SendToClients(TerrainData terrData, int x, int y)
         {
-            // Add that this patch needs to be sent to the accounting for each client.
-            lock (m_perClientPatchUpdates)
+            if (m_sendTerrainUpdatesByViewDistance)
             {
-                m_scene.ForEachScenePresence(presence =>
-                    {
-                        PatchUpdates thisClientUpdates;
-                        if (!m_perClientPatchUpdates.TryGetValue(presence.UUID, out thisClientUpdates))
+                // Add that this patch needs to be sent to the accounting for each client.
+                lock (m_perClientPatchUpdates)
+                {
+                    m_scene.ForEachScenePresence(presence =>
                         {
-                            // There is a ScenePresence without a send patch map. Create one.
-                            thisClientUpdates = new PatchUpdates(terrData, presence);
-                            m_perClientPatchUpdates.Add(presence.UUID, thisClientUpdates);
+                            PatchUpdates thisClientUpdates;
+                            if (!m_perClientPatchUpdates.TryGetValue(presence.UUID, out thisClientUpdates))
+                            {
+                                // There is a ScenePresence without a send patch map. Create one.
+                                thisClientUpdates = new PatchUpdates(terrData, presence);
+                                m_perClientPatchUpdates.Add(presence.UUID, thisClientUpdates);
+                            }
+                            thisClientUpdates.SetByXY(x, y, true);
                         }
-                        thisClientUpdates.SetByXY(x, y, true);
+                    );
+                }
+            }
+            else
+            {
+                // Legacy update sending where the update is sent out as soon as noticed
+                // We know the actual terrain data that is passed is ignored so this passes a dummy heightmap.
+                //float[] heightMap = terrData.GetFloatsSerialized();
+                float[] heightMap = new float[10];
+                m_scene.ForEachClient(
+                    delegate (IClientAPI controller)
+                    {
+                        controller.SendLayerData(x / Constants.TerrainPatchSize,
+                                                 y / Constants.TerrainPatchSize,
+                                                 heightMap);
                     }
                 );
             }
@@ -998,35 +1034,107 @@ namespace OpenSim.Region.CoreModules.World.Terrain
 
                     if (pups.HasUpdates())
                     {
-                        // There is something that could be sent to this client.
-                        List<PatchesToSend> toSend = GetModifiedPatchesInViewDistance(pups);
-                        if (toSend.Count > 0)
+                        if (m_sendTerrainUpdatesByViewDistance)
                         {
-                            // m_log.DebugFormat("{0} CheckSendingPatchesToClient: sending {1} patches to {2} in region {3}",
-                            //                     LogHeader, toSend.Count, pups.Presence.Name, m_scene.RegionInfo.RegionName);
-                            // Sort the patches to send by the distance from the presence
-                            toSend.Sort();
-                            /*
-                            foreach (PatchesToSend pts in toSend)
+                            // There is something that could be sent to this client.
+                            List<PatchesToSend> toSend = GetModifiedPatchesInViewDistance(pups);
+                            if (toSend.Count > 0)
                             {
-                                pups.Presence.ControllingClient.SendLayerData(pts.PatchX, pts.PatchY, null);
-                                // presence.ControllingClient.SendLayerData(xs.ToArray(), ys.ToArray(), null, TerrainPatch.LayerType.Land);
+                                // m_log.DebugFormat("{0} CheckSendingPatchesToClient: sending {1} patches to {2} in region {3}",
+                                //                     LogHeader, toSend.Count, pups.Presence.Name, m_scene.RegionInfo.RegionName);
+                                // Sort the patches to send by the distance from the presence
+                                toSend.Sort();
+                                /*
+                                foreach (PatchesToSend pts in toSend)
+                                {
+                                    pups.Presence.ControllingClient.SendLayerData(pts.PatchX, pts.PatchY, null);
+                                    // presence.ControllingClient.SendLayerData(xs.ToArray(), ys.ToArray(), null, TerrainPatch.LayerType.Land);
+                                }
+                                */
+
+                                int[] xPieces = new int[toSend.Count];
+                                int[] yPieces = new int[toSend.Count];
+                                float[] patchPieces = new float[toSend.Count * 2];
+                                int pieceIndex = 0;
+                                foreach (PatchesToSend pts in toSend)
+                                {
+                                    patchPieces[pieceIndex++] = pts.PatchX;
+                                    patchPieces[pieceIndex++] = pts.PatchY;
+                                }
+                                pups.Presence.ControllingClient.SendLayerData(-toSend.Count, 0, patchPieces);
                             }
-                            */
+                            if (pups.sendAll && toSend.Count < 1024)
+                                SendAllModifiedPatchs(pups);
+                        }
+                        else
+                            SendAllModifiedPatchs(pups);
+                    }
+                }
+            }
+        }
+        private void SendAllModifiedPatchs(PatchUpdates pups)
+        {
+            if (!pups.sendAll) // sanity
+                return;
 
-                            int[] xPieces = new int[toSend.Count];
-                            int[] yPieces = new int[toSend.Count];
-                            float[] patchPieces = new float[toSend.Count * 2];
-                            int pieceIndex = 0;
-                            foreach (PatchesToSend pts in toSend)
-                            {
-                                patchPieces[pieceIndex++] = pts.PatchX;
-                                patchPieces[pieceIndex++] = pts.PatchY;
-                            }
-                            pups.Presence.ControllingClient.SendLayerData(-toSend.Count, 0, patchPieces);
+            int limitX = (int)m_scene.RegionInfo.RegionSizeX / Constants.TerrainPatchSize;
+            int limitY = (int)m_scene.RegionInfo.RegionSizeY / Constants.TerrainPatchSize;
+
+            if (pups.sendAllcurrentX > limitX || pups.sendAllcurrentY > limitY)
+            {
+                pups.sendAll = false;
+                pups.sendAllcurrentX = 0;
+                pups.sendAllcurrentY = 0;
+                return;
+            }
+
+            int npatchs = 0;
+            List<PatchesToSend> patchs = new List<PatchesToSend>();
+            int x = pups.sendAllcurrentX;
+            int y = pups.sendAllcurrentY;
+            // send it in the order viewer draws it
+            // even if not best for memory scan
+            for (; y < limitY; y++)
+            {
+                for (; x < limitX; x++)
+                {
+                    if (pups.GetByPatch(x, y))
+                    {
+                        pups.SetByPatch(x, y, false);
+                        patchs.Add(new PatchesToSend(x, y, 0));
+                        if (++npatchs >= 512)
+                        {
+                            pups.sendAllcurrentX = x + 1;
+                            pups.sendAllcurrentY = y;
+                            break;
                         }
                     }
                 }
+                if (npatchs >= 512)
+                    break;
+                x = 0;
+            }
+
+            if (x >= limitX && y >= limitY)
+            {
+                pups.sendAll = false;
+                pups.sendAllcurrentX = 0;
+                pups.sendAllcurrentY = 0;
+            }
+
+            npatchs = patchs.Count;
+            if (npatchs > 0)
+            {
+                int[] xPieces = new int[npatchs];
+                int[] yPieces = new int[npatchs];
+                float[] patchPieces = new float[npatchs * 2];
+                int pieceIndex = 0;
+                foreach (PatchesToSend pts in patchs)
+                {
+                    patchPieces[pieceIndex++] = pts.PatchX;
+                    patchPieces[pieceIndex++] = pts.PatchY;
+                }
+                pups.Presence.ControllingClient.SendLayerData(-npatchs, 0, patchPieces);
             }
         }
 
@@ -1099,7 +1207,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             int distsq;
 
             DrawDistance *= DrawDistance;
-  
+
             for (int x = startX; x < endX; x++)
             {
                 for (int y = startY; y < endY; y++)
@@ -1113,7 +1221,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                         {
                             pups.SetByPatch(x, y, false);
                             ret.Add(new PatchesToSend(x, y, (float)distsq));
-                            if (npatchs++ > 65536)
+                            if (npatchs++ > 1024)
                             {
                                 y = endY;
                                 x = endX;
@@ -1123,7 +1231,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                 }
             }
             return ret;
-        }
+        }   
 
         private void client_OnModifyTerrain(UUID user, float height, float seconds, byte size, byte action,
                                             float north, float west, float south, float east, UUID agentId)
@@ -1414,7 +1522,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                 }
 
             }
-
         }
 
         private void InterfaceElevateTerrain(Object[] args)
@@ -1707,7 +1814,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
 
         public void ModifyCommand(string module, string[] cmd)
         {
-            /*
             string result;
             Scene scene = SceneManager.Instance.CurrentScene;
             if ((scene != null) && (scene != m_scene))
@@ -1747,7 +1853,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             {
                 MainConsole.Instance.Output(result);
             }
-             */
         }
 
 #endregion
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 05edd20..1b90af4 100755
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -1939,6 +1939,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="ticks">Elapsed Stopwatch ticks</param>
         public void AddScriptExecutionTime(long ticks)
         {
+            StatsReporter.addScriptEvents(1);
             Interlocked.Add(ref m_scriptExecutionTime, ticks);
         }
 
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index 66cf14f..de3c3d6 100755
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -230,6 +230,7 @@ namespace OpenSim.Region.Framework.Scenes
         private int m_pendingUploads = 0;  // FIXME: Not currently filled in
         private int m_activeScripts;
         private int m_scriptLinesPerSecond;
+        private int m_scriptEventsPerSecond;
 
         private int m_objectCapacity = 45000;
 
@@ -496,8 +497,8 @@ namespace OpenSim.Region.Framework.Scenes
                 sb[27].StatID = (uint)Stats.PhysicsLodTasks;
                 sb[27].StatValue = 0;
 
-                sb[28].StatID = (uint)Stats.ScriptEps; // we should have this
-                sb[28].StatValue = 0;
+                sb[28].StatID = (uint)Stats.ScriptEps; // we actuall have this, but not messing array order AGAIN
+                sb[28].StatValue = m_scriptEventsPerSecond * updateFactor;
 
                 sb[29].StatID = (uint)Stats.SimAIStepTimeMS;
                 sb[29].StatValue = 0;
@@ -620,6 +621,7 @@ namespace OpenSim.Region.Framework.Scenes
             //m_outPacketsPerSecond = 0;
             m_unAckedBytes = 0;
             m_scriptLinesPerSecond = 0;
+            m_scriptEventsPerSecond = 0;
 
             m_frameMS = 0;
             m_agentMS = 0;
@@ -756,6 +758,11 @@ namespace OpenSim.Region.Framework.Scenes
             m_scriptLinesPerSecond += count;
         }
 
+        public void addScriptEvents(int count)
+        {
+            m_scriptEventsPerSecond += count;
+        }
+
         public void AddPacketsStats(int inPackets, int outPackets, int unAckedBytes)
         {
             AddInPackets(inPackets);
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs b/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs
index 5e48de6..54a2033 100644
--- a/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs
@@ -1691,6 +1691,9 @@ Console.WriteLine(" JointCreateFixed");
             float fy = 0;
             float fz = 0;
 
+            if (outofBounds)
+                return;
+
             if (IsPhysical && (Body != IntPtr.Zero) && !m_isSelected && !childPrim)        // KF: Only move root prims.
             {
                 if (m_vehicle.Type != Vehicle.TYPE_NONE)
@@ -2664,16 +2667,38 @@ Console.WriteLine(" JointCreateFixed");
 
         public override void CrossingFailure()
         {
-            m_crossingfailures++;
-            if (m_crossingfailures > _parent_scene.geomCrossingFailuresBeforeOutofbounds)
-            {
-                base.RaiseOutOfBounds(_position);
-                return;
-            }
-            else if (m_crossingfailures == _parent_scene.geomCrossingFailuresBeforeOutofbounds)
+            /*
+                        m_crossingfailures++;
+                        if (m_crossingfailures > _parent_scene.geomCrossingFailuresBeforeOutofbounds)
+                        {
+                            base.RaiseOutOfBounds(_position);
+                            return;
+                        }
+                        else if (m_crossingfailures == _parent_scene.geomCrossingFailuresBeforeOutofbounds)
+                        {
+                            m_log.Warn("[PHYSICS]: Too many crossing failures for: " + Name);
+                        }
+            */
+            _position.X = Util.Clip(_position.X, 0.5f, _parent_scene.WorldExtents.X - 0.5f);
+            _position.Y = Util.Clip(_position.Y, 0.5f, _parent_scene.WorldExtents.Y - 0.5f);
+            _position.Z = Util.Clip(_position.Z + 0.2f, -100f, 50000f);
+
+            m_lastposition = _position;
+            _velocity.X = 0;
+            _velocity.Y = 0;
+            _velocity.Z = 0;
+
+            m_lastVelocity = _velocity;
+
+            if (Body != IntPtr.Zero)
             {
-                m_log.Warn("[PHYSICS]: Too many crossing failures for: " + Name);
+                d.BodySetLinearVel(Body, 0, 0, 0); // stop it
+                d.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
             }
+
+            outofBounds = false;
+            base.RequestPhysicsterseUpdate();
+
         }
 
         public override float Buoyancy
@@ -2712,6 +2737,8 @@ Console.WriteLine(" JointCreateFixed");
         internal void UpdatePositionAndVelocity()
         {
             //  no lock; called from Simulate() -- if you call this from elsewhere, gotta lock or do Monitor.Enter/Exit!
+            if (outofBounds)
+                return;
             if (_parent == null)
             {
                 Vector3 pv = Vector3.Zero;
@@ -2728,12 +2755,6 @@ Console.WriteLine(" JointCreateFixed");
                     Vector3 l_position = Vector3.Zero;
                     Quaternion l_orientation = Quaternion.Identity;
 
-                    //  kluge to keep things in bounds.  ODE lets dead avatars drift away (they should be removed!)
-                    //if (vec.X < 0.0f) { vec.X = 0.0f; if (Body != (IntPtr)0) d.BodySetAngularVel(Body, 0, 0, 0); }
-                    //if (vec.Y < 0.0f) { vec.Y = 0.0f; if (Body != (IntPtr)0) d.BodySetAngularVel(Body, 0, 0, 0); }
-                    //if (vec.X > 255.95f) { vec.X = 255.95f; if (Body != (IntPtr)0) d.BodySetAngularVel(Body, 0, 0, 0); }
-                    //if (vec.Y > 255.95f) { vec.Y = 255.95f; if (Body != (IntPtr)0) d.BodySetAngularVel(Body, 0, 0, 0); }
-
                     m_lastposition = _position;
                     m_lastorientation = _orientation;
 
@@ -2745,26 +2766,6 @@ Console.WriteLine(" JointCreateFixed");
                     l_orientation.Z = ori.Z;
                     l_orientation.W = ori.W;
 
-                    if (l_position.X > ((int)_parent_scene.WorldExtents.X - 0.05f) || l_position.X < 0f || l_position.Y > ((int)_parent_scene.WorldExtents.Y - 0.05f) || l_position.Y < 0f)
-                    {
-                        //base.RaiseOutOfBounds(l_position);
-
-                        if (m_crossingfailures < _parent_scene.geomCrossingFailuresBeforeOutofbounds)
-                        {
-                            _position = l_position;
-                            //_parent_scene.remActivePrim(this);
-                            if (_parent == null)
-                                base.RequestPhysicsterseUpdate();
-                            return;
-                        }
-                        else
-                        {
-                            if (_parent == null)
-                                base.RaiseOutOfBounds(l_position);
-                            return;
-                        }
-                    }
-
                     if (l_position.Z < 0)
                     {
                         // This is so prim that get lost underground don't fall forever and suck up
@@ -2774,8 +2775,6 @@ Console.WriteLine(" JointCreateFixed");
                         // It's a hack and will generate a console message if it fails.
 
                         //IsPhysical = false;
-                        if (_parent == null)
-                            base.RaiseOutOfBounds(_position);
 
                         _acceleration.X = 0;
                         _acceleration.Y = 0;
@@ -2789,16 +2788,64 @@ Console.WriteLine(" JointCreateFixed");
                         m_rotationalVelocity.Z = 0;
 
                         if (_parent == null)
+                            base.RaiseOutOfBounds(_position);
+
+                        if (_parent == null)
                             base.RequestPhysicsterseUpdate();
 
                         m_throttleUpdates = false;
                         throttleCounter = 0;
                         _zeroFlag = true;
                         //outofBounds = true;
+                        return;
                     }
 
+                    if (l_position.X > ((int)_parent_scene.WorldExtents.X - 0.05f) || l_position.X < 0f || l_position.Y > ((int)_parent_scene.WorldExtents.Y - 0.05f) || l_position.Y < 0f)
+                    {
+                        //base.RaiseOutOfBounds(l_position);
+                        /*
+                                                if (m_crossingfailures < _parent_scene.geomCrossingFailuresBeforeOutofbounds)
+                                                {
+                                                    _position = l_position;
+                                                    //_parent_scene.remActivePrim(this);
+                                                    if (_parent == null)
+                                                        base.RequestPhysicsterseUpdate();
+                                                    return;
+                                                }
+                                                else
+                                                {
+                                                    if (_parent == null)
+                                                        base.RaiseOutOfBounds(l_position);
+                                                    return;
+                                                }
+                        */
+                        outofBounds = true;
+                        // part near the border on outside
+                        if (l_position.X < 0)
+                            Util.Clamp(l_position.X, -0.1f, -2f);
+                        else
+                            Util.Clamp(l_position.X, _parent_scene.WorldExtents.X + 0.1f, _parent_scene.WorldExtents.X + 2f);
+                        if (l_position.Y < 0)
+                            Util.Clamp(l_position.Y, -0.1f, -2f);
+                        else
+                            Util.Clamp(l_position.Y, _parent_scene.WorldExtents.Y + 0.1f, _parent_scene.WorldExtents.Y + 2f);
+
+                        d.BodySetPosition(Body, l_position.X, l_position.Y, l_position.Z);
+
+                        // stop it
+                        d.BodySetAngularVel(Body, 0, 0, 0);
+                        d.BodySetLinearVel(Body, 0, 0, 0);
+                        disableBodySoft();
+
+                        // tell framework to fix it
+                        if (_parent == null)
+                            base.RequestPhysicsterseUpdate();
+                        return;
+                    }
+
+
                     //float Adiff = 1.0f - Math.Abs(Quaternion.Dot(m_lastorientation, l_orientation));
-//Console.WriteLine("Adiff " + Name + " = " + Adiff);
+                    //Console.WriteLine("Adiff " + Name + " = " + Adiff);
                     if ((Math.Abs(m_lastposition.X - l_position.X) < 0.02)
                         && (Math.Abs(m_lastposition.Y - l_position.Y) < 0.02)
                         && (Math.Abs(m_lastposition.Z - l_position.Z) < 0.02)
diff --git a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
index 2633f30..1d15d61 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
@@ -30,7 +30,6 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
-using System.Diagnostics; //for [DebuggerNonUserCode]
 using System.Reflection;
 using System.Runtime.Remoting;
 using System.Runtime.Remoting.Lifetime;
@@ -52,7 +51,8 @@ using OpenSim.Region.ScriptEngine.Shared.Api.Runtime;
 using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
 using OpenSim.Region.ScriptEngine.Shared.CodeTools;
 using OpenSim.Region.ScriptEngine.Interfaces;
-using System.Diagnostics;
+
+using System.Diagnostics; //for [DebuggerNonUserCode]
 
 namespace OpenSim.Region.ScriptEngine.Shared.Instance
 {
@@ -187,13 +187,13 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
 
         public UUID ItemID { get; private set; }
 
-        public UUID ObjectID { get; private set; }
+        public UUID ObjectID { get { return Part.UUID; } }
 
-        public uint LocalID { get; private set; }
+        public uint LocalID { get { return Part.LocalId; } }
 
-        public UUID RootObjectID { get; private set; }
+        public UUID RootObjectID { get { return Part.ParentGroup.UUID; } }
 
-        public uint RootLocalID { get; private set; }
+        public uint RootLocalID { get { return Part.ParentGroup.LocalId; } }
 
         public UUID AssetID { get; private set; }
 
@@ -252,7 +252,6 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
                 ItemID = ScriptTask.ItemID;
                 AssetID = ScriptTask.AssetID;
             }
-            LocalID = part.LocalId;
 
             PrimName = part.ParentGroup.Name;
             StartParam = startParam;
@@ -1070,7 +1069,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
 
         public Dictionary<string, object> GetVars()
         {
-            return m_Script.GetVars();
+            if (m_Script != null)
+                return m_Script.GetVars();
+            else
+                return new Dictionary<string, object>();
         }
 
         public void SetVars(Dictionary<string, object> vars)