seems to compile ( tests comented out)

3 files changed, 44 insertions, 504 deletions

diff --git a/OpenSim/Region/CoreModules/World/Terrain/FloodBrushes/NoiseArea.cs b/OpenSim/Region/CoreModules/World/Terrain/FloodBrushes/NoiseArea.cs
index 236584a..d634e8b 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/FloodBrushes/NoiseArea.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/FloodBrushes/NoiseArea.cs
@@ -46,10 +46,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FloodBrushes
                     if (fillArea[x, y])
                     {
                         double noise = TerrainUtil.PerlinNoise2D((double) x / map.Width, (double) y / map.Height, 8, 1.0);
-<<<<<<< HEAD
-
-=======
->>>>>>> avn/ubitvar
                         map[x, y] += noise * strength;
                     }
                 }
diff --git a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
index 925de2a..22723fc 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
@@ -75,15 +75,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         #endregion
 
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-<<<<<<< HEAD
-=======
-        
-#pragma warning disable 414
-        private static readonly string LogHeader = "[TERRAIN MODULE]";
-#pragma warning restore 414
-
-        private readonly Commander m_commander = new Commander("terrain");
->>>>>>> avn/ubitvar
 
 #pragma warning disable 414
         private static readonly string LogHeader = "[TERRAIN MODULE]";
@@ -95,16 +86,6 @@ 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>();
-<<<<<<< HEAD
-        private Dictionary<string, ITerrainEffect> m_plugineffects;
-        private Dictionary<string, ITerrainModifier> m_modifyOperations =
-            new Dictionary<string, ITerrainModifier>();
-        private ITerrainChannel m_channel;
-        private ITerrainChannel m_revert;
-        private Scene m_scene;
-        private volatile bool m_tainted;
-        private readonly Stack<LandUndoState> m_undo = new Stack<LandUndoState>(5);
-=======
 
         private Dictionary<string, ITerrainEffect> m_plugineffects;
         private ITerrainChannel m_channel;
@@ -112,7 +93,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         private Scene m_scene;
         private volatile bool m_tainted;
 
->>>>>>> avn/ubitvar
         private String m_InitialTerrain = "pinhead-island";
 
         // If true, send terrain patch updates to clients based on their view distance
@@ -126,19 +106,12 @@ 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
-<<<<<<< HEAD
-            public TerrainData Terrain; // reference to the underlying terrain
-=======
->>>>>>> avn/ubitvar
+
             public PatchUpdates(TerrainData terrData, ScenePresence pPresence)
             {
                 updated = new bool[terrData.SizeX / Constants.TerrainPatchSize, terrData.SizeY / Constants.TerrainPatchSize];
                 updateCount = 0;
                 Presence = pPresence;
-<<<<<<< HEAD
-                Terrain = terrData;
-=======
->>>>>>> avn/ubitvar
                 // Initially, send all patches to the client
                 SetAll(true);
             }
@@ -147,26 +120,17 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             {
                 return (updateCount > 0);
             }
-<<<<<<< HEAD
 
-=======
->>>>>>> avn/ubitvar
             public void SetByXY(int x, int y, bool state)
             {
                 this.SetByPatch(x / Constants.TerrainPatchSize, y / Constants.TerrainPatchSize, state);
             }
-<<<<<<< HEAD
 
-=======
->>>>>>> avn/ubitvar
             public bool GetByPatch(int patchX, int patchY)
             {
                 return updated[patchX, patchY];
             }
-<<<<<<< HEAD
 
-=======
->>>>>>> avn/ubitvar
             public void SetByPatch(int patchX, int patchY, bool state)
             {
                 bool prevState = updated[patchX, patchY];
@@ -176,24 +140,17 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                     updateCount--;
                 updated[patchX, patchY] = state;
             }
-<<<<<<< HEAD
 
             public void SetAll(bool state)
             {
                 updateCount = 0;
-                for(int xx = 0; xx < updated.GetLength(0); xx++)
-                    for(int yy = 0; yy < updated.GetLength(1); yy++)
-=======
-            public void SetAll(bool state)
-            {
-                updateCount = 0;
                 for (int xx = 0; xx < updated.GetLength(0); xx++)
                     for (int yy = 0; yy < updated.GetLength(1); yy++)
->>>>>>> avn/ubitvar
                         updated[xx, yy] = state;
                 if (state)
                     updateCount = updated.GetLength(0) * updated.GetLength(1);
             }
+
             // Logically OR's the terrain data's patch taint map into this client's update map.
             public void SetAll(TerrainData terrData)
             {
@@ -206,15 +163,10 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                                 terrData.SizeX / Constants.TerrainPatchSize, terrData.SizeY / Constants.TerrainPatchSize)
                     );
                 }
-<<<<<<< HEAD
-                for(int xx = 0; xx < terrData.SizeX; xx += Constants.TerrainPatchSize)
-                {
-                    for(int yy = 0; yy < terrData.SizeY; yy += Constants.TerrainPatchSize)
-=======
+
                 for (int xx = 0; xx < terrData.SizeX; xx += Constants.TerrainPatchSize)
                 {
                     for (int yy = 0; yy < terrData.SizeY; yy += Constants.TerrainPatchSize)
->>>>>>> avn/ubitvar
                     {
                         // Only set tainted. The patch bit may be set if the patch was to be sent later.
                         if (terrData.IsTaintedAt(xx, yy, false))
@@ -275,20 +227,13 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                                                                      (int)m_scene.RegionInfo.RegionSizeY,
                                                                      (int)m_scene.RegionInfo.RegionSizeZ);
                     m_scene.Heightmap = m_channel;
-<<<<<<< HEAD
-                    UpdateRevertMap();
-=======
+
                     UpdateBakedMap();
->>>>>>> avn/ubitvar
                 }
                 else
                 {
                     m_channel = m_scene.Heightmap;
-<<<<<<< HEAD
-                    UpdateRevertMap();
-=======
                     UpdateBakedMap();
->>>>>>> avn/ubitvar
                 }
 
                 m_scene.RegisterModuleInterface<ITerrainModule>(this);
@@ -296,11 +241,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                 m_scene.EventManager.OnClientClosed += EventManager_OnClientClosed;
                 m_scene.EventManager.OnPluginConsole += EventManager_OnPluginConsole;
                 m_scene.EventManager.OnTerrainTick += EventManager_OnTerrainTick;
-<<<<<<< HEAD
-                m_scene.EventManager.OnFrame += EventManager_OnFrame;
-=======
                 m_scene.EventManager.OnTerrainCheckUpdates += EventManager_TerrainCheckUpdates;
->>>>>>> avn/ubitvar
             }
 
             InstallDefaultEffects();
@@ -339,11 +280,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                 // remove the commands
                 m_scene.UnregisterModuleCommander(m_commander.Name);
                 // remove the event-handlers
-<<<<<<< HEAD
-                m_scene.EventManager.OnFrame -= EventManager_OnFrame;
-=======
+
                 m_scene.EventManager.OnTerrainCheckUpdates -= EventManager_TerrainCheckUpdates;
->>>>>>> avn/ubitvar
                 m_scene.EventManager.OnTerrainTick -= EventManager_OnTerrainTick;
                 m_scene.EventManager.OnPluginConsole -= EventManager_OnPluginConsole;
                 m_scene.EventManager.OnClientClosed -= EventManager_OnClientClosed;
@@ -490,11 +428,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                         {
                             ITerrainChannel channel = loader.Value.LoadStream(stream);
                             m_channel.Merge(channel, displacement, radianRotation, rotationDisplacement);
-<<<<<<< HEAD
-                            UpdateRevertMap();
-=======
                             UpdateBakedMap();
->>>>>>> avn/ubitvar
                         }
                         catch(NotImplementedException)
                         {
@@ -574,27 +508,16 @@ namespace OpenSim.Region.CoreModules.World.Terrain
 
         // Someone diddled terrain outside the normal code paths. Set the taintedness for all clients.
         // ITerrainModule.TaintTerrain()
-<<<<<<< HEAD
-        public void TaintTerrain()
-        {
-            lock(m_perClientPatchUpdates)
-            {
-                // Set the flags for all clients so the tainted patches will be sent out
-                foreach(PatchUpdates pups in m_perClientPatchUpdates.Values)
-=======
         public void TaintTerrain ()
         {
             lock (m_perClientPatchUpdates)
             {
                 // Set the flags for all clients so the tainted patches will be sent out
                 foreach (PatchUpdates pups in m_perClientPatchUpdates.Values)
->>>>>>> avn/ubitvar
                 {
                     pups.SetAll(m_scene.Heightmap.GetTerrainData());
                 }
             }
-<<<<<<< HEAD
-=======
         }
 
         // ITerrainModule.PushTerrain()
@@ -615,38 +538,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                     pups.SetAll(true);
                 }
             }
->>>>>>> avn/ubitvar
         }
 
-        // ITerrainModule.PushTerrain()
-        public void PushTerrain(IClientAPI pClient)
-        {
-            // If view distance based, set the modified patch bits and the frame event will send the updates
-            if (m_sendTerrainUpdatesByViewDistance)
-            {
-                ScenePresence presence = m_scene.GetScenePresence(pClient.AgentId);
-                if (presence != null)
-                {
-                    lock(m_perClientPatchUpdates)
-                    {
-                        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);
-                        }
-                        // By setting all to modified, the next update tick will send the patches
-                        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
 
         private void LoadPlugins()
@@ -750,6 +643,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);
@@ -757,7 +651,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"];
@@ -778,24 +672,9 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         /// </summary>
         public void UpdateBakedMap()
         {
-<<<<<<< HEAD
-            /*
-            int x;
-            for (x = 0; x < m_channel.Width; x++)
-            {
-                int y;
-                for (y = 0; y < m_channel.Height; y++)
-                {
-                    m_revert[x, y] = m_channel[x, y];
-                }
-            }
-             */
-            m_revert = m_channel.MakeCopy();
-=======
             m_baked = m_channel.MakeCopy();
             m_painteffects[StandardTerrainEffects.Revert] = new RevertSphere(m_baked);
             m_floodeffects[StandardTerrainEffects.Revert] = new RevertArea(m_baked);
->>>>>>> avn/ubitvar
         }
 
         /// <summary>
@@ -822,13 +701,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                         {
                             ITerrainChannel channel = loader.Value.LoadFile(filename, offsetX, offsetY,
                                                                             fileWidth, fileHeight,
-<<<<<<< HEAD
-                                                                            (int)m_scene.RegionInfo.RegionSizeX,
-                                                                            (int)m_scene.RegionInfo.RegionSizeY);
-=======
                                                                             (int) m_scene.RegionInfo.RegionSizeX,
                                                                             (int) m_scene.RegionInfo.RegionSizeY);
->>>>>>> avn/ubitvar
                             m_scene.Heightmap = channel;
                             m_channel = channel;
                             UpdateBakedMap();
@@ -894,27 +768,11 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         }
 
         /// <summary>
-<<<<<<< HEAD
-        /// Called before processing of every simulation frame.
-=======
->>>>>>> avn/ubitvar
         /// This is used to check to see of any of the terrain is tainted and, if so, schedule
         /// updates for all the presences.
         /// This also checks to see if there are updates that need to be sent for each presence.
         /// This is where the logic is to send terrain updates to clients.
         /// </summary>
-<<<<<<< HEAD
-        private void EventManager_OnFrame()
-        {
-            TerrainData terrData = m_channel.GetTerrainData();
-
-            bool shouldTaint = false;
-            for(int x = 0; x < terrData.SizeX; x += Constants.TerrainPatchSize)
-            {
-                for(int y = 0; y < terrData.SizeY; y += Constants.TerrainPatchSize)
-                {
-                    if (terrData.IsTaintedAt(x, y))
-=======
         private void EventManager_TerrainCheckUpdates()
         {
             // this needs fixing
@@ -926,7 +784,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                 for (int y = 0; y < terrData.SizeY; y += Constants.TerrainPatchSize)
                 {
                     if (terrData.IsTaintedAt(x, y,true))
->>>>>>> avn/ubitvar
                     {
                         // Found a patch that was modified. Push this flag into the clients.
                         SendToClients(terrData, x, y);
@@ -944,10 +801,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                 m_scene.EventManager.TriggerTerrainTainted();
                 m_tainted = true;
             }
-<<<<<<< HEAD
-=======
-
->>>>>>> avn/ubitvar
         }
 
         /// <summary>
@@ -1016,14 +869,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                 presence.ControllingClient.OnLandUndo -= client_OnLandUndo;
                 presence.ControllingClient.OnUnackedTerrain -= client_OnUnackedTerrain;
             }
-<<<<<<< HEAD
-
-            lock(m_perClientPatchUpdates)
-                m_perClientPatchUpdates.Remove(client);
-        }
-=======
->>>>>>> avn/ubitvar
-
             lock (m_perClientPatchUpdates)
                 m_perClientPatchUpdates.Remove(client);
         }
@@ -1038,21 +883,12 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             TerrainData terrData = m_channel.GetTerrainData();
 
             bool wasLimited = false;
-<<<<<<< HEAD
-            for(int x = 0; x < terrData.SizeX; x += Constants.TerrainPatchSize)
-            {
-                for(int y = 0; y < terrData.SizeY; y += Constants.TerrainPatchSize)
-                {
-                    if (terrData.IsTaintedAt(x, y, false /* clearOnTest */))
-                    {
-=======
             for (int x = 0; x < terrData.SizeX; x += Constants.TerrainPatchSize)
             {
                 for (int y = 0; y < terrData.SizeY; y += Constants.TerrainPatchSize)
                 {
                     if (terrData.IsTaintedAt(x, y, false /* clearOnTest */))
                    {
->>>>>>> avn/ubitvar
                         // If we should respect the estate settings then
                         //     fixup and height deltas that don't respect them.
                         // Note that LimitChannelChanges() modifies the TerrainChannel with the limited height values.
@@ -1075,22 +911,13 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             float maxDelta = (float)m_scene.RegionInfo.RegionSettings.TerrainRaiseLimit;
 
             // loop through the height map for this patch and compare it against
-<<<<<<< HEAD
-            // the revert map
-            for(int x = xStart; x < xStart + Constants.TerrainPatchSize; x++)
-=======
             // the baked map
             for (int x = xStart; x < xStart + Constants.TerrainPatchSize; x++)
->>>>>>> avn/ubitvar
             {
                 for(int y = yStart; y < yStart + Constants.TerrainPatchSize; y++)
                 {
                     float requestedHeight = terrData[x, y];
-<<<<<<< HEAD
-                    float bakedHeight = (float)m_revert[x, y];
-=======
                     float bakedHeight = (float)m_baked[x, y];
->>>>>>> avn/ubitvar
                     float requestedDelta = requestedHeight - bakedHeight;
 
                     if (requestedDelta > maxDelta)
@@ -1111,19 +938,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
 
         private void client_OnLandUndo(IClientAPI client)
         {
-<<<<<<< HEAD
-            lock(m_undo)
-            {
-                if (m_undo.Count > 0)
-                {
-                    LandUndoState goback = m_undo.Pop();
-                    if (goback != null)
-                        goback.PlaybackState();
-                }
-            }
-=======
-
->>>>>>> avn/ubitvar
         }
 
         /// <summary>
@@ -1133,175 +947,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         /// <param name="x">The patch corner to send</param>
         /// <param name="y">The patch corner to send</param>
         private void SendToClients(TerrainData terrData, int x, int y)
-<<<<<<< HEAD
-        {
-            if (m_sendTerrainUpdatesByViewDistance)
-            {
-                // Add that this patch needs to be sent to the accounting for each client.
-                lock(m_perClientPatchUpdates)
-                {
-                    m_scene.ForEachScenePresence(presence =>
-                    {
-                        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);
-                    }
-                    );
-                }
-            }
-            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);
-                    }
-                );
-            }
-        }
-
-        private class PatchesToSend : IComparable<PatchesToSend>
-        {
-            public int PatchX;
-            public int PatchY;
-            public float Dist;
-
-            public PatchesToSend(int pX, int pY, float pDist)
-            {
-                PatchX = pX;
-                PatchY = pY;
-                Dist = pDist;
-            }
-
-            public int CompareTo(PatchesToSend other)
-            {
-                return Dist.CompareTo(other.Dist);
-            }
-        }
-
-        // Called each frame time to see if there are any patches to send to any of the
-        //    ScenePresences.
-        // We know this is only called if we are doing view distance patch sending so some
-        //    tests are not made.
-        // Loop through all the per-client info and send any patches necessary.
-        private void CheckSendingPatchesToClients()
-        {
-            lock(m_perClientPatchUpdates)
-            {
-                foreach(PatchUpdates pups in m_perClientPatchUpdates.Values)
-                {
-                    if (pups.HasUpdates())
-                    {
-                        // There is something that could be sent to this client.
-                        List<PatchesToSend> toSend = GetModifiedPatchesInViewDistance(pups);
-                        if (toSend.Count > 0)
-                        {
-                            // 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();
-                            /* old way that sent individual patches
-                            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);
-                            }
-                            */
-
-                            // new way that sends all patches to the protocol so they can be sent in one block
-                            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);
-                        }
-                    }
-                }
-            }
-        }
-
-        // Compute a list of modified patches that are within our view distance.
-        private List<PatchesToSend> GetModifiedPatchesInViewDistance(PatchUpdates pups)
-        {
-            List<PatchesToSend> ret = new List<PatchesToSend>();
-
-            ScenePresence presence = pups.Presence;
-            if (presence == null)
-                return ret;
-
-            Vector3 presencePos = presence.AbsolutePosition;
-
-            // Before this distance check, the whole region just showed up. Adding the distance
-            //   check causes different things to happen for the current and adjacent regions.
-            //   So, to keep legacy views, if the region is legacy sized, don't do distance check.
-            bool isLegacySizedRegion = pups.Terrain.SizeX == Constants.RegionSize && pups.Terrain.SizeY == Constants.RegionSize;
-            bool shouldCheckViewDistance = m_sendTerrainUpdatesByViewDistance && !isLegacySizedRegion;
-
-            int startX = 0;
-            int endX = (int)m_scene.RegionInfo.RegionSizeX / Constants.TerrainPatchSize;
-            int startY = 0;
-            int endY = (int)m_scene.RegionInfo.RegionSizeY / Constants.TerrainPatchSize;
-
-            // The following only reduces the size of area scanned for updates. Only significant for very large varregions.
-            if (shouldCheckViewDistance)
-            {
-                // Compute the area of patches within our draw distance
-                startX = (((int)(presencePos.X - presence.DrawDistance)) / Constants.TerrainPatchSize) - 2;
-                startX = Math.Max(startX, 0);
-                startX = Math.Min(startX, (int)m_scene.RegionInfo.RegionSizeX / Constants.TerrainPatchSize);
-                startY = (((int)(presencePos.Y - presence.DrawDistance)) / Constants.TerrainPatchSize) - 2;
-                startY = Math.Max(startY, 0);
-                startY = Math.Min(startY, (int)m_scene.RegionInfo.RegionSizeY / Constants.TerrainPatchSize);
-                endX = (((int)(presencePos.X + presence.DrawDistance)) / Constants.TerrainPatchSize) + 2;
-                endX = Math.Max(endX, 0);
-                endX = Math.Min(endX, (int)m_scene.RegionInfo.RegionSizeX / Constants.TerrainPatchSize);
-                endY = (((int)(presencePos.Y + presence.DrawDistance)) / Constants.TerrainPatchSize) + 2;
-                endY = Math.Max(endY, 0);
-                endY = Math.Min(endY, (int)m_scene.RegionInfo.RegionSizeY / Constants.TerrainPatchSize);
-            }
-
-            // m_log.DebugFormat("{0} GetModifiedPatchesInViewDistance. rName={1}, ddist={2}, apos={3}, cpos={4}, isChild={5}, start=<{6},{7}>, end=<{8},{9}>",
-            //                                     LogHeader, m_scene.RegionInfo.RegionName,
-            //                                     presence.DrawDistance, presencePos, presence.CameraPosition,
-            //                                     isLegacySizeChildRegion,
-            //                                     startX, startY, endX, endY);
-            for(int x = startX; x < endX; x++)
-            {
-                for(int y = startY; y < endY; y++)
-                {
-                    //Need to make sure we don't send the same ones over and over
-                    Vector3 patchPos = new Vector3(x * Constants.TerrainPatchSize, y * Constants.TerrainPatchSize, presencePos.Z);
-                    if (pups.GetByPatch(x, y))
-                    {
-                        //Check which has less distance, camera or avatar position, both have to be done.
-                        //Its not a radius, its a diameter and we add 50 so that it doesn't look like it cuts off
-                        if (!shouldCheckViewDistance
-                            || Util.DistanceLessThan(presencePos, patchPos, presence.DrawDistance + 50)
-                            || Util.DistanceLessThan(presence.CameraPosition, patchPos, presence.DrawDistance + 50))
-                        {
-                            //They can see it, send it to them
-                            pups.SetByPatch(x, y, false);
-                            float dist = Vector3.DistanceSquared(presencePos, patchPos);
-                            ret.Add(new PatchesToSend(x, y, dist));
-                        }
-                    }
-=======
         {
             // Add that this patch needs to be sent to the accounting for each client.
             lock (m_perClientPatchUpdates)
@@ -1475,7 +1120,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                             }
                         }
                     }
->>>>>>> avn/ubitvar
                 }
             }
             return ret;
@@ -1499,24 +1143,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                     int zx = (int)(west + 0.5);
                     int zy = (int)(north + 0.5);
 
-<<<<<<< HEAD
-                    int dx;
-                    for(dx=-n; dx<=n; dx++)
-                    {
-                        int dy;
-                        for(dy=-n; dy<=n; dy++)
-                        {
-                            int x = zx + dx;
-                            int y = zy + dy;
-                            if (x >= 0 && y >= 0 && x < m_channel.Width && y < m_channel.Height)
-                            {
-                                if (m_scene.Permissions.CanTerraformLand(agentId, new Vector3(x, y, 0)))
-                                {
-                                    allowMask[x, y] = true;
-                                    allowed = true;
-                                }
-=======
-
                     int startX = zx - n;
                     if (startX < 0)
                         startX = 0;
@@ -1542,25 +1168,17 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                             {
                                 allowMask[x, y] = true;
                                 allowed = true;
->>>>>>> avn/ubitvar
                             }
                         }
                     }
                     if (allowed)
                     {
                         StoreUndoState();
-<<<<<<< HEAD
-                        m_painteffects[(StandardTerrainEffects)action].PaintEffect(
-                            m_channel, allowMask, west, south, height, size, seconds);
-
-                        //revert changes outside estate limits
-=======
                         m_painteffects[(StandardTerrainEffects) action].PaintEffect(
                             m_channel, allowMask, west, south, height, size, seconds,
                             startX, endX, startY, endY);
 
                         //block changes outside estate limits
->>>>>>> avn/ubitvar
                         if (!god)
                             EnforceEstateLimits();
                     }
@@ -1577,22 +1195,42 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                     bool[,] fillArea = new bool[m_channel.Width, m_channel.Height];
                     fillArea.Initialize();
 
-                    int x;
-                    for(x = 0; x < m_channel.Width; x++)
+                    int startX = (int)west;
+                    int startY = (int)south;
+                    int endX = (int)east;
+                    int endY = (int)north;
+
+                    if (startX < 0)
+                        startX = 0;
+                    else if (startX >= m_channel.Width)
+                        startX = m_channel.Width - 1;
+
+                    if (endX < 0)
+                        endX = 0;
+                    else if (endX >= m_channel.Width)
+                        endX = m_channel.Width - 1;
+
+                    if (startY < 0)
+                        startY = 0;
+                    else if (startY >= m_channel.Height)
+                        startY = m_channel.Height - 1;
+
+                    if (endY < 0)
+                        endY = 0;
+                    else if (endY >= m_channel.Height)
+                        endY = m_channel.Height - 1;
+
+
+                    int x, y;
+
+                    for (x = startX; x <= endX; x++)
                     {
-                        int y;
-                        for(y = 0; y < m_channel.Height; y++)
+                        for (y = startY; y <= endY; y++)
                         {
-                            if (x < east && x > west)
+                            if (m_scene.Permissions.CanTerraformLand(agentId, new Vector3(x, y, 0)))
                             {
-                                if (y < north && y > south)
-                                {
-                                    if (m_scene.Permissions.CanTerraformLand(agentId, new Vector3(x, y, 0)))
-                                    {
-                                        fillArea[x, y] = true;
-                                        allowed = true;
-                                    }
-                                }
+                                fillArea[x, y] = true;
+                                allowed = true;
                             }
                         }
                     }
@@ -1600,15 +1238,10 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                     if (allowed)
                     {
                         StoreUndoState();
-<<<<<<< HEAD
-                        m_floodeffects[(StandardTerrainEffects)action].FloodEffect(m_channel, fillArea, size);
-
-                        //revert changes outside estate limits
-=======
-                        m_floodeffects[(StandardTerrainEffects) action].FloodEffect(m_channel, fillArea, size);
+                        m_floodeffects[(StandardTerrainEffects)action].FloodEffect(m_channel, fillArea, size,
+                            startX, endX, startY, endY);
 
                         //block changes outside estate limits
->>>>>>> avn/ubitvar
                         if (!god)
                             EnforceEstateLimits();
                     }
@@ -1641,52 +1274,22 @@ namespace OpenSim.Region.CoreModules.World.Terrain
 
         private void StoreUndoState()
         {
-<<<<<<< HEAD
-            lock(m_undo)
-            {
-                if (m_undo.Count > 0)
-                {
-                    LandUndoState last = m_undo.Peek();
-                    if (last != null)
-                    {
-                        if (last.Compare(m_channel))
-                            return;
-                    }
-                }
-
-                LandUndoState nUndo = new LandUndoState(this, m_channel);
-                m_undo.Push(nUndo);
-            }
-=======
->>>>>>> avn/ubitvar
         }
 
         #region Console Commands
 
         private void InterfaceLoadFile(Object[] args)
         {
-<<<<<<< HEAD
-            LoadFromFile((string)args[0]);
-=======
             LoadFromFile((string) args[0]);
->>>>>>> avn/ubitvar
         }
 
         private void InterfaceLoadTileFile(Object[] args)
         {
-<<<<<<< HEAD
-            LoadFromFile((string)args[0],
-                         (int)args[1],
-                         (int)args[2],
-                         (int)args[3],
-                         (int)args[4]);
-=======
             LoadFromFile((string) args[0],
                          (int) args[1],
                          (int) args[2],
                          (int) args[3],
                          (int) args[4]);
->>>>>>> avn/ubitvar
         }
 
         private void InterfaceSaveFile(Object[] args)
@@ -1711,15 +1314,9 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         private void InterfaceRevertTerrain(Object[] args)
         {
             int x, y;
-<<<<<<< HEAD
-            for(x = 0; x < m_channel.Width; x++)
-                for(y = 0; y < m_channel.Height; y++)
-                    m_channel[x, y] = m_revert[x, y];
-=======
             for (x = 0; x < m_channel.Width; x++)
                 for (y = 0; y < m_channel.Height; y++)
                     m_channel[x, y] = m_baked[x, y];
->>>>>>> avn/ubitvar
 
         }
 
@@ -1729,15 +1326,9 @@ namespace OpenSim.Region.CoreModules.World.Terrain
 
             if (direction.ToLower().StartsWith("y"))
             {
-<<<<<<< HEAD
-                for(int x = 0; x < m_channel.Width; x++)
-                {
-                    for(int y = 0; y < m_channel.Height / 2; y++)
-=======
                 for (int x = 0; x < m_channel.Width; x++)
                 {
                     for (int y = 0; y < m_channel.Height / 2; y++)
->>>>>>> avn/ubitvar
                     {
                         double height = m_channel[x, y];
                         double flippedHeight = m_channel[x, (int)m_channel.Height - 1 - y];
@@ -1749,15 +1340,9 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             }
             else if (direction.ToLower().StartsWith("x"))
             {
-<<<<<<< HEAD
-                for(int y = 0; y < m_channel.Height; y++)
-                {
-                    for(int x = 0; x < m_channel.Width / 2; x++)
-=======
                 for (int y = 0; y < m_channel.Height; y++)
                 {
                     for (int x = 0; x < m_channel.Width / 2; x++)
->>>>>>> avn/ubitvar
                     {
                         double height = m_channel[x, y];
                         double flippedHeight = m_channel[(int)m_channel.Width - 1 - x, y];
@@ -1837,47 +1422,29 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             double val = (double)args[0];
 
             int x, y;
-<<<<<<< HEAD
-            for(x = 0; x < m_channel.Width; x++)
-                for(y = 0; y < m_channel.Height; y++)
-                    m_channel[x, y] += (double)args[0];
-=======
             for (x = 0; x < m_channel.Width; x++)
                 for (y = 0; y < m_channel.Height; y++)
                     m_channel[x, y] += val;
->>>>>>> avn/ubitvar
         }
 
         private void InterfaceMultiplyTerrain(Object[] args)
         {
             int x, y;
-<<<<<<< HEAD
-            for(x = 0; x < m_channel.Width; x++)
-                for(y = 0; y < m_channel.Height; y++)
-                    m_channel[x, y] *= (double)args[0];
-=======
             double val = (double)args[0];
 
             for (x = 0; x < m_channel.Width; x++)
                 for (y = 0; y < m_channel.Height; y++)
                     m_channel[x, y] *= val;
->>>>>>> avn/ubitvar
         }
 
         private void InterfaceLowerTerrain(Object[] args)
         {
             int x, y;
-<<<<<<< HEAD
-            for(x = 0; x < m_channel.Width; x++)
-                for(y = 0; y < m_channel.Height; y++)
-                    m_channel[x, y] -= (double)args[0];
-=======
             double val = (double)args[0];
 
             for (x = 0; x < m_channel.Width; x++)
                 for (y = 0; y < m_channel.Height; y++)
                     m_channel[x, y] -= val;
->>>>>>> avn/ubitvar
         }
 
         public void InterfaceFillTerrain(Object[] args)
@@ -1885,26 +1452,16 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             int x, y;
             double val = (double)args[0];
 
-<<<<<<< HEAD
-            for(x = 0; x < m_channel.Width; x++)
-                for(y = 0; y < m_channel.Height; y++)
-                    m_channel[x, y] = (double)args[0];
-=======
             for (x = 0; x < m_channel.Width; x++)
                 for (y = 0; y < m_channel.Height; y++)
                     m_channel[x, y] = val;
->>>>>>> avn/ubitvar
         }
 
         private void InterfaceMinTerrain(Object[] args)
         {
             int x, y;
-<<<<<<< HEAD
-            for(x = 0; x < m_channel.Width; x++)
-=======
             double val = (double)args[0];
             for (x = 0; x < m_channel.Width; x++)
->>>>>>> avn/ubitvar
             {
                 for(y = 0; y < m_channel.Height; y++)
                 {
@@ -1916,19 +1473,14 @@ namespace OpenSim.Region.CoreModules.World.Terrain
         private void InterfaceMaxTerrain(Object[] args)
         {
             int x, y;
-<<<<<<< HEAD
-            for(x = 0; x < m_channel.Width; x++)
-=======
             double val = (double)args[0];
             for (x = 0; x < m_channel.Width; x++)
->>>>>>> avn/ubitvar
             {
                 for(y = 0; y < m_channel.Height; y++)
                 {
                     m_channel[x, y] = Math.Min(val, m_channel[x, y]);
                 }
             }
-<<<<<<< HEAD
         }
 
         private void InterfaceShow(Object[] args)
@@ -1944,8 +1496,6 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             double height = m_channel[(int)point.X, (int)point.Y];
 
             Console.WriteLine("Terrain height at {0} is {1}", point, height);
-=======
->>>>>>> avn/ubitvar
         }
 
         private void InterfaceShowDebugStats(Object[] args)
@@ -2157,6 +1707,7 @@ 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))
@@ -2196,6 +1747,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
             {
                 MainConsole.Instance.Output(result);
             }
+             */
         }
 
 #endregion
diff --git a/OpenSim/Region/CoreModules/World/Terrain/Tests/TerrainTest.cs b/OpenSim/Region/CoreModules/World/Terrain/Tests/TerrainTest.cs
index 40db370..b209b33 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/Tests/TerrainTest.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/Tests/TerrainTest.cs
@@ -60,12 +60,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain.Tests
             TerrainChannel map = new TerrainChannel((int)Constants.RegionSize, (int)Constants.RegionSize);
             ITerrainPaintableEffect effect = new RaiseSphere();
 
-<<<<<<< HEAD
-            effect.PaintEffect(map, allowMask, midRegion, midRegion, -1.0, 2, 6.0);
-=======
             effect.PaintEffect(map, allowMask, midRegion, midRegion, -1.0, 2, 6.0,
                 0, midRegion - 1,0, (int)Constants.RegionSize -1);
->>>>>>> avn/ubitvar
             Assert.That(map[127, midRegion] > 0.0, "Raise brush should raising value at this point (127,128).");
             Assert.That(map[125, midRegion] > 0.0, "Raise brush should raising value at this point (124,128).");
             Assert.That(map[120, midRegion] == 0.0, "Raise brush should not change value at this point (120,128).");
@@ -84,12 +80,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain.Tests
             }
             effect = new LowerSphere();
 
-<<<<<<< HEAD
-            effect.PaintEffect(map, allowMask, midRegion, midRegion, -1.0, 2, 6.0);
-=======
             effect.PaintEffect(map, allowMask, midRegion, midRegion, -1.0, 2, 6.0,
                 0, (int)Constants.RegionSize -1,0, (int)Constants.RegionSize -1);
->>>>>>> avn/ubitvar
             Assert.That(map[127, midRegion] >= 0.0, "Lower should not lowering value below 0.0 at this point (127,128).");
             Assert.That(map[127, midRegion] == 0.0, "Lower brush should lowering value to 0.0 at this point (127,128).");
             Assert.That(map[125, midRegion] < 1.0, "Lower brush should lowering value at this point (124,128).");