OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

*Refactor of the LandManagementModule that allows OpenSim to run without it

0.6.0-stable
mingchen 2008-05-23 15:12:15 +00:00
parent bf23e5d66c
commit d04443b4fe
9 changed files with 1071 additions and 944 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
OpenSim/Region/Application/OpenSimMain.cs
View File

@ -617,7 +617,7 @@ namespace OpenSim
scene.StartScripts();
scene.loadAllLandObjectsFromStorage(regionInfo.originRegionID);
scene.LandChannel.PerformParcelPrimCountUpdate();
scene.EventManager.TriggerParcelPrimCountUpdate();
m_sceneManager.Add(scene);

25
OpenSim/Region/Environment/Interfaces/ILandChannel.cs
View File

@ -34,31 +34,12 @@ namespace OpenSim.Region.Environment.Interfaces
{
public interface ILandChannel
{
bool AllowedForcefulBans { get; set; }
void IncomingLandObjectsFromStorage(List<LandData> data);
void IncomingLandObjectFromStorage(LandData data);
void NoLandDataFromStorage();
List<ILandObject> ParcelsNearPoint(LLVector3 position);
ILandObject GetLandObject(int x, int y);
ILandObject GetLandObject(float x, float y);
void SetPrimsTainted();
bool IsLandPrimCountTainted();
void SendLandUpdate(ScenePresence avatar, bool force);
void SendLandUpdate(ScenePresence avatar);
void ResetAllLandPrimCounts();
void AddPrimToLandPrimCounts(SceneObjectGroup obj);
void RemovePrimFromLandPrimCounts(SceneObjectGroup obj);
void FinalizeLandPrimCountUpdate();
void UpdateLandPrimCounts();
void PerformParcelPrimCountUpdate();
void UpdateLandObject(int local_id, LandData newData);
void SendParcelOverlay(IClientAPI remote_client);
void ResetSimLandObjects();
List<ILandObject> ParcelsNearPoint(LLVector3 position);
void SendYouAreBannedNotice(ScenePresence avatar);
void handleAvatarChangingParcel(ScenePresence avatar, int localLandID, LLUUID regionID);
void SendOutNearestBanLine(IClientAPI avatar);
bool IsForcefulBansAllowed();
void UpdateLandObject(int localID, LandData data);
}
}

884
OpenSim/Region/Environment/Modules/World/Land/LandChannel.cs
View File

@ -27,12 +27,10 @@
using System;
using System.Collections.Generic;
using Axiom.Math;
using libsecondlife;
using OpenSim.Framework;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Physics.Manager;
namespace OpenSim.Region.Environment.Modules.World.Land
{
@ -66,68 +64,17 @@ namespace OpenSim.Region.Environment.Modules.World.Land
#endregion
private readonly int[,] landIDList = new int[64,64];
private readonly Dictionary<int, ILandObject> landList = new Dictionary<int, ILandObject>();
private bool landPrimCountTainted;
private int lastLandLocalID = START_LAND_LOCAL_ID - 1;
private bool m_allowedForcefulBans = true;
private readonly Scene m_scene;
private readonly LandManagementModule m_landManagementModule;
public LandChannel(Scene scene)
public LandChannel(Scene scene, LandManagementModule landManagementMod)
{
m_scene = scene;
landIDList.Initialize();
m_landManagementModule = landManagementMod;
}
#region Land Object From Storage Functions
#region ILandChannel Members
public void IncomingLandObjectsFromStorage(List<LandData> data)
{
for (int i = 0; i < data.Count; i++)
{
//try
//{
IncomingLandObjectFromStorage(data[i]);
//}
//catch (Exception ex)
//{
//m_log.Error("[LandManager]: IncomingLandObjectsFromStorage: Exception: " + ex.ToString());
//throw ex;
//}
}
//foreach (LandData parcel in data)
//{
// IncomingLandObjectFromStorage(parcel);
//}
}
public void IncomingLandObjectFromStorage(LandData data)
{
ILandObject new_land = new LandObject(data.ownerID, data.isGroupOwned, m_scene);
new_land.landData = data.Copy();
new_land.setLandBitmapFromByteArray();
AddLandObject(new_land);
}
public void NoLandDataFromStorage()
{
ResetSimLandObjects();
}
#endregion
#region Parcel Add/Remove/Get/Create
public void UpdateLandObject(int local_id, LandData newData)
{
if (landList.ContainsKey(local_id))
{
landList[local_id].landData = newData.Copy();
m_scene.EventManager.TriggerLandObjectUpdated((uint) local_id, landList[local_id]);
}
}
/// <summary>
/// Get the land object at the specified point
@ -137,834 +84,65 @@ namespace OpenSim.Region.Environment.Modules.World.Land
/// <returns>Land object at the point supplied</returns>
public ILandObject GetLandObject(float x_float, float y_float)
{
int x;
int y;
try
if (m_landManagementModule != null)
{
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)));
return m_landManagementModule.GetLandObject(x_float, y_float);
}
catch (OverflowException)
{
return null;
}
if (x >= 64 || y >= 64 || x < 0 || y < 0)
{
return null;
}
return landList[landIDList[x, y]];
ILandObject obj = new LandObject(LLUUID.Zero, false, m_scene);
obj.landData.landName = "NO LAND";
return obj;
}
public ILandObject GetLandObject(int x, int y)
{
if (x >= Convert.ToInt32(Constants.RegionSize) || y >= Convert.ToInt32(Constants.RegionSize) || x < 0 || y < 0)
if (m_landManagementModule != null)
{
// These exceptions here will cause a lot of complaints from the users specifically because
// they happen every time at border crossings
throw new Exception("Error: Parcel not found at point " + x + ", " + y);
return m_landManagementModule.GetLandObject(x, y);
}
return landList[landIDList[x / 4, y / 4]];
}
/// <summary>
/// Creates a basic Parcel object without an owner (a zeroed key)
/// </summary>
/// <returns></returns>
public ILandObject CreateBaseLand()
{
return new LandObject(LLUUID.Zero, false, m_scene);
}
/// <summary>
/// Adds a land object to the stored list and adds them to the landIDList to what they own
/// </summary>
/// <param name="new_land">The land object being added</param>
public ILandObject AddLandObject(ILandObject new_land)
{
lastLandLocalID++;
new_land.landData.localID = lastLandLocalID;
landList.Add(lastLandLocalID, new_land.Copy());
bool[,] landBitmap = new_land.getLandBitmap();
int x;
for (x = 0; x < 64; x++)
{
int y;
for (y = 0; y < 64; y++)
{
if (landBitmap[x, y])
{
landIDList[x, y] = lastLandLocalID;
}
}
}
landList[lastLandLocalID].forceUpdateLandInfo();
m_scene.EventManager.TriggerLandObjectAdded(new_land);
return new_land;
}
/// <summary>
/// Removes a land object from the list. Will not remove if local_id is still owning an area in landIDList
/// </summary>
/// <param name="local_id">Land.localID of the peice of land to remove.</param>
public void removeLandObject(int local_id)
{
int x;
for (x = 0; x < 64; x++)
{
int y;
for (y = 0; y < 64; y++)
{
if (landIDList[x, y] == local_id)
{
return;
//throw new Exception("Could not remove land object. Still being used at " + x + ", " + y);
}
}
}
m_scene.EventManager.TriggerLandObjectRemoved(landList[local_id].landData.globalID);
landList.Remove(local_id);
}
private void performFinalLandJoin(ILandObject master, ILandObject slave)
{
int x;
bool[,] landBitmapSlave = slave.getLandBitmap();
for (x = 0; x < 64; x++)
{
int y;
for (y = 0; y < 64; y++)
{
if (landBitmapSlave[x, y])
{
landIDList[x, y] = master.landData.localID;
}
}
}
removeLandObject(slave.landData.localID);
UpdateLandObject(master.landData.localID, master.landData);
}
public ILandObject GetLandObject(int parcelLocalID)
{
lock (landList)
{
if (landList.ContainsKey(parcelLocalID))
{
return landList[parcelLocalID];
}
}
return null;
}
#endregion
#region Parcel Modification
public void ResetAllLandPrimCounts()
{
foreach (LandObject p in landList.Values)
{
p.resetLandPrimCounts();
}
}
public void SetPrimsTainted()
{
landPrimCountTainted = true;
}
public bool IsLandPrimCountTainted()
{
return landPrimCountTainted;
}
public void AddPrimToLandPrimCounts(SceneObjectGroup obj)
{
LLVector3 position = obj.AbsolutePosition;
ILandObject landUnderPrim = GetLandObject(position.X, position.Y);
if (landUnderPrim != null)
{
landUnderPrim.addPrimToCount(obj);
}
}
public void RemovePrimFromLandPrimCounts(SceneObjectGroup obj)
{
foreach (LandObject p in landList.Values)
{
p.removePrimFromCount(obj);
}
}
public void FinalizeLandPrimCountUpdate()
{
//Get Simwide prim count for owner
Dictionary<LLUUID, List<LandObject>> landOwnersAndParcels = new Dictionary<LLUUID, List<LandObject>>();
foreach (LandObject p in landList.Values)
{
if (!landOwnersAndParcels.ContainsKey(p.landData.ownerID))
{
List<LandObject> tempList = new List<LandObject>();
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 (LandObject p in landOwnersAndParcels[owner])
{
simArea += p.landData.area;
simPrims += p.landData.ownerPrims + p.landData.otherPrims + p.landData.groupPrims +
p.landData.selectedPrims;
}
foreach (LandObject p in landOwnersAndParcels[owner])
{
p.landData.simwideArea = simArea;
p.landData.simwidePrims = simPrims;
}
}
}
public void UpdateLandPrimCounts()
{
foreach (EntityBase obj in m_scene.Entities.Values)
{
if (obj is SceneObjectGroup)
{
m_scene.EventManager.TriggerParcelPrimCountAdd((SceneObjectGroup) obj);
}
}
}
public void PerformParcelPrimCountUpdate()
{
ResetAllLandPrimCounts();
m_scene.EventManager.TriggerParcelPrimCountUpdate();
FinalizeLandPrimCountUpdate();
landPrimCountTainted = false;
}
/// <summary>
/// Subdivides a piece of land
/// </summary>
/// <param name="start_x">West Point</param>
/// <param name="start_y">South Point</param>
/// <param name="end_x">East Point</param>
/// <param name="end_y">North Point</param>
/// <param name="attempting_user_id">LLUUID of user who is trying to subdivide</param>
/// <returns>Returns true if successful</returns>
private void 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
ILandObject startLandObject = GetLandObject(start_x, start_y);
if (startLandObject == null) return;
//Loop through the points
try
{
int totalX = end_x - start_x;
int totalY = end_y - start_y;
int y;
for (y = 0; y < totalY; y++)
{
int x;
for (x = 0; x < totalX; x++)
{
ILandObject tempLandObject = GetLandObject(start_x + x, start_y + y);
if (tempLandObject == null) return;
if (tempLandObject != startLandObject) return;
}
}
}
catch (Exception)
{
return;
}
//If we are still here, then they are subdividing within one piece of land
//Check owner
if (!m_scene.ExternalChecks.ExternalChecksCanEditParcel(attempting_user_id,startLandObject))
{
return;
}
//Lets create a new land object with bitmap activated at that point (keeping the old land objects info)
ILandObject newLand = startLandObject.Copy();
newLand.landData.landName = "Subdivision of " + newLand.landData.landName;
newLand.landData.globalID = LLUUID.Random();
newLand.setLandBitmap(newLand.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(
newLand.modifyLandBitmapSquare(startLandObject.getLandBitmap(), start_x, start_y, end_x, end_y, false));
landList[startLandObjectIndex].forceUpdateLandInfo();
SetPrimsTainted();
//Now add the new land object
ILandObject result = AddLandObject(newLand);
UpdateLandObject(startLandObject.landData.localID, startLandObject.landData);
result.sendLandUpdateToAvatarsOverMe();
return;
}
/// <summary>
/// Join 2 land objects together
/// </summary>
/// <param name="start_x">x value in first piece of land</param>
/// <param name="start_y">y value in first piece of land</param>
/// <param name="end_x">x value in second peice of land</param>
/// <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 void join(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id)
{
end_x -= 4;
end_y -= 4;
List<ILandObject> selectedLandObjects = new List<ILandObject>();
int stepYSelected;
for (stepYSelected = start_y; stepYSelected <= end_y; stepYSelected += 4)
{
int stepXSelected;
for (stepXSelected = start_x; stepXSelected <= end_x; stepXSelected += 4)
{
ILandObject p = GetLandObject(stepXSelected, stepYSelected);
if (p != null)
{
if (!selectedLandObjects.Contains(p))
{
selectedLandObjects.Add(p);
}
}
}
}
ILandObject masterLandObject = selectedLandObjects[0];
selectedLandObjects.RemoveAt(0);
if (selectedLandObjects.Count < 1)
{
return;
}
if (!m_scene.ExternalChecks.ExternalChecksCanEditParcel(attempting_user_id, masterLandObject))
{
return;
}
foreach (ILandObject p in selectedLandObjects)
{
if (p.landData.ownerID != masterLandObject.landData.ownerID)
{
return;
}
}
foreach (ILandObject slaveLandObject in selectedLandObjects)
{
landList[masterLandObject.landData.localID].setLandBitmap(
slaveLandObject.mergeLandBitmaps(masterLandObject.getLandBitmap(), slaveLandObject.getLandBitmap()));
performFinalLandJoin(masterLandObject, slaveLandObject);
}
SetPrimsTainted();
masterLandObject.sendLandUpdateToAvatarsOverMe();
return;
}
#endregion
#region Parcel Updating
/// <summary>
/// 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)
{
const int LAND_BLOCKS_PER_PACKET = 1024;
byte[] byteArray = new byte[LAND_BLOCKS_PER_PACKET];
int byteArrayCount = 0;
int sequenceID = 0;
int y;
for (y = 0; y < 64; y++)
{
int x;
for (x = 0; x < 64; x++)
{
byte tempByte = 0; //This represents the byte for the current 4x4
ILandObject currentParcelBlock = GetLandObject(x * 4, y * 4);
if (currentParcelBlock != null)
{
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
ILandObject westParcel = null;
ILandObject southParcel = null;
if (x > 0)
{
westParcel = GetLandObject((x - 1) * 4, y * 4);
}
if (y > 0)
{
southParcel = GetLandObject(x * 4, (y - 1) * 4);
}
if (x == 0)
{
tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_WEST);
}
else if (westParcel != null && westParcel != currentParcelBlock)
{
tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_WEST);
}
if (y == 0)
{
tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_SOUTH);
}
else if (southParcel != null && southParcel != currentParcelBlock)
{
tempByte = Convert.ToByte(tempByte | LAND_FLAG_PROPERTY_BORDER_SOUTH);
}
byteArray[byteArrayCount] = tempByte;
byteArrayCount++;
if (byteArrayCount >= LAND_BLOCKS_PER_PACKET)
{
remote_client.sendLandParcelOverlay(byteArray, sequenceID);
byteArrayCount = 0;
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<ILandObject> temp = new List<ILandObject>();
int x;
int i;
int inc_x = end_x - start_x;
int inc_y = end_y - start_y;
for (x = 0; x < inc_x; x++)
{
int y;
for (y = 0; y < inc_y; y++)
{
ILandObject currentParcel = GetLandObject(start_x + x, start_y + y);
if (currentParcel != null)
{
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(LandUpdateArgs args, int localID, IClientAPI remote_client)
{
if (landList.ContainsKey(localID))
{
landList[localID].updateLandProperties(args, 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);
}
public void handleParcelAbandonRequest(int local_id, IClientAPI remote_client)
{
if (landList.ContainsKey(local_id))
{
if (m_scene.ExternalChecks.ExternalChecksCanAbandonParcel(remote_client.AgentId, landList[local_id]))
{
landList[local_id].landData.ownerID = m_scene.RegionInfo.MasterAvatarAssignedUUID;
m_scene.Broadcast(SendParcelOverlay);
}
}
}
#endregion
#region ILandChannel Members
public bool AllowedForcefulBans
{
get { return m_allowedForcefulBans; }
set { m_allowedForcefulBans = value; }
}
/// <summary>
/// Resets the sim to the default land object (full sim piece of land owned by the default user)
/// </summary>
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();
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;
AddLandObject(fullSimParcel);
ILandObject obj = new LandObject(LLUUID.Zero, false, m_scene);
obj.landData.landName = "NO LAND";
return obj;
}
public List<ILandObject> ParcelsNearPoint(LLVector3 position)
{
List<ILandObject> parcelsNear = new List<ILandObject>();
int x;
for (x = -4; x <= 4; x += 4)
if (m_landManagementModule != null)
{
int y;
for (y = -4; y <= 4; y += 4)
{
ILandObject check = GetLandObject(position.X + x, position.Y + y);
if (check != null)
{
if (!parcelsNear.Contains(check))
{
parcelsNear.Add(check);
}
}
}
return m_landManagementModule.ParcelsNearPoint(position);
}
return parcelsNear;
return new List<ILandObject>();
}
public void SendYouAreBannedNotice(ScenePresence avatar)
public bool IsLandPrimCountTainted()
{
if (AllowedForcefulBans)
if (m_landManagementModule != null)
{
avatar.ControllingClient.SendAlertMessage(
"You are not allowed on this parcel because you are banned. Please go away. <3 OpenSim Developers");
return m_landManagementModule.IsLandPrimCountTainted();
}
avatar.PhysicsActor.Position =
new PhysicsVector(avatar.lastKnownAllowedPosition.x, avatar.lastKnownAllowedPosition.y,
avatar.lastKnownAllowedPosition.z);
avatar.PhysicsActor.Velocity = new PhysicsVector(0, 0, 0);
}
else
{
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");
}
return false;
}
public void handleAvatarChangingParcel(ScenePresence avatar, int localLandID, LLUUID regionID)
public bool IsForcefulBansAllowed()
{
if (m_scene.RegionInfo.RegionID == regionID)
if (m_landManagementModule != null)
{
if (landList[localLandID] != null)
{
ILandObject parcelAvatarIsEntering = landList[localLandID];
if (avatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT)
{
if (parcelAvatarIsEntering.isBannedFromLand(avatar.UUID))
{
SendYouAreBannedNotice(avatar);
}
else if (parcelAvatarIsEntering.isRestrictedFromLand(avatar.UUID))
{
avatar.ControllingClient.SendAlertMessage(
"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");
}
else
{
avatar.sentMessageAboutRestrictedParcelFlyingDown = true;
}
}
else
{
avatar.sentMessageAboutRestrictedParcelFlyingDown = true;
}
}
return m_landManagementModule.AllowedForcefulBans;
}
return false;
}
public void SendOutNearestBanLine(IClientAPI avatar)
public void UpdateLandObject(int localID, LandData data)
{
List<ScenePresence> avatars = m_scene.GetAvatars();
foreach (ScenePresence presence in avatars)
if (m_landManagementModule != null)
{
if (presence.UUID == avatar.AgentId)
{
List<ILandObject> checkLandParcels = ParcelsNearPoint(presence.AbsolutePosition);
foreach (ILandObject checkBan in checkLandParcels)
{
if (checkBan.isBannedFromLand(avatar.AgentId))
{
checkBan.sendLandProperties(-30000, false, (int) ParcelManager.ParcelResult.Single, avatar);
return; //Only send one
}
if (checkBan.isRestrictedFromLand(avatar.AgentId))
{
checkBan.sendLandProperties(-40000, false, (int) ParcelManager.ParcelResult.Single, avatar);
return; //Only send one
}
}
return;
}
m_landManagementModule.UpdateLandObject(localID, data);
}
}
public void SendLandUpdate(ScenePresence avatar, bool force)
{
ILandObject over = GetLandObject((int) Math.Min(255, Math.Max(0, Math.Round(avatar.AbsolutePosition.X))),
(int) Math.Min(255, Math.Max(0, Math.Round(avatar.AbsolutePosition.Y))));
if (over != null)
{
if (force)
{
if (!avatar.IsChildAgent)
{
over.sendLandUpdateToClient(avatar.ControllingClient);
m_scene.EventManager.TriggerAvatarEnteringNewParcel(avatar, over.landData.localID,
m_scene.RegionInfo.RegionID);
}
}
if (avatar.currentParcelUUID != over.landData.globalID)
{
if (!avatar.IsChildAgent)
{
over.sendLandUpdateToClient(avatar.ControllingClient);
avatar.currentParcelUUID = over.landData.globalID;
m_scene.EventManager.TriggerAvatarEnteringNewParcel(avatar, over.landData.localID,
m_scene.RegionInfo.RegionID);
}
}
}
}
public void SendLandUpdate(ScenePresence avatar)
{
SendLandUpdate(avatar, false);
}
public void handleSignificantClientMovement(IClientAPI remote_client)
{
ScenePresence clientAvatar = m_scene.GetScenePresence(remote_client.AgentId);
if (clientAvatar != null)
{
SendLandUpdate(clientAvatar);
SendOutNearestBanLine(remote_client);
ILandObject parcel = GetLandObject(clientAvatar.AbsolutePosition.X, clientAvatar.AbsolutePosition.Y);
if (parcel != null)
{
if (clientAvatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT &&
clientAvatar.sentMessageAboutRestrictedParcelFlyingDown)
{
handleAvatarChangingParcel(clientAvatar, parcel.landData.localID, m_scene.RegionInfo.RegionID);
//They are going below the safety line!
if (!parcel.isBannedFromLand(clientAvatar.UUID))
{
clientAvatar.sentMessageAboutRestrictedParcelFlyingDown = false;
}
}
else if (clientAvatar.AbsolutePosition.Z < BAN_LINE_SAFETY_HIEGHT &&
parcel.isBannedFromLand(clientAvatar.UUID))
{
SendYouAreBannedNotice(clientAvatar);
}
}
}
}
public void handleAnyClientMovement(ScenePresence avatar)
//Like handleSignificantClientMovement, but called with an AgentUpdate regardless of distance.
{
ILandObject over = GetLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
if (over != null)
{
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 handleParcelAccessRequest(LLUUID agentID, LLUUID sessionID, uint flags, int sequenceID,
int landLocalID, IClientAPI remote_client)
{
if (landList.ContainsKey(landLocalID))
{
landList[landLocalID].sendAccessList(agentID, sessionID, flags, sequenceID, remote_client);
}
}
public void handleParcelAccessUpdateRequest(LLUUID agentID, LLUUID sessionID, uint flags, int landLocalID,
List<ParcelManager.ParcelAccessEntry> entries,
IClientAPI remote_client)
{
if (landList.ContainsKey(landLocalID))
{
if (agentID == landList[landLocalID].landData.ownerID)
{
landList[landLocalID].updateAccessList(flags, entries, remote_client);
}
}
else
{
Console.WriteLine("INVALID LOCAL LAND ID");
}
}
#endregion
// If the economy has been validated by the economy module,
// and land has been validated as well, this method transfers
// the land ownership
public void handleLandBuyRequest(Object o, EventManager.LandBuyArgs e)
{
if (e.economyValidated && e.landValidated)
{
lock (landList)
{
if (landList.ContainsKey(e.parcelLocalID))
{
landList[e.parcelLocalID].updateLandSold(e.agentId, e.groupId, e.groupOwned, (uint) e.transactionID, e.parcelPrice, e.parcelArea);
return;
}
}
}
}
// After receiving a land buy packet, first the data needs to
// be validated. This method validates the right to buy the
// parcel
public void handleLandValidationRequest(Object o, EventManager.LandBuyArgs e)
{
if (e.landValidated == false)
{
ILandObject lob = null;
lock (landList)
{
if (landList.ContainsKey(e.parcelLocalID))
{
lob = landList[e.parcelLocalID];
}
}
if (lob != null)
{
LLUUID AuthorizedID = lob.landData.authBuyerID;
int saleprice = lob.landData.salePrice;
LLUUID pOwnerID = lob.landData.ownerID;
bool landforsale = ((lob.landData.landFlags &
(uint) (Parcel.ParcelFlags.ForSale | Parcel.ParcelFlags.ForSaleObjects | Parcel.ParcelFlags.SellParcelObjects)) != 0);
if ((AuthorizedID == LLUUID.Zero || AuthorizedID == e.agentId) && e.parcelPrice >= saleprice && landforsale)
{
lock (e)
{
e.parcelOwnerID = pOwnerID;
e.landValidated = true;
}
}
}
}
}
}
}

953
OpenSim/Region/Environment/Modules/World/Land/LandManagementModule.cs
View File

@ -25,10 +25,15 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using libsecondlife;
using Nini.Config;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Framework;
using OpenSim.Region.Physics.Manager;
using Axiom.Math;
namespace OpenSim.Region.Environment.Modules.World.Land
{
@ -37,21 +42,40 @@ namespace OpenSim.Region.Environment.Modules.World.Land
private LandChannel landChannel;
private Scene m_scene;
private readonly int[,] landIDList = new int[64, 64];
private readonly Dictionary<int, ILandObject> landList = new Dictionary<int, ILandObject>();
private bool landPrimCountTainted;
private int lastLandLocalID = LandChannel.START_LAND_LOCAL_ID - 1;
private bool m_allowedForcefulBans = true;
#region IRegionModule Members
public void Initialise(Scene scene, IConfigSource source)
{
m_scene = scene;
landChannel = new LandChannel(scene);
landIDList.Initialize();
landChannel = new LandChannel(scene, this);
m_scene.EventManager.OnParcelPrimCountAdd += landChannel.AddPrimToLandPrimCounts;
m_scene.EventManager.OnParcelPrimCountUpdate += landChannel.UpdateLandPrimCounts;
m_scene.EventManager.OnAvatarEnteringNewParcel += new EventManager.AvatarEnteringNewParcel(landChannel.handleAvatarChangingParcel);
m_scene.EventManager.OnClientMovement += new EventManager.ClientMovement(landChannel.handleAnyClientMovement);
m_scene.EventManager.OnValidateLandBuy += landChannel.handleLandValidationRequest;
m_scene.EventManager.OnLandBuy += landChannel.handleLandBuyRequest;
m_scene.EventManager.OnParcelPrimCountAdd += AddPrimToLandPrimCounts;
m_scene.EventManager.OnParcelPrimCountUpdate += UpdateLandPrimCounts;
m_scene.EventManager.OnAvatarEnteringNewParcel += new EventManager.AvatarEnteringNewParcel(handleAvatarChangingParcel);
m_scene.EventManager.OnClientMovement += new EventManager.ClientMovement(handleAnyClientMovement);
m_scene.EventManager.OnValidateLandBuy += handleLandValidationRequest;
m_scene.EventManager.OnLandBuy += handleLandBuyRequest;
m_scene.EventManager.OnNewClient += new EventManager.OnNewClientDelegate(EventManager_OnNewClient);
m_scene.EventManager.OnSignificantClientMovement += landChannel.handleSignificantClientMovement;
m_scene.EventManager.OnSignificantClientMovement += handleSignificantClientMovement;
m_scene.EventManager.OnObjectBeingRemovedFromScene += RemovePrimFromLandPrimCounts;
m_scene.EventManager.OnNoticeNoLandDataFromStorage += this.NoLandDataFromStorage;
m_scene.EventManager.OnIncomingLandDataFromStorage += this.IncomingLandObjectsFromStorage;
m_scene.EventManager.OnSetAllowForcefulBan += this.SetAllowedForcefulBans;
m_scene.EventManager.OnRequestParcelPrimCountUpdate += this.PerformParcelPrimCountUpdate;
m_scene.EventManager.OnParcelPrimCountTainted += this.SetPrimsTainted;
lock (m_scene)
{
m_scene.LandChannel = (ILandChannel) landChannel;
@ -61,15 +85,21 @@ namespace OpenSim.Region.Environment.Modules.World.Land
void EventManager_OnNewClient(IClientAPI client)
{
//Register some client events
client.OnParcelPropertiesRequest += new ParcelPropertiesRequest(landChannel.handleParcelPropertiesRequest);
client.OnParcelDivideRequest += new ParcelDivideRequest(landChannel.handleParcelDivideRequest);
client.OnParcelJoinRequest += new ParcelJoinRequest(landChannel.handleParcelJoinRequest);
client.OnParcelPropertiesUpdateRequest += new ParcelPropertiesUpdateRequest(landChannel.handleParcelPropertiesUpdateRequest);
client.OnParcelSelectObjects += new ParcelSelectObjects(landChannel.handleParcelSelectObjectsRequest);
client.OnParcelObjectOwnerRequest += new ParcelObjectOwnerRequest(landChannel.handleParcelObjectOwnersRequest);
client.OnParcelAccessListRequest += new ParcelAccessListRequest(landChannel.handleParcelAccessRequest);
client.OnParcelAccessListUpdateRequest += new ParcelAccessListUpdateRequest(landChannel.handleParcelAccessUpdateRequest);
client.OnParcelAbandonRequest += new ParcelAbandonRequest(landChannel.handleParcelAbandonRequest);
client.OnParcelPropertiesRequest += new ParcelPropertiesRequest(handleParcelPropertiesRequest);
client.OnParcelDivideRequest += new ParcelDivideRequest(handleParcelDivideRequest);
client.OnParcelJoinRequest += new ParcelJoinRequest(handleParcelJoinRequest);
client.OnParcelPropertiesUpdateRequest += new ParcelPropertiesUpdateRequest(handleParcelPropertiesUpdateRequest);
client.OnParcelSelectObjects += new ParcelSelectObjects(handleParcelSelectObjectsRequest);
client.OnParcelObjectOwnerRequest += new ParcelObjectOwnerRequest(handleParcelObjectOwnersRequest);
client.OnParcelAccessListRequest += new ParcelAccessListRequest(handleParcelAccessRequest);
client.OnParcelAccessListUpdateRequest += new ParcelAccessListUpdateRequest(handleParcelAccessUpdateRequest);
client.OnParcelAbandonRequest += new ParcelAbandonRequest(handleParcelAbandonRequest);
if (m_scene.Entities.ContainsKey(client.AgentId))
{
SendLandUpdate((ScenePresence)m_scene.Entities[client.AgentId], true);
SendParcelOverlay(client);
}
}
@ -93,5 +123,894 @@ namespace OpenSim.Region.Environment.Modules.World.Land
}
#endregion
#region Parcel Add/Remove/Get/Create
public void SetAllowedForcefulBans(bool forceful)
{
AllowedForcefulBans = forceful;
}
public void UpdateLandObject(int local_id, LandData newData)
{
if (landList.ContainsKey(local_id))
{
landList[local_id].landData = newData.Copy();
m_scene.EventManager.TriggerLandObjectUpdated((uint)local_id, landList[local_id]);
}
}
public bool AllowedForcefulBans
{
get { return m_allowedForcefulBans; }
set { m_allowedForcefulBans = value; }
}
/// <summary>
/// Resets the sim to the default land object (full sim piece of land owned by the default user)
/// </summary>
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 = LandChannel.START_LAND_LOCAL_ID - 1;
landIDList.Initialize();
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;
AddLandObject(fullSimParcel);
}
public List<ILandObject> ParcelsNearPoint(LLVector3 position)
{
List<ILandObject> parcelsNear = new List<ILandObject>();
int x;
for (x = -4; x <= 4; x += 4)
{
int y;
for (y = -4; y <= 4; y += 4)
{
ILandObject check = GetLandObject(position.X + x, position.Y + y);
if (check != null)
{
if (!parcelsNear.Contains(check))
{
parcelsNear.Add(check);
}
}
}
}
return parcelsNear;
}
public void SendYouAreBannedNotice(ScenePresence avatar)
{
if (AllowedForcefulBans)
{
avatar.ControllingClient.SendAlertMessage(
"You are not allowed on this parcel because you are banned. Please go away. <3 OpenSim Developers");
avatar.PhysicsActor.Position =
new PhysicsVector(avatar.lastKnownAllowedPosition.x, avatar.lastKnownAllowedPosition.y,
avatar.lastKnownAllowedPosition.z);
avatar.PhysicsActor.Velocity = new PhysicsVector(0, 0, 0);
}
else
{
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");
}
}
public void handleAvatarChangingParcel(ScenePresence avatar, int localLandID, LLUUID regionID)
{
if (m_scene.RegionInfo.RegionID == regionID)
{
if (landList[localLandID] != null)
{
ILandObject parcelAvatarIsEntering = landList[localLandID];
if (avatar.AbsolutePosition.Z < LandChannel.BAN_LINE_SAFETY_HIEGHT)
{
if (parcelAvatarIsEntering.isBannedFromLand(avatar.UUID))
{
SendYouAreBannedNotice(avatar);
}
else if (parcelAvatarIsEntering.isRestrictedFromLand(avatar.UUID))
{
avatar.ControllingClient.SendAlertMessage(
"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");
}
else
{
avatar.sentMessageAboutRestrictedParcelFlyingDown = true;
}
}
else
{
avatar.sentMessageAboutRestrictedParcelFlyingDown = true;
}
}
}
}
public void SendOutNearestBanLine(IClientAPI avatar)
{
List<ScenePresence> avatars = m_scene.GetAvatars();
foreach (ScenePresence presence in avatars)
{
if (presence.UUID == avatar.AgentId)
{
List<ILandObject> checkLandParcels = ParcelsNearPoint(presence.AbsolutePosition);
foreach (ILandObject checkBan in checkLandParcels)
{
if (checkBan.isBannedFromLand(avatar.AgentId))
{
checkBan.sendLandProperties(-30000, false, (int)ParcelManager.ParcelResult.Single, avatar);
return; //Only send one
}
if (checkBan.isRestrictedFromLand(avatar.AgentId))
{
checkBan.sendLandProperties(-40000, false, (int)ParcelManager.ParcelResult.Single, avatar);
return; //Only send one
}
}
return;
}
}
}
public void SendLandUpdate(ScenePresence avatar, bool force)
{
ILandObject over = GetLandObject((int)Math.Min(255, Math.Max(0, Math.Round(avatar.AbsolutePosition.X))),
(int)Math.Min(255, Math.Max(0, Math.Round(avatar.AbsolutePosition.Y))));
if (over != null)
{
if (force)
{
if (!avatar.IsChildAgent)
{
over.sendLandUpdateToClient(avatar.ControllingClient);
m_scene.EventManager.TriggerAvatarEnteringNewParcel(avatar, over.landData.localID,
m_scene.RegionInfo.RegionID);
}
}
if (avatar.currentParcelUUID != over.landData.globalID)
{
if (!avatar.IsChildAgent)
{
over.sendLandUpdateToClient(avatar.ControllingClient);
avatar.currentParcelUUID = over.landData.globalID;
m_scene.EventManager.TriggerAvatarEnteringNewParcel(avatar, over.landData.localID,
m_scene.RegionInfo.RegionID);
}
}
}
}
public void SendLandUpdate(ScenePresence avatar)
{
SendLandUpdate(avatar, false);
}
public void handleSignificantClientMovement(IClientAPI remote_client)
{
ScenePresence clientAvatar = m_scene.GetScenePresence(remote_client.AgentId);
if (clientAvatar != null)
{
SendLandUpdate(clientAvatar);
SendOutNearestBanLine(remote_client);
ILandObject parcel = GetLandObject(clientAvatar.AbsolutePosition.X, clientAvatar.AbsolutePosition.Y);
if (parcel != null)
{
if (clientAvatar.AbsolutePosition.Z < LandChannel.BAN_LINE_SAFETY_HIEGHT &&
clientAvatar.sentMessageAboutRestrictedParcelFlyingDown)
{
handleAvatarChangingParcel(clientAvatar, parcel.landData.localID, m_scene.RegionInfo.RegionID);
//They are going below the safety line!
if (!parcel.isBannedFromLand(clientAvatar.UUID))
{
clientAvatar.sentMessageAboutRestrictedParcelFlyingDown = false;
}
}
else if (clientAvatar.AbsolutePosition.Z < LandChannel.BAN_LINE_SAFETY_HIEGHT &&
parcel.isBannedFromLand(clientAvatar.UUID))
{
SendYouAreBannedNotice(clientAvatar);
}
}
}
}
public void handleAnyClientMovement(ScenePresence avatar)
//Like handleSignificantClientMovement, but called with an AgentUpdate regardless of distance.
{
ILandObject over = GetLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
if (over != null)
{
if (!over.isBannedFromLand(avatar.UUID) || avatar.AbsolutePosition.Z >= LandChannel.BAN_LINE_SAFETY_HIEGHT)
{
avatar.lastKnownAllowedPosition =
new Vector3(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y, avatar.AbsolutePosition.Z);
}
}
}
public void handleParcelAccessRequest(LLUUID agentID, LLUUID sessionID, uint flags, int sequenceID,
int landLocalID, IClientAPI remote_client)
{
if (landList.ContainsKey(landLocalID))
{
landList[landLocalID].sendAccessList(agentID, sessionID, flags, sequenceID, remote_client);
}
}
public void handleParcelAccessUpdateRequest(LLUUID agentID, LLUUID sessionID, uint flags, int landLocalID,
List<ParcelManager.ParcelAccessEntry> entries,
IClientAPI remote_client)
{
if (landList.ContainsKey(landLocalID))
{
if (agentID == landList[landLocalID].landData.ownerID)
{
landList[landLocalID].updateAccessList(flags, entries, remote_client);
}
}
else
{
Console.WriteLine("INVALID LOCAL LAND ID");
}
}
/// <summary>
/// Creates a basic Parcel object without an owner (a zeroed key)
/// </summary>
/// <returns></returns>
public ILandObject CreateBaseLand()
{
return new LandObject(LLUUID.Zero, false, m_scene);
}
/// <summary>
/// Adds a land object to the stored list and adds them to the landIDList to what they own
/// </summary>
/// <param name="new_land">The land object being added</param>
public ILandObject AddLandObject(ILandObject new_land)
{
lastLandLocalID++;
new_land.landData.localID = lastLandLocalID;
landList.Add(lastLandLocalID, new_land.Copy());
bool[,] landBitmap = new_land.getLandBitmap();
int x;
for (x = 0; x < 64; x++)
{
int y;
for (y = 0; y < 64; y++)
{
if (landBitmap[x, y])
{
landIDList[x, y] = lastLandLocalID;
}
}
}
landList[lastLandLocalID].forceUpdateLandInfo();
m_scene.EventManager.TriggerLandObjectAdded(new_land);
return new_land;
}
/// <summary>
/// Removes a land object from the list. Will not remove if local_id is still owning an area in landIDList
/// </summary>
/// <param name="local_id">Land.localID of the peice of land to remove.</param>
public void removeLandObject(int local_id)
{
int x;
for (x = 0; x < 64; x++)
{
int y;
for (y = 0; y < 64; y++)
{
if (landIDList[x, y] == local_id)
{
return;
//throw new Exception("Could not remove land object. Still being used at " + x + ", " + y);
}
}
}
m_scene.EventManager.TriggerLandObjectRemoved(landList[local_id].landData.globalID);
landList.Remove(local_id);
}
private void performFinalLandJoin(ILandObject master, ILandObject slave)
{
int x;
bool[,] landBitmapSlave = slave.getLandBitmap();
for (x = 0; x < 64; x++)
{
int y;
for (y = 0; y < 64; y++)
{
if (landBitmapSlave[x, y])
{
landIDList[x, y] = master.landData.localID;
}
}
}
removeLandObject(slave.landData.localID);
UpdateLandObject(master.landData.localID, master.landData);
}
public ILandObject GetLandObject(int parcelLocalID)
{
lock (landList)
{
if (landList.ContainsKey(parcelLocalID))
{
return landList[parcelLocalID];
}
}
return null;
}
/// <summary>
/// Get the land object at the specified point
/// </summary>
/// <param name="x_float">Value between 0 - 256 on the x axis of the point</param>
/// <param name="y_float">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;
int y;
try
{
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)));
}
catch (OverflowException)
{
return null;
}
if (x >= 64 || y >= 64 || x < 0 || y < 0)
{
return null;
}
return landList[landIDList[x, y]];
}
public ILandObject GetLandObject(int x, int y)
{
if (x >= Convert.ToInt32(Constants.RegionSize) || y >= Convert.ToInt32(Constants.RegionSize) || x < 0 || y < 0)
{
// These exceptions here will cause a lot of complaints from the users specifically because
// they happen every time at border crossings
throw new Exception("Error: Parcel not found at point " + x + ", " + y);
}
return landList[landIDList[x / 4, y / 4]];
}
#endregion
#region Parcel Modification
public void ResetAllLandPrimCounts()
{
foreach (LandObject p in landList.Values)
{
p.resetLandPrimCounts();
}
}
public void SetPrimsTainted()
{
landPrimCountTainted = true;
}
public bool IsLandPrimCountTainted()
{
return landPrimCountTainted;
}
public void AddPrimToLandPrimCounts(SceneObjectGroup obj)
{
LLVector3 position = obj.AbsolutePosition;
ILandObject landUnderPrim = GetLandObject(position.X, position.Y);
if (landUnderPrim != null)
{
landUnderPrim.addPrimToCount(obj);
}
}
public void RemovePrimFromLandPrimCounts(SceneObjectGroup obj)
{
foreach (LandObject p in landList.Values)
{
p.removePrimFromCount(obj);
}
}
public void FinalizeLandPrimCountUpdate()
{
//Get Simwide prim count for owner
Dictionary<LLUUID, List<LandObject>> landOwnersAndParcels = new Dictionary<LLUUID, List<LandObject>>();
foreach (LandObject p in landList.Values)
{
if (!landOwnersAndParcels.ContainsKey(p.landData.ownerID))
{
List<LandObject> tempList = new List<LandObject>();
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 (LandObject p in landOwnersAndParcels[owner])
{
simArea += p.landData.area;
simPrims += p.landData.ownerPrims + p.landData.otherPrims + p.landData.groupPrims +
p.landData.selectedPrims;
}
foreach (LandObject p in landOwnersAndParcels[owner])
{
p.landData.simwideArea = simArea;
p.landData.simwidePrims = simPrims;
}
}
}
public void UpdateLandPrimCounts()
{
foreach (EntityBase obj in m_scene.Entities.Values)
{
if (obj is SceneObjectGroup)
{
m_scene.EventManager.TriggerParcelPrimCountAdd((SceneObjectGroup)obj);
}
}
}
public void PerformParcelPrimCountUpdate()
{
ResetAllLandPrimCounts();
m_scene.EventManager.TriggerParcelPrimCountUpdate();
FinalizeLandPrimCountUpdate();
landPrimCountTainted = false;
}
/// <summary>
/// Subdivides a piece of land
/// </summary>
/// <param name="start_x">West Point</param>
/// <param name="start_y">South Point</param>
/// <param name="end_x">East Point</param>
/// <param name="end_y">North Point</param>
/// <param name="attempting_user_id">LLUUID of user who is trying to subdivide</param>
/// <returns>Returns true if successful</returns>
private void 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
ILandObject startLandObject = GetLandObject(start_x, start_y);
if (startLandObject == null) return;
//Loop through the points
try
{
int totalX = end_x - start_x;
int totalY = end_y - start_y;
int y;
for (y = 0; y < totalY; y++)
{
int x;
for (x = 0; x < totalX; x++)
{
ILandObject tempLandObject = GetLandObject(start_x + x, start_y + y);
if (tempLandObject == null) return;
if (tempLandObject != startLandObject) return;
}
}
}
catch (Exception)
{
return;
}
//If we are still here, then they are subdividing within one piece of land
//Check owner
if (!m_scene.ExternalChecks.ExternalChecksCanEditParcel(attempting_user_id, startLandObject))
{
return;
}
//Lets create a new land object with bitmap activated at that point (keeping the old land objects info)
ILandObject newLand = startLandObject.Copy();
newLand.landData.landName = "Subdivision of " + newLand.landData.landName;
newLand.landData.globalID = LLUUID.Random();
newLand.setLandBitmap(newLand.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(
newLand.modifyLandBitmapSquare(startLandObject.getLandBitmap(), start_x, start_y, end_x, end_y, false));
landList[startLandObjectIndex].forceUpdateLandInfo();
SetPrimsTainted();
//Now add the new land object
ILandObject result = AddLandObject(newLand);
UpdateLandObject(startLandObject.landData.localID, startLandObject.landData);
result.sendLandUpdateToAvatarsOverMe();
return;
}
/// <summary>
/// Join 2 land objects together
/// </summary>
/// <param name="start_x">x value in first piece of land</param>
/// <param name="start_y">y value in first piece of land</param>
/// <param name="end_x">x value in second peice of land</param>
/// <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 void join(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id)
{
end_x -= 4;
end_y -= 4;
List<ILandObject> selectedLandObjects = new List<ILandObject>();
int stepYSelected;
for (stepYSelected = start_y; stepYSelected <= end_y; stepYSelected += 4)
{
int stepXSelected;
for (stepXSelected = start_x; stepXSelected <= end_x; stepXSelected += 4)
{
ILandObject p = GetLandObject(stepXSelected, stepYSelected);
if (p != null)
{
if (!selectedLandObjects.Contains(p))
{
selectedLandObjects.Add(p);
}
}
}
}
ILandObject masterLandObject = selectedLandObjects[0];
selectedLandObjects.RemoveAt(0);
if (selectedLandObjects.Count < 1)
{
return;
}
if (!m_scene.ExternalChecks.ExternalChecksCanEditParcel(attempting_user_id, masterLandObject))
{
return;
}
foreach (ILandObject p in selectedLandObjects)
{
if (p.landData.ownerID != masterLandObject.landData.ownerID)
{
return;
}
}
foreach (ILandObject slaveLandObject in selectedLandObjects)
{
landList[masterLandObject.landData.localID].setLandBitmap(
slaveLandObject.mergeLandBitmaps(masterLandObject.getLandBitmap(), slaveLandObject.getLandBitmap()));
performFinalLandJoin(masterLandObject, slaveLandObject);
}
SetPrimsTainted();
masterLandObject.sendLandUpdateToAvatarsOverMe();
return;
}
#endregion
#region Parcel Updating
/// <summary>
/// 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)
{
const int LAND_BLOCKS_PER_PACKET = 1024;
byte[] byteArray = new byte[LAND_BLOCKS_PER_PACKET];
int byteArrayCount = 0;
int sequenceID = 0;
int y;
for (y = 0; y < 64; y++)
{
int x;
for (x = 0; x < 64; x++)
{
byte tempByte = 0; //This represents the byte for the current 4x4
ILandObject currentParcelBlock = GetLandObject(x * 4, y * 4);
if (currentParcelBlock != null)
{
if (currentParcelBlock.landData.ownerID == remote_client.AgentId)
{
//Owner Flag
tempByte = Convert.ToByte(tempByte | LandChannel.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 | LandChannel.LAND_TYPE_IS_FOR_SALE);
}
else if (currentParcelBlock.landData.ownerID == LLUUID.Zero)
{
//Public Flag
tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_PUBLIC);
}
else
{
//Other Flag
tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_OWNED_BY_OTHER);
}
//Now for border control
ILandObject westParcel = null;
ILandObject southParcel = null;
if (x > 0)
{
westParcel = GetLandObject((x - 1) * 4, y * 4);
}
if (y > 0)
{
southParcel = GetLandObject(x * 4, (y - 1) * 4);
}
if (x == 0)
{
tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_WEST);
}
else if (westParcel != null && westParcel != currentParcelBlock)
{
tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_WEST);
}
if (y == 0)
{
tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_SOUTH);
}
else if (southParcel != null && southParcel != currentParcelBlock)
{
tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_SOUTH);
}
byteArray[byteArrayCount] = tempByte;
byteArrayCount++;
if (byteArrayCount >= LAND_BLOCKS_PER_PACKET)
{
remote_client.sendLandParcelOverlay(byteArray, sequenceID);
byteArrayCount = 0;
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<ILandObject> temp = new List<ILandObject>();
int x;
int i;
int inc_x = end_x - start_x;
int inc_y = end_y - start_y;
for (x = 0; x < inc_x; x++)
{
int y;
for (y = 0; y < inc_y; y++)
{
ILandObject currentParcel = GetLandObject(start_x + x, start_y + y);
if (currentParcel != null)
{
if (!temp.Contains(currentParcel))
{
currentParcel.forceUpdateLandInfo();
temp.Add(currentParcel);
}
}
}
}
int requestResult = LandChannel.LAND_RESULT_SINGLE;
if (temp.Count > 1)
{
requestResult = LandChannel.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(LandUpdateArgs args, int localID, IClientAPI remote_client)
{
if (landList.ContainsKey(localID))
{
landList[localID].updateLandProperties(args, 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);
}
public void handleParcelAbandonRequest(int local_id, IClientAPI remote_client)
{
if (landList.ContainsKey(local_id))
{
if (m_scene.ExternalChecks.ExternalChecksCanAbandonParcel(remote_client.AgentId, landList[local_id]))
{
landList[local_id].landData.ownerID = m_scene.RegionInfo.MasterAvatarAssignedUUID;
m_scene.Broadcast(SendParcelOverlay);
}
}
}
#endregion
// If the economy has been validated by the economy module,
// and land has been validated as well, this method transfers
// the land ownership
public void handleLandBuyRequest(Object o, EventManager.LandBuyArgs e)
{
if (e.economyValidated && e.landValidated)
{
lock (landList)
{
if (landList.ContainsKey(e.parcelLocalID))
{
landList[e.parcelLocalID].updateLandSold(e.agentId, e.groupId, e.groupOwned, (uint)e.transactionID, e.parcelPrice, e.parcelArea);
return;
}
}
}
}
// After receiving a land buy packet, first the data needs to
// be validated. This method validates the right to buy the
// parcel
public void handleLandValidationRequest(Object o, EventManager.LandBuyArgs e)
{
if (e.landValidated == false)
{
ILandObject lob = null;
lock (landList)
{
if (landList.ContainsKey(e.parcelLocalID))
{
lob = landList[e.parcelLocalID];
}
}
if (lob != null)
{
LLUUID AuthorizedID = lob.landData.authBuyerID;
int saleprice = lob.landData.salePrice;
LLUUID pOwnerID = lob.landData.ownerID;
bool landforsale = ((lob.landData.landFlags &
(uint)(Parcel.ParcelFlags.ForSale | Parcel.ParcelFlags.ForSaleObjects | Parcel.ParcelFlags.SellParcelObjects)) != 0);
if ((AuthorizedID == LLUUID.Zero || AuthorizedID == e.agentId) && e.parcelPrice >= saleprice && landforsale)
{
lock (e)
{
e.parcelOwnerID = pOwnerID;
e.landValidated = true;
}
}
}
}
}
#region Land Object From Storage Functions
public void IncomingLandObjectsFromStorage(List<LandData> data)
{
for (int i = 0; i < data.Count; i++)
{
//try
//{
IncomingLandObjectFromStorage(data[i]);
//}
//catch (Exception ex)
//{
//m_log.Error("[LandManager]: IncomingLandObjectsFromStorage: Exception: " + ex.ToString());
//throw ex;
//}
}
//foreach (LandData parcel in data)
//{
// IncomingLandObjectFromStorage(parcel);
//}
}
public void IncomingLandObjectFromStorage(LandData data)
{
ILandObject new_land = new LandObject(data.ownerID, data.isGroupOwned, m_scene);
new_land.landData = data.Copy();
new_land.setLandBitmapFromByteArray();
AddLandObject(new_land);
}
public void NoLandDataFromStorage()
{
ResetSimLandObjects();
}
#endregion
}
}

89
OpenSim/Region/Environment/Scenes/EventManager.cs
View File

@ -30,6 +30,7 @@ using libsecondlife;
using OpenSim.Framework;
using OpenSim.Region.Environment.Interfaces;
using Caps=OpenSim.Framework.Communications.Capabilities.Caps;
using System.Collections.Generic;
namespace OpenSim.Region.Environment.Scenes
{
@ -169,6 +170,26 @@ namespace OpenSim.Region.Environment.Scenes
public event AvatarKillData OnAvatarKilled;
public delegate void ObjectBeingRemovedFromScene(SceneObjectGroup obj);
public event ObjectBeingRemovedFromScene OnObjectBeingRemovedFromScene;
public delegate void NoticeNoLandDataFromStorage();
public event NoticeNoLandDataFromStorage OnNoticeNoLandDataFromStorage;
public delegate void IncomingLandDataFromStorage(List<LandData> data);
public event IncomingLandDataFromStorage OnIncomingLandDataFromStorage;
public delegate void SetAllowForcefulBan(bool allow);
public event SetAllowForcefulBan OnSetAllowForcefulBan;
public delegate void RequestParcelPrimCountUpdate();
public event RequestParcelPrimCountUpdate OnRequestParcelPrimCountUpdate;
public delegate void ParcelPrimCountTainted();
public event ParcelPrimCountTainted OnParcelPrimCountTainted;
/// <summary>
/// RegisterCapsEvent is called by Scene after the Caps object
/// has been instantiated and before it is return to the
@ -300,6 +321,13 @@ namespace OpenSim.Region.Environment.Scenes
private LandBuy handlerValidateLandBuy = null;
private AvatarKillData handlerAvatarKill = null;
private NoticeNoLandDataFromStorage handlerNoticeNoLandDataFromStorage = null;
private IncomingLandDataFromStorage handlerIncomingLandDataFromStorage = null;
private SetAllowForcefulBan handlerSetAllowForcefulBan = null;
private RequestParcelPrimCountUpdate handlerRequestParcelPrimCountUpdate = null;
private ParcelPrimCountTainted handlerParcelPrimCountTainted = null;
private ObjectBeingRemovedFromScene handlerObjectBeingRemovedFromScene = null;
public void TriggerOnScriptChangedEvent(uint localID, uint change)
{
handlerScriptChangedEvent = OnScriptChangedEvent;
@ -651,5 +679,66 @@ namespace OpenSim.Region.Environment.Scenes
handlerScriptControlEvent(p, scriptUUID, avatarID, held, _changed);
}
}
public void TriggerNoticeNoLandDataFromStorage()
{
handlerNoticeNoLandDataFromStorage = OnNoticeNoLandDataFromStorage;
if (handlerNoticeNoLandDataFromStorage != null)
{
handlerNoticeNoLandDataFromStorage();
}
}
public void TriggerIncomingLandDataFromStorage(List<LandData> landData)
{
handlerIncomingLandDataFromStorage = OnIncomingLandDataFromStorage;
if (handlerIncomingLandDataFromStorage != null)
{
handlerIncomingLandDataFromStorage(landData);
}
}
public void TriggerSetAllowForcefulBan(bool allow)
{
handlerSetAllowForcefulBan = OnSetAllowForcefulBan;
if (handlerSetAllowForcefulBan != null)
{
handlerSetAllowForcefulBan(allow);
}
}
public void TriggerObjectBeingRemovedFromScene(SceneObjectGroup obj)
{
handlerObjectBeingRemovedFromScene = OnObjectBeingRemovedFromScene;
if (handlerObjectBeingRemovedFromScene != null)
{
handlerObjectBeingRemovedFromScene(obj);
}
}
public void TriggerRequestParcelPrimCountUpdate()
{
handlerRequestParcelPrimCountUpdate = OnRequestParcelPrimCountUpdate;
if (handlerRequestParcelPrimCountUpdate != null)
{
handlerRequestParcelPrimCountUpdate();
}
}
public void TriggerParcelPrimCountTainted()
{
handlerParcelPrimCountTainted = OnParcelPrimCountTainted;
if (handlerParcelPrimCountTainted != null)
{
handlerParcelPrimCountTainted();
}
}
}
}

4
OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs
View File

@ -86,7 +86,7 @@ namespace OpenSim.Region.Environment.Scenes
// A prim is only tainted if it's allowed to be edited by the person clicking it.
if (ExternalChecks.ExternalChecksCanEditObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId) || ExternalChecks.ExternalChecksCanMoveObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId))
{
LandChannel.SetPrimsTainted();
EventManager.TriggerParcelPrimCountTainted();
}
break;
}
@ -113,7 +113,7 @@ namespace OpenSim.Region.Environment.Scenes
((SceneObjectGroup)ent).ScheduleGroupForFullUpdate();
if (ExternalChecks.ExternalChecksCanEditObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId) || ExternalChecks.ExternalChecksCanMoveObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId))
{
LandChannel.SetPrimsTainted();
EventManager.TriggerParcelPrimCountTainted();
break;
}
}

35
OpenSim/Region/Environment/Scenes/Scene.cs
View File

@ -819,7 +819,7 @@ namespace OpenSim.Region.Environment.Scenes
{
if (LandChannel.IsLandPrimCountTainted())
{
LandChannel.PerformParcelPrimCountUpdate();
EventManager.TriggerParcelPrimCountUpdate();
}
}
}
@ -970,12 +970,12 @@ namespace OpenSim.Region.Environment.Scenes
if (dGridSettings["allow_forceful_banlines"] != "TRUE")
{
m_log.Info("[GRID]: Grid is disabling forceful parcel banlists");
LandChannel.AllowedForcefulBans = false;
EventManager.TriggerSetAllowForcefulBan(false);
}
else
{
m_log.Info("[GRID]: Grid is allowing forceful parcel banlists");
LandChannel.AllowedForcefulBans = true;
EventManager.TriggerSetAllowForcefulBan(true);
}
}
}
@ -1142,11 +1142,11 @@ namespace OpenSim.Region.Environment.Scenes
{
if (landData.Count == 0)
{
LandChannel.NoLandDataFromStorage();
EventManager.TriggerNoticeNoLandDataFromStorage();
}
else
{
LandChannel.IncomingLandObjectsFromStorage(landData);
EventManager.TriggerIncomingLandDataFromStorage(landData);
}
}
else
@ -1344,22 +1344,13 @@ namespace OpenSim.Region.Environment.Scenes
{
if (Entities.ContainsKey(sceneObject.UUID))
{
LandChannel.RemovePrimFromLandPrimCounts(sceneObject);
EventManager.TriggerObjectBeingRemovedFromScene(sceneObject);
Entities.Remove(sceneObject.UUID);
LandChannel.SetPrimsTainted();
EventManager.TriggerParcelPrimCountTainted();
m_innerScene.RemoveAPrimCount();
}
}
/// <summary>
/// Called by a prim when it has been created/cloned, so that its events can be subscribed to
/// </summary>
/// <param name="prim"></param>
public void AcknowledgeNewPrim(SceneObjectGroup prim)
{
prim.OnPrimCountTainted += LandChannel.SetPrimsTainted;
}
public void LoadPrimsFromXml(string fileName, bool newIdsFlag, LLVector3 loadOffset)
{
m_sceneXmlLoader.LoadPrimsFromXml(fileName, newIdsFlag, loadOffset);
@ -1589,15 +1580,6 @@ namespace OpenSim.Region.Environment.Scenes
CreateAndAddScenePresence(client, child);
try
{
LandChannel.SendParcelOverlay(client);
} //BUG: Mike - please fix this.
catch (KeyNotFoundException)
{
m_log.Warn("[LAND]: Bug #2 triggered with NPC. LandModule needs a refactor to fix this.");
}
CommsManager.UserProfileCacheService.AddNewUser(client.AgentId);
}
}
@ -3174,8 +3156,7 @@ namespace OpenSim.Region.Environment.Scenes
lock (Entities)
{
Entities.Remove(group.UUID);
m_innerScene.RemoveAPrimCount();
RemoveEntity(group);
}
group.DeleteParts();

13
OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs
View File

@ -601,7 +601,6 @@ namespace OpenSim.Region.Environment.Scenes
#endregion
public event PrimCountTaintedDelegate OnPrimCountTainted;
public string ToXmlString()
{
@ -1067,18 +1066,6 @@ namespace OpenSim.Region.Environment.Scenes
#region Events
/// <summary>
///
/// </summary>
public void TriggerTainted()
{
handlerPrimCountTainted = OnPrimCountTainted;
if (handlerPrimCountTainted != null)
{
handlerPrimCountTainted();
}
}
/// <summary>
/// Processes backup
/// </summary>

10
OpenSim/Region/Environment/Scenes/ScenePresence.cs
View File

@ -405,14 +405,7 @@ namespace OpenSim.Region.Environment.Scenes
RegisterToEvents();
SetDirectionVectors();
try
{
m_scene.LandChannel.SendLandUpdate(this, true);
} //BUG: Mike - please fix this.
catch (KeyNotFoundException)
{
m_log.Warn("[LAND]: Bug triggered with NPC. LandModule needs a refactor to fix this.");
}
}
public ScenePresence(IClientAPI client, Scene world, RegionInfo reginfo, byte[] visualParams,
@ -596,7 +589,6 @@ namespace OpenSim.Region.Environment.Scenes
//if (!m_gotAllObjectsInScene)
//{
m_scene.SendAllSceneObjectsToClient(this);
m_scene.LandChannel.SendLandUpdate(this, true);
//m_gotAllObjectsInScene = true;
//}