From 41b9baa054b135479939528016e31cbad4a9d765 Mon Sep 17 00:00:00 2001 From: mingchen Date: Mon, 16 Jul 2007 19:52:46 +0000 Subject: *Adding some more files --- .../Environment/LandManagement/LandManager.cs | 617 +++++++++++++++++++++ 1 file changed, 617 insertions(+) create mode 100644 OpenSim/Region/Environment/LandManagement/LandManager.cs (limited to 'OpenSim/Region/Environment/LandManagement/LandManager.cs') diff --git a/OpenSim/Region/Environment/LandManagement/LandManager.cs b/OpenSim/Region/Environment/LandManagement/LandManager.cs new file mode 100644 index 0000000..a596fae --- /dev/null +++ b/OpenSim/Region/Environment/LandManagement/LandManager.cs @@ -0,0 +1,617 @@ +/* +* Copyright (c) Contributors, http://www.openmetaverse.org/ +* See CONTRIBUTORS.TXT for a full list of copyright holders. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* * Neither the name of the OpenSim Project nor the +* names of its contributors may be used to endorse or promote products +* derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS AND ANY +* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY +* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*/ +using System; +using System.Collections.Generic; +using libsecondlife; +using libsecondlife.Packets; +using OpenSim.Framework.Interfaces; +using OpenSim.Framework.Types; +using OpenSim.Region.Environment.Scenes; + +namespace OpenSim.Region.Environment.LandManagement +{ + + + #region LandManager Class + /// + /// Handles Land objects and operations requiring information from other Land objects (divide, join, etc) + /// + public class LandManager : ILocalStorageLandObjectReceiver + { + + #region Constants + //Land types set with flags in ParcelOverlay. + //Only one of these can be used. + public const byte LAND_TYPE_PUBLIC = (byte)0; //Equals 00000000 + public const byte LAND_TYPE_OWNED_BY_OTHER = (byte)1; //Equals 00000001 + public const byte LAND_TYPE_OWNED_BY_GROUP = (byte)2; //Equals 00000010 + 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 + + + //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) + //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 + public const byte LAND_FLAG_PROPERTY_BORDER_SOUTH = (byte)128; //Equals 10000000 + + //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 + 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 const int LAND_SELECT_OBJECTS_GROUP = 4; + public const int LAND_SELECT_OBJECTS_OTHER = 8; + + + //These are other constants. Yay! + public const int START_LAND_LOCAL_ID = 1; + #endregion + + #region Member Variables + public Dictionary landList = new Dictionary(); + private int lastLandLocalID = START_LAND_LOCAL_ID - 1; + private int[,] landIDList = new int[64, 64]; + + /// + /// Set to true when a prim is moved, created, added. Performs a prim count update + /// + public bool landPrimCountTainted = false; + + private Scene m_world; + private RegionInfo m_regInfo; + + #endregion + + #region Constructors + public LandManager(Scene world, RegionInfo reginfo) + { + + m_world = world; + m_regInfo = reginfo; + landIDList.Initialize(); + + } + #endregion + + #region Member Functions + + #region Parcel From Storage Functions + public void LandFromStorage(LandData data) + { + Land new_land = new Land(data.ownerID, data.isGroupOwned, m_world); + new_land.landData = data.Copy(); + new_land.setLandBitmapFromByteArray(); + addLandObject(new_land); + + } + + public void NoLandDataFromStorage() + { + resetSimLandObjects(); + } + #endregion + + #region Parcel Add/Remove/Get/Create + /// + /// Creates a basic Parcel object without an owner (a zeroed key) + /// + /// + public Land createBaseLand() + { + return new Land(new LLUUID(), false, m_world); + } + + /// + /// Adds a land object to the stored list and adds them to the landIDList to what they own + /// + /// The land object being added + public Land addLandObject(Land new_land) + { + lastLandLocalID++; + new_land.landData.localID = lastLandLocalID; + landList.Add(lastLandLocalID, new_land.Copy()); + + + bool[,] landBitmap = new_land.getLandBitmap(); + int x, y; + for (x = 0; x < 64; x++) + { + for (y = 0; y < 64; y++) + { + if (landBitmap[x, y]) + { + landIDList[x, y] = lastLandLocalID; + } + } + } + landList[lastLandLocalID].forceUpdateLandInfo(); + + return new_land; + + } + /// + /// Removes a land object from the list. Will not remove if local_id is still owning an area in landIDList + /// + /// Land.localID of the peice of land to remove. + public void removeLandObject(int local_id) + { + int x, y; + for (x = 0; x < 64; x++) + { + for (y = 0; y < 64; y++) + { + if (landIDList[x, y] == local_id) + { + throw new Exception("Could not remove land object. Still being used at " + x + ", " + y); + } + } + } + m_world.localStorage.RemoveLandObject(landList[local_id].landData); + landList.Remove(local_id); + } + + private void performFinalLandJoin(Land master, Land slave) + { + int x, y; + bool[,] landBitmapSlave = slave.getLandBitmap(); + for (x = 0; x < 64; x++) + { + for (y = 0; y < 64; y++) + { + if (landBitmapSlave[x, y]) + { + landIDList[x, y] = master.landData.localID; + } + } + } + removeLandObject(slave.landData.localID); + } + /// + /// Get the land object at the specified point + /// + /// Value between 0 - 256 on the x axis of the point + /// Value between 0 - 256 on the y axis of the point + /// Land object at the point supplied + public Land getLandObject(float x_float, float y_float) + { + int x = Convert.ToInt32(Math.Floor(Convert.ToDecimal(x_float) / Convert.ToDecimal(4.0))); + int y = Convert.ToInt32(Math.Floor(Convert.ToDecimal(y_float) / Convert.ToDecimal(4.0))); + + if (x > 63 || y > 63 || x < 0 || y < 0) + { + throw new Exception("Error: Parcel not found at point " + x + ", " + y); + } + else + { + // Console.WriteLine("Point (" + x + ", " + y + ") determined from point (" + x_float + ", " + y_float + ")"); + return landList[landIDList[x, y]]; + } + } + + public Land getLandObject(int x, int y) + { + if (x > 256 || y > 256 || x < 0 || y < 0) + { + throw new Exception("Error: Parcel not found at point " + x + ", " + y); + } + else + { + return landList[landIDList[x / 4, y / 4]]; + } + } + #endregion + + #region Parcel Modification + /// + /// Subdivides a piece of land + /// + /// West Point + /// South Point + /// East Point + /// North Point + /// LLUUID of user who is trying to subdivide + /// Returns true if successful + private bool subdivide(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id) + { + + //First, lets loop through the points and make sure they are all in the same peice of land + //Get the land object at start + Land startLandObject = getLandObject(start_x, start_y); + if (startLandObject == null) return false; //No such land object at the beginning + + //Loop through the points + try + { + int totalX = end_x - start_x; + int totalY = end_y - start_y; + int x, y; + for (y = 0; y < totalY; y++) + { + for (x = 0; x < totalX; x++) + { + Land tempLandObject = getLandObject(start_x + x, start_y + y); + if (tempLandObject == null) return false; //No such land object at that point + if (tempLandObject != startLandObject) return false; //Subdividing over 2 land objects; no-no + } + } + } + catch (Exception) + { + return false; //Exception. For now, lets skip subdivision + } + + //If we are still here, then they are subdividing within one piece of land + //Check owner + if (startLandObject.landData.ownerID != attempting_user_id) + { + return false; //They cant do this! + } + + //Lets create a new land object with bitmap activated at that point (keeping the old land objects info) + Land newLand = startLandObject.Copy(); + newLand.landData.landName = "Subdivision of " + newLand.landData.landName; + newLand.landData.globalID = LLUUID.Random(); + + newLand.setLandBitmap(Land.getSquareLandBitmap(start_x, start_y, end_x, end_y)); + + //Now, lets set the subdivision area of the original to false + int startLandObjectIndex = startLandObject.landData.localID; + landList[startLandObjectIndex].setLandBitmap(Land.modifyLandBitmapSquare(startLandObject.getLandBitmap(), start_x, start_y, end_x, end_y, false)); + landList[startLandObjectIndex].forceUpdateLandInfo(); + + + this.setPrimsTainted(); + + //Now add the new land object + Land result = addLandObject(newLand); + result.sendLandUpdateToAvatarsOverMe(); + + + + + return true; + } + /// + /// Join 2 land objects together + /// + /// x value in first piece of land + /// y value in first piece of land + /// x value in second peice of land + /// y value in second peice of land + /// LLUUID of the avatar trying to join the land objects + /// Returns true if successful + private bool join(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id) + { + end_x -= 4; + end_y -= 4; + + List selectedLandObjects = new List(); + int stepXSelected = 0; + int stepYSelected = 0; + for (stepYSelected = start_y; stepYSelected <= end_y; stepYSelected += 4) + { + for (stepXSelected = start_x; stepXSelected <= end_x; stepXSelected += 4) + { + Land p = getLandObject(stepXSelected,stepYSelected); + if (!selectedLandObjects.Contains(p)) + { + selectedLandObjects.Add(p); + } + } + } + Land masterLandObject = selectedLandObjects[0]; + selectedLandObjects.RemoveAt(0); + + + if (selectedLandObjects.Count < 1) + { + return false; //Only one piece of land selected + } + if (masterLandObject.landData.ownerID != attempting_user_id) + { + return false; //Not the same owner + } + foreach (Land p in selectedLandObjects) + { + if (p.landData.ownerID != masterLandObject.landData.ownerID) + { + return false; //Over multiple users. TODO: make this just ignore this piece of land? + } + } + foreach (Land slaveLandObject in selectedLandObjects) + { + landList[masterLandObject.landData.localID].setLandBitmap(Land.mergeLandBitmaps(masterLandObject.getLandBitmap(), slaveLandObject.getLandBitmap())); + performFinalLandJoin(masterLandObject, slaveLandObject); + } + + + this.setPrimsTainted(); + + masterLandObject.sendLandUpdateToAvatarsOverMe(); + + return true; + + + + } + #endregion + + #region Parcel Updating + /// + /// Where we send the ParcelOverlay packet to the client + /// + /// The object representing the client + public void sendParcelOverlay(IClientAPI remote_client) + { + const int LAND_BLOCKS_PER_PACKET = 1024; + int x, y = 0; + byte[] byteArray = new byte[LAND_BLOCKS_PER_PACKET]; + int byteArrayCount = 0; + int sequenceID = 0; + ParcelOverlayPacket packet; + + for (y = 0; y < 64; y++) + { + for (x = 0; x < 64; x++) + { + byte tempByte = (byte)0; //This represents the byte for the current 4x4 + Land currentParcelBlock = getLandObject(x * 4, y * 4); + + if (currentParcelBlock.landData.ownerID == remote_client.AgentId) + { + //Owner Flag + tempByte = Convert.ToByte(tempByte | LAND_TYPE_OWNED_BY_REQUESTER); + } + else if (currentParcelBlock.landData.salePrice > 0 && (currentParcelBlock.landData.authBuyerID == LLUUID.Zero || currentParcelBlock.landData.authBuyerID == remote_client.AgentId)) + { + //Sale Flag + tempByte = Convert.ToByte(tempByte | LAND_TYPE_IS_FOR_SALE); + } + else if (currentParcelBlock.landData.ownerID == LLUUID.Zero) + { + //Public Flag + tempByte = Convert.ToByte(tempByte | LAND_TYPE_PUBLIC); + } + else + { + //Other Flag + tempByte = Convert.ToByte(tempByte | LAND_TYPE_OWNED_BY_OTHER); + } + + + //Now for border control + if (x == 0) + { + tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_WEST); + } + else if (getLandObject((x - 1) * 4, y * 4) != currentParcelBlock) + { + tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_WEST); + } + + if (y == 0) + { + tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_SOUTH); + } + else if (getLandObject(x * 4, (y - 1) * 4) != currentParcelBlock) + { + tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_SOUTH); + } + + byteArray[byteArrayCount] = tempByte; + byteArrayCount++; + if (byteArrayCount >= LAND_BLOCKS_PER_PACKET) + { + byteArrayCount = 0; + packet = new ParcelOverlayPacket(); + packet.ParcelData.Data = byteArray; + packet.ParcelData.SequenceID = sequenceID; + remote_client.OutPacket((Packet)packet); + sequenceID++; + byteArray = new byte[LAND_BLOCKS_PER_PACKET]; + } + } + } + + + } + + public void handleParcelPropertiesRequest(int start_x, int start_y, int end_x, int end_y, int sequence_id, bool snap_selection, IClientAPI remote_client) + { + //Get the land objects within the bounds + List temp = new List(); + int x, y, i; + int inc_x = end_x - start_x; + int inc_y = end_y - start_y; + for (x = 0; x < inc_x; x++) + { + for (y = 0; y < inc_y; y++) + { + Land currentParcel = getLandObject(start_x + x, start_y + y); + if (!temp.Contains(currentParcel)) + { + currentParcel.forceUpdateLandInfo(); + temp.Add(currentParcel); + } + } + } + + int requestResult = LAND_RESULT_SINGLE; + if (temp.Count > 1) + { + requestResult = LAND_RESULT_MULTIPLE; + } + + for (i = 0; i < temp.Count; i++) + { + temp[i].sendLandProperties(sequence_id, snap_selection, requestResult, remote_client); + } + + + sendParcelOverlay(remote_client); + } + + public void handleParcelPropertiesUpdateRequest(ParcelPropertiesUpdatePacket packet, IClientAPI remote_client) + { + if (landList.ContainsKey(packet.ParcelData.LocalID)) + { + landList[packet.ParcelData.LocalID].updateLandProperties(packet, remote_client); + } + } + public void handleParcelDivideRequest(int west, int south, int east, int north, IClientAPI remote_client) + { + subdivide(west, south, east, north, remote_client.AgentId); + } + public void handleParcelJoinRequest(int west, int south, int east, int north, IClientAPI remote_client) + { + join(west, south, east, north, remote_client.AgentId); + + } + + public void handleParcelSelectObjectsRequest(int local_id, int request_type, IClientAPI remote_client) + { + landList[local_id].sendForceObjectSelect(local_id, request_type, remote_client); + } + + public void handleParcelObjectOwnersRequest(int local_id, IClientAPI remote_client) + { + landList[local_id].sendLandObjectOwners(remote_client); + } + #endregion + + /// + /// Resets the sim to the default land object (full sim piece of land owned by the default user) + /// + public void resetSimLandObjects() + { + //Remove all the land objects in the sim and add a blank, full sim land object set to public + landList.Clear(); + lastLandLocalID = START_LAND_LOCAL_ID - 1; + landIDList.Initialize(); + + Land fullSimParcel = new Land(LLUUID.Zero, false, m_world); + + fullSimParcel.setLandBitmap(Land.getSquareLandBitmap(0, 0, 256, 256)); + fullSimParcel.landData.ownerID = m_regInfo.MasterAvatarAssignedUUID; + + addLandObject(fullSimParcel); + + } + + + public void handleSignificantClientMovement(IClientAPI remote_client) + { + ScenePresence clientAvatar = m_world.RequestAvatar(remote_client.AgentId); + if (clientAvatar != null) + { + Land over = getLandObject(clientAvatar.Pos.X,clientAvatar.Pos.Y); + if (over != null) + { + over.sendLandProperties(0, false, 0, remote_client); + } + } + } + + public void resetAllLandPrimCounts() + { + foreach (Land p in landList.Values) + { + p.resetLandPrimCounts(); + } + } + public void setPrimsTainted() + { + this.landPrimCountTainted = true; + } + + public void addPrimToLandPrimCounts(SceneObject obj) + { + LLVector3 position = obj.Pos; + Land landUnderPrim = getLandObject(position.X, position.Y); + if (landUnderPrim != null) + { + landUnderPrim.addPrimToCount(obj); + } + } + + public void removePrimFromLandPrimCounts(SceneObject obj) + { + foreach (Land p in landList.Values) + { + p.removePrimFromCount(obj); + } + } + + public void finalizeLandPrimCountUpdate() + { + //Get Simwide prim count for owner + Dictionary> landOwnersAndParcels = new Dictionary>(); + foreach (Land p in landList.Values) + { + if(!landOwnersAndParcels.ContainsKey(p.landData.ownerID)) + { + List tempList = new List(); + tempList.Add(p); + landOwnersAndParcels.Add(p.landData.ownerID,tempList); + } + 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 + + + + + +} -- cgit v1.1