1 files changed, 916 insertions, 942 deletions
diff --git a/OpenSim/Region/Environment/LandManagement/LandManager.cs b/OpenSim/Region/Environment/Modules/LandManagement/LandChannel.cs
index 0b3c5de..ba0c550 100644
--- a/OpenSim/Region/Environment/LandManagement/LandManager.cs
+++ b/OpenSim/Region/Environment/Modules/LandManagement/LandChannel.cs
@@ -1,942 +1,916 @@
-/*
+using System;
- * Copyright (c) Contributors, http://opensimulator.org/
+using System.Collections.Generic;
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
+using System.Text;
- *
- * Redistribution and use in source and binary forms, with or without
+using Axiom.Math;
- * modification, are permitted provided that the following conditions are met:
+using libsecondlife;
- *     * Redistributions of source code must retain the above copyright
+using libsecondlife.Packets;
- *       notice, this list of conditions and the following disclaimer.
+using OpenSim.Framework;
- *     * Redistributions in binary form must reproduce the above copyright
+using OpenSim.Framework.Console;
- *       notice, this list of conditions and the following disclaimer in the
+using OpenSim.Region.Environment.Scenes;
- *       documentation and/or other materials provided with the distribution.
+using OpenSim.Region.Environment.Interfaces;
- *     * Neither the name of the OpenSim Project nor the
+using OpenSim.Region.Physics.Manager;
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
+namespace OpenSim.Region.Environment.Modules.LandManagement
- *
+{
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+    public class LandChannel : ILandChannel
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    {
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        #region Constants
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+        //Land types set with flags in ParcelOverlay.
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+        //Only one of these can be used. 
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+        public const byte LAND_TYPE_PUBLIC = (byte)0; //Equals 00000000
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+        public const byte LAND_TYPE_OWNED_BY_OTHER = (byte)1; //Equals 00000001
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+        public const byte LAND_TYPE_OWNED_BY_GROUP = (byte)2; //Equals 00000010
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        public const byte LAND_TYPE_OWNED_BY_REQUESTER = (byte)3; //Equals 00000011
- */
+        public const byte LAND_TYPE_IS_FOR_SALE = (byte)4; //Equals 00000100
+        public const byte LAND_TYPE_IS_BEING_AUCTIONED = (byte)5; //Equals 00000101
-using System;
-using System.Collections.Generic;
+        //Flags that when set, a border on the given side will be placed
-using Axiom.Math;
+        //NOTE: North and East is assumable by the west and south sides (if land to east has a west border, then I have an east border; etc)
-using libsecondlife;
+        //This took forever to figure out -- jeesh. /blame LL for even having to send these
-using libsecondlife.Packets;
+        public const byte LAND_FLAG_PROPERTY_BORDER_WEST = (byte)64; //Equals 01000000
-using OpenSim.Framework;
+        public const byte LAND_FLAG_PROPERTY_BORDER_SOUTH = (byte)128; //Equals 10000000
-using OpenSim.Framework.Console;
-using OpenSim.Region.Environment.Scenes;
+        //RequestResults (I think these are right, they seem to work):
-using OpenSim.Region.Environment.Interfaces;
+        public const int LAND_RESULT_SINGLE = 0; // The request they made contained only a single piece of land
-using OpenSim.Region.Physics.Manager;
+        public const int LAND_RESULT_MULTIPLE = 1; // The request they made contained more than a single peice of land
-namespace OpenSim.Region.Environment.LandManagement
+        //ParcelSelectObjects
-{
+        public const int LAND_SELECT_OBJECTS_OWNER = 2;
-    #region LandManager Class
+        public const int LAND_SELECT_OBJECTS_GROUP = 4;
+        public const int LAND_SELECT_OBJECTS_OTHER = 8;
-    /// <summary>
-    /// Handles Land objects and operations requiring information from other Land objects (divide, join, etc)
+        //These are other constants. Yay!
-    /// </summary>
+        public const int START_LAND_LOCAL_ID = 1;
-    public class LandManager
-    {
+        public const float BAN_LINE_SAFETY_HIEGHT = 100;
-        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+        #endregion
-        #region Constants
+        private Scene m_scene;
-        //Land types set with flags in ParcelOverlay.
-        //Only one of these can be used. 
+        private Dictionary<int, ILandObject> landList = new Dictionary<int, ILandObject>();
-        public const byte LAND_TYPE_PUBLIC = (byte) 0; //Equals 00000000
+        private int lastLandLocalID = START_LAND_LOCAL_ID - 1;
-        public const byte LAND_TYPE_OWNED_BY_OTHER = (byte) 1; //Equals 00000001
+        private int[,] landIDList = new int[64, 64];
-        public const byte LAND_TYPE_OWNED_BY_GROUP = (byte) 2; //Equals 00000010
-        public const byte LAND_TYPE_OWNED_BY_REQUESTER = (byte) 3; //Equals 00000011
+        private bool landPrimCountTainted = false;
-        public const byte LAND_TYPE_IS_FOR_SALE = (byte) 4; //Equals 00000100
-        public const byte LAND_TYPE_IS_BEING_AUCTIONED = (byte) 5; //Equals 00000101
+        private bool m_allowedForcefulBans = true;
+        public bool allowedForcefulBans
-        //Flags that when set, a border on the given side will be placed
+        {
-        //NOTE: North and East is assumable by the west and south sides (if land to east has a west border, then I have an east border; etc)
+            get
-        //This took forever to figure out -- jeesh. /blame LL for even having to send these
+            {
-        public const byte LAND_FLAG_PROPERTY_BORDER_WEST = (byte) 64; //Equals 01000000
+                return m_allowedForcefulBans;
-        public const byte LAND_FLAG_PROPERTY_BORDER_SOUTH = (byte) 128; //Equals 10000000
+            }
+            set
-        //RequestResults (I think these are right, they seem to work):
+            {
-        public const int LAND_RESULT_SINGLE = 0; // The request they made contained only a single piece of land
+                m_allowedForcefulBans = value;
-        public const int LAND_RESULT_MULTIPLE = 1; // The request they made contained more than a single peice of land
+            }
+        }
-        //ParcelSelectObjects
-        public const int LAND_SELECT_OBJECTS_OWNER = 2;
+        public LandChannel(Scene scene)
-        public const int LAND_SELECT_OBJECTS_GROUP = 4;
+        {
-        public const int LAND_SELECT_OBJECTS_OTHER = 8;
+            m_scene = scene;
+            landIDList.Initialize();
-        //These are other constants. Yay!
+        }
-        public const int START_LAND_LOCAL_ID = 1;
+        #region Land Object From Storage Functions
-        public const float BAN_LINE_SAFETY_HIEGHT = 100;
+        public void IncomingLandObjectsFromStorage(List<LandData> data)
+        {
-        #endregion
+            for (int i = 0; i < data.Count; i++)
+            {
-        #region Member Variables
+                //try
+                //{
-        public Dictionary<int, Land> landList = new Dictionary<int, Land>();
+                IncomingLandObjectFromStorage(data[i]);
-        private int lastLandLocalID = START_LAND_LOCAL_ID - 1;
+                //}
-        private int[,] landIDList = new int[64,64];
+                //catch (Exception ex)
+                //{
-        /// <summary>
+                //m_log.Error("[LandManager]: IncomingLandObjectsFromStorage: Exception: " + ex.ToString());
-        /// Set to true when a prim is moved, created, added. Performs a prim count update
+                //throw ex;
-        /// </summary>
+                //}
-        public bool landPrimCountTainted = false;
+            }
+            //foreach (LandData parcel in data)
-        private readonly Scene m_scene;
+            //{
-        private readonly RegionInfo m_regInfo;
+            //    IncomingLandObjectFromStorage(parcel);
+            //}
-        public bool allowedForcefulBans = true;
+        }
-        #endregion
+        public void IncomingLandObjectFromStorage(LandData data)
+        {
-        #region Constructors
+            ILandObject new_land = new LandObject(data.ownerID, data.isGroupOwned, m_scene);
+            new_land.landData = data.Copy();
-        public LandManager(Scene scene, RegionInfo reginfo)
+            new_land.setLandBitmapFromByteArray();
-        {
+            addLandObject(new_land);
-            m_scene = scene;
+        }
-            m_regInfo = reginfo;
-            landIDList.Initialize();
+        public void NoLandDataFromStorage()
-            scene.EventManager.OnAvatarEnteringNewParcel +=
+        {
-                new EventManager.AvatarEnteringNewParcel(handleAvatarChangingParcel);
+            resetSimLandObjects();
-            scene.EventManager.OnClientMovement += new EventManager.ClientMovement(handleAnyClientMovement);
+        }
-        }
+        #endregion 
-        #endregion
+        #region Parcel Add/Remove/Get/Create
-        #region Member Functions
+        /// <summary>
-        #region Land Object From Storage Functions
+        /// Creates a basic Parcel object without an owner (a zeroed key)
+        /// </summary>
-        public void IncomingLandObjectsFromStorage(List<LandData> data)
+        /// <returns></returns>
-        {
+        public ILandObject createBaseLand()
-            for (int i = 0; i < data.Count; i++)
+        {
-            {
+            return new LandObject(LLUUID.Zero, false, m_scene);
-                //try
+        }
-                //{
-                    IncomingLandObjectFromStorage(data[i]);
+        /// <summary>
-                //}
+        /// Adds a land object to the stored list and adds them to the landIDList to what they own
-                //catch (Exception ex)
+        /// </summary>
-                //{
+        /// <param name="new_land">The land object being added</param>
-                    //m_log.Error("[LandManager]: IncomingLandObjectsFromStorage: Exception: " + ex.ToString());
+        public ILandObject addLandObject(ILandObject new_land)
-                    //throw ex;
+        {
-                //}
+            lastLandLocalID++;
-            }
+            new_land.landData.localID = lastLandLocalID;
-            //foreach (LandData parcel in data)
+            landList.Add(lastLandLocalID, (LandObject)new_land.Copy());
-            //{
-            //    IncomingLandObjectFromStorage(parcel);
-            //}
+            bool[,] landBitmap = new_land.getLandBitmap();
-        }
+            int x, y;
+            for (x = 0; x < 64; x++)
-        public void IncomingLandObjectFromStorage(LandData data)
+            {
-        {
+                for (y = 0; y < 64; y++)
-            Land new_land = new Land(data.ownerID, data.isGroupOwned, m_scene);
+                {
-            new_land.landData = data.Copy();
+                    if (landBitmap[x, y])
-            new_land.setLandBitmapFromByteArray();
+                    {
-            addLandObject(new_land);
+                        landIDList[x, y] = lastLandLocalID;
-        }
+                    }
+                }
-        public void NoLandDataFromStorage()
+            }
-        {
+            landList[lastLandLocalID].forceUpdateLandInfo();
-            Console.WriteLine("No LandData in storage! Loading a single, flat parcel instead");
+            m_scene.EventManager.TriggerLandObjectAdded(new_land);
-            resetSimLandObjects();
+            return new_land;
-        }
+        }
-        #endregion
+        /// <summary>
+        /// Removes a land object from the list. Will not remove if local_id is still owning an area in landIDList
-        #region Parcel Add/Remove/Get/Create
+        /// </summary>
+        /// <param name="local_id">Land.localID of the peice of land to remove.</param>
-        /// <summary>
+        public void removeLandObject(int local_id)
-        /// Creates a basic Parcel object without an owner (a zeroed key)
+        {
-        /// </summary>
+            int x, y;
-        /// <returns></returns>
+            for (x = 0; x < 64; x++)
-        public Land createBaseLand()
+            {
-        {
+                for (y = 0; y < 64; y++)
-            return new Land(LLUUID.Zero, false, m_scene);
+                {
-        }
+                    if (landIDList[x, y] == local_id)
+                    {
-        /// <summary>
+                        return;
-        /// Adds a land object to the stored list and adds them to the landIDList to what they own
+                        //throw new Exception("Could not remove land object. Still being used at " + x + ", " + y);
-        /// </summary>
+                    }
-        /// <param name="new_land">The land object being added</param>
+                }
-        public Land addLandObject(Land new_land)
+            }
-        {
-            lastLandLocalID++;
+            m_scene.EventManager.TriggerLandObjectRemoved(landList[local_id].landData.globalID);
-            new_land.landData.localID = lastLandLocalID;
+            landList.Remove(local_id);
-            landList.Add(lastLandLocalID, new_land.Copy());
+        }
+        public void updateLandObject(int local_id, LandData newData)
-            bool[,] landBitmap = new_land.getLandBitmap();
+        {
-            int x, y;
+            if (landList.ContainsKey(local_id))
-            for (x = 0; x < 64; x++)
+            {
-            {
+                landList[local_id].landData = newData.Copy();
-                for (y = 0; y < 64; y++)
+                m_scene.EventManager.TriggerLandObjectUpdated((uint)local_id, landList[local_id]);
-                {
+            }
-                    if (landBitmap[x, y])
+        }
-                    {
-                        landIDList[x, y] = lastLandLocalID;
+        private void performFinalLandJoin(ILandObject master, ILandObject slave)
-                    }
+        {
-                }
+            int x, y;
-            }
+            bool[,] landBitmapSlave = slave.getLandBitmap();
-            landList[lastLandLocalID].forceUpdateLandInfo();
+            for (x = 0; x < 64; x++)
-            m_scene.EventManager.TriggerLandObjectAdded(new_land, m_scene.RegionInfo.RegionID);
+            {
-            return new_land;
+                for (y = 0; y < 64; y++)
-        }
+                {
+                    if (landBitmapSlave[x, y])
-        /// <summary>
+                    {
-        /// Removes a land object from the list. Will not remove if local_id is still owning an area in landIDList
+                        landIDList[x, y] = master.landData.localID;
-        /// </summary>
+                    }
-        /// <param name="local_id">Land.localID of the peice of land to remove.</param>
+                }
-        public void removeLandObject(int local_id)
+            }
-        {
-            int x, y;
+            removeLandObject(slave.landData.localID);
-            for (x = 0; x < 64; x++)
+            updateLandObject(master.landData.localID, master.landData);
-            {
+        }
-                for (y = 0; y < 64; y++)
-                {
+        /// <summary>
-                    if (landIDList[x, y] == local_id)
+        /// Get the land object at the specified point
-                    {
+        /// </summary>
-                        return;
+        /// <param name="x">Value between 0 - 256 on the x axis of the point</param>
-                        //throw new Exception("Could not remove land object. Still being used at " + x + ", " + y);
+        /// <param name="y">Value between 0 - 256 on the y axis of the point</param>
-                    }
+        /// <returns>Land object at the point supplied</returns>
-                }
+        public ILandObject getLandObject(float x_float, float y_float)
-            }
+        {
+            int x;
-            m_scene.EventManager.TriggerLandObjectRemoved(landList[local_id].landData.globalID);
+            int y;
-            landList.Remove(local_id);
-        }
+            try
+            {
-        public void updateLandObject(int local_id, LandData newData)
+                x = Convert.ToInt32(Math.Floor(Convert.ToDouble(x_float) / Convert.ToDouble(4.0)));
-        {
+                y = Convert.ToInt32(Math.Floor(Convert.ToDouble(y_float) / Convert.ToDouble(4.0)));
-            if (landList.ContainsKey(local_id))
+            }
-            {
+            catch (System.OverflowException)
-                landList[local_id].landData = newData.Copy();
+            {
-                m_scene.EventManager.TriggerLandObjectUpdated((uint) local_id, landList[local_id]);
+                return null;
-            }
+            }
-            else
-            {
+            if (x >= 64 || y >= 64 || x < 0 || y < 0)
-                //throw new Exception("Could not update land object. Local ID '" + local_id + "' does not exist");
+            {
-            }
+                return null;
-        }
+            }
+            else
-        private void performFinalLandJoin(Land master, Land slave)
+            {
-        {
+                return landList[landIDList[x, y]];
-            int x, y;
+            }
-            bool[,] landBitmapSlave = slave.getLandBitmap();
+        }
-            for (x = 0; x < 64; x++)
-            {
+        public ILandObject getLandObject(int x, int y)
-                for (y = 0; y < 64; y++)
+        {
-                {
+            if (x >= Convert.ToInt32(Constants.RegionSize) || y >= Convert.ToInt32(Constants.RegionSize) || x < 0 || y < 0)
-                    if (landBitmapSlave[x, y])
+            {
-                    {
+                // These exceptions here will cause a lot of complaints from the users specifically because
-                        landIDList[x, y] = master.landData.localID;
+                // they happen every time at border crossings
-                    }
+                throw new Exception("Error: Parcel not found at point " + x + ", " + y);
-                }
+            }
-            }
+            else
+            {
-            removeLandObject(slave.landData.localID);
+                return landList[landIDList[x / 4, y / 4]];
-            updateLandObject(master.landData.localID, master.landData);
+            }
-        }
+        }
-        /// <summary>
+        #endregion
-        /// Get the land object at the specified point
-        /// </summary>
+        #region Parcel Modification
-        /// <param name="x">Value between 0 - 256 on the x axis of the point</param>
-        /// <param name="y">Value between 0 - 256 on the y axis of the point</param>
+        /// <summary>
-        /// <returns>Land object at the point supplied</returns>
+        /// Subdivides a piece of land
-        public Land getLandObject(float x_float, float y_float)
+        /// </summary>
-        {
+        /// <param name="start_x">West Point</param>
-            int x;
+        /// <param name="start_y">South Point</param>
-            int y;
+        /// <param name="end_x">East Point</param>
+        /// <param name="end_y">North Point</param>
-            try
+        /// <param name="attempting_user_id">LLUUID of user who is trying to subdivide</param>
-            {
+        /// <returns>Returns true if successful</returns>
-                x = Convert.ToInt32(Math.Floor(Convert.ToDouble(x_float) / Convert.ToDouble(4.0)));
+        private bool subdivide(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id)
-                y = Convert.ToInt32(Math.Floor(Convert.ToDouble(y_float) / Convert.ToDouble(4.0)));
+        {
-            }
+            //First, lets loop through the points and make sure they are all in the same peice of land
-            catch (System.OverflowException)
+            //Get the land object at start
-            {
+            ILandObject startLandObject = null;
-                return null;
+            try
-            }
+            {
+                startLandObject = getLandObject(start_x, start_y);
-            if (x >= 64 || y >= 64 || x < 0 || y < 0)
+            }
-            {
+            catch (Exception)
-                return null;
+            {
-            }
+                //m_log.Error("[LAND]: " + "Unable to get land object for subdivision at x: " + start_x + " y:" + start_y);
-            else
+            }
-            {
+            if (startLandObject == null) return false; //No such land object at the beginning
-                // Console.WriteLine("Point (" + x + ", " + y + ") determined from point (" + x_float + ", " + y_float + ")");
-                return landList[landIDList[x, y]];
+            //Loop through the points
-            }
+            try
-        }
+            {
+                int totalX = end_x - start_x;
-        public Land getLandObject(int x, int y)
+                int totalY = end_y - start_y;
-        {
+                int x, y;
-            if (x >= Convert.ToInt32(Constants.RegionSize) || y >= Convert.ToInt32(Constants.RegionSize) || x < 0 || y < 0)
+                for (y = 0; y < totalY; y++)
-            {
+                {
-                // These exceptions here will cause a lot of complaints from the users specifically because
+                    for (x = 0; x < totalX; x++)
-                // they happen every time at border crossings
+                    {
-                throw new Exception("Error: Parcel not found at point " + x + ", " + y);
+                        ILandObject tempLandObject = getLandObject(start_x + x, start_y + y);
-            }
+                        if (tempLandObject == null) return false; //No such land object at that point
-            else
+                        if (tempLandObject != startLandObject) return false; //Subdividing over 2 land objects; no-no
-            {
+                    }
-                return landList[landIDList[x/4, y/4]];
+                }
-            }
+            }
-        }
+            catch (Exception)
+            {
-        #endregion
+                return false; //Exception. For now, lets skip subdivision
+            }
-        #region Parcel Modification
+            //If we are still here, then they are subdividing within one piece of land
-        /// <summary>
+            //Check owner
-        /// Subdivides a piece of land
+            if (startLandObject.landData.ownerID != attempting_user_id)
-        /// </summary>
+            {
-        /// <param name="start_x">West Point</param>
+                return false; //They cant do this!
-        /// <param name="start_y">South Point</param>
+            }
-        /// <param name="end_x">East Point</param>
-        /// <param name="end_y">North Point</param>
+            //Lets create a new land object with bitmap activated at that point (keeping the old land objects info)
-        /// <param name="attempting_user_id">LLUUID of user who is trying to subdivide</param>
+            ILandObject newLand = startLandObject.Copy();
-        /// <returns>Returns true if successful</returns>
+            newLand.landData.landName = "Subdivision of " + newLand.landData.landName;
-        private bool subdivide(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id)
+            newLand.landData.globalID = LLUUID.Random();
-        {
-            //First, lets loop through the points and make sure they are all in the same peice of land
+            newLand.setLandBitmap(newLand.getSquareLandBitmap(start_x, start_y, end_x, end_y));
-            //Get the land object at start
-            Land startLandObject = null;
+            //Now, lets set the subdivision area of the original to false
-            try
+            int startLandObjectIndex = startLandObject.landData.localID;
-            {
+            landList[startLandObjectIndex].setLandBitmap(
-                startLandObject = getLandObject(start_x, start_y);
+                newLand.modifyLandBitmapSquare(startLandObject.getLandBitmap(), start_x, start_y, end_x, end_y, false));
-            }
+            landList[startLandObjectIndex].forceUpdateLandInfo();
-            catch (Exception)
-            {
+            setPrimsTainted();
-                m_log.Error("[LAND]: " + "Unable to get land object for subdivision at x: " + start_x + " y:" + start_y);
-            }
+            //Now add the new land object
-            if (startLandObject == null) return false; //No such land object at the beginning
+            ILandObject result = addLandObject(newLand);
+            updateLandObject(startLandObject.landData.localID, startLandObject.landData);
-            //Loop through the points
+            result.sendLandUpdateToAvatarsOverMe();
-            try
-            {
-                int totalX = end_x - start_x;
+            return true;
-                int totalY = end_y - start_y;
+        }
-                int x, y;
-                for (y = 0; y < totalY; y++)
+        /// <summary>
-                {
+        /// Join 2 land objects together
-                    for (x = 0; x < totalX; x++)
+        /// </summary>
-                    {
+        /// <param name="start_x">x value in first piece of land</param>
-                        Land tempLandObject = getLandObject(start_x + x, start_y + y);
+        /// <param name="start_y">y value in first piece of land</param>
-                        if (tempLandObject == null) return false; //No such land object at that point
+        /// <param name="end_x">x value in second peice of land</param>
-                        if (tempLandObject != startLandObject) return false; //Subdividing over 2 land objects; no-no
+        /// <param name="end_y">y value in second peice of land</param>
-                    }
+        /// <param name="attempting_user_id">LLUUID of the avatar trying to join the land objects</param>
-                }
+        /// <returns>Returns true if successful</returns>
-            }
+        private bool join(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id)
-            catch (Exception)
+        {
-            {
+            end_x -= 4;
-                return false; //Exception. For now, lets skip subdivision
+            end_y -= 4;
-            }
+            List<ILandObject> selectedLandObjects = new List<ILandObject>();
-            //If we are still here, then they are subdividing within one piece of land
+            int stepXSelected = 0;
-            //Check owner
+            int stepYSelected = 0;
-            if (startLandObject.landData.ownerID != attempting_user_id)
+            for (stepYSelected = start_y; stepYSelected <= end_y; stepYSelected += 4)
-            {
+            {
-                return false; //They cant do this!
+                for (stepXSelected = start_x; stepXSelected <= end_x; stepXSelected += 4)
-            }
+                {
+                    ILandObject p = null;
-            //Lets create a new land object with bitmap activated at that point (keeping the old land objects info)
+                    try
-            Land newLand = startLandObject.Copy();
+                    {
-            newLand.landData.landName = "Subdivision of " + newLand.landData.landName;
+                        p = getLandObject(stepXSelected, stepYSelected);
-            newLand.landData.globalID = LLUUID.Random();
+                    }
+                    catch (Exception)
-            newLand.setLandBitmap(Land.getSquareLandBitmap(start_x, start_y, end_x, end_y));
+                    {
+                        //m_log.Error("[LAND]: " + "Unable to get land object for subdivision at x: " + stepXSelected + " y:" + stepYSelected);
-            //Now, lets set the subdivision area of the original to false
+                    }
-            int startLandObjectIndex = startLandObject.landData.localID;
+                    if (p != null)
-            landList[startLandObjectIndex].setLandBitmap(
+                    {
-                Land.modifyLandBitmapSquare(startLandObject.getLandBitmap(), start_x, start_y, end_x, end_y, false));
+                        if (!selectedLandObjects.Contains(p))
-            landList[startLandObjectIndex].forceUpdateLandInfo();
+                        {
+                            selectedLandObjects.Add(p);
-            setPrimsTainted();
+                        }
+                    }
-            //Now add the new land object
+                }
-            Land result = addLandObject(newLand);
+            }
-            updateLandObject(startLandObject.landData.localID, startLandObject.landData);
+            ILandObject masterLandObject = selectedLandObjects[0];
-            result.sendLandUpdateToAvatarsOverMe();
+            selectedLandObjects.RemoveAt(0);
-            return true;
+            if (selectedLandObjects.Count < 1)
-        }
+            {
+                return false; //Only one piece of land selected
-        /// <summary>
+            }
-        /// Join 2 land objects together
+            if (masterLandObject.landData.ownerID != attempting_user_id)
-        /// </summary>
+            {
-        /// <param name="start_x">x value in first piece of land</param>
+                return false; //Not the same owner
-        /// <param name="start_y">y value in first piece of land</param>
+            }
-        /// <param name="end_x">x value in second peice of land</param>
+            foreach (ILandObject p in selectedLandObjects)
-        /// <param name="end_y">y value in second peice of land</param>
+            {
-        /// <param name="attempting_user_id">LLUUID of the avatar trying to join the land objects</param>
+                if (p.landData.ownerID != masterLandObject.landData.ownerID)
-        /// <returns>Returns true if successful</returns>
+                {
-        private bool join(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id)
+                    return false; //Over multiple users. TODO: make this just ignore this piece of land?
-        {
+                }
-            end_x -= 4;
+            }
-            end_y -= 4;
+            foreach (ILandObject slaveLandObject in selectedLandObjects)
+            {
-            List<Land> selectedLandObjects = new List<Land>();
+                landList[masterLandObject.landData.localID].setLandBitmap(
-            int stepXSelected = 0;
+                    slaveLandObject.mergeLandBitmaps(masterLandObject.getLandBitmap(), slaveLandObject.getLandBitmap()));
-            int stepYSelected = 0;
+                performFinalLandJoin(masterLandObject, slaveLandObject);
-            for (stepYSelected = start_y; stepYSelected <= end_y; stepYSelected += 4)
+            }
-            {
-                for (stepXSelected = start_x; stepXSelected <= end_x; stepXSelected += 4)
-                {
+            setPrimsTainted();
-                    Land p = null;
-                    try
+            masterLandObject.sendLandUpdateToAvatarsOverMe();
-                    {
-                        p = getLandObject(stepXSelected, stepYSelected);
+            return true;
-                    }
+        }
-                    catch (Exception)
-                    {
+        public void resetAllLandPrimCounts()
-                        m_log.Error("[LAND]: " + "Unable to get land object for subdivision at x: " + stepXSelected + " y:" + stepYSelected);
+        {
-                    }
+            foreach (LandObject p in landList.Values)
-                    if (p != null)
+            {
-                    {
+                p.resetLandPrimCounts();
-                        if (!selectedLandObjects.Contains(p))
+            }
-                        {
+        }
-                            selectedLandObjects.Add(p);
-                        }
+        public void setPrimsTainted()
-                    }
+        {
-                }
+            landPrimCountTainted = true;
-            }
+        }
-            Land masterLandObject = selectedLandObjects[0];
-            selectedLandObjects.RemoveAt(0);
+        public bool isLandPrimCountTainted()
+        {
+            return landPrimCountTainted;
-            if (selectedLandObjects.Count < 1)
+        }
-            {
-                return false; //Only one piece of land selected
+        public void addPrimToLandPrimCounts(SceneObjectGroup obj)
-            }
+        {
-            if (masterLandObject.landData.ownerID != attempting_user_id)
+            LLVector3 position = obj.AbsolutePosition;
-            {
+            ILandObject landUnderPrim = getLandObject(position.X, position.Y);
-                return false; //Not the same owner
+            if (landUnderPrim != null)
-            }
+            {
-            foreach (Land p in selectedLandObjects)
+                landUnderPrim.addPrimToCount(obj);
-            {
+            }
-                if (p.landData.ownerID != masterLandObject.landData.ownerID)
+        }
-                {
-                    return false; //Over multiple users. TODO: make this just ignore this piece of land?
+        public void removePrimFromLandPrimCounts(SceneObjectGroup obj)
-                }
+        {
-            }
+            foreach (LandObject p in landList.Values)
-            foreach (Land slaveLandObject in selectedLandObjects)
+            {
-            {
+                p.removePrimFromCount(obj);
-                landList[masterLandObject.landData.localID].setLandBitmap(
+            }
-                    Land.mergeLandBitmaps(masterLandObject.getLandBitmap(), slaveLandObject.getLandBitmap()));
+        }
-                performFinalLandJoin(masterLandObject, slaveLandObject);
-            }
+        public void finalizeLandPrimCountUpdate()
+        {
+            //Get Simwide prim count for owner
-            setPrimsTainted();
+            Dictionary<LLUUID, List<LandObject>> landOwnersAndParcels = new Dictionary<LLUUID, List<LandObject>>();
+            foreach (LandObject p in landList.Values)
-            masterLandObject.sendLandUpdateToAvatarsOverMe();
+            {
+                if (!landOwnersAndParcels.ContainsKey(p.landData.ownerID))
-            return true;
+                {
-        }
+                    List<LandObject> tempList = new List<LandObject>();
+                    tempList.Add(p);
-        #endregion
+                    landOwnersAndParcels.Add(p.landData.ownerID, tempList);
+                }
-        #region Parcel Updating
+                else
+                {
-        /// <summary>
+                    landOwnersAndParcels[p.landData.ownerID].Add(p);
-        /// Where we send the ParcelOverlay packet to the client
+                }
-        /// </summary>
+            }
-        /// <param name="remote_client">The object representing the client</param>
-        public void sendParcelOverlay(IClientAPI remote_client)
+            foreach (LLUUID owner in landOwnersAndParcels.Keys)
-        {
+            {
-            const int LAND_BLOCKS_PER_PACKET = 1024;
+                int simArea = 0;
-            int x, y = 0;
+                int simPrims = 0;
-            byte[] byteArray = new byte[LAND_BLOCKS_PER_PACKET];
+                foreach (LandObject p in landOwnersAndParcels[owner])
-            int byteArrayCount = 0;
+                {
-            int sequenceID = 0;
+                    simArea += p.landData.area;
-            ParcelOverlayPacket packet;
+                    simPrims += p.landData.ownerPrims + p.landData.otherPrims + p.landData.groupPrims +
+                                p.landData.selectedPrims;
-            for (y = 0; y < 64; y++)
+                }
-            {
-                for (x = 0; x < 64; x++)
+                foreach (LandObject p in landOwnersAndParcels[owner])
-                {
+                {
-                    byte tempByte = (byte) 0; //This represents the byte for the current 4x4
+                    p.landData.simwideArea = simArea;
-                    Land currentParcelBlock = null;
+                    p.landData.simwidePrims = simPrims;
+                }
-                    try
+            }
-                    {
+        }
-                        currentParcelBlock = getLandObject(x * 4, y * 4);
-                    }
+        public void updateLandPrimCounts()
-                    catch (Exception)
+        {
-                    {
+            foreach (EntityBase obj in m_scene.Entities.Values)
-                        m_log.Warn("[LAND]: " + "unable to get land at x: " + (x * 4) + " y: " + (y * 4));
+            {
-                    }
+                if (obj is SceneObjectGroup)
-                        
+                {
-                    
+                    m_scene.EventManager.TriggerParcelPrimCountAdd((SceneObjectGroup)obj);
-                    if (currentParcelBlock != null)
+                }
-                    {
+            }
-                        if (currentParcelBlock.landData.ownerID == remote_client.AgentId)
+        }
-                        {
-                            //Owner Flag
+        public void performParcelPrimCountUpdate()
-                            tempByte = Convert.ToByte(tempByte | LAND_TYPE_OWNED_BY_REQUESTER);
+        {
-                        }
+            resetAllLandPrimCounts();
-                        else if (currentParcelBlock.landData.salePrice > 0 &&
+            m_scene.EventManager.TriggerParcelPrimCountUpdate();
-                                 (currentParcelBlock.landData.authBuyerID == LLUUID.Zero ||
+            finalizeLandPrimCountUpdate();
-                                  currentParcelBlock.landData.authBuyerID == remote_client.AgentId))
+            landPrimCountTainted = false;
-                        {
+        }
-                            //Sale Flag
+        #endregion
-                            tempByte = Convert.ToByte(tempByte | LAND_TYPE_IS_FOR_SALE);
-                        }
+        #region Parcel Updating
-                        else if (currentParcelBlock.landData.ownerID == LLUUID.Zero)
-                        {
+        /// <summary>
-                            //Public Flag
+        /// Where we send the ParcelOverlay packet to the client
-                            tempByte = Convert.ToByte(tempByte | LAND_TYPE_PUBLIC);
+        /// </summary>
-                        }
+        /// <param name="remote_client">The object representing the client</param>
-                        else
+        public void sendParcelOverlay(IClientAPI remote_client)
-                        {
+        {
-                            //Other Flag
+            const int LAND_BLOCKS_PER_PACKET = 1024;
-                            tempByte = Convert.ToByte(tempByte | LAND_TYPE_OWNED_BY_OTHER);
+            int x, y = 0;
-                        }
+            byte[] byteArray = new byte[LAND_BLOCKS_PER_PACKET];
+            int byteArrayCount = 0;
+            int sequenceID = 0;
-                        //Now for border control
+            ParcelOverlayPacket packet;
-                        try
-                        {
+            for (y = 0; y < 64; y++)
-                            Land westParcel = null;
+            {
-                            Land southParcel = null;
+                for (x = 0; x < 64; x++)
-                            if (x > 0)
+                {
-                            {
+                    byte tempByte = (byte)0; //This represents the byte for the current 4x4
-                                westParcel = getLandObject((x - 1)*4, y*4);
+                    ILandObject currentParcelBlock = null;
-                            }
-                            if (y > 0)
+                    try
-                            {
+                    {
-                                southParcel = getLandObject(x*4, (y - 1)*4);
+                        currentParcelBlock = getLandObject(x * 4, y * 4);
-                            }
+                    }
+                    catch (Exception)
-                            if (x == 0)
+                    {
-                            {
+                        //m_log.Warn("[LAND]: " + "unable to get land at x: " + (x * 4) + " y: " + (y * 4));
-                                tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_WEST);
+                    }
-                            }
-                            else if (westParcel != null && westParcel != currentParcelBlock)
-                            {
+                    if (currentParcelBlock != null)
-                                tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_WEST);
+                    {
-                            }
+                        if (currentParcelBlock.landData.ownerID == remote_client.AgentId)
+                        {
-                            if (y == 0)
+                            //Owner Flag
-                            {
+                            tempByte = Convert.ToByte(tempByte | LAND_TYPE_OWNED_BY_REQUESTER);
-                                tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_SOUTH);
+                        }
-                            }
+                        else if (currentParcelBlock.landData.salePrice > 0 &&
-                            else if (southParcel != null && southParcel != currentParcelBlock)
+                                 (currentParcelBlock.landData.authBuyerID == LLUUID.Zero ||
-                            {
+                                  currentParcelBlock.landData.authBuyerID == remote_client.AgentId))
-                                tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_SOUTH);
+                        {
-                            }
+                            //Sale Flag
+                            tempByte = Convert.ToByte(tempByte | LAND_TYPE_IS_FOR_SALE);
-                            byteArray[byteArrayCount] = tempByte;
+                        }
-                            byteArrayCount++;
+                        else if (currentParcelBlock.landData.ownerID == LLUUID.Zero)
-                            if (byteArrayCount >= LAND_BLOCKS_PER_PACKET)
+                        {
-                            {
+                            //Public Flag
-                                byteArrayCount = 0;
+                            tempByte = Convert.ToByte(tempByte | LAND_TYPE_PUBLIC);
-                                packet = (ParcelOverlayPacket) PacketPool.Instance.GetPacket(PacketType.ParcelOverlay);
+                        }
-                                packet.ParcelData.Data = byteArray;
+                        else
-                                packet.ParcelData.SequenceID = sequenceID;
+                        {
-                                remote_client.OutPacket((Packet) packet, ThrottleOutPacketType.Task);
+                            //Other Flag
-                                sequenceID++;
+                            tempByte = Convert.ToByte(tempByte | LAND_TYPE_OWNED_BY_OTHER);
-                                byteArray = new byte[LAND_BLOCKS_PER_PACKET];
+                        }
-                            }
-                        }
-                        catch (Exception e)
+                        //Now for border control
-                        {
+                        try
-                            m_log.Debug("[LAND]: Skipped Land checks because avatar is out of bounds: " + e.Message);
+                        {
-                        }
+                            ILandObject westParcel = null;
-                    }
+                            ILandObject southParcel = null;
-                }
+                            if (x > 0)
-            }
+                            {
-        }
+                                westParcel = getLandObject((x - 1) * 4, y * 4);
+                            }
-        public void handleParcelPropertiesRequest(int start_x, int start_y, int end_x, int end_y, int sequence_id,
+                            if (y > 0)
-                                                  bool snap_selection, IClientAPI remote_client)
+                            {
-        {
+                                southParcel = getLandObject(x * 4, (y - 1) * 4);
-            //Get the land objects within the bounds
+                            }
-            List<Land> temp = new List<Land>();
-            int x, y, i;
+                            if (x == 0)
-            int inc_x = end_x - start_x;
+                            {
-            int inc_y = end_y - start_y;
+                                tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_WEST);
-            for (x = 0; x < inc_x; x++)
+                            }
-            {
+                            else if (westParcel != null && westParcel != currentParcelBlock)
-                for (y = 0; y < inc_y; y++)
+                            {
-                {
+                                tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_WEST);
-                    
+                            }
-                    Land currentParcel = null;
-                    try
+                            if (y == 0)
-                    {
+                            {
-                        currentParcel = getLandObject(start_x + x, start_y + y);
+                                tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_SOUTH);
-                    }
+                            }
-                    catch (Exception)
+                            else if (southParcel != null && southParcel != currentParcelBlock)
-                    {
+                            {
-                        m_log.Warn("[LAND]: " + "unable to get land at x: " + (start_x + x) + " y: " + (start_y + y));
+                                tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_SOUTH);
-                    }
+                            }
-                    if (currentParcel != null)
-                    {
+                            byteArray[byteArrayCount] = tempByte;
-                        if (!temp.Contains(currentParcel))
+                            byteArrayCount++;
-                        {
+                            if (byteArrayCount >= LAND_BLOCKS_PER_PACKET)
-                            currentParcel.forceUpdateLandInfo();
+                            {
-                            temp.Add(currentParcel);
+                                byteArrayCount = 0;
-                        }
+                                packet = (ParcelOverlayPacket)PacketPool.Instance.GetPacket(PacketType.ParcelOverlay);
-                    }
+                                packet.ParcelData.Data = byteArray;
-                }
+                                packet.ParcelData.SequenceID = sequenceID;
-            }
+                                remote_client.OutPacket((Packet)packet, ThrottleOutPacketType.Task);
+                                sequenceID++;
-            int requestResult = LAND_RESULT_SINGLE;
+                                byteArray = new byte[LAND_BLOCKS_PER_PACKET];
-            if (temp.Count > 1)
+                            }
-            {
+                        }
-                requestResult = LAND_RESULT_MULTIPLE;
+                        catch (Exception e)
-            }
+                        {
+                            //m_log.Debug("[LAND]: Skipped Land checks because avatar is out of bounds: " + e.Message);
-            for (i = 0; i < temp.Count; i++)
+                        }
-            {
+                    }
-                temp[i].sendLandProperties(sequence_id, snap_selection, requestResult, remote_client);
+                }
-            }
+            }
+        }
-            sendParcelOverlay(remote_client);
+        public void handleParcelPropertiesRequest(int start_x, int start_y, int end_x, int end_y, int sequence_id,
-        }
+                                                  bool snap_selection, IClientAPI remote_client)
+        {
-        public void handleParcelPropertiesUpdateRequest(ParcelPropertiesUpdatePacket packet, IClientAPI remote_client)
+            //Get the land objects within the bounds
-        {
+            List<ILandObject> temp = new List<ILandObject>();
-            if (landList.ContainsKey(packet.ParcelData.LocalID))
+            int x, y, i;
-            {
+            int inc_x = end_x - start_x;
-                landList[packet.ParcelData.LocalID].updateLandProperties(packet, remote_client);
+            int inc_y = end_y - start_y;
-            }
+            for (x = 0; x < inc_x; x++)
-        }
+            {
+                for (y = 0; y < inc_y; y++)
-        public void handleParcelDivideRequest(int west, int south, int east, int north, IClientAPI remote_client)
+                {
-        {
-            subdivide(west, south, east, north, remote_client.AgentId);
+                    ILandObject currentParcel = null;
-        }
+                    try
+                    {
-        public void handleParcelJoinRequest(int west, int south, int east, int north, IClientAPI remote_client)
+                        currentParcel = getLandObject(start_x + x, start_y + y);
-        {
+                    }
-            join(west, south, east, north, remote_client.AgentId);
+                    catch (Exception)
-        }
+                    {
+                        //m_log.Warn("[LAND]: " + "unable to get land at x: " + (start_x + x) + " y: " + (start_y + y));
-        public void handleParcelSelectObjectsRequest(int local_id, int request_type, IClientAPI remote_client)
+                    }
-        {
+                    if (currentParcel != null)
-            landList[local_id].sendForceObjectSelect(local_id, request_type, remote_client);
+                    {
-        }
+                        if (!temp.Contains(currentParcel))
+                        {
-        public void handleParcelObjectOwnersRequest(int local_id, IClientAPI remote_client)
+                            currentParcel.forceUpdateLandInfo();
-        {
+                            temp.Add(currentParcel);
-            landList[local_id].sendLandObjectOwners(remote_client);
+                        }
-        }
+                    }
+                }
-        #endregion
+            }
-        /// <summary>
+            int requestResult = LAND_RESULT_SINGLE;
-        /// Resets the sim to the default land object (full sim piece of land owned by the default user)
+            if (temp.Count > 1)
-        /// </summary>
+            {
-        public void resetSimLandObjects()
+                requestResult = LAND_RESULT_MULTIPLE;
-        {
+            }
-            //Remove all the land objects in the sim and add a blank, full sim land object set to public
-            landList.Clear();
+            for (i = 0; i < temp.Count; i++)
-            lastLandLocalID = START_LAND_LOCAL_ID - 1;
+            {
-            landIDList.Initialize();
+                temp[i].sendLandProperties(sequence_id, snap_selection, requestResult, remote_client);
+            }
-            Land fullSimParcel = new Land(LLUUID.Zero, false, m_scene);
-            fullSimParcel.setLandBitmap(Land.getSquareLandBitmap(0, 0, (int)Constants.RegionSize, (int)Constants.RegionSize));
+            sendParcelOverlay(remote_client);
-            fullSimParcel.landData.ownerID = m_regInfo.MasterAvatarAssignedUUID;
+        }
-            addLandObject(fullSimParcel);
+        public void handleParcelPropertiesUpdateRequest(ParcelPropertiesUpdatePacket packet, IClientAPI remote_client)
-        }
+        {
+            if (landList.ContainsKey(packet.ParcelData.LocalID))
-        public List<Land> parcelsNearPoint(LLVector3 position)
+            {
-        {
+                landList[packet.ParcelData.LocalID].updateLandProperties(packet, remote_client);
-            List<Land> parcelsNear = new List<Land>();
+            }
-            int x, y;
+        }
-            for (x = -4; x <= 4; x += 4)
-            {
+        public void handleParcelDivideRequest(int west, int south, int east, int north, IClientAPI remote_client)
-                for (y = -4; y <= 4; y += 4)
+        {
-                {
+            subdivide(west, south, east, north, remote_client.AgentId);
-                    Land check = getLandObject(position.X + x, position.Y + y);
+        }
-                    if (check != null)
-                    {
+        public void handleParcelJoinRequest(int west, int south, int east, int north, IClientAPI remote_client)
-                        if (!parcelsNear.Contains(check))
+        {
-                        {
+            join(west, south, east, north, remote_client.AgentId);
-                            parcelsNear.Add(check);
+        }
-                        }
-                    }
+        public void handleParcelSelectObjectsRequest(int local_id, int request_type, IClientAPI remote_client)
-                }
+        {
-            }
+            landList[local_id].sendForceObjectSelect(local_id, request_type, remote_client);
+        }
-            return parcelsNear;
-        }
+        public void handleParcelObjectOwnersRequest(int local_id, IClientAPI remote_client)
+        {
-        public void sendYouAreBannedNotice(ScenePresence avatar)
+            landList[local_id].sendLandObjectOwners(remote_client);
-        {
+        }
-            if (allowedForcefulBans)
-            {
+        #endregion
-                avatar.ControllingClient.SendAlertMessage(
-                    "You are not allowed on this parcel because you are banned. Please go away. <3 OpenSim Developers");
+        /// <summary>
+        /// Resets the sim to the default land object (full sim piece of land owned by the default user)
-                avatar.PhysicsActor.Position =
+        /// </summary>
-                    new PhysicsVector(avatar.lastKnownAllowedPosition.x, avatar.lastKnownAllowedPosition.y,
+        public void resetSimLandObjects()
-                                      avatar.lastKnownAllowedPosition.z);
+        {
-                avatar.PhysicsActor.Velocity = new PhysicsVector(0, 0, 0);
+            //Remove all the land objects in the sim and add a blank, full sim land object set to public
-            }
+            landList.Clear();
-            else
+            lastLandLocalID = START_LAND_LOCAL_ID - 1;
-            {
+            landIDList.Initialize();
-                avatar.ControllingClient.SendAlertMessage(
-                    "You are not allowed on this parcel because you are banned; however, the grid administrator has disabled ban lines globally. Please obey the land owner's requests or you can be banned from the entire sim! <3 OpenSim Developers");
+            ILandObject fullSimParcel = new LandObject(LLUUID.Zero, false, m_scene);
-            }
-        }
+            fullSimParcel.setLandBitmap(fullSimParcel.getSquareLandBitmap(0, 0, (int)Constants.RegionSize, (int)Constants.RegionSize));
+            fullSimParcel.landData.ownerID = m_scene.RegionInfo.MasterAvatarAssignedUUID;
-        public void handleAvatarChangingParcel(ScenePresence avatar, int localLandID, LLUUID regionID)
-        {
+            addLandObject(fullSimParcel);
-            if (m_scene.RegionInfo.RegionID == regionID)
+        }
-            {
-                if (landList[localLandID] != null)
+        public List<ILandObject> parcelsNearPoint(LLVector3 position)
-                {
+        {
-                    Land parcelAvatarIsEntering = landList[localLandID];
+            List<ILandObject> parcelsNear = new List<ILandObject>();
-                    if (avatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT)
+            int x, y;
-                    {
+            for (x = -4; x <= 4; x += 4)
-                        if (parcelAvatarIsEntering.isBannedFromLand(avatar.UUID))
+            {
-                        {
+                for (y = -4; y <= 4; y += 4)
-                            sendYouAreBannedNotice(avatar);
+                {
-                        }
+                    ILandObject check = getLandObject(position.X + x, position.Y + y);
-                        else if (parcelAvatarIsEntering.isRestrictedFromLand(avatar.UUID))
+                    if (check != null)
-                        {
+                    {
-                            avatar.ControllingClient.SendAlertMessage(
+                        if (!parcelsNear.Contains(check))
-                                "You are not allowed on this parcel because the land owner has restricted access. For now, you can enter, but please respect the land owner's decisions (or he can ban you!). <3 OpenSim Developers");
+                        {
-                        }
+                            parcelsNear.Add(check);
-                        else
+                        }
-                        {
+                    }
-                            avatar.sentMessageAboutRestrictedParcelFlyingDown = true;
+                }
-                        }
+            }
-                    }
-                    else
+            return parcelsNear;
-                    {
+        }
-                        avatar.sentMessageAboutRestrictedParcelFlyingDown = true;
-                    }
+        public void sendYouAreBannedNotice(ScenePresence avatar)
-                }
+        {
-            }
+            if (allowedForcefulBans)
-        }
+            {
+                avatar.ControllingClient.SendAlertMessage(
-        public void sendOutNearestBanLine(IClientAPI avatar)
+                    "You are not allowed on this parcel because you are banned. Please go away. <3 OpenSim Developers");
-        {
-            List<ScenePresence> avatars = m_scene.GetAvatars();
+                avatar.PhysicsActor.Position =
-            foreach (ScenePresence presence in avatars)
+                    new PhysicsVector(avatar.lastKnownAllowedPosition.x, avatar.lastKnownAllowedPosition.y,
-            {
+                                      avatar.lastKnownAllowedPosition.z);
-                if (presence.UUID == avatar.AgentId)
+                avatar.PhysicsActor.Velocity = new PhysicsVector(0, 0, 0);
-                {
+            }
+            else
-                    List<Land> checkLandParcels = parcelsNearPoint(presence.AbsolutePosition);
+            {
-                    foreach (Land checkBan in checkLandParcels)
+                avatar.ControllingClient.SendAlertMessage(
-                    {
+                    "You are not allowed on this parcel because you are banned; however, the grid administrator has disabled ban lines globally. Please obey the land owner's requests or you can be banned from the entire sim! <3 OpenSim Developers");
-                        if (checkBan.isBannedFromLand(avatar.AgentId))
+            }
-                        {
+        }
-                            checkBan.sendLandProperties(-30000, false, (int) ParcelManager.ParcelResult.Single, avatar);
-                            return; //Only send one
+        public void handleAvatarChangingParcel(ScenePresence avatar, int localLandID, LLUUID regionID)
-                        }
+        {
-                        else if (checkBan.isRestrictedFromLand(avatar.AgentId))
+            if (m_scene.RegionInfo.RegionID == regionID)
-                        {
+            {
-                            checkBan.sendLandProperties(-40000, false, (int) ParcelManager.ParcelResult.Single, avatar);
+                if (landList[localLandID] != null)
-                            return; //Only send one
+                {
-                        }
+                    ILandObject parcelAvatarIsEntering = landList[localLandID];
-                    }
+                    if (avatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT)
-                    return;
+                    {
-                }
+                        if (parcelAvatarIsEntering.isBannedFromLand(avatar.UUID))
-            }
+                        {
-        }
+                            sendYouAreBannedNotice(avatar);
+                        }
-        public void sendLandUpdate(ScenePresence avatar, bool force)
+                        else if (parcelAvatarIsEntering.isRestrictedFromLand(avatar.UUID))
-        {
+                        {
-            Land over  = null;
+                            avatar.ControllingClient.SendAlertMessage(
-            try
+                                "You are not allowed on this parcel because the land owner has restricted access. For now, you can enter, but please respect the land owner's decisions (or he can ban you!). <3 OpenSim Developers");
-            {
+                        }
-                over = getLandObject((int)Math.Min(255, Math.Max(0, Math.Round(avatar.AbsolutePosition.X))),
+                        else
-                                          (int)Math.Min(255, Math.Max(0, Math.Round(avatar.AbsolutePosition.Y))));
+                        {
-            }
+                            avatar.sentMessageAboutRestrictedParcelFlyingDown = true;
-            catch (Exception)
+                        }
-            {
+                    }
-                m_log.Warn("[LAND]: " + "unable to get land at x: " + Math.Round(avatar.AbsolutePosition.X) + " y: " + Math.Round(avatar.AbsolutePosition.Y));
+                    else
-            }
+                    {
+                        avatar.sentMessageAboutRestrictedParcelFlyingDown = true;
-            if (over != null)
+                    }
-            {
+                }
-                if (force)
+            }
-                {
+        }
-                    if (!avatar.IsChildAgent)
-                    {
+        public void sendOutNearestBanLine(IClientAPI avatar)
-                        over.sendLandUpdateToClient(avatar.ControllingClient);
+        {
-                        m_scene.EventManager.TriggerAvatarEnteringNewParcel(avatar, over.landData.localID,
+            List<ScenePresence> avatars = m_scene.GetAvatars();
-                                                                            m_scene.RegionInfo.RegionID);
+            foreach (ScenePresence presence in avatars)
-                    }
+            {
-                }
+                if (presence.UUID == avatar.AgentId)
+                {
-                if (avatar.currentParcelUUID != over.landData.globalID)
-                {
+                    List<ILandObject> checkLandParcels = parcelsNearPoint(presence.AbsolutePosition);
-                    if (!avatar.IsChildAgent)
+                    foreach (ILandObject checkBan in checkLandParcels)
-                    {
+                    {
-                        over.sendLandUpdateToClient(avatar.ControllingClient);
+                        if (checkBan.isBannedFromLand(avatar.AgentId))
-                        avatar.currentParcelUUID = over.landData.globalID;
+                        {
-                        m_scene.EventManager.TriggerAvatarEnteringNewParcel(avatar, over.landData.localID,
+                            checkBan.sendLandProperties(-30000, false, (int)ParcelManager.ParcelResult.Single, avatar);
-                                                                            m_scene.RegionInfo.RegionID);
+                            return; //Only send one
-                    }
+                        }
-                }
+                        else if (checkBan.isRestrictedFromLand(avatar.AgentId))
-            }
+                        {
-        }
+                            checkBan.sendLandProperties(-40000, false, (int)ParcelManager.ParcelResult.Single, avatar);
-        public void sendLandUpdate(ScenePresence avatar)
+                            return; //Only send one
-        {
+                        }
-            sendLandUpdate(avatar, false);
+                    }
+                    return;
-        }
+                }
-        public void handleSignificantClientMovement(IClientAPI remote_client)
+            }
-        {
+        }
-            ScenePresence clientAvatar = m_scene.GetScenePresence(remote_client.AgentId);
+        public void sendLandUpdate(ScenePresence avatar, bool force)
-            if (clientAvatar != null)
+        {
-            {
+            ILandObject over = null;
-                sendLandUpdate(clientAvatar);
+            try
-                sendOutNearestBanLine(remote_client);
+            {
-                Land parcel = getLandObject(clientAvatar.AbsolutePosition.X, clientAvatar.AbsolutePosition.Y);
+                over = getLandObject((int)Math.Min(255, Math.Max(0, Math.Round(avatar.AbsolutePosition.X))),
-                if (parcel != null)
+                                          (int)Math.Min(255, Math.Max(0, Math.Round(avatar.AbsolutePosition.Y))));
-                {
+            }
-                    if (clientAvatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT &&
+            catch (Exception)
-                        clientAvatar.sentMessageAboutRestrictedParcelFlyingDown)
+            {
-                    {
+                //m_log.Warn("[LAND]: " + "unable to get land at x: " + Math.Round(avatar.AbsolutePosition.X) + " y: " + Math.Round(avatar.AbsolutePosition.Y));
-                        handleAvatarChangingParcel(clientAvatar, parcel.landData.localID, m_scene.RegionInfo.RegionID);
+            }
-                            //They are going below the safety line!
-                        if (!parcel.isBannedFromLand(clientAvatar.UUID))
+            if (over != null)
-                        {
+            {
-                            clientAvatar.sentMessageAboutRestrictedParcelFlyingDown = false;
+                if (force)
-                        }
+                {
-                    }
+                    if (!avatar.IsChildAgent)
-                    else if (clientAvatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT &&
+                    {
-                             parcel.isBannedFromLand(clientAvatar.UUID))
+                        over.sendLandUpdateToClient(avatar.ControllingClient);
-                    {
+                        m_scene.EventManager.TriggerAvatarEnteringNewParcel(avatar, over.landData.localID,
-                        sendYouAreBannedNotice(clientAvatar);
+                                                                            m_scene.RegionInfo.RegionID);
-                    }
+                    }
-                }
+                }
-            }
-        }
+                if (avatar.currentParcelUUID != over.landData.globalID)
+                {
-        public void handleAnyClientMovement(ScenePresence avatar)
+                    if (!avatar.IsChildAgent)
-            //Like handleSignificantClientMovement, but called with an AgentUpdate regardless of distance. 
+                    {
-        {
+                        over.sendLandUpdateToClient(avatar.ControllingClient);
-            Land over = getLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
+                        avatar.currentParcelUUID = over.landData.globalID;
-            if (over != null)
+                        m_scene.EventManager.TriggerAvatarEnteringNewParcel(avatar, over.landData.localID,
-            {
+                                                                            m_scene.RegionInfo.RegionID);
-                if (!over.isBannedFromLand(avatar.UUID) || avatar.AbsolutePosition.Z >= BAN_LINE_SAFETY_HIEGHT)
+                    }
-                {
+                }
-                    avatar.lastKnownAllowedPosition =
+            }
-                        new Vector3(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y, avatar.AbsolutePosition.Z);
+        }
-                }
+        public void sendLandUpdate(ScenePresence avatar)
-            }
+        {
-        }
+            sendLandUpdate(avatar, false);
+        }
-        public void handleParcelAccessRequest(LLUUID agentID, LLUUID sessionID, uint flags, int sequenceID,
+        public void handleSignificantClientMovement(IClientAPI remote_client)
-                                              int landLocalID, IClientAPI remote_client)
+        {
-        {
+            ScenePresence clientAvatar = m_scene.GetScenePresence(remote_client.AgentId);
-            if (landList.ContainsKey(landLocalID))
-            {
+            if (clientAvatar != null)
-                landList[landLocalID].sendAccessList(agentID, sessionID, flags, sequenceID, remote_client);
+            {
-            }
+                sendLandUpdate(clientAvatar);
-        }
+                sendOutNearestBanLine(remote_client);
+                ILandObject parcel = getLandObject(clientAvatar.AbsolutePosition.X, clientAvatar.AbsolutePosition.Y);
-        public void handleParcelAccessUpdateRequest(LLUUID agentID, LLUUID sessionID, uint flags, int landLocalID,
+                if (parcel != null)
-                                                    List<ParcelManager.ParcelAccessEntry> entries,
+                {
-                                                    IClientAPI remote_client)
+                    if (clientAvatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT &&
-        {
+                        clientAvatar.sentMessageAboutRestrictedParcelFlyingDown)
-            if (landList.ContainsKey(landLocalID))
+                    {
-            {
+                        handleAvatarChangingParcel(clientAvatar, parcel.landData.localID, m_scene.RegionInfo.RegionID);
-                if (agentID == landList[landLocalID].landData.ownerID)
+                        //They are going below the safety line!
-                {
+                        if (!parcel.isBannedFromLand(clientAvatar.UUID))
-                    landList[landLocalID].updateAccessList(flags, entries, remote_client);
+                        {
-                }
+                            clientAvatar.sentMessageAboutRestrictedParcelFlyingDown = false;
-            }
+                        }
-            else
+                    }
-            {
+                    else if (clientAvatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT &&
-                Console.WriteLine("INVALID LOCAL LAND ID");
+                             parcel.isBannedFromLand(clientAvatar.UUID))
-            }
+                    {
-        }
+                        sendYouAreBannedNotice(clientAvatar);
+                    }
-        public void resetAllLandPrimCounts()
+                }
-        {
+            }
-            foreach (Land p in landList.Values)
+        }
-            {
-                p.resetLandPrimCounts();
+        public void handleAnyClientMovement(ScenePresence avatar)
-            }
+        //Like handleSignificantClientMovement, but called with an AgentUpdate regardless of distance. 
-        }
+        {
+            ILandObject over = getLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
-        public void setPrimsTainted()
+            if (over != null)
-        {
+            {
-            landPrimCountTainted = true;
+                if (!over.isBannedFromLand(avatar.UUID) || avatar.AbsolutePosition.Z >= BAN_LINE_SAFETY_HIEGHT)
-        }
+                {
+                    avatar.lastKnownAllowedPosition =
-        public void addPrimToLandPrimCounts(SceneObjectGroup obj)
+                        new Vector3(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y, avatar.AbsolutePosition.Z);
-        {
+                }
-            LLVector3 position = obj.AbsolutePosition;
+            }
-            Land landUnderPrim = getLandObject(position.X, position.Y);
+        }
-            if (landUnderPrim != null)
-            {
-                landUnderPrim.addPrimToCount(obj);
+        public void handleParcelAccessRequest(LLUUID agentID, LLUUID sessionID, uint flags, int sequenceID,
-            }
+                                              int landLocalID, IClientAPI remote_client)
-        }
+        {
+            if (landList.ContainsKey(landLocalID))
-        public void removePrimFromLandPrimCounts(SceneObjectGroup obj)
+            {
-        {
+                landList[landLocalID].sendAccessList(agentID, sessionID, flags, sequenceID, remote_client);
-            foreach (Land p in landList.Values)
+            }
-            {
+        }
-                p.removePrimFromCount(obj);
-            }
+        public void handleParcelAccessUpdateRequest(LLUUID agentID, LLUUID sessionID, uint flags, int landLocalID,
-        }
+                                                    List<ParcelManager.ParcelAccessEntry> entries,
+                                                    IClientAPI remote_client)
-        public void finalizeLandPrimCountUpdate()
+        {
-        {
+            if (landList.ContainsKey(landLocalID))
-            //Get Simwide prim count for owner
+            {
-            Dictionary<LLUUID, List<Land>> landOwnersAndParcels = new Dictionary<LLUUID, List<Land>>();
+                if (agentID == landList[landLocalID].landData.ownerID)
-            foreach (Land p in landList.Values)
+                {
-            {
+                    landList[landLocalID].updateAccessList(flags, entries, remote_client);
-                if (!landOwnersAndParcels.ContainsKey(p.landData.ownerID))
+                }
-                {
+            }
-                    List<Land> tempList = new List<Land>();
+            else
-                    tempList.Add(p);
+            {
-                    landOwnersAndParcels.Add(p.landData.ownerID, tempList);
+                Console.WriteLine("INVALID LOCAL LAND ID");
-                }
+            }
-                else
+        }
-                {
-                    landOwnersAndParcels[p.landData.ownerID].Add(p);
+    }
-                }
+}
-            }
-            foreach (LLUUID owner in landOwnersAndParcels.Keys)
-            {
-                int simArea = 0;
-                int simPrims = 0;
-                foreach (Land p in landOwnersAndParcels[owner])
-                {
-                    simArea += p.landData.area;
-                    simPrims += p.landData.ownerPrims + p.landData.otherPrims + p.landData.groupPrims +
-                                p.landData.selectedPrims;
-                }
-                foreach (Land p in landOwnersAndParcels[owner])
-                {
-                    p.landData.simwideArea = simArea;
-                    p.landData.simwidePrims = simPrims;
-                }
-            }
-        }
-        #endregion
-    }
-    #endregion
-}