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

Merge branch 'master' of ssh://diva@opensimulator.org/var/git/opensim

remotes/origin/0.6.7-post-fixes
Diva Canto 2009-09-14 10:29:28 -07:00
parent 2f3cf540ca 5a64ca4642
commit 69b19a3b85
16 changed files with 1062 additions and 578 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs
View File

@ -92,12 +92,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
scene.AddCommand(
this, "load iar",
"load iar <first> <last> <inventory path> [<archive path>]",
"Load user inventory archive. EXPERIMENTAL, CURRENTLY DISABLED", HandleLoadInvConsoleCommand);
"Load user inventory archive. EXPERIMENTAL", HandleLoadInvConsoleCommand);
scene.AddCommand(
this, "save iar",
"save iar <first> <last> <inventory path> [<archive path>]",
"Save user inventory archive. EXPERIMENTAL, CURRENTLY DISABLED", HandleSaveInvConsoleCommand);
"Save user inventory archive. EXPERIMENTAL", HandleSaveInvConsoleCommand);
m_aScene = scene;
}
@ -233,9 +233,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
/// <param name="cmdparams"></param>
protected void HandleLoadInvConsoleCommand(string module, string[] cmdparams)
{
return;
/*
if (cmdparams.Length < 5)
{
m_log.Error(
@ -243,6 +240,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
return;
}
m_log.Info("[INVENTORY ARCHIVER]: PLEASE NOTE THAT THIS FACILITY IS EXPERIMENTAL. BUG REPORTS WELCOME.");
string firstName = cmdparams[2];
string lastName = cmdparams[3];
string invPath = cmdparams[4];
@ -256,7 +255,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
m_log.InfoFormat(
"[INVENTORY ARCHIVER]: Loaded archive {0} for {1} {2}",
loadPath, firstName, lastName);
*/
}
/// <summary>
@ -265,9 +263,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
/// <param name="cmdparams"></param>
protected void HandleSaveInvConsoleCommand(string module, string[] cmdparams)
{
return;
/*
if (cmdparams.Length < 5)
{
m_log.Error(
@ -275,6 +270,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
return;
}
m_log.Info("[INVENTORY ARCHIVER]: PLEASE NOTE THAT THIS FACILITY IS EXPERIMENTAL. BUG REPORTS WELCOME.");
string firstName = cmdparams[2];
string lastName = cmdparams[3];
string invPath = cmdparams[4];
@ -289,7 +286,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
lock (m_pendingConsoleSaves)
m_pendingConsoleSaves.Add(id);
*/
}
private void SaveInvConsoleCommandCompleted(

94
OpenSim/Region/CoreModules/World/Land/RegionCombinerClientEventForwarder.cs Normal file
View File

@ -0,0 +1,94 @@
/*
* Copyright (c) Contributors, http://opensimulator.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 OpenSimulator 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 OpenMetaverse;
using OpenSim.Region.Framework.Scenes;
namespace OpenSim.Region.CoreModules.World.Land
{
public class RegionCombinerClientEventForwarder
{
private Scene m_rootScene;
private Dictionary<UUID, Scene> m_virtScene = new Dictionary<UUID, Scene>();
private Dictionary<UUID,RegionCombinerIndividualEventForwarder> m_forwarders = new Dictionary<UUID,
RegionCombinerIndividualEventForwarder>();
public RegionCombinerClientEventForwarder(RegionConnections rootScene)
{
m_rootScene = rootScene.RegionScene;
}
public void AddSceneToEventForwarding(Scene virtualScene)
{
lock (m_virtScene)
{
if (m_virtScene.ContainsKey(virtualScene.RegionInfo.originRegionID))
{
m_virtScene[virtualScene.RegionInfo.originRegionID] = virtualScene;
}
else
{
m_virtScene.Add(virtualScene.RegionInfo.originRegionID, virtualScene);
}
}
lock (m_forwarders)
{
// TODO: Fix this to unregister if this happens
if (m_forwarders.ContainsKey(virtualScene.RegionInfo.originRegionID))
m_forwarders.Remove(virtualScene.RegionInfo.originRegionID);
RegionCombinerIndividualEventForwarder forwarder =
new RegionCombinerIndividualEventForwarder(m_rootScene, virtualScene);
m_forwarders.Add(virtualScene.RegionInfo.originRegionID, forwarder);
virtualScene.EventManager.OnNewClient += forwarder.ClientConnect;
virtualScene.EventManager.OnClientClosed += forwarder.ClientClosed;
}
}
public void RemoveSceneFromEventForwarding (Scene virtualScene)
{
lock (m_forwarders)
{
RegionCombinerIndividualEventForwarder forwarder = m_forwarders[virtualScene.RegionInfo.originRegionID];
virtualScene.EventManager.OnNewClient -= forwarder.ClientConnect;
virtualScene.EventManager.OnClientClosed -= forwarder.ClientClosed;
m_forwarders.Remove(virtualScene.RegionInfo.originRegionID);
}
lock (m_virtScene)
{
if (m_virtScene.ContainsKey(virtualScene.RegionInfo.originRegionID))
{
m_virtScene.Remove(virtualScene.RegionInfo.originRegionID);
}
}
}
}
}

125
OpenSim/Region/CoreModules/World/Land/RegionCombinerIndividualEventForwarder.cs Normal file
View File

@ -0,0 +1,125 @@
/*
* Copyright (c) Contributors, http://opensimulator.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 OpenSimulator 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 OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Scenes;
namespace OpenSim.Region.CoreModules.World.Land
{
public class RegionCombinerIndividualEventForwarder
{
private Scene m_rootScene;
private Scene m_virtScene;
public RegionCombinerIndividualEventForwarder(Scene rootScene, Scene virtScene)
{
m_rootScene = rootScene;
m_virtScene = virtScene;
}
public void ClientConnect(IClientAPI client)
{
m_virtScene.UnSubscribeToClientPrimEvents(client);
m_virtScene.UnSubscribeToClientPrimRezEvents(client);
m_virtScene.UnSubscribeToClientInventoryEvents(client);
m_virtScene.UnSubscribeToClientAttachmentEvents(client);
//m_virtScene.UnSubscribeToClientTeleportEvents(client);
m_virtScene.UnSubscribeToClientScriptEvents(client);
m_virtScene.UnSubscribeToClientGodEvents(client);
m_virtScene.UnSubscribeToClientNetworkEvents(client);
m_rootScene.SubscribeToClientPrimEvents(client);
client.OnAddPrim += LocalAddNewPrim;
client.OnRezObject += LocalRezObject;
m_rootScene.SubscribeToClientInventoryEvents(client);
m_rootScene.SubscribeToClientAttachmentEvents(client);
//m_rootScene.SubscribeToClientTeleportEvents(client);
m_rootScene.SubscribeToClientScriptEvents(client);
m_rootScene.SubscribeToClientGodEvents(client);
m_rootScene.SubscribeToClientNetworkEvents(client);
}
public void ClientClosed(UUID clientid, Scene scene)
{
}
/// <summary>
/// Fixes position based on the region the Rez event came in on
/// </summary>
/// <param name="remoteclient"></param>
/// <param name="itemid"></param>
/// <param name="rayend"></param>
/// <param name="raystart"></param>
/// <param name="raytargetid"></param>
/// <param name="bypassraycast"></param>
/// <param name="rayendisintersection"></param>
/// <param name="rezselected"></param>
/// <param name="removeitem"></param>
/// <param name="fromtaskid"></param>
private void LocalRezObject(IClientAPI remoteclient, UUID itemid, Vector3 rayend, Vector3 raystart,
UUID raytargetid, byte bypassraycast, bool rayendisintersection, bool rezselected, bool removeitem,
UUID fromtaskid)
{
int differenceX = (int)m_virtScene.RegionInfo.RegionLocX - (int)m_rootScene.RegionInfo.RegionLocX;
int differenceY = (int)m_virtScene.RegionInfo.RegionLocY - (int)m_rootScene.RegionInfo.RegionLocY;
rayend.X += differenceX * (int)Constants.RegionSize;
rayend.Y += differenceY * (int)Constants.RegionSize;
raystart.X += differenceX * (int)Constants.RegionSize;
raystart.Y += differenceY * (int)Constants.RegionSize;
m_rootScene.RezObject(remoteclient, itemid, rayend, raystart, raytargetid, bypassraycast,
rayendisintersection, rezselected, removeitem, fromtaskid);
}
/// <summary>
/// Fixes position based on the region the AddPrimShape event came in on
/// </summary>
/// <param name="ownerid"></param>
/// <param name="groupid"></param>
/// <param name="rayend"></param>
/// <param name="rot"></param>
/// <param name="shape"></param>
/// <param name="bypassraycast"></param>
/// <param name="raystart"></param>
/// <param name="raytargetid"></param>
/// <param name="rayendisintersection"></param>
private void LocalAddNewPrim(UUID ownerid, UUID groupid, Vector3 rayend, Quaternion rot,
PrimitiveBaseShape shape, byte bypassraycast, Vector3 raystart, UUID raytargetid,
byte rayendisintersection)
{
int differenceX = (int)m_virtScene.RegionInfo.RegionLocX - (int)m_rootScene.RegionInfo.RegionLocX;
int differenceY = (int)m_virtScene.RegionInfo.RegionLocY - (int)m_rootScene.RegionInfo.RegionLocY;
rayend.X += differenceX * (int)Constants.RegionSize;
rayend.Y += differenceY * (int)Constants.RegionSize;
raystart.X += differenceX * (int)Constants.RegionSize;
raystart.Y += differenceY * (int)Constants.RegionSize;
m_rootScene.AddNewPrim(ownerid, groupid, rayend, rot, shape, bypassraycast, raystart, raytargetid,
rayendisintersection);
}
}
}

163
OpenSim/Region/CoreModules/World/Land/RegionCombinerLargeLandChannel.cs Normal file
View File

@ -0,0 +1,163 @@
/*
* Copyright (c) Contributors, http://opensimulator.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 OpenSimulator 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 OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
namespace OpenSim.Region.CoreModules.World.Land
{
public class RegionCombinerLargeLandChannel : ILandChannel
{
// private static readonly ILog m_log =
// LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private RegionData RegData;
private ILandChannel RootRegionLandChannel;
private readonly List<RegionData> RegionConnections;
#region ILandChannel Members
public RegionCombinerLargeLandChannel(RegionData regData, ILandChannel rootRegionLandChannel,
List<RegionData> regionConnections)
{
RegData = regData;
RootRegionLandChannel = rootRegionLandChannel;
RegionConnections = regionConnections;
}
public List<ILandObject> ParcelsNearPoint(Vector3 position)
{
//m_log.DebugFormat("[LANDPARCELNEARPOINT]: {0}>", position);
return RootRegionLandChannel.ParcelsNearPoint(position - RegData.Offset);
}
public List<ILandObject> AllParcels()
{
return RootRegionLandChannel.AllParcels();
}
public ILandObject GetLandObject(int x, int y)
{
//m_log.DebugFormat("[BIGLANDTESTINT]: <{0},{1}>", x, y);
if (x > 0 && x <= (int)Constants.RegionSize && y > 0 && y <= (int)Constants.RegionSize)
{
return RootRegionLandChannel.GetLandObject(x, y);
}
else
{
int offsetX = (x / (int)Constants.RegionSize);
int offsetY = (y / (int)Constants.RegionSize);
offsetX *= (int)Constants.RegionSize;
offsetY *= (int)Constants.RegionSize;
foreach (RegionData regionData in RegionConnections)
{
if (regionData.Offset.X == offsetX && regionData.Offset.Y == offsetY)
{
return regionData.RegionScene.LandChannel.GetLandObject(x - offsetX, y - offsetY);
}
}
ILandObject obj = new LandObject(UUID.Zero, false, RegData.RegionScene);
obj.landData.Name = "NO LAND";
return obj;
}
}
public ILandObject GetLandObject(int localID)
{
return RootRegionLandChannel.GetLandObject(localID);
}
public ILandObject GetLandObject(float x, float y)
{
//m_log.DebugFormat("[BIGLANDTESTFLOAT]: <{0},{1}>", x, y);
if (x > 0 && x <= (int)Constants.RegionSize && y > 0 && y <= (int)Constants.RegionSize)
{
return RootRegionLandChannel.GetLandObject(x, y);
}
else
{
int offsetX = (int)(x/(int) Constants.RegionSize);
int offsetY = (int)(y/(int) Constants.RegionSize);
offsetX *= (int) Constants.RegionSize;
offsetY *= (int) Constants.RegionSize;
foreach (RegionData regionData in RegionConnections)
{
if (regionData.Offset.X == offsetX && regionData.Offset.Y == offsetY)
{
return regionData.RegionScene.LandChannel.GetLandObject(x - offsetX, y - offsetY);
}
}
ILandObject obj = new LandObject(UUID.Zero, false, RegData.RegionScene);
obj.landData.Name = "NO LAND";
return obj;
}
}
public bool IsLandPrimCountTainted()
{
return RootRegionLandChannel.IsLandPrimCountTainted();
}
public bool IsForcefulBansAllowed()
{
return RootRegionLandChannel.IsForcefulBansAllowed();
}
public void UpdateLandObject(int localID, LandData data)
{
RootRegionLandChannel.UpdateLandObject(localID, data);
}
public void ReturnObjectsInParcel(int localID, uint returnType, UUID[] agentIDs, UUID[] taskIDs, IClientAPI remoteClient)
{
RootRegionLandChannel.ReturnObjectsInParcel(localID, returnType, agentIDs, taskIDs, remoteClient);
}
public void setParcelObjectMaxOverride(overrideParcelMaxPrimCountDelegate overrideDel)
{
RootRegionLandChannel.setParcelObjectMaxOverride(overrideDel);
}
public void setSimulatorObjectMaxOverride(overrideSimulatorMaxPrimCountDelegate overrideDel)
{
RootRegionLandChannel.setSimulatorObjectMaxOverride(overrideDel);
}
public void SetParcelOtherCleanTime(IClientAPI remoteClient, int localID, int otherCleanTime)
{
RootRegionLandChannel.SetParcelOtherCleanTime(remoteClient, localID, otherCleanTime);
}
#endregion
}
}

607
OpenSim/Region/CoreModules/World/Land/RegionCombinerModule.cs
View File

@ -80,9 +80,15 @@ namespace OpenSim.Region.CoreModules.World.Land
if (!enabledYN)
return;
// For testing on a single instance
if (scene.RegionInfo.RegionLocX == 1004 && scene.RegionInfo.RegionLocY == 1000)
return;
//
lock (m_startingScenes)
m_startingScenes.Add(scene.RegionInfo.originRegionID, scene);
// Give each region a standard set of non-infinite borders
Border northBorder = new Border();
northBorder.BorderLine = new Vector3(0, (int)Constants.RegionSize, (int)Constants.RegionSize); //<---
northBorder.CrossDirection = Cardinals.N;
@ -103,6 +109,8 @@ namespace OpenSim.Region.CoreModules.World.Land
westBorder.CrossDirection = Cardinals.W;
scene.WestBorders[0] = westBorder;
RegionConnections regionConnections = new RegionConnections();
regionConnections.ConnectedRegions = new List<RegionData>();
regionConnections.RegionScene = scene;
@ -112,6 +120,8 @@ namespace OpenSim.Region.CoreModules.World.Land
regionConnections.Y = scene.RegionInfo.RegionLocY;
regionConnections.XEnd = (int)Constants.RegionSize;
regionConnections.YEnd = (int)Constants.RegionSize;
lock (m_regions)
{
bool connectedYN = false;
@ -280,6 +290,7 @@ namespace OpenSim.Region.CoreModules.World.Land
//xxx
//xxy
//xxx
if ((((int)conn.X * (int)Constants.RegionSize) + conn.XEnd
>= (regionConnections.X * (int)Constants.RegionSize))
&& (((int)conn.Y * (int)Constants.RegionSize)
@ -310,9 +321,13 @@ namespace OpenSim.Region.CoreModules.World.Land
ConnectedRegion.RegionScene = scene;
conn.ConnectedRegions.Add(ConnectedRegion);
// Inform root region Physics about the extents of this region
conn.RegionScene.PhysicsScene.Combine(null, Vector3.Zero, extents);
// Inform Child region that it needs to forward it's terrain to the root region
scene.PhysicsScene.Combine(conn.RegionScene.PhysicsScene, offset, Vector3.Zero);
// Extend the borders as appropriate
lock (conn.RegionScene.EastBorders)
conn.RegionScene.EastBorders[0].BorderLine.Z += (int)Constants.RegionSize;
@ -323,15 +338,24 @@ namespace OpenSim.Region.CoreModules.World.Land
conn.RegionScene.SouthBorders[0].BorderLine.Y += (int)Constants.RegionSize;
lock (scene.WestBorders)
{
scene.WestBorders[0].BorderLine.Z += (int) Constants.RegionSize; //auto teleport West
// Reset Terrain.. since terrain normally loads first.
//
scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
//conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
// Trigger auto teleport to root region
scene.WestBorders[0].TriggerRegionX = conn.RegionScene.RegionInfo.RegionLocX;
scene.WestBorders[0].TriggerRegionY = conn.RegionScene.RegionInfo.RegionLocY;
}
// Reset Terrain.. since terrain loads before we get here, we need to load
// it again so it loads in the root region
scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
// Unlock borders
conn.RegionScene.BordersLocked = false;
scene.BordersLocked = false;
// Create a client event forwarder and add this region's events to the root region.
if (conn.ClientEventForwarder != null)
conn.ClientEventForwarder.AddSceneToEventForwarding(scene);
connectedYN = true;
@ -381,7 +405,11 @@ namespace OpenSim.Region.CoreModules.World.Land
lock (conn.RegionScene.WestBorders)
conn.RegionScene.WestBorders[0].BorderLine.Y += (int)Constants.RegionSize;
lock (scene.SouthBorders)
{
scene.SouthBorders[0].BorderLine.Z += (int) Constants.RegionSize; //auto teleport south
scene.SouthBorders[0].TriggerRegionX = conn.RegionScene.RegionInfo.RegionLocX;
scene.SouthBorders[0].TriggerRegionY = conn.RegionScene.RegionInfo.RegionLocY;
}
// Reset Terrain.. since terrain normally loads first.
//conn.RegionScene.PhysicsScene.SetTerrain(conn.RegionScene.Heightmap.GetFloatsSerialised());
@ -446,8 +474,13 @@ namespace OpenSim.Region.CoreModules.World.Land
conn.RegionScene.WestBorders[0].BorderLine.Y += (int)Constants.RegionSize;
}
}
lock (scene.SouthBorders)
{
scene.SouthBorders[0].BorderLine.Z += (int) Constants.RegionSize; //auto teleport south
scene.SouthBorders[0].TriggerRegionX = conn.RegionScene.RegionInfo.RegionLocX;
scene.SouthBorders[0].TriggerRegionY = conn.RegionScene.RegionInfo.RegionLocY;
}
lock (conn.RegionScene.EastBorders)
{
@ -465,7 +498,12 @@ namespace OpenSim.Region.CoreModules.World.Land
}
lock (scene.WestBorders)
{
scene.WestBorders[0].BorderLine.Z += (int) Constants.RegionSize; //auto teleport West
scene.WestBorders[0].TriggerRegionX = conn.RegionScene.RegionInfo.RegionLocX;
scene.WestBorders[0].TriggerRegionY = conn.RegionScene.RegionInfo.RegionLocY;
}
/*
else
{
@ -495,17 +533,21 @@ namespace OpenSim.Region.CoreModules.World.Land
}
}
// If !connectYN means that this region is a root region
if (!connectedYN)
{
RegionData rdata = new RegionData();
rdata.Offset = Vector3.Zero;
rdata.RegionId = scene.RegionInfo.originRegionID;
rdata.RegionScene = scene;
// save it's land channel
regionConnections.RegionLandChannel = scene.LandChannel;
// Substitue our landchannel
RegionCombinerLargeLandChannel lnd = new RegionCombinerLargeLandChannel(rdata, scene.LandChannel,
regionConnections.ConnectedRegions);
scene.LandChannel = lnd;
// Forward the permissions modules of each of the connected regions to the root region
lock (m_regions)
{
foreach (RegionData r in regionConnections.ConnectedRegions)
@ -513,12 +555,17 @@ namespace OpenSim.Region.CoreModules.World.Land
ForwardPermissionRequests(regionConnections, r.RegionScene);
}
}
// Create the root region's Client Event Forwarder
regionConnections.ClientEventForwarder = new RegionCombinerClientEventForwarder(regionConnections);
// Sets up the CoarseLocationUpdate forwarder for this root region
scene.EventManager.OnNewPresence += SetCourseLocationDelegate;
// Adds this root region to a dictionary of regions that are connectable
m_regions.Add(scene.RegionInfo.originRegionID, regionConnections);
}
}
// Set up infinite borders around the entire AABB of the combined ConnectedRegions
AdjustLargeRegionBounds();
}
@ -646,6 +693,13 @@ namespace OpenSim.Region.CoreModules.World.Land
}
}
/// <summary>
/// Locates a the Client of a particular region in an Array of RegionData based on offset
/// </summary>
/// <param name="offset"></param>
/// <param name="uUID"></param>
/// <param name="rdata"></param>
/// <returns>IClientAPI or null</returns>
private IClientAPI LocateUsersChildAgentIClientAPI(Vector2 offset, UUID uUID, RegionData[] rdata)
{
IClientAPI returnclient = null;
@ -664,6 +718,10 @@ namespace OpenSim.Region.CoreModules.World.Land
{
}
/// <summary>
/// TODO:
/// </summary>
/// <param name="rdata"></param>
public void UnCombineRegion(RegionData rdata)
{
lock (m_regions)
@ -706,7 +764,7 @@ namespace OpenSim.Region.CoreModules.World.Land
lock (rconn.RegionScene.NorthBorders)
{
Border northBorder = null;
// If we don't already have an infinite border, create one.
if (!TryGetInfiniteBorder(rconn.RegionScene.NorthBorders, out northBorder))
{
northBorder = new Border();
@ -721,6 +779,7 @@ namespace OpenSim.Region.CoreModules.World.Land
lock (rconn.RegionScene.SouthBorders)
{
Border southBorder = null;
// If we don't already have an infinite border, create one.
if (!TryGetInfiniteBorder(rconn.RegionScene.SouthBorders, out southBorder))
{
southBorder = new Border();
@ -733,6 +792,7 @@ namespace OpenSim.Region.CoreModules.World.Land
lock (rconn.RegionScene.EastBorders)
{
Border eastBorder = null;
// If we don't already have an infinite border, create one.
if (!TryGetInfiniteBorder(rconn.RegionScene.EastBorders, out eastBorder))
{
eastBorder = new Border();
@ -746,6 +806,7 @@ namespace OpenSim.Region.CoreModules.World.Land
lock (rconn.RegionScene.WestBorders)
{
Border westBorder = null;
// If we don't already have an infinite border, create one.
if (!TryGetInfiniteBorder(rconn.RegionScene.WestBorders, out westBorder))
{
westBorder = new Border();
@ -761,6 +822,12 @@ namespace OpenSim.Region.CoreModules.World.Land
}
}
/// <summary>
/// Try and get an Infinite border out of a listT of borders
/// </summary>
/// <param name="borders"></param>
/// <param name="oborder"></param>
/// <returns></returns>
public static bool TryGetInfiniteBorder(List<Border> borders, out Border oborder)
{
// Warning! Should be locked before getting here!
@ -844,532 +911,4 @@ namespace OpenSim.Region.CoreModules.World.Land
VirtualRegion.Permissions.OnUseObjectReturn += BigRegion.PermissionModule.CanUseObjectReturn; //NOT YET IMPLEMENTED
}
}
public class RegionConnections
{
public UUID RegionId;
public Scene RegionScene;
public ILandChannel RegionLandChannel;
public uint X;
public uint Y;
public int XEnd;
public int YEnd;
public List<RegionData> ConnectedRegions;
public RegionCombinerPermissionModule PermissionModule;
public RegionCombinerClientEventForwarder ClientEventForwarder;
public void UpdateExtents(Vector3 extents)
{
XEnd = (int)extents.X;
YEnd = (int)extents.Y;
}
}
public class RegionData
{
public UUID RegionId;
public Scene RegionScene;
public Vector3 Offset;
}
struct RegionCourseLocationStruct
{
public List<Vector3> Locations;
public List<UUID> Uuids;
public IClientAPI UserAPI;
public Vector2 Offset;
}
public class RegionCombinerLargeLandChannel : ILandChannel
{
// private static readonly ILog m_log =
// LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private RegionData RegData;
private ILandChannel RootRegionLandChannel;
private readonly List<RegionData> RegionConnections;
#region ILandChannel Members
public RegionCombinerLargeLandChannel(RegionData regData, ILandChannel rootRegionLandChannel,
List<RegionData> regionConnections)
{
RegData = regData;
RootRegionLandChannel = rootRegionLandChannel;
RegionConnections = regionConnections;
}
public List<ILandObject> ParcelsNearPoint(Vector3 position)
{
//m_log.DebugFormat("[LANDPARCELNEARPOINT]: {0}>", position);
return RootRegionLandChannel.ParcelsNearPoint(position - RegData.Offset);
}
public List<ILandObject> AllParcels()
{
return RootRegionLandChannel.AllParcels();
}
public ILandObject GetLandObject(int x, int y)
{
//m_log.DebugFormat("[BIGLANDTESTINT]: <{0},{1}>", x, y);
if (x > 0 && x <= (int)Constants.RegionSize && y > 0 && y <= (int)Constants.RegionSize)
{
return RootRegionLandChannel.GetLandObject(x, y);
}
else
{
int offsetX = (x / (int)Constants.RegionSize);
int offsetY = (y / (int)Constants.RegionSize);
offsetX *= (int)Constants.RegionSize;
offsetY *= (int)Constants.RegionSize;
foreach (RegionData regionData in RegionConnections)
{
if (regionData.Offset.X == offsetX && regionData.Offset.Y == offsetY)
{
return regionData.RegionScene.LandChannel.GetLandObject(x - offsetX, y - offsetY);
}
}
ILandObject obj = new LandObject(UUID.Zero, false, RegData.RegionScene);
obj.landData.Name = "NO LAND";
return obj;
}
}
public ILandObject GetLandObject(int localID)
{
return RootRegionLandChannel.GetLandObject(localID);
}
public ILandObject GetLandObject(float x, float y)
{
//m_log.DebugFormat("[BIGLANDTESTFLOAT]: <{0},{1}>", x, y);
if (x > 0 && x <= (int)Constants.RegionSize && y > 0 && y <= (int)Constants.RegionSize)
{
return RootRegionLandChannel.GetLandObject(x, y);
}
else
{
int offsetX = (int)(x/(int) Constants.RegionSize);
int offsetY = (int)(y/(int) Constants.RegionSize);
offsetX *= (int) Constants.RegionSize;
offsetY *= (int) Constants.RegionSize;
foreach (RegionData regionData in RegionConnections)
{
if (regionData.Offset.X == offsetX && regionData.Offset.Y == offsetY)
{
return regionData.RegionScene.LandChannel.GetLandObject(x - offsetX, y - offsetY);
}
}
ILandObject obj = new LandObject(UUID.Zero, false, RegData.RegionScene);
obj.landData.Name = "NO LAND";
return obj;
}
}
public bool IsLandPrimCountTainted()
{
return RootRegionLandChannel.IsLandPrimCountTainted();
}
public bool IsForcefulBansAllowed()
{
return RootRegionLandChannel.IsForcefulBansAllowed();
}
public void UpdateLandObject(int localID, LandData data)
{
RootRegionLandChannel.UpdateLandObject(localID, data);
}
public void ReturnObjectsInParcel(int localID, uint returnType, UUID[] agentIDs, UUID[] taskIDs, IClientAPI remoteClient)
{
RootRegionLandChannel.ReturnObjectsInParcel(localID, returnType, agentIDs, taskIDs, remoteClient);
}
public void setParcelObjectMaxOverride(overrideParcelMaxPrimCountDelegate overrideDel)
{
RootRegionLandChannel.setParcelObjectMaxOverride(overrideDel);
}
public void setSimulatorObjectMaxOverride(overrideSimulatorMaxPrimCountDelegate overrideDel)
{
RootRegionLandChannel.setSimulatorObjectMaxOverride(overrideDel);
}
public void SetParcelOtherCleanTime(IClientAPI remoteClient, int localID, int otherCleanTime)
{
RootRegionLandChannel.SetParcelOtherCleanTime(remoteClient, localID, otherCleanTime);
}
#endregion
}
public class RegionCombinerPermissionModule
{
private Scene m_rootScene;
public RegionCombinerPermissionModule(Scene RootScene)
{
m_rootScene = RootScene;
}
#region Permission Override
public bool BypassPermissions()
{
return m_rootScene.Permissions.BypassPermissions();
}
public void SetBypassPermissions(bool value)
{
m_rootScene.Permissions.SetBypassPermissions(value);
}
public bool PropagatePermissions()
{
return m_rootScene.Permissions.PropagatePermissions();
}
public uint GenerateClientFlags(UUID userid, UUID objectidid)
{
return m_rootScene.Permissions.GenerateClientFlags(userid,objectidid);
}
public bool CanAbandonParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanAbandonParcel(user,parcel);
}
public bool CanReclaimParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanReclaimParcel(user, parcel);
}
public bool CanDeedParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanDeedParcel(user, parcel);
}
public bool CanDeedObject(UUID user, UUID @group, Scene scene)
{
return m_rootScene.Permissions.CanDeedObject(user,@group);
}
public bool IsGod(UUID user, Scene requestfromscene)
{
return m_rootScene.Permissions.IsGod(user);
}
public bool CanDuplicateObject(int objectcount, UUID objectid, UUID owner, Scene scene, Vector3 objectposition)
{
return m_rootScene.Permissions.CanDuplicateObject(objectcount, objectid, owner, objectposition);
}
public bool CanDeleteObject(UUID objectid, UUID deleter, Scene scene)
{
return m_rootScene.Permissions.CanDeleteObject(objectid, deleter);
}
public bool CanEditObject(UUID objectid, UUID editorid, Scene scene)
{
return m_rootScene.Permissions.CanEditObject(objectid, editorid);
}
public bool CanEditParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanEditParcel(user, parcel);
}
public bool CanInstantMessage(UUID user, UUID target, Scene startscene)
{
return m_rootScene.Permissions.CanInstantMessage(user, target);
}
public bool CanInventoryTransfer(UUID user, UUID target, Scene startscene)
{
return m_rootScene.Permissions.CanInventoryTransfer(user, target);
}
public bool CanIssueEstateCommand(UUID user, Scene requestfromscene, bool ownercommand)
{
return m_rootScene.Permissions.CanIssueEstateCommand(user, ownercommand);
}
public bool CanMoveObject(UUID objectid, UUID moverid, Scene scene)
{
return m_rootScene.Permissions.CanMoveObject(objectid, moverid);
}
public bool CanObjectEntry(UUID objectid, bool enteringregion, Vector3 newpoint, Scene scene)
{
return m_rootScene.Permissions.CanObjectEntry(objectid, enteringregion, newpoint);
}
public bool CanReturnObject(UUID objectid, UUID returnerid, Scene scene)
{
return m_rootScene.Permissions.CanReturnObject(objectid, returnerid);
}
public bool CanRezObject(int objectcount, UUID owner, Vector3 objectposition, Scene scene)
{
return m_rootScene.Permissions.CanRezObject(objectcount, owner, objectposition);
}
public bool CanRunConsoleCommand(UUID user, Scene requestfromscene)
{
return m_rootScene.Permissions.CanRunConsoleCommand(user);
}
public bool CanRunScript(UUID script, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanRunScript(script, objectid, user);
}
public bool CanCompileScript(UUID owneruuid, int scripttype, Scene scene)
{
return m_rootScene.Permissions.CanCompileScript(owneruuid, scripttype);
}
public bool CanSellParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanSellParcel(user, parcel);
}
public bool CanTakeObject(UUID objectid, UUID stealer, Scene scene)
{
return m_rootScene.Permissions.CanTakeObject(objectid, stealer);
}
public bool CanTakeCopyObject(UUID objectid, UUID userid, Scene inscene)
{
return m_rootScene.Permissions.CanTakeObject(objectid, userid);
}
public bool CanTerraformLand(UUID user, Vector3 position, Scene requestfromscene)
{
return m_rootScene.Permissions.CanTerraformLand(user, position);
}
public bool CanLinkObject(UUID user, UUID objectid)
{
return m_rootScene.Permissions.CanLinkObject(user, objectid);
}
public bool CanDelinkObject(UUID user, UUID objectid)
{
return m_rootScene.Permissions.CanDelinkObject(user, objectid);
}
public bool CanBuyLand(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanBuyLand(user, parcel);
}
public bool CanViewNotecard(UUID script, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanViewNotecard(script, objectid, user);
}
public bool CanViewScript(UUID script, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanViewScript(script, objectid, user);
}
public bool CanEditNotecard(UUID notecard, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanEditNotecard(notecard, objectid, user);
}
public bool CanEditScript(UUID script, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanEditScript(script, objectid, user);
}
public bool CanCreateObjectInventory(int invtype, UUID objectid, UUID userid)
{
return m_rootScene.Permissions.CanCreateObjectInventory(invtype, objectid, userid);
}
public bool CanEditObjectInventory(UUID objectid, UUID editorid, Scene scene)
{
return m_rootScene.Permissions.CanEditObjectInventory(objectid, editorid);
}
public bool CanCopyObjectInventory(UUID itemid, UUID objectid, UUID userid)
{
return m_rootScene.Permissions.CanCopyObjectInventory(itemid, objectid, userid);
}
public bool CanDeleteObjectInventory(UUID itemid, UUID objectid, UUID userid)
{
return m_rootScene.Permissions.CanDeleteObjectInventory(itemid, objectid, userid);
}
public bool CanResetScript(UUID prim, UUID script, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanResetScript(prim, script, user);
}
public bool CanCreateUserInventory(int invtype, UUID userid)
{
return m_rootScene.Permissions.CanCreateUserInventory(invtype, userid);
}
public bool CanCopyUserInventory(UUID itemid, UUID userid)
{
return m_rootScene.Permissions.CanCopyUserInventory(itemid, userid);
}
public bool CanEditUserInventory(UUID itemid, UUID userid)
{
return m_rootScene.Permissions.CanEditUserInventory(itemid, userid);
}
public bool CanDeleteUserInventory(UUID itemid, UUID userid)
{
return m_rootScene.Permissions.CanDeleteUserInventory(itemid, userid);
}
public bool CanTeleport(UUID userid, Scene scene)
{
return m_rootScene.Permissions.CanTeleport(userid);
}
public bool CanUseObjectReturn(ILandObject landdata, uint type, IClientAPI client, List<SceneObjectGroup> retlist, Scene scene)
{
return m_rootScene.Permissions.CanUseObjectReturn(landdata, type, client, retlist);
}
#endregion
}
public class RegionCombinerClientEventForwarder
{
private Scene m_rootScene;
private Dictionary<UUID, Scene> m_virtScene = new Dictionary<UUID, Scene>();
private Dictionary<UUID,RegionCombinerModuleIndividualForwarder> m_forwarders = new Dictionary<UUID,
RegionCombinerModuleIndividualForwarder>();
public RegionCombinerClientEventForwarder(RegionConnections rootScene)
{
m_rootScene = rootScene.RegionScene;
}
public void AddSceneToEventForwarding(Scene virtualScene)
{
lock (m_virtScene)
{
if (m_virtScene.ContainsKey(virtualScene.RegionInfo.originRegionID))
{
m_virtScene[virtualScene.RegionInfo.originRegionID] = virtualScene;
}
else
{
m_virtScene.Add(virtualScene.RegionInfo.originRegionID, virtualScene);
}
}
lock (m_forwarders)
{
// TODO: Fix this to unregister if this happens
if (m_forwarders.ContainsKey(virtualScene.RegionInfo.originRegionID))
m_forwarders.Remove(virtualScene.RegionInfo.originRegionID);
RegionCombinerModuleIndividualForwarder forwarder =
new RegionCombinerModuleIndividualForwarder(m_rootScene, virtualScene);
m_forwarders.Add(virtualScene.RegionInfo.originRegionID, forwarder);
virtualScene.EventManager.OnNewClient += forwarder.ClientConnect;
virtualScene.EventManager.OnClientClosed += forwarder.ClientClosed;
}
}
public void RemoveSceneFromEventForwarding (Scene virtualScene)
{
lock (m_forwarders)
{
RegionCombinerModuleIndividualForwarder forwarder = m_forwarders[virtualScene.RegionInfo.originRegionID];
virtualScene.EventManager.OnNewClient -= forwarder.ClientConnect;
virtualScene.EventManager.OnClientClosed -= forwarder.ClientClosed;
m_forwarders.Remove(virtualScene.RegionInfo.originRegionID);
}
lock (m_virtScene)
{
if (m_virtScene.ContainsKey(virtualScene.RegionInfo.originRegionID))
{
m_virtScene.Remove(virtualScene.RegionInfo.originRegionID);
}
}
}
}
public class RegionCombinerModuleIndividualForwarder
{
private Scene m_rootScene;
private Scene m_virtScene;
public RegionCombinerModuleIndividualForwarder(Scene rootScene, Scene virtScene)
{
m_rootScene = rootScene;
m_virtScene = virtScene;
}
public void ClientConnect(IClientAPI client)
{
m_virtScene.UnSubscribeToClientPrimEvents(client);
m_virtScene.UnSubscribeToClientPrimRezEvents(client);
m_virtScene.UnSubscribeToClientInventoryEvents(client);
m_virtScene.UnSubscribeToClientAttachmentEvents(client);
m_virtScene.UnSubscribeToClientTeleportEvents(client);
m_virtScene.UnSubscribeToClientScriptEvents(client);
m_virtScene.UnSubscribeToClientGodEvents(client);
m_virtScene.UnSubscribeToClientNetworkEvents(client);
m_rootScene.SubscribeToClientPrimEvents(client);
client.OnAddPrim += LocalAddNewPrim;
client.OnRezObject += LocalRezObject;
m_rootScene.SubscribeToClientInventoryEvents(client);
m_rootScene.SubscribeToClientAttachmentEvents(client);
m_rootScene.SubscribeToClientTeleportEvents(client);
m_rootScene.SubscribeToClientScriptEvents(client);
m_rootScene.SubscribeToClientGodEvents(client);
m_rootScene.SubscribeToClientNetworkEvents(client);
}
public void ClientClosed(UUID clientid, Scene scene)
{
}
private void LocalRezObject(IClientAPI remoteclient, UUID itemid, Vector3 rayend, Vector3 raystart,
UUID raytargetid, byte bypassraycast, bool rayendisintersection, bool rezselected, bool removeitem,
UUID fromtaskid)
{
int differenceX = (int)m_virtScene.RegionInfo.RegionLocX - (int)m_rootScene.RegionInfo.RegionLocX;
int differenceY = (int)m_virtScene.RegionInfo.RegionLocY - (int)m_rootScene.RegionInfo.RegionLocY;
rayend.X += differenceX * (int)Constants.RegionSize;
rayend.Y += differenceY * (int)Constants.RegionSize;
raystart.X += differenceX * (int)Constants.RegionSize;
raystart.Y += differenceY * (int)Constants.RegionSize;
m_rootScene.RezObject(remoteclient, itemid, rayend, raystart, raytargetid, bypassraycast,
rayendisintersection, rezselected, removeitem, fromtaskid);
}
private void LocalAddNewPrim(UUID ownerid, UUID groupid, Vector3 rayend, Quaternion rot,
PrimitiveBaseShape shape, byte bypassraycast, Vector3 raystart, UUID raytargetid,
byte rayendisintersection)
{
int differenceX = (int)m_virtScene.RegionInfo.RegionLocX - (int)m_rootScene.RegionInfo.RegionLocX;
int differenceY = (int)m_virtScene.RegionInfo.RegionLocY - (int)m_rootScene.RegionInfo.RegionLocY;
rayend.X += differenceX * (int)Constants.RegionSize;
rayend.Y += differenceY * (int)Constants.RegionSize;
raystart.X += differenceX * (int)Constants.RegionSize;
raystart.Y += differenceY * (int)Constants.RegionSize;
m_rootScene.AddNewPrim(ownerid, groupid, rayend, rot, shape, bypassraycast, raystart, raytargetid,
rayendisintersection);
}
}
}

275
OpenSim/Region/CoreModules/World/Land/RegionCombinerPermissionModule.cs Normal file
View File

@ -0,0 +1,275 @@
/*
* Copyright (c) Contributors, http://opensimulator.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 OpenSimulator 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 OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
namespace OpenSim.Region.CoreModules.World.Land
{
public class RegionCombinerPermissionModule
{
private Scene m_rootScene;
public RegionCombinerPermissionModule(Scene RootScene)
{
m_rootScene = RootScene;
}
#region Permission Override
public bool BypassPermissions()
{
return m_rootScene.Permissions.BypassPermissions();
}
public void SetBypassPermissions(bool value)
{
m_rootScene.Permissions.SetBypassPermissions(value);
}
public bool PropagatePermissions()
{
return m_rootScene.Permissions.PropagatePermissions();
}
public uint GenerateClientFlags(UUID userid, UUID objectidid)
{
return m_rootScene.Permissions.GenerateClientFlags(userid,objectidid);
}
public bool CanAbandonParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanAbandonParcel(user,parcel);
}
public bool CanReclaimParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanReclaimParcel(user, parcel);
}
public bool CanDeedParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanDeedParcel(user, parcel);
}
public bool CanDeedObject(UUID user, UUID @group, Scene scene)
{
return m_rootScene.Permissions.CanDeedObject(user,@group);
}
public bool IsGod(UUID user, Scene requestfromscene)
{
return m_rootScene.Permissions.IsGod(user);
}
public bool CanDuplicateObject(int objectcount, UUID objectid, UUID owner, Scene scene, Vector3 objectposition)
{
return m_rootScene.Permissions.CanDuplicateObject(objectcount, objectid, owner, objectposition);
}
public bool CanDeleteObject(UUID objectid, UUID deleter, Scene scene)
{
return m_rootScene.Permissions.CanDeleteObject(objectid, deleter);
}
public bool CanEditObject(UUID objectid, UUID editorid, Scene scene)
{
return m_rootScene.Permissions.CanEditObject(objectid, editorid);
}
public bool CanEditParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanEditParcel(user, parcel);
}
public bool CanInstantMessage(UUID user, UUID target, Scene startscene)
{
return m_rootScene.Permissions.CanInstantMessage(user, target);
}
public bool CanInventoryTransfer(UUID user, UUID target, Scene startscene)
{
return m_rootScene.Permissions.CanInventoryTransfer(user, target);
}
public bool CanIssueEstateCommand(UUID user, Scene requestfromscene, bool ownercommand)
{
return m_rootScene.Permissions.CanIssueEstateCommand(user, ownercommand);
}
public bool CanMoveObject(UUID objectid, UUID moverid, Scene scene)
{
return m_rootScene.Permissions.CanMoveObject(objectid, moverid);
}
public bool CanObjectEntry(UUID objectid, bool enteringregion, Vector3 newpoint, Scene scene)
{
return m_rootScene.Permissions.CanObjectEntry(objectid, enteringregion, newpoint);
}
public bool CanReturnObject(UUID objectid, UUID returnerid, Scene scene)
{
return m_rootScene.Permissions.CanReturnObject(objectid, returnerid);
}
public bool CanRezObject(int objectcount, UUID owner, Vector3 objectposition, Scene scene)
{
return m_rootScene.Permissions.CanRezObject(objectcount, owner, objectposition);
}
public bool CanRunConsoleCommand(UUID user, Scene requestfromscene)
{
return m_rootScene.Permissions.CanRunConsoleCommand(user);
}
public bool CanRunScript(UUID script, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanRunScript(script, objectid, user);
}
public bool CanCompileScript(UUID owneruuid, int scripttype, Scene scene)
{
return m_rootScene.Permissions.CanCompileScript(owneruuid, scripttype);
}
public bool CanSellParcel(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanSellParcel(user, parcel);
}
public bool CanTakeObject(UUID objectid, UUID stealer, Scene scene)
{
return m_rootScene.Permissions.CanTakeObject(objectid, stealer);
}
public bool CanTakeCopyObject(UUID objectid, UUID userid, Scene inscene)
{
return m_rootScene.Permissions.CanTakeObject(objectid, userid);
}
public bool CanTerraformLand(UUID user, Vector3 position, Scene requestfromscene)
{
return m_rootScene.Permissions.CanTerraformLand(user, position);
}
public bool CanLinkObject(UUID user, UUID objectid)
{
return m_rootScene.Permissions.CanLinkObject(user, objectid);
}
public bool CanDelinkObject(UUID user, UUID objectid)
{
return m_rootScene.Permissions.CanDelinkObject(user, objectid);
}
public bool CanBuyLand(UUID user, ILandObject parcel, Scene scene)
{
return m_rootScene.Permissions.CanBuyLand(user, parcel);
}
public bool CanViewNotecard(UUID script, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanViewNotecard(script, objectid, user);
}
public bool CanViewScript(UUID script, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanViewScript(script, objectid, user);
}
public bool CanEditNotecard(UUID notecard, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanEditNotecard(notecard, objectid, user);
}
public bool CanEditScript(UUID script, UUID objectid, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanEditScript(script, objectid, user);
}
public bool CanCreateObjectInventory(int invtype, UUID objectid, UUID userid)
{
return m_rootScene.Permissions.CanCreateObjectInventory(invtype, objectid, userid);
}
public bool CanEditObjectInventory(UUID objectid, UUID editorid, Scene scene)
{
return m_rootScene.Permissions.CanEditObjectInventory(objectid, editorid);
}
public bool CanCopyObjectInventory(UUID itemid, UUID objectid, UUID userid)
{
return m_rootScene.Permissions.CanCopyObjectInventory(itemid, objectid, userid);
}
public bool CanDeleteObjectInventory(UUID itemid, UUID objectid, UUID userid)
{
return m_rootScene.Permissions.CanDeleteObjectInventory(itemid, objectid, userid);
}
public bool CanResetScript(UUID prim, UUID script, UUID user, Scene scene)
{
return m_rootScene.Permissions.CanResetScript(prim, script, user);
}
public bool CanCreateUserInventory(int invtype, UUID userid)
{
return m_rootScene.Permissions.CanCreateUserInventory(invtype, userid);
}
public bool CanCopyUserInventory(UUID itemid, UUID userid)
{
return m_rootScene.Permissions.CanCopyUserInventory(itemid, userid);
}
public bool CanEditUserInventory(UUID itemid, UUID userid)
{
return m_rootScene.Permissions.CanEditUserInventory(itemid, userid);
}
public bool CanDeleteUserInventory(UUID itemid, UUID userid)
{
return m_rootScene.Permissions.CanDeleteUserInventory(itemid, userid);
}
public bool CanTeleport(UUID userid, Scene scene)
{
return m_rootScene.Permissions.CanTeleport(userid);
}
public bool CanUseObjectReturn(ILandObject landdata, uint type, IClientAPI client, List<SceneObjectGroup> retlist, Scene scene)
{
return m_rootScene.Permissions.CanUseObjectReturn(landdata, type, client, retlist);
}
#endregion
}
}

65
OpenSim/Region/CoreModules/World/Land/RegionConnections.cs Normal file
View File

@ -0,0 +1,65 @@
/*
* Copyright (c) Contributors, http://opensimulator.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 OpenSimulator 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 OpenMetaverse;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
namespace OpenSim.Region.CoreModules.World.Land
{
public class RegionConnections
{
/// <summary>
/// Root Region ID
/// </summary>
public UUID RegionId;
/// <summary>
/// Root Region Scene
/// </summary>
public Scene RegionScene;
/// <summary>
/// LargeLandChannel for combined region
/// </summary>
public ILandChannel RegionLandChannel;
public uint X;
public uint Y;
public int XEnd;
public int YEnd;
public List<RegionData> ConnectedRegions;
public RegionCombinerPermissionModule PermissionModule;
public RegionCombinerClientEventForwarder ClientEventForwarder;
public void UpdateExtents(Vector3 extents)
{
XEnd = (int)extents.X;
YEnd = (int)extents.Y;
}
}
}

43
OpenSim/Region/CoreModules/World/Land/RegionCourseLocation.cs Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright (c) Contributors, http://opensimulator.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 OpenSimulator 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 OpenMetaverse;
using OpenSim.Framework;
namespace OpenSim.Region.CoreModules.World.Land
{
struct RegionCourseLocationStruct
{
public List<Vector3> Locations;
public List<UUID> Uuids;
public IClientAPI UserAPI;
public Vector2 Offset;
}
}

39
OpenSim/Region/CoreModules/World/Land/RegionData.cs Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) Contributors, http://opensimulator.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 OpenSimulator 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 OpenMetaverse;
using OpenSim.Region.Framework.Scenes;
namespace OpenSim.Region.CoreModules.World.Land
{
public class RegionData
{
public UUID RegionId;
public Scene RegionScene;
public Vector3 Offset;
}
}

2
OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
View File

@ -1136,7 +1136,7 @@ namespace OpenSim.Region.Framework.Scenes
UUID newFolderID = UUID.Random();
InventoryFolderBase newFolder = new InventoryFolderBase(newFolderID, category, destID, 0xff, rootFolder.ID, rootFolder.Version);
InventoryFolderBase newFolder = new InventoryFolderBase(newFolderID, category, destID, -1, rootFolder.ID, rootFolder.Version);
InventoryService.AddFolder(newFolder);
foreach (UUID itemID in items)

124
OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
View File

@ -1074,7 +1074,7 @@ namespace OpenSim.Region.Framework.Scenes
if (eq != null)
{
eq.TeleportFinishEvent(reg.RegionHandle, 13, endPoint,
4, teleportFlags, capsPath, avatar.UUID);
0, teleportFlags, capsPath, avatar.UUID);
}
else
{
@ -1272,13 +1272,50 @@ namespace OpenSim.Region.Framework.Scenes
neighboury += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
}
else if (scene.TestBorderCross(pos + southCross, Cardinals.S))
{
Border b = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
if (b.TriggerRegionX == 0 && b.TriggerRegionY == 0)
{
neighboury--;
newpos.Y = Constants.RegionSize - enterDistance;
}
else
{
neighboury = b.TriggerRegionY;
neighbourx = b.TriggerRegionX;
Vector3 newposition = pos;
newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
agent.ControllingClient.SendAgentAlertMessage(
String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
return;
}
}
Border ba = scene.GetCrossedBorder(pos + westCross, Cardinals.W);
if (ba.TriggerRegionX == 0 && ba.TriggerRegionY == 0)
{
neighbourx--;
newpos.X = Constants.RegionSize - enterDistance;
}
else
{
neighboury = ba.TriggerRegionY;
neighbourx = ba.TriggerRegionX;
Vector3 newposition = pos;
newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
agent.ControllingClient.SendAgentAlertMessage(
String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
return;
}
}
else if (scene.TestBorderCross(pos + eastCross, Cardinals.E))
@ -1288,10 +1325,26 @@ namespace OpenSim.Region.Framework.Scenes
newpos.X = enterDistance;
if (scene.TestBorderCross(pos + southCross, Cardinals.S))
{
Border ba = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
if (ba.TriggerRegionX == 0 && ba.TriggerRegionY == 0)
{
neighboury--;
newpos.Y = Constants.RegionSize - enterDistance;
}
else
{
neighboury = ba.TriggerRegionY;
neighbourx = ba.TriggerRegionX;
Vector3 newposition = pos;
newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
agent.ControllingClient.SendAgentAlertMessage(
String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
return;
}
}
else if (scene.TestBorderCross(pos + northCross, Cardinals.N))
{
Border c = scene.GetCrossedBorder(pos + northCross, Cardinals.N);
@ -1302,12 +1355,29 @@ namespace OpenSim.Region.Framework.Scenes
}
else if (scene.TestBorderCross(pos + southCross, Cardinals.S))
{
Border b = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
if (b.TriggerRegionX == 0 && b.TriggerRegionY == 0)
{
neighboury--;
newpos.Y = Constants.RegionSize - enterDistance;
}
else
{
neighboury = b.TriggerRegionY;
neighbourx = b.TriggerRegionX;
Vector3 newposition = pos;
newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
agent.ControllingClient.SendAgentAlertMessage(
String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
return;
}
}
else if (scene.TestBorderCross(pos + northCross, Cardinals.N))
{
Border b = scene.GetCrossedBorder(pos + northCross, Cardinals.N);
neighboury += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
newpos.Y = enterDistance;
@ -1342,6 +1412,58 @@ namespace OpenSim.Region.Framework.Scenes
d.BeginInvoke(agent, newpos, neighbourx, neighboury, isFlying, CrossAgentToNewRegionCompleted, d);
}
public delegate void InformClientToInitateTeleportToLocationDelegate(ScenePresence agent, uint regionX, uint regionY,
Vector3 position,
Scene initiatingScene);
public void InformClientToInitateTeleportToLocation(ScenePresence agent, uint regionX, uint regionY, Vector3 position,
Scene initiatingScene)
{
// This assumes that we know what our neighbors are.
InformClientToInitateTeleportToLocationDelegate d = InformClientToInitiateTeleportToLocationAsync;
d.BeginInvoke(agent,regionX,regionY,position,initiatingScene,
InformClientToInitiateTeleportToLocationCompleted,
d);
}
public void InformClientToInitiateTeleportToLocationAsync(ScenePresence agent, uint regionX, uint regionY, Vector3 position,
Scene initiatingScene)
{
Thread.Sleep(10000);
IMessageTransferModule im = initiatingScene.RequestModuleInterface<IMessageTransferModule>();
if (im != null)
{
UUID gotoLocation = Util.BuildFakeParcelID(
Util.UIntsToLong(
(regionX *
(uint)Constants.RegionSize),
(regionY *
(uint)Constants.RegionSize)),
(uint)(int)position.X,
(uint)(int)position.Y,
(uint)(int)position.Z);
GridInstantMessage m = new GridInstantMessage(initiatingScene, UUID.Zero,
"Region", agent.UUID,
(byte)InstantMessageDialog.GodLikeRequestTeleport, false,
"", gotoLocation, false, new Vector3(127, 0, 0),
new Byte[0]);
im.SendInstantMessage(m, delegate(bool success)
{
m_log.DebugFormat("[CLIENT]: Client Initiating Teleport sending IM success = {0}", success);
});
}
}
private void InformClientToInitiateTeleportToLocationCompleted(IAsyncResult iar)
{
InformClientToInitateTeleportToLocationDelegate icon =
(InformClientToInitateTeleportToLocationDelegate) iar.AsyncState;
icon.EndInvoke(iar);
}
public delegate ScenePresence CrossAgentToNewRegionDelegate(ScenePresence agent, Vector3 pos, uint neighbourx, uint neighboury, bool isFlying);
/// <summary>

22
OpenSim/Region/Framework/Scenes/ScenePresence.cs
View File

@ -776,8 +776,20 @@ namespace OpenSim.Region.Framework.Scenes
// before the inventory is processed in MakeRootAgent. This fixes a race condition
// related to the handling of attachments
//m_scene.GetAvatarAppearance(m_controllingClient, out m_appearance);
if (m_scene.TestBorderCross(pos, Cardinals.E))
{
Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.E);
pos.X = crossedBorder.BorderLine.Z - 1;
}
if (pos.X < 0 || pos.X >= (int)Constants.RegionSize || pos.Y < 0 || pos.Y >= (int)Constants.RegionSize || pos.Z < 0)
if (m_scene.TestBorderCross(pos, Cardinals.N))
{
Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.N);
pos.Y = crossedBorder.BorderLine.Z - 1;
}
if (pos.X < 0 || pos.Y < 0 || pos.Z < 0)
{
Vector3 emergencyPos = new Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 128);
@ -795,7 +807,11 @@ namespace OpenSim.Region.Framework.Scenes
localAVHeight = m_avHeight;
}
float posZLimit = (float)m_scene.Heightmap[(int)pos.X, (int)pos.Y];
float posZLimit = 0;
if (pos.X <Constants.RegionSize && pos.Y < Constants.RegionSize)
posZLimit = (float)m_scene.Heightmap[(int)pos.X, (int)pos.Y];
float newPosZ = posZLimit + localAVHeight / 2;
if (posZLimit >= (pos.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
{
@ -877,6 +893,7 @@ namespace OpenSim.Region.Framework.Scenes
m_isChildAgent = true;
m_scene.SwapRootAgentCount(true);
RemoveFromPhysicalScene();
m_scene.EventManager.TriggerOnMakeChildAgent(this);
}
@ -2412,6 +2429,7 @@ namespace OpenSim.Region.Framework.Scenes
}
// followed suggestion from mic bowman. reversed the two lines below.
if (m_parentID == 0 && m_physicsActor != null || m_parentID != 0) // Check that we have a physics actor or we're sitting on something
CheckForBorderCrossing();
CheckForSignificantMovement(); // sends update to the modules.
}

6
OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
View File

@ -304,8 +304,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
using (FileStream fs = File.Open(savedState,
FileMode.Open, FileAccess.Read, FileShare.None))
{
System.Text.ASCIIEncoding enc =
new System.Text.ASCIIEncoding();
System.Text.UTF8Encoding enc =
new System.Text.UTF8Encoding();
Byte[] data = new Byte[size];
fs.Read(data, 0, size);
@ -899,7 +899,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
try
{
FileStream fs = File.Create(Path.Combine(Path.GetDirectoryName(assembly), m_ItemID.ToString() + ".state"));
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
Byte[] buf = enc.GetBytes(xml);
fs.Write(buf, 0, buf.Length);
fs.Close();

5
bin/OpenSim.ini.example
View File

@ -81,6 +81,11 @@
; How many prims to send to each avatar in the scene on each Update()
; MaxPrimsPerFrame = 200
; Combine all contiguous regions into one large region
; Order your regions from South to North, West to East in your regions.ini and then set this to true
; Warning! Don't use this with regions that have existing content!, This will likely break them
CombineContiguousRegions=false
; ##
; ## STORAGE
; ##