807 lines
29 KiB
C#
807 lines
29 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://www.openmetaverse.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSim Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using System.Timers;
|
|
using libsecondlife;
|
|
using libsecondlife.Packets;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Framework.Communications;
|
|
using OpenSim.Framework.Console;
|
|
using OpenSim.Framework.Interfaces;
|
|
using OpenSim.Framework.Servers;
|
|
using OpenSim.Framework.Types;
|
|
using OpenSim.Physics.Manager;
|
|
using OpenSim.Region.Caches;
|
|
using OpenSim.Region.Environment.Scripting;
|
|
using OpenSim.Region.Terrain;
|
|
using Caps=OpenSim.Region.Capabilities.Caps;
|
|
using Timer=System.Timers.Timer;
|
|
|
|
namespace OpenSim.Region.Environment.Scenes
|
|
{
|
|
public delegate bool FilterAvatarList(ScenePresence avatar);
|
|
|
|
public partial class Scene : SceneBase, ILocalStorageReceiver
|
|
{
|
|
protected Timer m_heartbeatTimer = new Timer();
|
|
protected Dictionary<LLUUID, ScenePresence> Avatars;
|
|
protected Dictionary<LLUUID, SceneObject> Prims;
|
|
private PhysicsScene phyScene;
|
|
private float timeStep = 0.1f;
|
|
private Random Rand = new Random();
|
|
private uint _primCount = 702000;
|
|
private System.Threading.Mutex _primAllocateMutex = new Mutex(false);
|
|
private int storageCount;
|
|
private Mutex updateLock;
|
|
|
|
protected AuthenticateSessionsBase authenticateHandler;
|
|
protected RegionCommsListener regionCommsHost;
|
|
protected CommunicationsManager commsManager;
|
|
|
|
protected Dictionary<LLUUID, Caps> capsHandlers = new Dictionary<LLUUID, Caps>();
|
|
protected BaseHttpServer httpListener;
|
|
|
|
public ParcelManager parcelManager;
|
|
public EstateManager estateManager;
|
|
public EventManager eventManager;
|
|
public ScriptManager scriptManager;
|
|
|
|
#region Properties
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public PhysicsScene PhysScene
|
|
{
|
|
set
|
|
{
|
|
this.phyScene = value;
|
|
}
|
|
get
|
|
{
|
|
return (this.phyScene);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
/// <summary>
|
|
/// Creates a new World class, and a region to go with it.
|
|
/// </summary>
|
|
/// <param name="clientThreads">Dictionary to contain client threads</param>
|
|
/// <param name="regionHandle">Region Handle for this region</param>
|
|
/// <param name="regionName">Region Name for this region</param>
|
|
public Scene(ClientManager clientManager, RegionInfo regInfo, AuthenticateSessionsBase authen, CommunicationsManager commsMan, AssetCache assetCach, BaseHttpServer httpServer)
|
|
{
|
|
updateLock = new Mutex(false);
|
|
this.authenticateHandler = authen;
|
|
this.commsManager = commsMan;
|
|
this.assetCache = assetCach;
|
|
m_clientManager = clientManager;
|
|
m_regInfo = regInfo;
|
|
m_regionHandle = m_regInfo.RegionHandle;
|
|
m_regionName = m_regInfo.RegionName;
|
|
this.m_datastore = m_regInfo.DataStore;
|
|
this.RegisterRegionWithComms();
|
|
|
|
parcelManager = new ParcelManager(this, this.m_regInfo);
|
|
estateManager = new EstateManager(this, this.m_regInfo);
|
|
scriptManager = new ScriptManager(this);
|
|
eventManager = new EventManager();
|
|
|
|
MainLog.Instance.Verbose("World.cs - creating new entitities instance");
|
|
Entities = new Dictionary<LLUUID, EntityBase>();
|
|
Avatars = new Dictionary<LLUUID, ScenePresence>();
|
|
Prims = new Dictionary<LLUUID, SceneObject>();
|
|
|
|
MainLog.Instance.Verbose("World.cs - creating LandMap");
|
|
Terrain = new TerrainEngine();
|
|
|
|
ScenePresence.LoadAnims();
|
|
this.httpListener = httpServer;
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public void StartTimer()
|
|
{
|
|
m_heartbeatTimer.Enabled = true;
|
|
m_heartbeatTimer.Interval = 100;
|
|
m_heartbeatTimer.Elapsed += new ElapsedEventHandler(this.Heartbeat);
|
|
}
|
|
|
|
|
|
#region Update Methods
|
|
|
|
|
|
/// <summary>
|
|
/// Performs per-frame updates regularly
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void Heartbeat(object sender, EventArgs e)
|
|
{
|
|
this.Update();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs per-frame updates on the world, this should be the central world loop
|
|
/// </summary>
|
|
public override void Update()
|
|
{
|
|
updateLock.WaitOne();
|
|
try
|
|
{
|
|
if (this.phyScene.IsThreaded)
|
|
{
|
|
this.phyScene.GetResults();
|
|
|
|
}
|
|
|
|
foreach (LLUUID UUID in Entities.Keys)
|
|
{
|
|
Entities[UUID].updateMovement();
|
|
}
|
|
|
|
lock (this.m_syncRoot)
|
|
{
|
|
this.phyScene.Simulate(timeStep);
|
|
}
|
|
|
|
foreach (LLUUID UUID in Entities.Keys)
|
|
{
|
|
Entities[UUID].update();
|
|
}
|
|
|
|
// General purpose event manager
|
|
eventManager.TriggerOnFrame();
|
|
|
|
//backup world data
|
|
this.storageCount++;
|
|
if (storageCount > 1200) //set to how often you want to backup
|
|
{
|
|
this.Backup();
|
|
storageCount = 0;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MainLog.Instance.Warn("World.cs: Update() - Failed with exception " + e.ToString());
|
|
}
|
|
updateLock.ReleaseMutex();
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool Backup()
|
|
{
|
|
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
#region Regenerate Terrain
|
|
|
|
/// <summary>
|
|
/// Rebuilds the terrain using a procedural algorithm
|
|
/// </summary>
|
|
public void RegenerateTerrain()
|
|
{
|
|
try
|
|
{
|
|
Terrain.hills();
|
|
|
|
lock (this.m_syncRoot)
|
|
{
|
|
this.phyScene.SetTerrain(Terrain.getHeights1D());
|
|
}
|
|
this.localStorage.SaveMap(this.Terrain.getHeights1D());
|
|
|
|
m_clientManager.ForEachClient(delegate(IClientAPI client)
|
|
{
|
|
this.SendLayerData(client);
|
|
});
|
|
|
|
foreach (LLUUID UUID in Entities.Keys)
|
|
{
|
|
Entities[UUID].LandRenegerated();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MainLog.Instance.Warn("World.cs: RegenerateTerrain() - Failed with exception " + e.ToString());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rebuilds the terrain using a 2D float array
|
|
/// </summary>
|
|
/// <param name="newMap">256,256 float array containing heights</param>
|
|
public void RegenerateTerrain(float[,] newMap)
|
|
{
|
|
try
|
|
{
|
|
this.Terrain.setHeights2D(newMap);
|
|
lock (this.m_syncRoot)
|
|
{
|
|
this.phyScene.SetTerrain(this.Terrain.getHeights1D());
|
|
}
|
|
this.localStorage.SaveMap(this.Terrain.getHeights1D());
|
|
|
|
m_clientManager.ForEachClient(delegate(IClientAPI client)
|
|
{
|
|
this.SendLayerData(client);
|
|
});
|
|
|
|
foreach (LLUUID UUID in Entities.Keys)
|
|
{
|
|
Entities[UUID].LandRenegerated();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MainLog.Instance.Warn("World.cs: RegenerateTerrain() - Failed with exception " + e.ToString());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rebuilds the terrain assuming changes occured at a specified point[?]
|
|
/// </summary>
|
|
/// <param name="changes">???</param>
|
|
/// <param name="pointx">???</param>
|
|
/// <param name="pointy">???</param>
|
|
public void RegenerateTerrain(bool changes, int pointx, int pointy)
|
|
{
|
|
try
|
|
{
|
|
if (changes)
|
|
{
|
|
/* Dont save here, rely on tainting system instead */
|
|
|
|
m_clientManager.ForEachClient(delegate(IClientAPI client)
|
|
{
|
|
this.SendLayerData(pointx, pointy, client);
|
|
});
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MainLog.Instance.Warn("World.cs: RegenerateTerrain() - Failed with exception " + e.ToString());
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Load Terrain
|
|
/// <summary>
|
|
/// Loads the World heightmap
|
|
/// </summary>
|
|
///
|
|
public override void LoadWorldMap()
|
|
{
|
|
try
|
|
{
|
|
float[] map = this.localStorage.LoadWorld();
|
|
if (map == null)
|
|
{
|
|
if (string.IsNullOrEmpty(this.m_regInfo.estateSettings.terrainFile))
|
|
{
|
|
Console.WriteLine("No default terrain, procedurally generating...");
|
|
this.Terrain.hills();
|
|
|
|
this.localStorage.SaveMap(this.Terrain.getHeights1D());
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
this.Terrain.loadFromFileF32(this.m_regInfo.estateSettings.terrainFile);
|
|
this.Terrain *= this.m_regInfo.estateSettings.terrainMultiplier;
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Unable to load default terrain, procedurally generating instead...");
|
|
Terrain.hills();
|
|
}
|
|
this.localStorage.SaveMap(this.Terrain.getHeights1D());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.Terrain.setHeights1D(map);
|
|
}
|
|
|
|
CreateTerrainTexture();
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MainLog.Instance.Warn("World.cs: LoadWorldMap() - Failed with exception " + e.ToString());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
private void CreateTerrainTexture()
|
|
{
|
|
//create a texture asset of the terrain
|
|
byte[] data = this.Terrain.exportJpegImage("defaultstripe.png");
|
|
this.m_regInfo.estateSettings.terrainImageID = LLUUID.Random();
|
|
AssetBase asset = new AssetBase();
|
|
asset.FullID = this.m_regInfo.estateSettings.terrainImageID;
|
|
asset.Data = data;
|
|
asset.Name = "terrainImage";
|
|
asset.Type = 0;
|
|
this.assetCache.AddAsset(asset);
|
|
}
|
|
#endregion
|
|
|
|
#region Primitives Methods
|
|
|
|
|
|
/// <summary>
|
|
/// Loads the World's objects
|
|
/// </summary>
|
|
public void LoadPrimsFromStorage()
|
|
{
|
|
try
|
|
{
|
|
MainLog.Instance.Verbose("World.cs: LoadPrimsFromStorage() - Loading primitives");
|
|
this.localStorage.LoadPrimitives(this);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MainLog.Instance.Warn("World.cs: LoadPrimsFromStorage() - Failed with exception " + e.ToString());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads a specific object from storage
|
|
/// </summary>
|
|
/// <param name="prim">The object to load</param>
|
|
public void PrimFromStorage(PrimData prim)
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a new unallocated primitive ID
|
|
/// </summary>
|
|
/// <returns>A brand new primitive ID</returns>
|
|
public uint PrimIDAllocate()
|
|
{
|
|
uint myID;
|
|
|
|
_primAllocateMutex.WaitOne();
|
|
++_primCount;
|
|
myID = _primCount;
|
|
_primAllocateMutex.ReleaseMutex();
|
|
|
|
return myID;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="addPacket"></param>
|
|
/// <param name="agentClient"></param>
|
|
public void AddNewPrim(Packet addPacket, IClientAPI agentClient)
|
|
{
|
|
AddNewPrim((ObjectAddPacket)addPacket, agentClient.AgentId);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="addPacket"></param>
|
|
/// <param name="ownerID"></param>
|
|
public void AddNewPrim(ObjectAddPacket addPacket, LLUUID ownerID)
|
|
{
|
|
try
|
|
{
|
|
SceneObject sceneOb = new SceneObject(m_regionHandle, this, addPacket, ownerID, this.PrimIDAllocate());
|
|
this.Entities.Add(sceneOb.rootUUID, sceneOb);
|
|
|
|
// Trigger event for listeners
|
|
// eventManager.TriggerOnNewPrimitive(prim);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MainLog.Instance.Warn("World.cs: AddNewPrim() - Failed with exception " + e.ToString());
|
|
}
|
|
}
|
|
|
|
public override uint AddNewPrim(LLUUID ownerId, PrimData primData, LLVector3 pos, LLQuaternion rotation, LLUUID texture, int flags)
|
|
{
|
|
uint id = NextLocalId;
|
|
|
|
throw new NotImplementedException("Not implemented yet.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Add/Remove Avatar Methods
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="remoteClient"></param
|
|
/// <param name="agentID"></param>
|
|
/// <param name="child"></param>
|
|
public override void AddNewClient(IClientAPI client, bool child)
|
|
{
|
|
client.OnRegionHandShakeReply += this.SendLayerData;
|
|
//remoteClient.OnRequestWearables += new GenericCall(this.GetInitialPrims);
|
|
client.OnChatFromViewer += this.SimChat;
|
|
client.OnInstantMessage += this.InstantMessage;
|
|
client.OnRequestWearables += this.InformClientOfNeighbours;
|
|
client.OnAddPrim += this.AddNewPrim;
|
|
client.OnUpdatePrimGroupPosition += this.UpdatePrimPosition;
|
|
client.OnUpdatePrimSinglePosition += this.UpdatePrimSinglePosition;
|
|
client.OnUpdatePrimGroupRotation += this.UpdatePrimRotation;
|
|
client.OnUpdatePrimGroupMouseRotation += this.UpdatePrimRotation;
|
|
client.OnUpdatePrimSingleRotation += this.UpdatePrimSingleRotation;
|
|
client.OnUpdatePrimScale += this.UpdatePrimScale;
|
|
client.OnUpdatePrimShape += this.UpdatePrimShape;
|
|
client.OnRequestMapBlocks += this.RequestMapBlocks;
|
|
client.OnTeleportLocationRequest += this.RequestTeleportLocation;
|
|
client.OnObjectSelect += this.SelectPrim;
|
|
client.OnGrapUpdate += this.MoveObject;
|
|
client.OnNameFromUUIDRequest += this.commsManager.HandleUUIDNameRequest;
|
|
client.OnObjectDescription += this.PrimDescription;
|
|
client.OnObjectName += this.PrimName;
|
|
client.OnLinkObjects += this.LinkObjects;
|
|
client.OnObjectDuplicate += this.DuplicateObject;
|
|
|
|
/* remoteClient.OnParcelPropertiesRequest += new ParcelPropertiesRequest(parcelManager.handleParcelPropertiesRequest);
|
|
remoteClient.OnParcelDivideRequest += new ParcelDivideRequest(parcelManager.handleParcelDivideRequest);
|
|
remoteClient.OnParcelJoinRequest += new ParcelJoinRequest(parcelManager.handleParcelJoinRequest);
|
|
remoteClient.OnParcelPropertiesUpdateRequest += new ParcelPropertiesUpdateRequest(parcelManager.handleParcelPropertiesUpdateRequest);
|
|
remoteClient.OnEstateOwnerMessage += new EstateOwnerMessageRequest(estateManager.handleEstateOwnerMessage);
|
|
*/
|
|
this.estateManager.sendRegionHandshake(client);
|
|
|
|
CreateAndAddScenePresence(client);
|
|
return;
|
|
}
|
|
|
|
protected void CreateAndAddScenePresence(IClientAPI client)
|
|
{
|
|
ScenePresence newAvatar = null;
|
|
|
|
MainLog.Instance.Verbose("World.cs:AddViewerAgent() - Creating new avatar for remote viewer agent");
|
|
newAvatar = new ScenePresence(client, this, this.m_regInfo);
|
|
MainLog.Instance.Verbose("World.cs:AddViewerAgent() - Adding new avatar to world");
|
|
MainLog.Instance.Verbose("World.cs:AddViewerAgent() - Starting RegionHandshake ");
|
|
|
|
PhysicsVector pVec = new PhysicsVector(newAvatar.Pos.X, newAvatar.Pos.Y, newAvatar.Pos.Z);
|
|
lock (this.m_syncRoot)
|
|
{
|
|
newAvatar.PhysActor = this.phyScene.AddAvatar(pVec);
|
|
}
|
|
|
|
lock (Entities)
|
|
{
|
|
if (!Entities.ContainsKey(client.AgentId))
|
|
{
|
|
this.Entities.Add(client.AgentId, newAvatar);
|
|
}
|
|
else
|
|
{
|
|
Entities[client.AgentId] = newAvatar;
|
|
}
|
|
}
|
|
lock (Avatars)
|
|
{
|
|
if (Avatars.ContainsKey(client.AgentId))
|
|
{
|
|
Avatars[client.AgentId] = newAvatar;
|
|
}
|
|
else
|
|
{
|
|
this.Avatars.Add(client.AgentId, newAvatar);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="agentID"></param>
|
|
public override void RemoveClient(LLUUID agentID)
|
|
{
|
|
eventManager.TriggerOnRemovePresence(agentID);
|
|
|
|
ScenePresence avatar = this.RequestAvatar(agentID);
|
|
|
|
m_clientManager.ForEachClient(
|
|
delegate(IClientAPI client)
|
|
{
|
|
client.SendKillObject(avatar.RegionHandle, avatar.LocalId);
|
|
});
|
|
|
|
lock (Avatars) {
|
|
if (Avatars.ContainsKey(agentID)) {
|
|
Avatars.Remove(agentID);
|
|
}
|
|
}
|
|
lock (Entities) {
|
|
if (Entities.ContainsKey(agentID)) {
|
|
Entities.Remove(agentID);
|
|
}
|
|
}
|
|
// TODO: Add the removal from physics ?
|
|
|
|
|
|
|
|
return;
|
|
}
|
|
#endregion
|
|
|
|
#region Request Avatars List Methods
|
|
//The idea is to have a group of method that return a list of avatars meeting some requirement
|
|
// ie it could be all Avatars within a certain range of the calling prim/avatar.
|
|
|
|
/// <summary>
|
|
/// Request a List of all Avatars in this World
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ScenePresence> RequestAvatarList()
|
|
{
|
|
List<ScenePresence> result = new List<ScenePresence>();
|
|
|
|
foreach (ScenePresence avatar in Avatars.Values)
|
|
{
|
|
result.Add(avatar);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Request a filtered list of Avatars in this World
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ScenePresence> RequestAvatarList(FilterAvatarList filter)
|
|
{
|
|
List<ScenePresence> result = new List<ScenePresence>();
|
|
|
|
foreach (ScenePresence avatar in Avatars.Values)
|
|
{
|
|
if (filter(avatar))
|
|
{
|
|
result.Add(avatar);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Request a Avatar by UUID
|
|
/// </summary>
|
|
/// <param name="avatarID"></param>
|
|
/// <returns></returns>
|
|
public ScenePresence RequestAvatar(LLUUID avatarID)
|
|
{
|
|
if (this.Avatars.ContainsKey(avatarID))
|
|
{
|
|
return Avatars[avatarID];
|
|
}
|
|
return null;
|
|
}
|
|
#endregion
|
|
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="entID"></param>
|
|
/// <returns></returns>
|
|
public bool DeleteEntity(LLUUID entID)
|
|
{
|
|
if (this.Entities.ContainsKey(entID))
|
|
{
|
|
this.Entities.Remove(entID);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void SendAllSceneObjectsToClient(IClientAPI client)
|
|
{
|
|
foreach (EntityBase ent in Entities.Values)
|
|
{
|
|
if (ent is SceneObject)
|
|
{
|
|
((SceneObject)ent).SendAllChildPrimsToClient(client);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region RegionCommsHost
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public void RegisterRegionWithComms()
|
|
{
|
|
|
|
this.regionCommsHost = this.commsManager.GridServer.RegisterRegion(this.m_regInfo);
|
|
if (this.regionCommsHost != null)
|
|
{
|
|
this.regionCommsHost.OnExpectUser += this.NewUserConnection;
|
|
this.regionCommsHost.OnAvatarCrossingIntoRegion += this.AgentCrossing;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="regionHandle"></param>
|
|
/// <param name="agent"></param>
|
|
public void NewUserConnection(ulong regionHandle, AgentCircuitData agent)
|
|
{
|
|
// Console.WriteLine("World.cs - add new user connection");
|
|
//should just check that its meant for this region
|
|
if (regionHandle == this.m_regInfo.RegionHandle)
|
|
{
|
|
if (agent.CapsPath != "")
|
|
{
|
|
//Console.WriteLine("new user, so creating caps handler for it");
|
|
Caps cap = new Caps(this.assetCache, httpListener, this.m_regInfo.ExternalHostName, this.m_regInfo.ExternalEndPoint.Port, agent.CapsPath, agent.AgentID);
|
|
cap.RegisterHandlers();
|
|
this.capsHandlers.Add(agent.AgentID, cap);
|
|
}
|
|
this.authenticateHandler.AddNewCircuit(agent.circuitcode, agent);
|
|
}
|
|
}
|
|
|
|
public void AgentCrossing(ulong regionHandle, LLUUID agentID, LLVector3 position)
|
|
{
|
|
if (regionHandle == this.m_regInfo.RegionHandle)
|
|
{
|
|
if (this.Avatars.ContainsKey(agentID))
|
|
{
|
|
this.Avatars[agentID].MakeAvatar(position);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public void InformClientOfNeighbours(IClientAPI remoteClient)
|
|
{
|
|
List<RegionInfo> neighbours = this.commsManager.GridServer.RequestNeighbours(this.m_regInfo);
|
|
|
|
if (neighbours != null)
|
|
{
|
|
for (int i = 0; i < neighbours.Count; i++)
|
|
{
|
|
AgentCircuitData agent = remoteClient.RequestClientInfo();
|
|
agent.BaseFolder = LLUUID.Zero;
|
|
agent.InventoryFolder = LLUUID.Zero;
|
|
agent.startpos = new LLVector3(128, 128, 70);
|
|
agent.child = true;
|
|
this.commsManager.InterRegion.InformRegionOfChildAgent(neighbours[i].RegionHandle, agent);
|
|
remoteClient.InformClientOfNeighbour(neighbours[i].RegionHandle, neighbours[i].ExternalEndPoint);
|
|
//this.capsHandlers[remoteClient.AgentId].CreateEstablishAgentComms("", System.Net.IPAddress.Parse(neighbours[i].CommsIPListenAddr) + ":" + neighbours[i].CommsIPListenPort);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="regionHandle"></param>
|
|
/// <returns></returns>
|
|
public RegionInfo RequestNeighbouringRegionInfo(ulong regionHandle)
|
|
{
|
|
return this.commsManager.GridServer.RequestNeighbourInfo(regionHandle);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="minX"></param>
|
|
/// <param name="minY"></param>
|
|
/// <param name="maxX"></param>
|
|
/// <param name="maxY"></param>
|
|
public void RequestMapBlocks(IClientAPI remoteClient, int minX, int minY, int maxX, int maxY)
|
|
{
|
|
List<MapBlockData> mapBlocks;
|
|
mapBlocks = this.commsManager.GridServer.RequestNeighbourMapBlocks(minX, minY, maxX, maxY);
|
|
remoteClient.SendMapBlock(mapBlocks);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="remoteClient"></param>
|
|
/// <param name="RegionHandle"></param>
|
|
/// <param name="position"></param>
|
|
/// <param name="lookAt"></param>
|
|
/// <param name="flags"></param>
|
|
public void RequestTeleportLocation(IClientAPI remoteClient, ulong regionHandle, LLVector3 position, LLVector3 lookAt, uint flags)
|
|
{
|
|
if (regionHandle == this.m_regionHandle)
|
|
{
|
|
if (this.Avatars.ContainsKey(remoteClient.AgentId))
|
|
{
|
|
remoteClient.SendTeleportLocationStart();
|
|
remoteClient.SendLocalTeleport(position, lookAt, flags);
|
|
this.Avatars[remoteClient.AgentId].Teleport(position);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RegionInfo reg = this.RequestNeighbouringRegionInfo(regionHandle);
|
|
if (reg != null)
|
|
{
|
|
remoteClient.SendTeleportLocationStart();
|
|
AgentCircuitData agent = remoteClient.RequestClientInfo();
|
|
agent.BaseFolder = LLUUID.Zero;
|
|
agent.InventoryFolder = LLUUID.Zero;
|
|
agent.startpos = new LLVector3(128, 128, 70);
|
|
agent.child = true;
|
|
this.commsManager.InterRegion.InformRegionOfChildAgent(regionHandle, agent);
|
|
this.commsManager.InterRegion.ExpectAvatarCrossing(regionHandle, remoteClient.AgentId, position);
|
|
|
|
remoteClient.SendRegionTeleport(regionHandle, 13, reg.ExternalEndPoint, 4, (1 << 4));
|
|
|
|
}
|
|
//remoteClient.SendTeleportCancel();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="regionhandle"></param>
|
|
/// <param name="agentID"></param>
|
|
/// <param name="position"></param>
|
|
public bool InformNeighbourOfCrossing(ulong regionhandle, LLUUID agentID, LLVector3 position)
|
|
{
|
|
return this.commsManager.InterRegion.ExpectAvatarCrossing(regionhandle, agentID, position);
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|