4373 lines
176 KiB
C#
4373 lines
176 KiB
C#
/*
|
|
* 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 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.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Threading;
|
|
using System.Timers;
|
|
using OpenMetaverse;
|
|
using OpenMetaverse.Imaging;
|
|
using OpenMetaverse.Packets;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Framework.Communications;
|
|
using OpenSim.Framework.Communications.Cache;
|
|
using OpenSim.Framework.Servers;
|
|
using OpenSim.Region.Environment.Interfaces;
|
|
using OpenSim.Region.Environment.Modules.World.Archiver;
|
|
using OpenSim.Region.Environment.Modules.World.Serialiser;
|
|
using OpenSim.Region.Environment.Modules.World.Terrain;
|
|
using OpenSim.Region.Environment.Scenes.Scripting;
|
|
using OpenSim.Region.Physics.Manager;
|
|
using Nini.Config;
|
|
using Caps = OpenSim.Framework.Communications.Capabilities.Caps;
|
|
using Image = System.Drawing.Image;
|
|
using TPFlags = OpenSim.Framework.Constants.TeleportFlags;
|
|
using Timer = System.Timers.Timer;
|
|
|
|
namespace OpenSim.Region.Environment.Scenes
|
|
{
|
|
public delegate bool FilterAvatarList(ScenePresence avatar);
|
|
|
|
public partial class Scene : SceneBase
|
|
{
|
|
public delegate void SynchronizeSceneHandler(Scene scene);
|
|
public SynchronizeSceneHandler SynchronizeScene = null;
|
|
public int splitID = 0;
|
|
|
|
#region Fields
|
|
|
|
protected Timer m_restartWaitTimer = new Timer();
|
|
|
|
protected SimStatsReporter m_statsReporter;
|
|
|
|
protected List<RegionInfo> m_regionRestartNotifyList = new List<RegionInfo>();
|
|
protected List<RegionInfo> m_neighbours = new List<RegionInfo>();
|
|
|
|
public InnerScene m_innerScene;
|
|
|
|
private int m_timePhase = 24;
|
|
|
|
/// <summary>
|
|
/// Are we applying physics to any of the prims in this scene?
|
|
/// </summary>
|
|
public bool m_physicalPrim;
|
|
public float m_maxNonphys = 65536;
|
|
public float m_maxPhys = 10;
|
|
|
|
public bool m_seeIntoRegionFromNeighbor;
|
|
public int MaxUndoCount = 5;
|
|
private int m_RestartTimerCounter;
|
|
private readonly Timer m_restartTimer = new Timer(15000); // Wait before firing
|
|
private int m_incrementsof15seconds = 0;
|
|
private volatile bool m_backingup = false;
|
|
|
|
private Dictionary<UUID, ReturnInfo> m_returns = new Dictionary<UUID, ReturnInfo>();
|
|
|
|
protected string m_simulatorVersion = "OpenSimulator Server";
|
|
|
|
protected ModuleLoader m_moduleLoader;
|
|
protected StorageManager m_storageManager;
|
|
protected AgentCircuitManager m_authenticateHandler;
|
|
public CommunicationsManager CommsManager;
|
|
|
|
protected SceneCommunicationService m_sceneGridService;
|
|
|
|
public SceneCommunicationService SceneGridService
|
|
{
|
|
get { return m_sceneGridService; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Each agent has its own capabilities handler.
|
|
/// </summary>
|
|
protected Dictionary<UUID, Caps> m_capsHandlers = new Dictionary<UUID, Caps>();
|
|
|
|
protected BaseHttpServer m_httpListener;
|
|
|
|
protected Dictionary<string, IRegionModule> m_modules = new Dictionary<string, IRegionModule>();
|
|
public Dictionary<string, IRegionModule> Modules
|
|
{
|
|
get { return m_modules; }
|
|
}
|
|
protected Dictionary<Type, List<object> > ModuleInterfaces = new Dictionary<Type, List<object> >();
|
|
protected Dictionary<string, object> ModuleAPIMethods = new Dictionary<string, object>();
|
|
protected Dictionary<string, ICommander> m_moduleCommanders = new Dictionary<string, ICommander>();
|
|
|
|
//API module interfaces
|
|
|
|
public IXfer XferManager;
|
|
|
|
protected IHttpRequests m_httpRequestModule;
|
|
protected IXMLRPC m_xmlrpcModule;
|
|
protected IWorldComm m_worldCommModule;
|
|
protected IAvatarFactory m_AvatarFactory;
|
|
protected IConfigSource m_config;
|
|
protected IRegionArchiver m_archiver;
|
|
protected IRegionSerialiser m_serialiser;
|
|
|
|
// Central Update Loop
|
|
|
|
protected int m_fps = 10;
|
|
protected int m_frame = 0;
|
|
protected float m_timespan = 0.089f;
|
|
protected DateTime m_lastupdate = DateTime.Now;
|
|
|
|
protected float m_timedilation = 1.0f;
|
|
|
|
private int m_update_physics = 1;
|
|
private int m_update_entitymovement = 1;
|
|
private int m_update_entities = 1; // Run through all objects checking for updates
|
|
private int m_update_entitiesquick = 200; // Run through objects that have scheduled updates checking for updates
|
|
private int m_update_presences = 1; // Update scene presence movements
|
|
private int m_update_events = 1;
|
|
private int m_update_backup = 200;
|
|
private int m_update_terrain = 50;
|
|
private int m_update_land = 1;
|
|
|
|
private int frameMS = 0;
|
|
private int physicsMS2 = 0;
|
|
private int physicsMS = 0;
|
|
private int otherMS = 0;
|
|
|
|
private bool m_physics_enabled = true;
|
|
private bool m_scripts_enabled = true;
|
|
private string m_defaultScriptEngine;
|
|
private int m_LastLogin = 0;
|
|
private Thread HeartbeatThread;
|
|
private volatile bool shuttingdown = false;
|
|
|
|
private object m_deleting_scene_object = new object();
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public AgentCircuitManager AuthenticateHandler
|
|
{
|
|
get { return m_authenticateHandler; }
|
|
}
|
|
|
|
// an instance to the physics plugin's Scene object.
|
|
public PhysicsScene PhysicsScene
|
|
{
|
|
set { m_innerScene.PhysicsScene = value; }
|
|
get { return (m_innerScene.PhysicsScene); }
|
|
}
|
|
|
|
// This gets locked so things stay thread safe.
|
|
public object SyncRoot
|
|
{
|
|
get { return m_innerScene.m_syncRoot; }
|
|
}
|
|
|
|
public float TimeDilation
|
|
{
|
|
get { return m_timedilation; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This is for llGetRegionFPS
|
|
/// </summary>
|
|
public float SimulatorFPS
|
|
{
|
|
get { return m_statsReporter.getLastReportedSimFPS(); }
|
|
}
|
|
|
|
public int TimePhase
|
|
{
|
|
get { return m_timePhase; }
|
|
}
|
|
|
|
public string DefaultScriptEngine
|
|
{
|
|
get { return m_defaultScriptEngine; }
|
|
}
|
|
|
|
// Local reference to the objects in the scene (which are held in innerScene)
|
|
// public Dictionary<UUID, SceneObjectGroup> Objects
|
|
// {
|
|
// get { return m_innerScene.SceneObjects; }
|
|
// }
|
|
|
|
// Reference to all of the agents in the scene (root and child)
|
|
protected Dictionary<UUID, ScenePresence> m_scenePresences
|
|
{
|
|
get { return m_innerScene.ScenePresences; }
|
|
set { m_innerScene.ScenePresences = value; }
|
|
}
|
|
|
|
// protected Dictionary<UUID, SceneObjectGroup> m_sceneObjects
|
|
// {
|
|
// get { return m_innerScene.SceneObjects; }
|
|
// set { m_innerScene.SceneObjects = value; }
|
|
// }
|
|
|
|
/// <summary>
|
|
/// The dictionary of all entities in this scene. The contents of this dictionary may be changed at any time.
|
|
/// If you wish to add or remove entities, please use the appropriate method for that entity rather than
|
|
/// editing this dictionary directly.
|
|
///
|
|
/// If you want a list of entities where the list itself is guaranteed not to change, please use
|
|
/// GetEntities()
|
|
/// </summary>
|
|
public Dictionary<UUID, EntityBase> Entities
|
|
{
|
|
get { return m_innerScene.Entities; }
|
|
set { m_innerScene.Entities = value; }
|
|
}
|
|
|
|
public Dictionary<UUID, ScenePresence> m_restorePresences
|
|
{
|
|
get { return m_innerScene.RestorePresences; }
|
|
set { m_innerScene.RestorePresences = value; }
|
|
}
|
|
|
|
public int objectCapacity = 45000;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
public Scene(RegionInfo regInfo, AgentCircuitManager authen,
|
|
CommunicationsManager commsMan, SceneCommunicationService sceneGridService,
|
|
AssetCache assetCach, StorageManager storeManager, BaseHttpServer httpServer,
|
|
ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim,
|
|
bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion)
|
|
{
|
|
m_config = config;
|
|
|
|
m_moduleLoader = moduleLoader;
|
|
m_authenticateHandler = authen;
|
|
CommsManager = commsMan;
|
|
m_sceneGridService = sceneGridService;
|
|
m_storageManager = storeManager;
|
|
AssetCache = assetCach;
|
|
m_regInfo = regInfo;
|
|
m_regionHandle = m_regInfo.RegionHandle;
|
|
m_regionName = m_regInfo.RegionName;
|
|
m_datastore = m_regInfo.DataStore;
|
|
|
|
m_physicalPrim = physicalPrim;
|
|
m_seeIntoRegionFromNeighbor = SeeIntoRegionFromNeighbor;
|
|
|
|
m_eventManager = new EventManager();
|
|
m_externalChecks = new SceneExternalChecks(this);
|
|
m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this);
|
|
|
|
// Load region settings
|
|
m_regInfo.RegionSettings = m_storageManager.DataStore.LoadRegionSettings(m_regInfo.RegionID);
|
|
if (m_storageManager.EstateDataStore != null)
|
|
m_regInfo.EstateSettings = m_storageManager.EstateDataStore.LoadEstateSettings(m_regInfo.RegionID);
|
|
|
|
//Bind Storage Manager functions to some land manager functions for this scene
|
|
EventManager.OnLandObjectAdded +=
|
|
new EventManager.LandObjectAdded(m_storageManager.DataStore.StoreLandObject);
|
|
EventManager.OnLandObjectRemoved +=
|
|
new EventManager.LandObjectRemoved(m_storageManager.DataStore.RemoveLandObject);
|
|
|
|
m_innerScene = new InnerScene(this, m_regInfo);
|
|
|
|
// If the Inner scene has an Unrecoverable error, restart this sim.
|
|
// Currently the only thing that causes it to happen is two kinds of specific
|
|
// Physics based crashes.
|
|
//
|
|
// Out of memory
|
|
// Operating system has killed the plugin
|
|
m_innerScene.UnRecoverableError += RestartNow;
|
|
|
|
RegisterDefaultSceneEvents();
|
|
|
|
m_httpListener = httpServer;
|
|
m_dumpAssetsToFile = dumpAssetsToFile;
|
|
|
|
m_scripts_enabled = !RegionInfo.RegionSettings.DisableScripts;
|
|
|
|
m_physics_enabled = !RegionInfo.RegionSettings.DisablePhysics;
|
|
|
|
m_statsReporter = new SimStatsReporter(this);
|
|
m_statsReporter.OnSendStatsResult += SendSimStatsPackets;
|
|
|
|
m_statsReporter.SetObjectCapacity(objectCapacity);
|
|
|
|
m_simulatorVersion = simulatorVersion
|
|
+ " ChilTasks:" + m_seeIntoRegionFromNeighbor.ToString()
|
|
+ " PhysPrim:" + m_physicalPrim.ToString();
|
|
|
|
try
|
|
{
|
|
IConfig startupConfig = m_config.Configs["Startup"];
|
|
m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", 65536.0f);
|
|
m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", 10.0f);
|
|
|
|
m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "DotNetEngine");
|
|
}
|
|
catch
|
|
{
|
|
m_log.Warn("[SCENE]: Failed to load StartupConfig");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Startup / Close Methods
|
|
|
|
protected virtual void RegisterDefaultSceneEvents()
|
|
{
|
|
m_eventManager.OnPermissionError += SendPermissionAlert;
|
|
}
|
|
|
|
public override string GetSimulatorVersion()
|
|
{
|
|
return m_simulatorVersion;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Another region is up. Gets called from Grid Comms:
|
|
/// (OGS1 -> LocalBackEnd -> RegionListened -> SceneCommunicationService)
|
|
/// We have to tell all our ScenePresences about it, and add it to the
|
|
/// neighbor list.
|
|
///
|
|
/// We only add it to the neighbor list if it's within 1 region from here.
|
|
/// Agents may have draw distance values that cross two regions though, so
|
|
/// we add it to the notify list regardless of distance. We'll check
|
|
/// the agent's draw distance before notifying them though.
|
|
/// </summary>
|
|
/// <param name="otherRegion">RegionInfo handle for the new region.</param>
|
|
/// <returns>True after all operations complete, throws exceptions otherwise.</returns>
|
|
public override bool OtherRegionUp(RegionInfo otherRegion)
|
|
{
|
|
if (RegionInfo.RegionHandle != otherRegion.RegionHandle)
|
|
{
|
|
for (int i = 0; i < m_neighbours.Count; i++)
|
|
{
|
|
// The purpose of this loop is to re-update the known neighbors
|
|
// when another region comes up on top of another one.
|
|
// The latest region in that location ends up in the
|
|
// 'known neighbors list'
|
|
// Additionally, the commFailTF property gets reset to false.
|
|
if (m_neighbours[i].RegionHandle == otherRegion.RegionHandle)
|
|
{
|
|
lock (m_neighbours)
|
|
{
|
|
m_neighbours[i] = otherRegion;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the value isn't in the neighbours, add it.
|
|
// If the RegionInfo isn't exact but is for the same XY World location,
|
|
// then the above loop will fix that.
|
|
|
|
if (!(CheckNeighborRegion(otherRegion)))
|
|
{
|
|
lock (m_neighbours)
|
|
{
|
|
m_neighbours.Add(otherRegion);
|
|
//m_log.Info("[UP]: " + otherRegion.RegionHandle.ToString());
|
|
}
|
|
}
|
|
|
|
// If these are cast to INT because long + negative values + abs returns invalid data
|
|
int resultX = Math.Abs((int)otherRegion.RegionLocX - (int)RegionInfo.RegionLocX);
|
|
int resultY = Math.Abs((int)otherRegion.RegionLocY - (int)RegionInfo.RegionLocY);
|
|
if (resultX <= 1 && resultY <= 1)
|
|
{
|
|
try
|
|
{
|
|
ForEachScenePresence(delegate(ScenePresence agent)
|
|
{
|
|
// If agent is a root agent.
|
|
if (!agent.IsChildAgent)
|
|
{
|
|
//agent.ControllingClient.new
|
|
//this.CommsManager.InterRegion.InformRegionOfChildAgent(otherRegion.RegionHandle, agent.ControllingClient.RequestClientInfo());
|
|
InformClientOfNeighbor(agent, otherRegion);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
catch (NullReferenceException)
|
|
{
|
|
// This means that we're not booted up completely yet.
|
|
// This shouldn't happen too often anymore.
|
|
m_log.Error("[SCENE]: Couldn't inform client of regionup because we got a null reference exception");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.Info("[INTERGRID]: Got notice about far away Region: " + otherRegion.RegionName.ToString() +
|
|
" at (" + otherRegion.RegionLocX.ToString() + ", " +
|
|
otherRegion.RegionLocY.ToString() + ")");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void AddNeighborRegion(RegionInfo region)
|
|
{
|
|
lock (m_neighbours)
|
|
{
|
|
if (!CheckNeighborRegion(region))
|
|
{
|
|
m_neighbours.Add(region);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool CheckNeighborRegion(RegionInfo region)
|
|
{
|
|
bool found = false;
|
|
lock (m_neighbours)
|
|
{
|
|
foreach (RegionInfo reg in m_neighbours)
|
|
{
|
|
if (reg.RegionHandle == region.RegionHandle)
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Given float seconds, this will restart the region.
|
|
/// </summary>
|
|
/// <param name="seconds">float indicating duration before restart.</param>
|
|
public virtual void Restart(float seconds)
|
|
{
|
|
// notifications are done in 15 second increments
|
|
// so .. if the number of seconds is less then 15 seconds, it's not really a restart request
|
|
// It's a 'Cancel restart' request.
|
|
|
|
// RestartNow() does immediate restarting.
|
|
if (seconds < 15)
|
|
{
|
|
m_restartTimer.Stop();
|
|
SendGeneralAlert("Restart Aborted");
|
|
}
|
|
else
|
|
{
|
|
// Now we figure out what to set the timer to that does the notifications and calls, RestartNow()
|
|
m_restartTimer.Interval = 15000;
|
|
m_incrementsof15seconds = (int)seconds / 15;
|
|
m_RestartTimerCounter = 0;
|
|
m_restartTimer.AutoReset = true;
|
|
m_restartTimer.Elapsed += new ElapsedEventHandler(RestartTimer_Elapsed);
|
|
m_log.Error("[REGION]: Restarting Region in " + (seconds / 60) + " minutes");
|
|
m_restartTimer.Start();
|
|
SendRegionMessageFromEstateTools(UUID.Random(), UUID.Random(), String.Empty, RegionInfo.RegionName + ": Restarting in 2 Minutes");
|
|
//SendGeneralAlert(RegionInfo.RegionName + ": Restarting in 2 Minutes");
|
|
}
|
|
}
|
|
|
|
// The Restart timer has occured.
|
|
// We have to figure out if this is a notification or if the number of seconds specified in Restart
|
|
// have elapsed.
|
|
// If they have elapsed, call RestartNow()
|
|
public void RestartTimer_Elapsed(object sender, ElapsedEventArgs e)
|
|
{
|
|
m_RestartTimerCounter++;
|
|
if (m_RestartTimerCounter <= m_incrementsof15seconds)
|
|
{
|
|
if (m_RestartTimerCounter == 4 || m_RestartTimerCounter == 6 || m_RestartTimerCounter == 7)
|
|
SendRegionMessageFromEstateTools(UUID.Random(), UUID.Random(), String.Empty, RegionInfo.RegionName + ": Restarting in " +
|
|
((8 - m_RestartTimerCounter) * 15) + " seconds");
|
|
|
|
// SendGeneralAlert(RegionInfo.RegionName + ": Restarting in " + ((8 - m_RestartTimerCounter)*15) +
|
|
//" seconds");
|
|
}
|
|
else
|
|
{
|
|
m_restartTimer.Stop();
|
|
m_restartTimer.AutoReset = false;
|
|
RestartNow();
|
|
}
|
|
}
|
|
|
|
// This causes the region to restart immediatley.
|
|
public void RestartNow()
|
|
{
|
|
if (PhysicsScene != null)
|
|
{
|
|
PhysicsScene.Dispose();
|
|
}
|
|
|
|
m_log.Error("[REGION]: Closing");
|
|
Close();
|
|
m_log.Error("[REGION]: Firing Region Restart Message");
|
|
base.Restart(0);
|
|
}
|
|
|
|
// This is a helper function that notifies root agents in this region that a new sim near them has come up
|
|
// This is in the form of a timer because when an instance of OpenSim.exe is started,
|
|
// Even though the sims initialize, they don't listen until 'all of the sims are initialized'
|
|
// If we tell an agent about a sim that's not listening yet, the agent will not be able to connect to it.
|
|
// subsequently the agent will never see the region come back online.
|
|
public void RestartNotifyWaitElapsed(object sender, ElapsedEventArgs e)
|
|
{
|
|
m_restartWaitTimer.Stop();
|
|
lock (m_regionRestartNotifyList)
|
|
{
|
|
foreach (RegionInfo region in m_regionRestartNotifyList)
|
|
{
|
|
try
|
|
{
|
|
ForEachScenePresence(delegate(ScenePresence agent)
|
|
{
|
|
// If agent is a root agent.
|
|
if (!agent.IsChildAgent)
|
|
{
|
|
//agent.ControllingClient.new
|
|
//this.CommsManager.InterRegion.InformRegionOfChildAgent(otherRegion.RegionHandle, agent.ControllingClient.RequestClientInfo());
|
|
InformClientOfNeighbor(agent, region);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
catch (NullReferenceException)
|
|
{
|
|
// This means that we're not booted up completely yet.
|
|
// This shouldn't happen too often anymore.
|
|
}
|
|
}
|
|
|
|
// Reset list to nothing.
|
|
m_regionRestartNotifyList.Clear();
|
|
}
|
|
}
|
|
|
|
public void SetSceneCoreDebug(bool ScriptEngine, bool CollisionEvents, bool PhysicsEngine)
|
|
{
|
|
if (m_scripts_enabled != !ScriptEngine)
|
|
{
|
|
// Tedd! Here's the method to disable the scripting engine!
|
|
if (ScriptEngine)
|
|
{
|
|
m_log.Info("Stopping all Scripts in Scene");
|
|
lock (Entities)
|
|
{
|
|
foreach (EntityBase ent in Entities.Values)
|
|
{
|
|
if (ent is SceneObjectGroup)
|
|
{
|
|
((SceneObjectGroup)ent).RemoveScriptInstances();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.Info("Starting all Scripts in Scene");
|
|
lock (Entities)
|
|
{
|
|
foreach (EntityBase ent in Entities.Values)
|
|
{
|
|
if (ent is SceneObjectGroup)
|
|
{
|
|
((SceneObjectGroup)ent).CreateScriptInstances(0, false, DefaultScriptEngine, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
m_scripts_enabled = !ScriptEngine;
|
|
m_log.Info("[TOTEDD]: Here is the method to trigger disabling of the scripting engine");
|
|
}
|
|
|
|
if (m_physics_enabled != !PhysicsEngine)
|
|
{
|
|
m_physics_enabled = !PhysicsEngine;
|
|
}
|
|
}
|
|
|
|
public int GetInaccurateNeighborCount()
|
|
{
|
|
lock (m_neighbours)
|
|
{
|
|
return m_neighbours.Count;
|
|
}
|
|
}
|
|
|
|
// This is the method that shuts down the scene.
|
|
public override void Close()
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Closing down the single simulator: {0}", RegionInfo.RegionName);
|
|
|
|
// Kick all ROOT agents with the message, 'The simulator is going down'
|
|
ForEachScenePresence(delegate(ScenePresence avatar)
|
|
{
|
|
if (avatar.KnownChildRegions.Contains(RegionInfo.RegionHandle))
|
|
avatar.KnownChildRegions.Remove(RegionInfo.RegionHandle);
|
|
|
|
if (!avatar.IsChildAgent)
|
|
avatar.ControllingClient.Kick("The simulator is going down.");
|
|
|
|
avatar.ControllingClient.SendShutdownConnectionNotice();
|
|
});
|
|
|
|
// Wait here, or the kick messages won't actually get to the agents before the scene terminates.
|
|
Thread.Sleep(500);
|
|
|
|
// Stop all client threads.
|
|
ForEachScenePresence(delegate(ScenePresence avatar) { avatar.ControllingClient.Close(true); });
|
|
// Stop updating the scene objects and agents.
|
|
//m_heartbeatTimer.Close();
|
|
shuttingdown = true;
|
|
// close the inner scene
|
|
m_innerScene.Close();
|
|
// De-register with region communications (events cleanup)
|
|
UnRegisterRegionWithComms();
|
|
|
|
// Shut down all non shared modules.
|
|
foreach (IRegionModule module in Modules.Values)
|
|
{
|
|
if (!module.IsSharedModule)
|
|
{
|
|
module.Close();
|
|
}
|
|
}
|
|
Modules.Clear();
|
|
|
|
// call the base class Close method.
|
|
base.Close();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start the timer which triggers regular scene updates
|
|
/// </summary>
|
|
public void StartTimer()
|
|
{
|
|
//m_log.Debug("[SCENE]: Starting timer");
|
|
//m_heartbeatTimer.Enabled = true;
|
|
//m_heartbeatTimer.Interval = (int)(m_timespan * 1000);
|
|
//m_heartbeatTimer.Elapsed += new ElapsedEventHandler(Heartbeat);
|
|
HeartbeatThread = new Thread(new ParameterizedThreadStart(Heartbeat));
|
|
HeartbeatThread.SetApartmentState(ApartmentState.MTA);
|
|
HeartbeatThread.Name = "Heartbeat";
|
|
HeartbeatThread.Priority = ThreadPriority.AboveNormal;
|
|
ThreadTracker.Add(HeartbeatThread);
|
|
HeartbeatThread.Start();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets up references to modules required by the scene
|
|
/// </summary>
|
|
public void SetModuleInterfaces()
|
|
{
|
|
m_httpRequestModule = RequestModuleInterface<IHttpRequests>();
|
|
m_xmlrpcModule = RequestModuleInterface<IXMLRPC>();
|
|
m_worldCommModule = RequestModuleInterface<IWorldComm>();
|
|
XferManager = RequestModuleInterface<IXfer>();
|
|
m_AvatarFactory = RequestModuleInterface<IAvatarFactory>();
|
|
m_archiver = RequestModuleInterface<IRegionArchiver>();
|
|
m_serialiser = RequestModuleInterface<IRegionSerialiser>();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Update Methods
|
|
|
|
/// <summary>
|
|
/// Performs per-frame updates regularly
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void Heartbeat(object sender)
|
|
{
|
|
Update();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs per-frame updates on the scene, this should be the central scene loop
|
|
/// </summary>
|
|
public override void Update()
|
|
{
|
|
int maintc = 0;
|
|
while (!shuttingdown)
|
|
{
|
|
maintc = System.Environment.TickCount;
|
|
|
|
TimeSpan SinceLastFrame = DateTime.Now - m_lastupdate;
|
|
// Aquire a lock so only one update call happens at once
|
|
//updateLock.WaitOne();
|
|
float physicsFPS = 0;
|
|
//m_log.Info("sadfadf" + m_neighbours.Count.ToString());
|
|
int agentsInScene = m_innerScene.GetRootAgentCount() + m_innerScene.GetChildAgentCount();
|
|
|
|
if (agentsInScene > 21)
|
|
{
|
|
if (m_update_entities == 1)
|
|
{
|
|
m_update_entities = 5;
|
|
m_statsReporter.SetUpdateMS(6000);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_update_entities == 5)
|
|
{
|
|
m_update_entities = 1;
|
|
m_statsReporter.SetUpdateMS(3000);
|
|
}
|
|
}
|
|
|
|
frameMS = System.Environment.TickCount;
|
|
try
|
|
{
|
|
// Increment the frame counter
|
|
m_frame++;
|
|
|
|
// Loop it
|
|
if (m_frame == Int32.MaxValue)
|
|
m_frame = 0;
|
|
|
|
physicsMS2 = System.Environment.TickCount;
|
|
if ((m_frame % m_update_physics == 0) && m_physics_enabled)
|
|
m_innerScene.UpdatePreparePhysics();
|
|
physicsMS2 = System.Environment.TickCount - physicsMS2;
|
|
|
|
if (m_frame % m_update_entitymovement == 0)
|
|
m_innerScene.UpdateEntityMovement();
|
|
|
|
physicsMS = System.Environment.TickCount;
|
|
if ((m_frame % m_update_physics == 0) && m_physics_enabled)
|
|
physicsFPS = m_innerScene.UpdatePhysics(
|
|
Math.Max(SinceLastFrame.TotalSeconds, m_timespan)
|
|
);
|
|
if (m_frame % m_update_physics == 0 && SynchronizeScene != null)
|
|
SynchronizeScene(this);
|
|
|
|
physicsMS = System.Environment.TickCount - physicsMS;
|
|
physicsMS += physicsMS2;
|
|
|
|
otherMS = System.Environment.TickCount;
|
|
// run through all entities looking for updates (slow)
|
|
if (m_frame % m_update_entities == 0)
|
|
m_innerScene.UpdateEntities();
|
|
|
|
// run through entities that have scheduled themselves for
|
|
// updates looking for updates(faster)
|
|
if (m_frame % m_update_entitiesquick == 0)
|
|
m_innerScene.ProcessUpdates();
|
|
|
|
// Run through scenepresences looking for updates
|
|
if (m_frame % m_update_presences == 0)
|
|
m_innerScene.UpdatePresences();
|
|
|
|
// Delete temp-on-rez stuff
|
|
if (m_frame % m_update_backup == 0)
|
|
CleanTempObjects();
|
|
|
|
if (Region_Status != RegionStatus.SlaveScene)
|
|
{
|
|
if (m_frame % m_update_events == 0)
|
|
UpdateEvents();
|
|
|
|
if (m_frame % m_update_backup == 0)
|
|
{
|
|
UpdateStorageBackup();
|
|
}
|
|
|
|
if (m_frame % m_update_terrain == 0)
|
|
UpdateTerrain();
|
|
|
|
if (m_frame % m_update_land == 0)
|
|
UpdateLand();
|
|
otherMS = System.Environment.TickCount - otherMS;
|
|
// if (m_frame%m_update_avatars == 0)
|
|
// UpdateInWorldTime();
|
|
m_statsReporter.AddPhysicsFPS(physicsFPS);
|
|
m_statsReporter.AddTimeDilation(m_timedilation);
|
|
m_statsReporter.AddFPS(1);
|
|
m_statsReporter.AddInPackets(0);
|
|
m_statsReporter.SetRootAgents(m_innerScene.GetRootAgentCount());
|
|
m_statsReporter.SetChildAgents(m_innerScene.GetChildAgentCount());
|
|
m_statsReporter.SetObjects(m_innerScene.GetTotalObjectsCount());
|
|
m_statsReporter.SetActiveObjects(m_innerScene.GetActiveObjectsCount());
|
|
frameMS = System.Environment.TickCount - frameMS;
|
|
m_statsReporter.addFrameMS(frameMS);
|
|
m_statsReporter.addPhysicsMS(physicsMS);
|
|
m_statsReporter.addOtherMS(otherMS);
|
|
m_statsReporter.SetActiveScripts(m_innerScene.GetActiveScriptsCount());
|
|
m_statsReporter.addScriptLines(m_innerScene.GetScriptLPS());
|
|
}
|
|
}
|
|
catch (NotImplementedException)
|
|
{
|
|
throw;
|
|
}
|
|
catch (AccessViolationException e)
|
|
{
|
|
m_log.Error("[Scene]: Failed with exception " + e.ToString() + " On Region: " + RegionInfo.RegionName);
|
|
}
|
|
catch (NullReferenceException e)
|
|
{
|
|
m_log.Error("[Scene]: Failed with exception " + e.ToString() + " On Region: " + RegionInfo.RegionName);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
m_log.Error("[Scene]: Failed with exception " + e.ToString() + " On Region: " + RegionInfo.RegionName);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Error("[Scene]: Failed with exception " + e.ToString() + " On Region: " + RegionInfo.RegionName);
|
|
}
|
|
finally
|
|
{
|
|
//updateLock.ReleaseMutex();
|
|
// Get actual time dilation
|
|
float tmpval = (m_timespan / (float)SinceLastFrame.TotalSeconds);
|
|
|
|
// If actual time dilation is greater then one, we're catching up, so subtract
|
|
// the amount that's greater then 1 from the time dilation
|
|
if (tmpval > 1.0)
|
|
{
|
|
tmpval = tmpval - (tmpval - 1.0f);
|
|
}
|
|
m_timedilation = tmpval;
|
|
|
|
m_lastupdate = DateTime.Now;
|
|
}
|
|
maintc = System.Environment.TickCount - maintc;
|
|
maintc = (int)(m_timespan * 1000) - maintc;
|
|
|
|
if ((maintc < (m_timespan * 1000)) && maintc > 0)
|
|
Thread.Sleep(maintc);
|
|
}
|
|
}
|
|
|
|
private void SendSimStatsPackets(SimStats stats)
|
|
{
|
|
List<ScenePresence> StatSendAgents = GetScenePresences();
|
|
foreach (ScenePresence agent in StatSendAgents)
|
|
{
|
|
if (!agent.IsChildAgent)
|
|
{
|
|
agent.ControllingClient.SendSimStats(stats);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateLand()
|
|
{
|
|
if (LandChannel != null)
|
|
{
|
|
if (LandChannel.IsLandPrimCountTainted())
|
|
{
|
|
EventManager.TriggerParcelPrimCountUpdate();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateTerrain()
|
|
{
|
|
EventManager.TriggerTerrainTick();
|
|
}
|
|
|
|
private void UpdateStorageBackup()
|
|
{
|
|
if (!m_backingup)
|
|
{
|
|
m_backingup = true;
|
|
Thread backupthread = new Thread(Backup);
|
|
backupthread.Name = "BackupWriter";
|
|
backupthread.IsBackground = true;
|
|
backupthread.Start();
|
|
}
|
|
}
|
|
|
|
private void UpdateEvents()
|
|
{
|
|
m_eventManager.TriggerOnFrame();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Perform delegate action on all clients subscribing to updates from this region.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
internal void Broadcast(Action<IClientAPI> whatToDo)
|
|
{
|
|
ForEachScenePresence(delegate(ScenePresence presence) { whatToDo(presence.ControllingClient); });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Backup the scene. This acts as the main method of the backup thread.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public void Backup()
|
|
{
|
|
m_returns.Clear();
|
|
|
|
EventManager.TriggerOnBackup(m_storageManager.DataStore);
|
|
m_backingup = false;
|
|
|
|
foreach (KeyValuePair<UUID, ReturnInfo> ret in m_returns)
|
|
{
|
|
UUID transaction = UUID.Random();
|
|
|
|
GridInstantMessage msg = new GridInstantMessage();
|
|
msg.fromAgentID = new Guid(UUID.Zero.ToString()); // From server
|
|
msg.fromAgentSession = new Guid(transaction.ToString());
|
|
msg.toAgentID = new Guid(ret.Key.ToString());
|
|
msg.imSessionID = new Guid(transaction.ToString());
|
|
msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
|
|
msg.fromAgentName = "Server";
|
|
msg.dialog = (byte)19; // Object msg
|
|
msg.fromGroup = false;
|
|
msg.offline = (byte)1;
|
|
msg.ParentEstateID = RegionInfo.EstateSettings.ParentEstateID;
|
|
msg.Position = Vector3.Zero;
|
|
msg.RegionID = RegionInfo.RegionID.Guid;
|
|
msg.binaryBucket = new byte[0];
|
|
if (ret.Value.count > 1)
|
|
msg.message = string.Format("Your {0} objects were returned from {1} in region {2} due to parcel auto return", ret.Value.count, ret.Value.location.ToString(), RegionInfo.RegionName);
|
|
else
|
|
msg.message = string.Format("Your object {0} was returned from {1} in region {2} due to parcel auto return", ret.Value.objectName, ret.Value.location.ToString(), RegionInfo.RegionName);
|
|
|
|
TriggerGridInstantMessage(msg, InstantMessageReceiver.IMModule);
|
|
}
|
|
}
|
|
|
|
public void AddReturn(UUID agentID, string objectName, Vector3 location)
|
|
{
|
|
if (m_returns.ContainsKey(agentID))
|
|
{
|
|
ReturnInfo info = m_returns[agentID];
|
|
info.count++;
|
|
m_returns[agentID] = info;
|
|
}
|
|
else
|
|
{
|
|
ReturnInfo info = new ReturnInfo();
|
|
info.count = 1;
|
|
info.objectName = objectName;
|
|
info.location = location;
|
|
m_returns[agentID] = info;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Load Terrain
|
|
|
|
public void ExportWorldMap(string fileName)
|
|
{
|
|
List<MapBlockData> mapBlocks =
|
|
m_sceneGridService.RequestNeighbourMapBlocks((int)(RegionInfo.RegionLocX - 9),
|
|
(int)(RegionInfo.RegionLocY - 9),
|
|
(int)(RegionInfo.RegionLocX + 9),
|
|
(int)(RegionInfo.RegionLocY + 9));
|
|
List<AssetBase> textures = new List<AssetBase>();
|
|
List<Image> bitImages = new List<Image>();
|
|
|
|
foreach (MapBlockData mapBlock in mapBlocks)
|
|
{
|
|
AssetBase texAsset = AssetCache.GetAsset(mapBlock.MapImageId, true);
|
|
|
|
if (texAsset != null)
|
|
{
|
|
textures.Add(texAsset);
|
|
}
|
|
else
|
|
{
|
|
texAsset = AssetCache.GetAsset(mapBlock.MapImageId, true);
|
|
if (texAsset != null)
|
|
{
|
|
textures.Add(texAsset);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (AssetBase asset in textures)
|
|
{
|
|
ManagedImage managedImage;
|
|
Image image;
|
|
|
|
if (OpenJPEG.DecodeToImage(asset.Data, out managedImage, out image))
|
|
bitImages.Add(image);
|
|
}
|
|
|
|
Bitmap mapTexture = new Bitmap(2560, 2560);
|
|
Graphics g = Graphics.FromImage(mapTexture);
|
|
SolidBrush sea = new SolidBrush(Color.DarkBlue);
|
|
g.FillRectangle(sea, 0, 0, 2560, 2560);
|
|
|
|
for (int i = 0; i < mapBlocks.Count; i++)
|
|
{
|
|
ushort x = (ushort)((mapBlocks[i].X - RegionInfo.RegionLocX) + 10);
|
|
ushort y = (ushort)((mapBlocks[i].Y - RegionInfo.RegionLocY) + 10);
|
|
g.DrawImage(bitImages[i], (x * 128), (y * 128), 128, 128);
|
|
}
|
|
mapTexture.Save(fileName, ImageFormat.Jpeg);
|
|
}
|
|
|
|
public void SaveTerrain()
|
|
{
|
|
m_storageManager.DataStore.StoreTerrain(Heightmap.GetDoubles(), RegionInfo.RegionID);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads the World heightmap
|
|
/// </summary>
|
|
///
|
|
public override void LoadWorldMap()
|
|
{
|
|
try
|
|
{
|
|
double[,] map = m_storageManager.DataStore.LoadTerrain(RegionInfo.RegionID);
|
|
if (map == null)
|
|
{
|
|
m_log.Info("[TERRAIN]: No default terrain. Generating a new terrain.");
|
|
Heightmap = new TerrainChannel();
|
|
|
|
m_storageManager.DataStore.StoreTerrain(Heightmap.GetDoubles(), RegionInfo.RegionID);
|
|
}
|
|
else
|
|
{
|
|
Heightmap = new TerrainChannel(map);
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Warn("[terrain]: Scene.cs: LoadWorldMap() - Failed with exception " + e.ToString());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register this region with a grid service
|
|
/// </summary>
|
|
/// <exception cref="System.Exception">Thrown if registration of the region itself fails.</exception>
|
|
public void RegisterRegionWithGrid()
|
|
{
|
|
RegisterCommsEvents();
|
|
|
|
// These two 'commands' *must be* next to each other or sim rebooting fails.
|
|
m_sceneGridService.RegisterRegion(RegionInfo);
|
|
m_sceneGridService.InformNeighborsThatRegionisUp(RegionInfo);
|
|
|
|
Dictionary<string, string> dGridSettings = m_sceneGridService.GetGridSettings();
|
|
|
|
if (dGridSettings.ContainsKey("allow_forceful_banlines"))
|
|
{
|
|
if (dGridSettings["allow_forceful_banlines"] != "TRUE")
|
|
{
|
|
m_log.Info("[GRID]: Grid is disabling forceful parcel banlists");
|
|
EventManager.TriggerSetAllowForcefulBan(false);
|
|
}
|
|
else
|
|
{
|
|
m_log.Info("[GRID]: Grid is allowing forceful parcel banlists");
|
|
EventManager.TriggerSetAllowForcefulBan(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public void CreateTerrainTexture(bool temporary)
|
|
{
|
|
//create a texture asset of the terrain
|
|
IMapImageGenerator terrain = RequestModuleInterface<IMapImageGenerator>();
|
|
|
|
// Cannot create a map for a nonexistant heightmap yet.
|
|
if (Heightmap == null)
|
|
return;
|
|
|
|
if (terrain == null)
|
|
{
|
|
#region Fallback default maptile generation
|
|
|
|
int tc = System.Environment.TickCount;
|
|
m_log.Info("[MAPTILE]: Generating Maptile Step 1: Terrain");
|
|
Bitmap mapbmp = new Bitmap(256, 256);
|
|
double[,] hm = Heightmap.GetDoubles();
|
|
bool ShadowDebugContinue = true;
|
|
//Color prim = Color.FromArgb(120, 120, 120);
|
|
//Vector3 RayEnd = new Vector3(0, 0, 0);
|
|
//Vector3 RayStart = new Vector3(0, 0, 0);
|
|
//Vector3 direction = new Vector3(0, 0, -1);
|
|
//Vector3 AXOrigin = new Vector3();
|
|
//Vector3 AXdirection = new Vector3();
|
|
//Ray testRay = new Ray();
|
|
//EntityIntersection rt = new EntityIntersection();
|
|
bool terraincorruptedwarningsaid = false;
|
|
|
|
float low = 255;
|
|
float high = 0;
|
|
for (int x = 0; x < 256; x++)
|
|
{
|
|
for (int y = 0; y < 256; y++)
|
|
{
|
|
float hmval = (float)hm[x, y];
|
|
if (hmval < low)
|
|
low = hmval;
|
|
if (hmval > high)
|
|
high = hmval;
|
|
}
|
|
}
|
|
|
|
float mid = (high + low) * 0.5f;
|
|
|
|
// temporary initializer
|
|
float hfvalue = (float)m_regInfo.RegionSettings.WaterHeight;
|
|
float hfvaluecompare = hfvalue;
|
|
float hfdiff = hfvalue;
|
|
int hfdiffi = 0;
|
|
|
|
for (int x = 0; x < 256; x++)
|
|
{
|
|
//int tc = System.Environment.TickCount;
|
|
for (int y = 0; y < 256; y++)
|
|
{
|
|
//RayEnd = new Vector3(x, y, 0);
|
|
//RayStart = new Vector3(x, y, 255);
|
|
|
|
//direction = Vector3.Norm(RayEnd - RayStart);
|
|
//AXOrigin = new Vector3(RayStart.X, RayStart.Y, RayStart.Z);
|
|
//AXdirection = new Vector3(direction.X, direction.Y, direction.Z);
|
|
|
|
//testRay = new Ray(AXOrigin, AXdirection);
|
|
//rt = m_innerScene.GetClosestIntersectingPrim(testRay);
|
|
|
|
//if (rt.HitTF)
|
|
//{
|
|
//mapbmp.SetPixel(x, y, prim);
|
|
//}
|
|
//else
|
|
//{
|
|
//float tmpval = (float)hm[x, y];
|
|
float heightvalue = (float)hm[x, y];
|
|
|
|
if (heightvalue > (float)m_regInfo.RegionSettings.WaterHeight)
|
|
{
|
|
// scale height value
|
|
heightvalue = low + mid * (heightvalue - low) / mid;
|
|
|
|
if (heightvalue > 255)
|
|
heightvalue = 255;
|
|
|
|
if (heightvalue < 0)
|
|
heightvalue = 0;
|
|
|
|
if (Single.IsInfinity(heightvalue) || Single.IsNaN(heightvalue))
|
|
heightvalue = 0;
|
|
|
|
try
|
|
{
|
|
Color green = Color.FromArgb((int)heightvalue, 100, (int)heightvalue);
|
|
|
|
// Y flip the cordinates
|
|
mapbmp.SetPixel(x, (256 - y) - 1, green);
|
|
|
|
//X
|
|
// .
|
|
//
|
|
// Shade the terrain for shadows
|
|
if ((x - 1 > 0) && (y - 1 > 0))
|
|
{
|
|
hfvalue = (float)hm[x, y];
|
|
hfvaluecompare = (float)hm[x - 1, y - 1];
|
|
|
|
if (Single.IsInfinity(hfvalue) || Single.IsNaN(hfvalue))
|
|
hfvalue = 0;
|
|
|
|
if (Single.IsInfinity(hfvaluecompare) || Single.IsNaN(hfvaluecompare))
|
|
hfvaluecompare = 0;
|
|
|
|
hfdiff = hfvaluecompare - hfvalue;
|
|
|
|
if (hfdiff > 0.3f)
|
|
{
|
|
|
|
}
|
|
else if (hfdiff < -0.3f)
|
|
{
|
|
// We have to desaturate and blacken the land at the same time
|
|
// we use floats, colors use bytes, so shrink are space down to
|
|
// 0-255
|
|
|
|
try
|
|
{
|
|
hfdiffi = Math.Abs((int)((hfdiff * 4) + (hfdiff * 0.5))) + 1;
|
|
if (hfdiff % 1 != 0)
|
|
{
|
|
hfdiffi = hfdiffi + Math.Abs((int)(((hfdiff % 1) * 0.5f) * 10f) - 1);
|
|
}
|
|
}
|
|
catch (System.OverflowException)
|
|
{
|
|
m_log.Debug("[MAPTILE]: Shadow failed at value: " + hfdiff.ToString());
|
|
ShadowDebugContinue = false;
|
|
}
|
|
|
|
if (ShadowDebugContinue)
|
|
{
|
|
if ((256 - y) - 1 > 0)
|
|
{
|
|
Color Shade = mapbmp.GetPixel(x - 1, (256 - y) - 1);
|
|
|
|
int r = Shade.R;
|
|
|
|
int g = Shade.G;
|
|
int b = Shade.B;
|
|
Shade = Color.FromArgb((r - hfdiffi > 0) ? r - hfdiffi : 0, (g - hfdiffi > 0) ? g - hfdiffi : 0, (b - hfdiffi > 0) ? b - hfdiffi : 0);
|
|
//Console.WriteLine("d:" + hfdiff.ToString() + ", i:" + hfdiffi + ", pos: " + x + "," + y + " - R:" + Shade.R.ToString() + ", G:" + Shade.G.ToString() + ", B:" + Shade.G.ToString());
|
|
mapbmp.SetPixel(x - 1, (256 - y) - 1, Shade);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (System.ArgumentException)
|
|
{
|
|
if (!terraincorruptedwarningsaid)
|
|
{
|
|
m_log.WarnFormat("[MAPIMAGE]: Your terrain is corrupted in region {0}, it might take a few minutes to generate the map image depending on the corruption level", RegionInfo.RegionName);
|
|
terraincorruptedwarningsaid = true;
|
|
}
|
|
Color black = Color.Black;
|
|
mapbmp.SetPixel(x, (256 - y) - 1, black);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Y flip the cordinates
|
|
heightvalue = (float)m_regInfo.RegionSettings.WaterHeight - heightvalue;
|
|
if (heightvalue > 19)
|
|
heightvalue = 19;
|
|
if (heightvalue < 0)
|
|
heightvalue = 0;
|
|
|
|
heightvalue = 100 - (heightvalue * 100) / 19;
|
|
|
|
if (heightvalue > 255)
|
|
heightvalue = 255;
|
|
|
|
if (heightvalue < 0)
|
|
heightvalue = 0;
|
|
|
|
if (Single.IsInfinity(heightvalue) || Single.IsNaN(heightvalue))
|
|
heightvalue = 0;
|
|
|
|
try
|
|
{
|
|
Color water = Color.FromArgb((int)heightvalue, (int)heightvalue, 255);
|
|
mapbmp.SetPixel(x, (256 - y) - 1, water);
|
|
}
|
|
catch (System.ArgumentException)
|
|
{
|
|
if (!terraincorruptedwarningsaid)
|
|
{
|
|
m_log.WarnFormat("[MAPIMAGE]: Your terrain is corrupted in region {0}, it might take a few minutes to generate the map image depending on the corruption level", RegionInfo.RegionName);
|
|
terraincorruptedwarningsaid = true;
|
|
}
|
|
Color black = Color.Black;
|
|
mapbmp.SetPixel(x, (256 - y) - 1, black);
|
|
}
|
|
}
|
|
}
|
|
//}
|
|
|
|
//tc = System.Environment.TickCount - tc;
|
|
//m_log.Info("[MAPTILE]: Completed One row in " + tc + " ms");
|
|
}
|
|
|
|
m_log.Info("[MAPTILE]: Generating Maptile Step 1: Done in " + (System.Environment.TickCount - tc) + " ms");
|
|
|
|
bool drawPrimVolume = true;
|
|
|
|
try
|
|
{
|
|
IConfig startupConfig = m_config.Configs["Startup"];
|
|
drawPrimVolume = startupConfig.GetBoolean("DrawPrimOnMapTile", true);
|
|
}
|
|
catch
|
|
{
|
|
m_log.Warn("[MAPTILE]: Failed to load StartupConfig");
|
|
}
|
|
|
|
if (drawPrimVolume)
|
|
{
|
|
tc = System.Environment.TickCount;
|
|
m_log.Info("[MAPTILE]: Generating Maptile Step 2: Object Volume Profile");
|
|
List<EntityBase> objs = GetEntities();
|
|
|
|
lock (objs)
|
|
{
|
|
foreach (EntityBase obj in objs)
|
|
{
|
|
// Only draw the contents of SceneObjectGroup
|
|
if (obj is SceneObjectGroup)
|
|
{
|
|
SceneObjectGroup mapdot = (SceneObjectGroup)obj;
|
|
Color mapdotspot = Color.Gray; // Default color when prim color is white
|
|
// Loop over prim in group
|
|
foreach (SceneObjectPart part in mapdot.Children.Values)
|
|
{
|
|
if (part == null)
|
|
continue;
|
|
|
|
// Draw if the object is at least 1 meter wide in any direction
|
|
if (part.Scale.X > 1f || part.Scale.Y > 1f || part.Scale.Z > 1f)
|
|
{
|
|
// Try to get the RGBA of the default texture entry..
|
|
//
|
|
try
|
|
{
|
|
if (part == null)
|
|
continue;
|
|
|
|
if (part.Shape == null)
|
|
continue;
|
|
|
|
if (part.Shape.PCode == (byte)PCode.Tree || part.Shape.PCode == (byte)PCode.NewTree)
|
|
continue; // eliminates trees from this since we don't really have a good tree representation
|
|
// if you want tree blocks on the map comment the above line and uncomment the below line
|
|
//mapdotspot = Color.PaleGreen;
|
|
|
|
if (part.Shape.Textures == null)
|
|
continue;
|
|
|
|
if (part.Shape.Textures.DefaultTexture == null)
|
|
continue;
|
|
|
|
Color4 texcolor = part.Shape.Textures.DefaultTexture.RGBA;
|
|
|
|
// Not sure why some of these are null, oh well.
|
|
|
|
int colorr = 255 - (int)(texcolor.R * 255f);
|
|
int colorg = 255 - (int)(texcolor.G * 255f);
|
|
int colorb = 255 - (int)(texcolor.B * 255f);
|
|
|
|
if (!(colorr == 255 && colorg == 255 && colorb == 255))
|
|
{
|
|
//Try to set the map spot color
|
|
try
|
|
{
|
|
// If the color gets goofy somehow, skip it *shakes fist at Color4
|
|
mapdotspot = Color.FromArgb(colorr, colorg, colorb);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
catch (IndexOutOfRangeException)
|
|
{
|
|
// Windows Array
|
|
}
|
|
catch (ArgumentOutOfRangeException)
|
|
{
|
|
// Mono Array
|
|
}
|
|
|
|
Vector3 pos = part.GetWorldPosition();
|
|
|
|
// skip prim outside of retion
|
|
if (pos.X < 0f || pos.X > 256f || pos.Y < 0f || pos.Y > 256f)
|
|
continue;
|
|
|
|
// skip prim in non-finite position
|
|
if (Single.IsNaN(pos.X) || Single.IsNaN(pos.Y) || Single.IsInfinity(pos.X)
|
|
|| Single.IsInfinity(pos.Y))
|
|
continue;
|
|
|
|
// Figure out if object is under 256m above the height of the terrain
|
|
bool isBelow256AboveTerrain = false;
|
|
|
|
try
|
|
{
|
|
isBelow256AboveTerrain = (pos.Z < ((float)hm[(int)pos.X, (int)pos.Y] + 256f));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
|
|
if (isBelow256AboveTerrain)
|
|
{
|
|
// Translate scale by rotation so scale is represented properly when object is rotated
|
|
Vector3 scale = part.Shape.Scale;
|
|
Quaternion rot = part.GetWorldRotation();
|
|
scale *= rot;
|
|
|
|
// negative scales don't work in this situation
|
|
scale.X = Math.Abs(scale.X);
|
|
scale.Y = Math.Abs(scale.Y);
|
|
scale.Z = Math.Abs(scale.Z);
|
|
|
|
// This scaling isn't very accurate and doesn't take into account the face rotation :P
|
|
int mapdrawstartX = (int)(pos.X - scale.X);
|
|
int mapdrawstartY = (int)(pos.Y - scale.Y);
|
|
int mapdrawendX = (int)(pos.X + scale.X);
|
|
int mapdrawendY = (int)(pos.Y + scale.Y);
|
|
|
|
// If object is beyond the edge of the map, don't draw it to avoid errors
|
|
if (mapdrawstartX < 0 || mapdrawstartX > 255 || mapdrawendX < 0 || mapdrawendX > 255
|
|
|| mapdrawstartY < 0 || mapdrawstartY > 255 || mapdrawendY < 0
|
|
|| mapdrawendY > 255)
|
|
continue;
|
|
|
|
int wy = 0;
|
|
|
|
bool breakYN = false; // If we run into an error drawing, break out of the
|
|
// loop so we don't lag to death on error handling
|
|
for (int wx = mapdrawstartX; wx < mapdrawendX; wx++)
|
|
{
|
|
for (wy = mapdrawstartY; wy < mapdrawendY; wy++)
|
|
{
|
|
//m_log.InfoFormat("[MAPDEBUG]: {0},{1}({2})", wx, (255 - wy),wy);
|
|
try
|
|
{
|
|
// Remember, flip the y!
|
|
mapbmp.SetPixel(wx, (255 - wy), mapdotspot);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
breakYN = true;
|
|
}
|
|
|
|
if (breakYN)
|
|
break;
|
|
}
|
|
|
|
if (breakYN)
|
|
break;
|
|
}
|
|
} // Object is within 256m Z of terrain
|
|
} // object is at least a meter wide
|
|
} // loop over group children
|
|
} // entitybase is sceneobject group
|
|
} // foreach loop over entities
|
|
} // lock entities objs
|
|
|
|
m_log.Info("[MAPTILE]: Generating Maptile Step 2: Done in " + (System.Environment.TickCount - tc) + " ms");
|
|
} // end if drawPrimOnMaptle
|
|
|
|
byte[] data;
|
|
try
|
|
{
|
|
data = OpenJPEG.EncodeFromImage(mapbmp, false);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LazySaveGeneratedMaptile(data,temporary);
|
|
|
|
#endregion
|
|
}
|
|
else
|
|
{
|
|
// Use the module to generate the maptile.
|
|
byte[] data = terrain.WriteJpeg2000Image("defaultstripe.png");
|
|
if (data != null)
|
|
{
|
|
LazySaveGeneratedMaptile(data,temporary);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void LazySaveGeneratedMaptile(byte[] data, bool temporary)
|
|
{
|
|
// Overwrites the local Asset cache with new maptile data
|
|
// Assets are single write, this causes the asset server to ignore this update,
|
|
// but the local asset cache does not
|
|
|
|
// this is on purpose! The net result of this is the region always has the most up to date
|
|
// map tile while protecting the (grid) asset database from bloat caused by a new asset each
|
|
// time a mapimage is generated!
|
|
|
|
UUID lastMapRegionUUID = m_regInfo.lastMapUUID;
|
|
|
|
int lastMapRefresh = 0;
|
|
int twoDays = 172800;
|
|
int RefreshSeconds = twoDays;
|
|
|
|
try
|
|
{
|
|
lastMapRefresh = Convert.ToInt32(m_regInfo.lastMapRefresh);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
}
|
|
|
|
UUID TerrainImageUUID = UUID.Random();
|
|
|
|
if (lastMapRegionUUID == UUID.Zero || (lastMapRefresh + RefreshSeconds) < Util.UnixTimeSinceEpoch())
|
|
{
|
|
m_regInfo.SaveLastMapUUID(TerrainImageUUID);
|
|
|
|
m_log.Warn("[MAPTILE]: STORING MAPTILE IMAGE");
|
|
}
|
|
else
|
|
{
|
|
TerrainImageUUID = lastMapRegionUUID;
|
|
m_log.Warn("[MAPTILE]: REUSING OLD MAPTILE IMAGE ID");
|
|
}
|
|
|
|
m_regInfo.RegionSettings.TerrainImageID = TerrainImageUUID;
|
|
|
|
AssetBase asset = new AssetBase();
|
|
asset.FullID = m_regInfo.RegionSettings.TerrainImageID;
|
|
asset.Data = data;
|
|
asset.Name = "terrainImage_" + m_regInfo.RegionID.ToString() + "_" + lastMapRefresh.ToString();
|
|
asset.Description = RegionInfo.RegionName;
|
|
|
|
asset.Type = 0;
|
|
asset.Temporary = temporary;
|
|
AssetCache.AddAsset(asset);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Load Land
|
|
|
|
public void loadAllLandObjectsFromStorage(UUID regionID)
|
|
{
|
|
m_log.Info("[SCENE]: Loading land objects from storage");
|
|
List<LandData> landData = m_storageManager.DataStore.LoadLandObjects(regionID);
|
|
|
|
if (LandChannel != null)
|
|
{
|
|
if (landData.Count == 0)
|
|
{
|
|
EventManager.TriggerNoticeNoLandDataFromStorage();
|
|
}
|
|
else
|
|
{
|
|
EventManager.TriggerIncomingLandDataFromStorage(landData);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.Error("[SCENE]: Land Channel is not defined. Cannot load from storage!");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Primitives Methods
|
|
|
|
/// <summary>
|
|
/// Loads the World's objects
|
|
/// </summary>
|
|
public virtual void LoadPrimsFromStorage(UUID regionID)
|
|
{
|
|
m_log.Info("[SCENE]: Loading objects from datastore");
|
|
|
|
List<SceneObjectGroup> PrimsFromDB = m_storageManager.DataStore.LoadObjects(regionID);
|
|
foreach (SceneObjectGroup group in PrimsFromDB)
|
|
{
|
|
if (group.RootPart == null)
|
|
{
|
|
m_log.ErrorFormat("[SCENE] Found a SceneObjectGroup with m_rootPart == null and {0} children",
|
|
group.Children == null ? 0 : group.Children.Count);
|
|
}
|
|
|
|
AddRestoredSceneObject(group, true, true);
|
|
SceneObjectPart rootPart = group.GetChildPart(group.UUID);
|
|
rootPart.ObjectFlags &= ~(uint)PrimFlags.Scripted;
|
|
rootPart.TrimPermissions();
|
|
group.CheckSculptAndLoad();
|
|
//rootPart.DoPhysicsPropertyUpdate(UsePhysics, true);
|
|
}
|
|
|
|
m_log.Info("[SCENE]: Loaded " + PrimsFromDB.Count.ToString() + " SceneObject(s)");
|
|
}
|
|
|
|
public Vector3 GetNewRezLocation(Vector3 RayStart, Vector3 RayEnd, UUID RayTargetID, Quaternion rot, byte bypassRayCast, byte RayEndIsIntersection, bool frontFacesOnly, Vector3 scale, bool FaceCenter)
|
|
{
|
|
Vector3 pos = Vector3.Zero;
|
|
if (RayEndIsIntersection == (byte)1)
|
|
{
|
|
pos = RayEnd;
|
|
return pos;
|
|
}
|
|
|
|
if (RayTargetID != UUID.Zero)
|
|
{
|
|
SceneObjectPart target = GetSceneObjectPart(RayTargetID);
|
|
|
|
Vector3 direction = Vector3.Normalize(RayEnd - RayStart);
|
|
Vector3 AXOrigin = new Vector3(RayStart.X, RayStart.Y, RayStart.Z);
|
|
Vector3 AXdirection = new Vector3(direction.X, direction.Y, direction.Z);
|
|
|
|
if (target != null)
|
|
{
|
|
pos = target.AbsolutePosition;
|
|
//m_log.Info("[OBJECT_REZ]: TargetPos: " + pos.ToString() + ", RayStart: " + RayStart.ToString() + ", RayEnd: " + RayEnd.ToString() + ", Volume: " + Util.GetDistanceTo(RayStart,RayEnd).ToString() + ", mag1: " + Util.GetMagnitude(RayStart).ToString() + ", mag2: " + Util.GetMagnitude(RayEnd).ToString());
|
|
|
|
// TODO: Raytrace better here
|
|
|
|
//EntityIntersection ei = m_innerScene.GetClosestIntersectingPrim(new Ray(AXOrigin, AXdirection));
|
|
Ray NewRay = new Ray(AXOrigin, AXdirection);
|
|
|
|
// Ray Trace against target here
|
|
EntityIntersection ei = target.TestIntersectionOBB(NewRay, Quaternion.Identity, frontFacesOnly, FaceCenter);
|
|
|
|
// Un-comment out the following line to Get Raytrace results printed to the console.
|
|
// m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
|
|
float ScaleOffset = 0.5f;
|
|
|
|
// If we hit something
|
|
if (ei.HitTF)
|
|
{
|
|
Vector3 scaleComponent = new Vector3(ei.AAfaceNormal.X, ei.AAfaceNormal.Y, ei.AAfaceNormal.Z);
|
|
if (scaleComponent.X != 0) ScaleOffset = scale.X;
|
|
if (scaleComponent.Y != 0) ScaleOffset = scale.Y;
|
|
if (scaleComponent.Z != 0) ScaleOffset = scale.Z;
|
|
ScaleOffset = Math.Abs(ScaleOffset);
|
|
Vector3 intersectionpoint = new Vector3(ei.ipoint.X, ei.ipoint.Y, ei.ipoint.Z);
|
|
Vector3 normal = new Vector3(ei.normal.X, ei.normal.Y, ei.normal.Z);
|
|
// Set the position to the intersection point
|
|
Vector3 offset = (normal * (ScaleOffset / 2f));
|
|
pos = (intersectionpoint + offset);
|
|
|
|
// Un-offset the prim (it gets offset later by the consumer method)
|
|
pos.Z -= 0.25F;
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
else
|
|
{
|
|
// We don't have a target here, so we're going to raytrace all the objects in the scene.
|
|
|
|
EntityIntersection ei = m_innerScene.GetClosestIntersectingPrim(new Ray(AXOrigin, AXdirection), true, false);
|
|
|
|
// Un-comment the following line to print the raytrace results to the console.
|
|
//m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
|
|
|
|
if (ei.HitTF)
|
|
{
|
|
pos = new Vector3(ei.ipoint.X, ei.ipoint.Y, ei.ipoint.Z);
|
|
} else
|
|
{
|
|
// fall back to our stupid functionality
|
|
pos = RayEnd;
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// fall back to our stupid functionality
|
|
pos = RayEnd;
|
|
return pos;
|
|
}
|
|
}
|
|
|
|
public virtual void AddNewPrim(UUID ownerID, Vector3 RayEnd, Quaternion rot, PrimitiveBaseShape shape,
|
|
byte bypassRaycast, Vector3 RayStart, UUID RayTargetID,
|
|
byte RayEndIsIntersection)
|
|
{
|
|
Vector3 pos = GetNewRezLocation(RayStart, RayEnd, RayTargetID, rot, bypassRaycast, RayEndIsIntersection, true, new Vector3(0.5f, 0.5f, 0.5f), false);
|
|
|
|
if (ExternalChecks.ExternalChecksCanRezObject(1, ownerID, pos))
|
|
{
|
|
// rez ON the ground, not IN the ground
|
|
pos.Z += 0.25F;
|
|
|
|
AddNewPrim(ownerID, pos, rot, shape);
|
|
}
|
|
}
|
|
|
|
public virtual SceneObjectGroup AddNewPrim(UUID ownerID, Vector3 pos, Quaternion rot, PrimitiveBaseShape shape)
|
|
{
|
|
//m_log.DebugFormat(
|
|
// "[SCENE]: Scene.AddNewPrim() called for agent {0} in {1}", ownerID, RegionInfo.RegionName);
|
|
|
|
SceneObjectGroup sceneObject = new SceneObjectGroup(ownerID, pos, rot, shape);
|
|
|
|
SceneObjectPart rootPart = sceneObject.GetChildPart(sceneObject.UUID);
|
|
// if grass or tree, make phantom
|
|
//rootPart.TrimPermissions();
|
|
if ((rootPart.Shape.PCode == (byte)PCode.Grass)
|
|
|| (rootPart.Shape.PCode == (byte)PCode.Tree) || (rootPart.Shape.PCode == (byte)PCode.NewTree))
|
|
{
|
|
rootPart.AddFlag(PrimFlags.Phantom);
|
|
//rootPart.ObjectFlags += (uint)PrimFlags.Phantom;
|
|
if (rootPart.Shape.PCode != (byte)PCode.Grass)
|
|
AdaptTree(ref shape);
|
|
}
|
|
|
|
AddNewSceneObject(sceneObject, true);
|
|
|
|
return sceneObject;
|
|
}
|
|
|
|
void AdaptTree(ref PrimitiveBaseShape tree)
|
|
{
|
|
// Tree size has to be adapted depending on its type
|
|
switch ((Tree)tree.State)
|
|
{
|
|
case Tree.Cypress1:
|
|
case Tree.Cypress2:
|
|
tree.Scale = new Vector3(4, 4, 10);
|
|
break;
|
|
|
|
// case... other tree types
|
|
// tree.Scale = new Vector3(?, ?, ?);
|
|
// break;
|
|
|
|
default:
|
|
tree.Scale = new Vector3(4, 4, 4);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public SceneObjectGroup AddTree(UUID uuid, Vector3 scale, Quaternion rotation, Vector3 position,
|
|
Tree treeType, bool newTree)
|
|
{
|
|
PrimitiveBaseShape treeShape = new PrimitiveBaseShape();
|
|
treeShape.PathCurve = 16;
|
|
treeShape.PathEnd = 49900;
|
|
treeShape.PCode = newTree ? (byte)PCode.NewTree : (byte)PCode.Tree;
|
|
treeShape.Scale = scale;
|
|
treeShape.State = (byte)treeType;
|
|
return AddNewPrim(uuid, position, rotation, treeShape);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add an object into the scene that has come from storage
|
|
/// </summary>
|
|
/// <param name="sceneObject"></param>
|
|
/// <param name="attachToBackup">
|
|
/// If true, changes to the object will be reflected in its persisted data
|
|
/// If false, the persisted data will not be changed even if the object in the scene is changed
|
|
/// </param>
|
|
/// <param name="alreadyPersisted">
|
|
/// If true, we won't persist this object until it changes
|
|
/// If false, we'll persist this object immediately
|
|
/// </param>
|
|
/// <returns>
|
|
/// true if the object was added, false if an object with the same uuid was already in the scene
|
|
/// </returns>
|
|
public bool AddRestoredSceneObject(
|
|
SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted)
|
|
{
|
|
return m_innerScene.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a newly created object to the scene
|
|
/// </summary>
|
|
/// <param name="sceneObject"></param>
|
|
/// <param name="attachToBackup">
|
|
/// If true, the object is made persistent into the scene.
|
|
/// If false, the object will not persist over server restarts
|
|
/// </param>
|
|
public bool AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup)
|
|
{
|
|
return m_innerScene.AddNewSceneObject(sceneObject, attachToBackup);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete every object from the scene
|
|
/// </summary>
|
|
public void DeleteAllSceneObjects()
|
|
{
|
|
lock (Entities)
|
|
{
|
|
ICollection<EntityBase> entities = new List<EntityBase>(Entities.Values);
|
|
|
|
foreach (EntityBase e in entities)
|
|
{
|
|
if (e is SceneObjectGroup)
|
|
DeleteSceneObject((SceneObjectGroup)e, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete the given object from the scene.
|
|
/// </summary>
|
|
/// <param name="group"></param>
|
|
public void DeleteSceneObject(SceneObjectGroup group, bool silent)
|
|
{
|
|
//SceneObjectPart rootPart = group.GetChildPart(group.UUID);
|
|
|
|
// Serialise calls to RemoveScriptInstances to avoid
|
|
// deadlocking on m_parts inside SceneObjectGroup
|
|
lock (m_deleting_scene_object)
|
|
{
|
|
group.RemoveScriptInstances();
|
|
}
|
|
|
|
foreach (SceneObjectPart part in group.Children.Values)
|
|
{
|
|
if (part.PhysActor != null)
|
|
{
|
|
PhysicsScene.RemovePrim(part.PhysActor);
|
|
part.PhysActor = null;
|
|
}
|
|
}
|
|
// if (rootPart.PhysActor != null)
|
|
// {
|
|
// PhysicsScene.RemovePrim(rootPart.PhysActor);
|
|
// rootPart.PhysActor = null;
|
|
// }
|
|
|
|
if (UnlinkSceneObject(group.UUID, false))
|
|
{
|
|
EventManager.TriggerObjectBeingRemovedFromScene(group);
|
|
EventManager.TriggerParcelPrimCountTainted();
|
|
}
|
|
|
|
group.DeleteGroup(silent);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unlink the given object from the scene. Unlike delete, this just removes the record of the object - the
|
|
/// object itself is not destroyed.
|
|
/// </summary>
|
|
/// <param name="uuid"></param>
|
|
/// <returns>true if the object was in the scene, false if it was not</returns>
|
|
public bool UnlinkSceneObject(UUID uuid, bool resultOfLinkingObjects)
|
|
{
|
|
if (m_innerScene.DeleteSceneObject(uuid, resultOfLinkingObjects))
|
|
{
|
|
if (!resultOfLinkingObjects)
|
|
m_storageManager.DataStore.RemoveObject(uuid,
|
|
m_regInfo.RegionID);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void LoadPrimsFromXml(string fileName, bool newIdsFlag, Vector3 loadOffset)
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Loading prims in xml format to region {0} from {1}", RegionInfo.RegionName, fileName);
|
|
|
|
m_serialiser.LoadPrimsFromXml(this, fileName, newIdsFlag, loadOffset);
|
|
}
|
|
|
|
public void SavePrimsToXml(string fileName)
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Saving prims in xml format for region {0} to {1}", RegionInfo.RegionName, fileName);
|
|
|
|
m_serialiser.SavePrimsToXml(this, fileName);
|
|
}
|
|
|
|
public void LoadPrimsFromXml2(string fileName)
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Loading prims in xml2 format to region {0} from {1}", RegionInfo.RegionName, fileName);
|
|
|
|
m_serialiser.LoadPrimsFromXml2(this, fileName);
|
|
}
|
|
|
|
public void LoadPrimsFromXml2(TextReader reader, bool startScripts)
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Loading prims in xml2 format to region {0} from stream", RegionInfo.RegionName);
|
|
|
|
m_serialiser.LoadPrimsFromXml2(this, reader, startScripts);
|
|
}
|
|
|
|
public void SavePrimsToXml2(string fileName)
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Saving prims in xml2 format for region {0} to {1}", RegionInfo.RegionName, fileName);
|
|
|
|
m_serialiser.SavePrimsToXml2(this, fileName);
|
|
}
|
|
|
|
public void SavePrimsToXml2(TextWriter stream, Vector3 min, Vector3 max)
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Saving prims in xml2 format for region {0} to stream", RegionInfo.RegionName);
|
|
|
|
m_serialiser.SavePrimsToXml2(this, stream, min, max);
|
|
}
|
|
|
|
public void SaveNamedPrimsToXml2(string primName, string fileName)
|
|
{
|
|
m_log.InfoFormat(
|
|
"[SCENE]: Saving prims with name {0} in xml2 format for region {1} to {2}", primName, RegionInfo.RegionName, fileName);
|
|
|
|
List<EntityBase> entityList = GetEntities();
|
|
List<EntityBase> primList = new List<EntityBase>();
|
|
|
|
foreach (EntityBase ent in entityList)
|
|
{
|
|
if (ent is SceneObjectGroup)
|
|
{
|
|
if (ent.Name == primName)
|
|
{
|
|
primList.Add(ent);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_serialiser.SavePrimListToXml2(primList, fileName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load a prim archive into the scene. This loads both prims and their assets.
|
|
/// </summary>
|
|
/// <param name="filePath"></param>
|
|
public void LoadPrimsFromArchive(string filePath)
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Loading archive to region {0} from {1}", RegionInfo.RegionName, filePath);
|
|
|
|
m_archiver.DearchiveRegion(filePath);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Save the prims in the scene to an archive. This saves both prims and their assets.
|
|
/// </summary>
|
|
/// <param name="filePath"></param>
|
|
public void SavePrimsToArchive(string filePath)
|
|
{
|
|
m_log.InfoFormat("[SCENE]: Writing archive for region {0} to {1}", RegionInfo.RegionName, filePath);
|
|
|
|
m_archiver.ArchiveRegion(filePath);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Move the given scene object into a new region depending on which region its absolute position has moved
|
|
/// into.
|
|
///
|
|
/// This method locates the new region handle and offsets the prim position for the new region
|
|
/// </summary>
|
|
/// <param name="attemptedPosition">the attempted out of region position of the scene object</param>
|
|
/// <param name="grp">the scene object that we're crossing</param>
|
|
public void CrossPrimGroupIntoNewRegion(Vector3 attemptedPosition, SceneObjectGroup grp, bool silent)
|
|
{
|
|
if (grp == null)
|
|
return;
|
|
if (grp.RootPart == null)
|
|
return;
|
|
|
|
if (grp.RootPart.DIE_AT_EDGE)
|
|
{
|
|
// We remove the object here
|
|
try
|
|
{
|
|
DeleteSceneObject(grp, false);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
m_log.Warn("[DATABASE]: exception when trying to remove the prim that crossed the border.");
|
|
}
|
|
return;
|
|
}
|
|
|
|
int thisx = (int)RegionInfo.RegionLocX;
|
|
int thisy = (int)RegionInfo.RegionLocY;
|
|
|
|
ulong newRegionHandle = 0;
|
|
Vector3 pos = attemptedPosition;
|
|
|
|
if (attemptedPosition.X > Constants.RegionSize + 0.1f)
|
|
{
|
|
pos.X = ((pos.X - Constants.RegionSize));
|
|
newRegionHandle
|
|
= Util.UIntsToLong((uint)((thisx + 1) * Constants.RegionSize), (uint)(thisy * Constants.RegionSize));
|
|
// x + 1
|
|
}
|
|
else if (attemptedPosition.X < -0.1f)
|
|
{
|
|
pos.X = ((pos.X + Constants.RegionSize));
|
|
newRegionHandle
|
|
= Util.UIntsToLong((uint)((thisx - 1) * Constants.RegionSize), (uint)(thisy * Constants.RegionSize));
|
|
// x - 1
|
|
}
|
|
|
|
if (attemptedPosition.Y > Constants.RegionSize + 0.1f)
|
|
{
|
|
pos.Y = ((pos.Y - Constants.RegionSize));
|
|
newRegionHandle
|
|
= Util.UIntsToLong((uint)(thisx * Constants.RegionSize), (uint)((thisy + 1) * Constants.RegionSize));
|
|
// y + 1
|
|
}
|
|
else if (attemptedPosition.Y < -0.1f)
|
|
{
|
|
pos.Y = ((pos.Y + Constants.RegionSize));
|
|
newRegionHandle
|
|
= Util.UIntsToLong((uint)(thisx * Constants.RegionSize), (uint)((thisy - 1) * Constants.RegionSize));
|
|
// y - 1
|
|
}
|
|
|
|
// Offset the positions for the new region across the border
|
|
Vector3 oldGroupPosition = grp.RootPart.GroupPosition;
|
|
grp.OffsetForNewRegion(pos);
|
|
|
|
// If we fail to cross the border, then reset the position of the scene object on that border.
|
|
if (!CrossPrimGroupIntoNewRegion(newRegionHandle, grp, silent))
|
|
{
|
|
grp.OffsetForNewRegion(oldGroupPosition);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Move the given scene object into a new region
|
|
/// </summary>
|
|
/// <param name="newRegionHandle"></param>
|
|
/// <param name="grp">Scene Object Group that we're crossing</param>
|
|
/// <returns>
|
|
/// true if the crossing itself was successful, false on failure
|
|
/// FIMXE: we still return true if the crossing object was not successfully deleted from the originating region
|
|
/// </returns>
|
|
public bool CrossPrimGroupIntoNewRegion(ulong newRegionHandle, SceneObjectGroup grp, bool silent)
|
|
{
|
|
bool successYN = false;
|
|
grp.RootPart.UpdateFlag = 0;
|
|
int primcrossingXMLmethod = 0;
|
|
|
|
if (newRegionHandle != 0)
|
|
{
|
|
successYN
|
|
= m_sceneGridService.PrimCrossToNeighboringRegion(
|
|
newRegionHandle, grp.UUID, m_serialiser.SaveGroupToXml2(grp), primcrossingXMLmethod);
|
|
|
|
if (successYN)
|
|
{
|
|
// We remove the object here
|
|
try
|
|
{
|
|
DeleteSceneObject(grp, silent);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.ErrorFormat(
|
|
"[INTERREGION]: Exception deleting the old object left behind on a border crossing for {0}, {1}",
|
|
grp, e);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (grp.RootPart != null)
|
|
{
|
|
if (grp.RootPart.PhysActor != null)
|
|
{
|
|
grp.RootPart.PhysActor.CrossingFailure();
|
|
}
|
|
}
|
|
|
|
m_log.ErrorFormat("[INTERREGION]: Prim crossing failed for {0}", grp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.Error("[INTERREGION]: region handle was unexpectedly 0 in Scene.CrossPrimGroupIntoNewRegion()");
|
|
}
|
|
|
|
return successYN;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle a scene object that is crossing into this region from another.
|
|
/// </summary>
|
|
/// <param name="regionHandle"></param>
|
|
/// <param name="primID"></param>
|
|
/// <param name="objXMLData"></param>
|
|
/// <param name="XMLMethod"></param>
|
|
/// <returns></returns>
|
|
public bool IncomingInterRegionPrimGroup(ulong regionHandle, UUID primID, string objXMLData, int XMLMethod)
|
|
{
|
|
m_log.Warn("[INTERREGION]: A new prim arrived from a neighbor");
|
|
if (XMLMethod == 0)
|
|
{
|
|
SceneObjectGroup sceneObject = m_serialiser.DeserializeGroupFromXml2(objXMLData);
|
|
AddRestoredSceneObject(sceneObject, true, false);
|
|
|
|
SceneObjectPart RootPrim = GetSceneObjectPart(primID);
|
|
if (RootPrim != null)
|
|
{
|
|
if (m_regInfo.EstateSettings.IsBanned(RootPrim.OwnerID))
|
|
{
|
|
SceneObjectGroup grp = RootPrim.ParentGroup;
|
|
if (grp != null)
|
|
{
|
|
DeleteSceneObject(grp, false);
|
|
}
|
|
|
|
m_log.Info("[INTERREGION]: Denied prim crossing for banned avatar");
|
|
|
|
return false;
|
|
}
|
|
if (RootPrim.Shape.PCode == (byte)PCode.Prim)
|
|
{
|
|
SceneObjectGroup grp = RootPrim.ParentGroup;
|
|
if (grp != null)
|
|
{
|
|
if (RootPrim.Shape.State != 0)
|
|
{
|
|
// Never persist
|
|
|
|
m_log.DebugFormat("[ATTACHMENT]: Received attachment {0}, inworld asset id {1}", grp.RootPart.LastOwnerID.ToString(), grp.UUID.ToString());
|
|
|
|
grp.DetachFromBackup();
|
|
|
|
// Attachment
|
|
ScenePresence sp = GetScenePresence(grp.OwnerID);
|
|
if (sp != null)
|
|
{
|
|
// hack assetID until we get assetID into the XML format.
|
|
// LastOwnerID is used for group deeding, so when you do stuff
|
|
// with the deeded object, it goes back to them
|
|
|
|
grp.SetFromAssetID(grp.RootPart.LastOwnerID);
|
|
m_log.DebugFormat("[ATTACHMENT]: Attach to avatar {0}", sp.UUID.ToString());
|
|
AttachObject(sp.ControllingClient, grp.LocalId, (uint)0, grp.GroupRotation, grp.AbsolutePosition, false);
|
|
}
|
|
else
|
|
{
|
|
// Remove, then add, to ensure the expire
|
|
// time is refreshed. Wouldn't do to
|
|
// have it poof before the avatar gets
|
|
// there.
|
|
//
|
|
RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
|
|
RootPrim.AddFlag(PrimFlags.TemporaryOnRez);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Add/Remove Avatar Methods
|
|
|
|
public override void AddNewClient(IClientAPI client, bool child)
|
|
{
|
|
SubscribeToClientEvents(client);
|
|
ScenePresence presence;
|
|
|
|
if (m_restorePresences.ContainsKey(client.AgentId))
|
|
{
|
|
m_log.DebugFormat("[SCENE]: Restoring agent {0} {1} in {2}", client.Name, client.AgentId, RegionInfo.RegionName);
|
|
|
|
presence = m_restorePresences[client.AgentId];
|
|
m_restorePresences.Remove(client.AgentId);
|
|
|
|
// This is one of two paths to create avatars that are
|
|
// used. This tends to get called more in standalone
|
|
// than grid, not really sure why, but as such needs
|
|
// an explicity appearance lookup here.
|
|
AvatarAppearance appearance = null;
|
|
GetAvatarAppearance(client, out appearance);
|
|
presence.Appearance = appearance;
|
|
|
|
presence.initializeScenePresence(client, RegionInfo, this);
|
|
|
|
m_innerScene.AddScenePresence(presence);
|
|
|
|
lock (m_restorePresences)
|
|
{
|
|
Monitor.PulseAll(m_restorePresences);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.DebugFormat(
|
|
"[SCENE]: Adding new {0} agent {1} {2} in {3}",
|
|
(child ? "child" : "root"), client.Name, client.AgentId, RegionInfo.RegionName);
|
|
|
|
CommsManager.UserProfileCacheService.AddNewUser(client.AgentId);
|
|
|
|
CreateAndAddScenePresence(client, child);
|
|
}
|
|
m_LastLogin = System.Environment.TickCount;
|
|
EventManager.TriggerOnNewClient(client);
|
|
}
|
|
|
|
protected virtual void SubscribeToClientEvents(IClientAPI client)
|
|
{
|
|
client.OnRegionHandShakeReply += SendLayerData;
|
|
client.OnAddPrim += AddNewPrim;
|
|
client.OnUpdatePrimGroupPosition += m_innerScene.UpdatePrimPosition;
|
|
client.OnUpdatePrimSinglePosition += m_innerScene.UpdatePrimSinglePosition;
|
|
client.OnUpdatePrimGroupRotation += m_innerScene.UpdatePrimRotation;
|
|
client.OnUpdatePrimGroupMouseRotation += m_innerScene.UpdatePrimRotation;
|
|
client.OnUpdatePrimSingleRotation += m_innerScene.UpdatePrimSingleRotation;
|
|
client.OnUpdatePrimScale += m_innerScene.UpdatePrimScale;
|
|
client.OnUpdatePrimGroupScale += m_innerScene.UpdatePrimGroupScale;
|
|
client.OnUpdateExtraParams += m_innerScene.UpdateExtraParam;
|
|
client.OnUpdatePrimShape += m_innerScene.UpdatePrimShape;
|
|
//client.OnRequestMapBlocks += RequestMapBlocks; // handled in a module now.
|
|
client.OnUpdatePrimTexture += m_innerScene.UpdatePrimTexture;
|
|
client.OnTeleportLocationRequest += RequestTeleportLocation;
|
|
client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
|
|
client.OnObjectSelect += SelectPrim;
|
|
client.OnObjectDeselect += DeselectPrim;
|
|
client.OnGrabUpdate += m_innerScene.MoveObject;
|
|
client.OnDeRezObject += DeRezObject;
|
|
client.OnRezObject += RezObject;
|
|
client.OnRezSingleAttachmentFromInv += RezSingleAttachment;
|
|
client.OnDetachAttachmentIntoInv += DetachSingleAttachmentToInv;
|
|
client.OnObjectAttach += m_innerScene.AttachObject;
|
|
client.OnObjectDetach += m_innerScene.DetachObject;
|
|
client.OnObjectDrop += m_innerScene.DropObject;
|
|
client.OnNameFromUUIDRequest += CommsManager.HandleUUIDNameRequest;
|
|
client.OnObjectDescription += m_innerScene.PrimDescription;
|
|
client.OnObjectName += m_innerScene.PrimName;
|
|
client.OnObjectClickAction += m_innerScene.PrimClickAction;
|
|
client.OnObjectMaterial += m_innerScene.PrimMaterial;
|
|
client.OnLinkObjects += m_innerScene.LinkObjects;
|
|
client.OnDelinkObjects += m_innerScene.DelinkObjects;
|
|
client.OnObjectDuplicate += m_innerScene.DuplicateObject;
|
|
client.OnObjectDuplicateOnRay += doObjectDuplicateOnRay;
|
|
client.OnUpdatePrimFlags += m_innerScene.UpdatePrimFlags;
|
|
client.OnRequestObjectPropertiesFamily += m_innerScene.RequestObjectPropertiesFamily;
|
|
client.OnRequestGodlikePowers += handleRequestGodlikePowers;
|
|
client.OnGodKickUser += HandleGodlikeKickUser;
|
|
client.OnObjectPermissions += HandleObjectPermissionsUpdate;
|
|
client.OnCreateNewInventoryItem += CreateNewInventoryItem;
|
|
client.OnCreateNewInventoryFolder += CommsManager.UserProfileCacheService.HandleCreateInventoryFolder;
|
|
client.OnUpdateInventoryFolder += CommsManager.UserProfileCacheService.HandleUpdateInventoryFolder;
|
|
client.OnMoveInventoryFolder += CommsManager.UserProfileCacheService.HandleMoveInventoryFolder;
|
|
client.OnFetchInventoryDescendents += CommsManager.UserProfileCacheService.HandleFetchInventoryDescendents;
|
|
client.OnPurgeInventoryDescendents += CommsManager.UserProfileCacheService.HandlePurgeInventoryDescendents;
|
|
client.OnFetchInventory += CommsManager.UserProfileCacheService.HandleFetchInventory;
|
|
client.OnUpdateInventoryItem += UpdateInventoryItemAsset;
|
|
client.OnCopyInventoryItem += CopyInventoryItem;
|
|
client.OnMoveInventoryItem += MoveInventoryItem;
|
|
client.OnRemoveInventoryItem += RemoveInventoryItem;
|
|
client.OnRemoveInventoryFolder += RemoveInventoryFolder;
|
|
client.OnRezScript += RezScript;
|
|
client.OnRequestTaskInventory += RequestTaskInventory;
|
|
client.OnRemoveTaskItem += RemoveTaskInventory;
|
|
client.OnUpdateTaskInventory += UpdateTaskInventory;
|
|
client.OnMoveTaskItem += ClientMoveTaskInventoryItem;
|
|
client.OnGrabObject += ProcessObjectGrab;
|
|
client.OnDeGrabObject += ProcessObjectDeGrab;
|
|
client.OnMoneyTransferRequest += ProcessMoneyTransferRequest;
|
|
client.OnParcelBuy += ProcessParcelBuy;
|
|
client.OnAvatarPickerRequest += ProcessAvatarPickerRequest;
|
|
client.OnObjectIncludeInSearch += m_innerScene.MakeObjectSearchable;
|
|
client.OnTeleportHomeRequest += TeleportClientHome;
|
|
client.OnSetStartLocationRequest += SetHomeRezPoint;
|
|
client.OnUndo += m_innerScene.HandleUndo;
|
|
client.OnObjectGroupRequest += m_innerScene.HandleObjectGroupUpdate;
|
|
client.OnParcelReturnObjectsRequest += LandChannel.ReturnObjectsInParcel;
|
|
client.OnParcelSetOtherCleanTime += LandChannel.SetParcelOtherCleanTime;
|
|
client.OnObjectSaleInfo += ObjectSaleInfo;
|
|
client.OnScriptReset += ProcessScriptReset;
|
|
client.OnGetScriptRunning += GetScriptRunning;
|
|
client.OnSetScriptRunning += SetScriptRunning;
|
|
client.OnRegionHandleRequest += RegionHandleRequest;
|
|
client.OnUnackedTerrain += TerrainUnAcked;
|
|
|
|
//Gesture
|
|
client.OnActivateGesture += ActivateGesture;
|
|
client.OnDeactivateGesture += DeactivateGesture;
|
|
|
|
client.OnObjectOwner += ObjectOwner;
|
|
|
|
// EventManager.TriggerOnNewClient(client);
|
|
}
|
|
|
|
// Gesture
|
|
public virtual void ActivateGesture(IClientAPI client, UUID assetId, UUID gestureId)
|
|
{
|
|
// UserProfileCacheService User = CommsManager.SecureInventoryService.UpdateItem(gestureid, agentID);
|
|
CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(client.AgentId);
|
|
|
|
if (userInfo != null)
|
|
{
|
|
InventoryItemBase item = userInfo.RootFolder.FindItem(gestureId);
|
|
if (item != null)
|
|
{
|
|
item.Flags = 1;
|
|
userInfo.UpdateItem(item);
|
|
}
|
|
else m_log.Error("Unable to find gesture");
|
|
}
|
|
else m_log.Error("Gesture : Unable to find user ");
|
|
|
|
m_log.DebugFormat("Asset : {0} gesture :{1}", gestureId.ToString(), assetId.ToString());
|
|
}
|
|
|
|
public virtual void DeactivateGesture(IClientAPI client, UUID gestureId)
|
|
{
|
|
// UserProfileCacheService User = CommsManager.SecureInventoryService.UpdateItem(gestureid, agentID);
|
|
CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(client.AgentId);
|
|
|
|
if (userInfo != null)
|
|
{
|
|
InventoryItemBase item = userInfo.RootFolder.FindItem(gestureId);
|
|
if (item != null)
|
|
{
|
|
item.Flags = 0;
|
|
userInfo.UpdateItem(item);
|
|
}
|
|
else m_log.Error("Unable to find gesture");
|
|
}
|
|
else m_log.Error("Gesture : Unable to find user ");
|
|
|
|
m_log.DebugFormat("gesture : {0} ", gestureId.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Teleport an avatar to their home region
|
|
/// </summary>
|
|
/// <param name="agentId"></param>
|
|
/// <param name="client"></param>
|
|
public virtual void TeleportClientHome(UUID agentId, IClientAPI client)
|
|
{
|
|
UserProfileData UserProfile = CommsManager.UserService.GetUserProfile(agentId);
|
|
if (UserProfile != null)
|
|
{
|
|
RegionInfo regionInfo = CommsManager.GridService.RequestNeighbourInfo(UserProfile.HomeRegionID);
|
|
if (regionInfo == null)
|
|
{
|
|
regionInfo = CommsManager.GridService.RequestNeighbourInfo(UserProfile.HomeRegion);
|
|
UserProfile.HomeRegionID = regionInfo.RegionID;
|
|
CommsManager.UserService.UpdateUserProfile(UserProfile);
|
|
}
|
|
if (regionInfo == null)
|
|
{
|
|
// can't find the Home region: Tell viewer and abort
|
|
client.SendTeleportFailed("Your home-region could not be found.");
|
|
return;
|
|
}
|
|
RequestTeleportLocation(
|
|
client, regionInfo.RegionHandle, UserProfile.HomeLocation, UserProfile.HomeLookAt,
|
|
(uint)(TPFlags.SetLastToTarget | TPFlags.ViaHome));
|
|
}
|
|
}
|
|
|
|
public void doObjectDuplicateOnRay(uint localID, uint dupeFlags, UUID AgentID, UUID GroupID,
|
|
UUID RayTargetObj, Vector3 RayEnd, Vector3 RayStart,
|
|
bool BypassRaycast, bool RayEndIsIntersection, bool CopyCenters, bool CopyRotates)
|
|
{
|
|
Vector3 pos;
|
|
const bool frontFacesOnly = true;
|
|
//m_log.Info("HITTARGET: " + RayTargetObj.ToString() + ", COPYTARGET: " + localID.ToString());
|
|
SceneObjectPart target = GetSceneObjectPart(localID);
|
|
SceneObjectPart target2 = GetSceneObjectPart(RayTargetObj);
|
|
|
|
if (target != null && target2 != null)
|
|
{
|
|
Vector3 direction = Vector3.Normalize(RayEnd - RayStart);
|
|
Vector3 AXOrigin = new Vector3(RayStart.X, RayStart.Y, RayStart.Z);
|
|
Vector3 AXdirection = new Vector3(direction.X, direction.Y, direction.Z);
|
|
|
|
if (target2.ParentGroup != null)
|
|
{
|
|
pos = target2.AbsolutePosition;
|
|
//m_log.Info("[OBJECT_REZ]: TargetPos: " + pos.ToString() + ", RayStart: " + RayStart.ToString() + ", RayEnd: " + RayEnd.ToString() + ", Volume: " + Util.GetDistanceTo(RayStart,RayEnd).ToString() + ", mag1: " + Util.GetMagnitude(RayStart).ToString() + ", mag2: " + Util.GetMagnitude(RayEnd).ToString());
|
|
|
|
// TODO: Raytrace better here
|
|
|
|
//EntityIntersection ei = m_innerScene.GetClosestIntersectingPrim(new Ray(AXOrigin, AXdirection));
|
|
Ray NewRay = new Ray(AXOrigin, AXdirection);
|
|
|
|
// Ray Trace against target here
|
|
EntityIntersection ei = target2.TestIntersectionOBB(NewRay, Quaternion.Identity, frontFacesOnly, CopyCenters);
|
|
|
|
// Un-comment out the following line to Get Raytrace results printed to the console.
|
|
//m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
|
|
float ScaleOffset = 0.5f;
|
|
|
|
// If we hit something
|
|
if (ei.HitTF)
|
|
{
|
|
Vector3 scale = target.Scale;
|
|
Vector3 scaleComponent = new Vector3(ei.AAfaceNormal.X, ei.AAfaceNormal.Y, ei.AAfaceNormal.Z);
|
|
if (scaleComponent.X != 0) ScaleOffset = scale.X;
|
|
if (scaleComponent.Y != 0) ScaleOffset = scale.Y;
|
|
if (scaleComponent.Z != 0) ScaleOffset = scale.Z;
|
|
ScaleOffset = Math.Abs(ScaleOffset);
|
|
Vector3 intersectionpoint = new Vector3(ei.ipoint.X, ei.ipoint.Y, ei.ipoint.Z);
|
|
Vector3 normal = new Vector3(ei.normal.X, ei.normal.Y, ei.normal.Z);
|
|
Vector3 offset = normal * (ScaleOffset / 2f);
|
|
pos = intersectionpoint + offset;
|
|
|
|
// stick in offset format from the original prim
|
|
pos = pos - target.ParentGroup.AbsolutePosition;
|
|
if (CopyRotates)
|
|
{
|
|
Quaternion worldRot = target2.GetWorldRotation();
|
|
|
|
// SceneObjectGroup obj = m_innerScene.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
|
|
m_innerScene.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
|
|
//obj.Rotation = worldRot;
|
|
//obj.UpdateGroupRotation(worldRot);
|
|
}
|
|
else
|
|
{
|
|
m_innerScene.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
public virtual void SetHomeRezPoint(IClientAPI remoteClient, ulong regionHandle, Vector3 position, Vector3 lookAt, uint flags)
|
|
{
|
|
UserProfileData UserProfile = CommsManager.UserService.GetUserProfile(remoteClient.AgentId);
|
|
if (UserProfile != null)
|
|
{
|
|
// I know I'm ignoring the regionHandle provided by the teleport location request.
|
|
// reusing the TeleportLocationRequest delegate, so regionHandle isn't valid
|
|
UserProfile.HomeRegionID = RegionInfo.RegionID;
|
|
// TODO: The next line can be removed, as soon as only homeRegionID based UserServers are around.
|
|
// TODO: The HomeRegion property can be removed then, too
|
|
UserProfile.HomeRegion = RegionInfo.RegionHandle;
|
|
UserProfile.HomeLocation = position;
|
|
UserProfile.HomeLookAt = lookAt;
|
|
CommsManager.UserService.UpdateUserProfile(UserProfile);
|
|
|
|
// FUBAR ALERT: this needs to be "Home position set." so the viewer saves a home-screenshot.
|
|
remoteClient.SendAgentAlertMessage("Home position set.",false);
|
|
}
|
|
else
|
|
{
|
|
remoteClient.SendAgentAlertMessage("Set Home request Failed",false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a scene presence and add it to this scene.
|
|
/// </summary>
|
|
/// <param name="client"></param>
|
|
/// <param name="child"></param>
|
|
/// <returns></returns>
|
|
protected virtual ScenePresence CreateAndAddScenePresence(IClientAPI client, bool child)
|
|
{
|
|
AvatarAppearance appearance = null;
|
|
GetAvatarAppearance(client, out appearance);
|
|
|
|
ScenePresence avatar = m_innerScene.CreateAndAddScenePresence(client, child, appearance);
|
|
|
|
return avatar;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the avatar apperance for the given client.
|
|
/// </summary>
|
|
/// <param name="client"></param>
|
|
/// <param name="appearance"></param>
|
|
public void GetAvatarAppearance(IClientAPI client, out AvatarAppearance appearance)
|
|
{
|
|
appearance = new AvatarAppearance();
|
|
|
|
try
|
|
{
|
|
if (m_AvatarFactory != null)
|
|
{
|
|
if (m_AvatarFactory.TryGetAvatarAppearance(client.AgentId, out appearance))
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.ErrorFormat("[APPEARANCE]: Problem fetching appearance for avatar {0}, {1}",
|
|
client.Name, e);
|
|
}
|
|
|
|
m_log.Warn("[APPEARANCE]: Appearance not found, returning default");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove the given client from the scene.
|
|
/// </summary>
|
|
/// <param name="agentID"></param>
|
|
public override void RemoveClient(UUID agentID)
|
|
{
|
|
bool childagentYN = false;
|
|
ScenePresence avatar = GetScenePresence(agentID);
|
|
if (avatar != null)
|
|
{
|
|
childagentYN = avatar.IsChildAgent;
|
|
}
|
|
|
|
try
|
|
{
|
|
m_log.DebugFormat(
|
|
"[SCENE]: Removing {0} agent {1} from region {2}",
|
|
(childagentYN ? "child" : "root"), agentID, RegionInfo.RegionName);
|
|
|
|
if (avatar.IsChildAgent)
|
|
{
|
|
m_innerScene.removeUserCount(false);
|
|
}
|
|
else
|
|
{
|
|
m_innerScene.removeUserCount(true);
|
|
m_sceneGridService.LogOffUser(agentID, RegionInfo.RegionID, RegionInfo.RegionHandle, avatar.AbsolutePosition, avatar.Lookat);
|
|
List<ulong> childknownRegions = new List<ulong>();
|
|
List<ulong> ckn = avatar.GetKnownRegionList();
|
|
for (int i = 0; i < ckn.Count; i++)
|
|
{
|
|
childknownRegions.Add(ckn[i]);
|
|
}
|
|
m_sceneGridService.SendCloseChildAgentConnections(agentID, childknownRegions);
|
|
|
|
RemoveCapsHandler(agentID);
|
|
|
|
CommsManager.UserProfileCacheService.RemoveUser(agentID);
|
|
}
|
|
|
|
m_eventManager.TriggerClientClosed(agentID);
|
|
}
|
|
catch (NullReferenceException)
|
|
{
|
|
// We don't know which count to remove it from
|
|
// Avatar is already disposed :/
|
|
}
|
|
|
|
m_eventManager.TriggerOnRemovePresence(agentID);
|
|
Broadcast(delegate(IClientAPI client)
|
|
{
|
|
try
|
|
{
|
|
client.SendKillObject(avatar.RegionHandle, avatar.LocalId);
|
|
}
|
|
catch (NullReferenceException)
|
|
{
|
|
//We can safely ignore null reference exceptions. It means the avatar are dead and cleaned up anyway.
|
|
}
|
|
});
|
|
|
|
ForEachScenePresence(
|
|
delegate(ScenePresence presence) { presence.CoarseLocationChange(); });
|
|
|
|
IAgentAssetTransactions agentTransactions = this.RequestModuleInterface<IAgentAssetTransactions>();
|
|
if (agentTransactions != null)
|
|
{
|
|
agentTransactions.RemoveAgentAssetTransactions(agentID);
|
|
}
|
|
|
|
m_innerScene.RemoveScenePresence(agentID);
|
|
|
|
try
|
|
{
|
|
avatar.Close();
|
|
}
|
|
catch (NullReferenceException)
|
|
{
|
|
//We can safely ignore null reference exceptions. It means the avatar are dead and cleaned up anyway.
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Error("[SCENE] Scene.cs:RemoveClient exception: " + e.ToString());
|
|
}
|
|
|
|
// Remove client agent from profile, so new logins will work
|
|
if (!childagentYN)
|
|
{
|
|
m_sceneGridService.ClearUserAgent(agentID);
|
|
}
|
|
|
|
//m_log.InfoFormat("[SCENE] Memory pre GC {0}", System.GC.GetTotalMemory(false));
|
|
//m_log.InfoFormat("[SCENE] Memory post GC {0}", System.GC.GetTotalMemory(true));
|
|
}
|
|
|
|
public void HandleRemoveKnownRegionsFromAvatar(UUID avatarID, List<ulong> regionslst)
|
|
{
|
|
ScenePresence av = GetScenePresence(avatarID);
|
|
if (av != null)
|
|
{
|
|
lock (av)
|
|
{
|
|
|
|
for (int i = 0; i < regionslst.Count; i++)
|
|
{
|
|
av.KnownChildRegions.Remove(regionslst[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void CloseAllAgents(uint circuitcode)
|
|
{
|
|
// Called by ClientView to kill all circuit codes
|
|
ClientManager.CloseAllAgents(circuitcode);
|
|
}
|
|
|
|
public void NotifyMyCoarseLocationChange()
|
|
{
|
|
ForEachScenePresence(delegate(ScenePresence presence) { presence.CoarseLocationChange(); });
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Entities
|
|
|
|
public void SendKillObject(uint localID)
|
|
{
|
|
SceneObjectPart part = GetSceneObjectPart(localID);
|
|
if (part != null) // It is a prim
|
|
{
|
|
if (part.ParentGroup != null && part.ParentGroup.RootPart != null) // Valid
|
|
{
|
|
if (part.ParentGroup.RootPart != part) // Child part
|
|
return;
|
|
}
|
|
}
|
|
Broadcast(delegate(IClientAPI client) { client.SendKillObject(m_regionHandle, localID); });
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RegionComms
|
|
|
|
/// <summary>
|
|
/// Register the methods that should be invoked when this scene receives various incoming events
|
|
/// </summary>
|
|
public void RegisterCommsEvents()
|
|
{
|
|
m_sceneGridService.OnExpectUser += NewUserConnection;
|
|
m_sceneGridService.OnAvatarCrossingIntoRegion += AgentCrossing;
|
|
m_sceneGridService.OnCloseAgentConnection += CloseConnection;
|
|
m_sceneGridService.OnRegionUp += OtherRegionUp;
|
|
m_sceneGridService.OnChildAgentUpdate += IncomingChildAgentDataUpdate;
|
|
m_sceneGridService.OnExpectPrim += IncomingInterRegionPrimGroup;
|
|
m_sceneGridService.OnRemoveKnownRegionFromAvatar += HandleRemoveKnownRegionsFromAvatar;
|
|
m_sceneGridService.OnLogOffUser += HandleLogOffUserFromGrid;
|
|
m_sceneGridService.KiPrimitive += SendKillObject;
|
|
m_sceneGridService.OnGetLandData += GetLandData;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public void UnRegisterRegionWithComms()
|
|
{
|
|
m_sceneGridService.KiPrimitive -= SendKillObject;
|
|
m_sceneGridService.OnLogOffUser -= HandleLogOffUserFromGrid;
|
|
m_sceneGridService.OnRemoveKnownRegionFromAvatar -= HandleRemoveKnownRegionsFromAvatar;
|
|
m_sceneGridService.OnExpectPrim -= IncomingInterRegionPrimGroup;
|
|
m_sceneGridService.OnChildAgentUpdate -= IncomingChildAgentDataUpdate;
|
|
m_sceneGridService.OnRegionUp -= OtherRegionUp;
|
|
m_sceneGridService.OnExpectUser -= NewUserConnection;
|
|
m_sceneGridService.OnAvatarCrossingIntoRegion -= AgentCrossing;
|
|
m_sceneGridService.OnCloseAgentConnection -= CloseConnection;
|
|
m_sceneGridService.OnGetLandData -= GetLandData;
|
|
|
|
m_sceneGridService.Close();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Do the work necessary to initiate a new user connection for a particular scene.
|
|
/// At the moment, this consists of setting up the caps infrastructure
|
|
/// </summary>
|
|
/// <param name="regionHandle"></param>
|
|
/// <param name="agent"></param>
|
|
public void NewUserConnection(ulong regionHandle, AgentCircuitData agent)
|
|
{
|
|
if (regionHandle == m_regInfo.RegionHandle)
|
|
{
|
|
if (m_regInfo.EstateSettings.IsBanned(agent.AgentID))
|
|
{
|
|
m_log.WarnFormat(
|
|
"[CONNECTION DEBUGGING]: Denied access to: {0} [{1}] at {2} because the user is on the region banlist",
|
|
agent.AgentID, regionHandle, RegionInfo.RegionName);
|
|
}
|
|
|
|
capsPaths[agent.AgentID] = agent.CapsPath;
|
|
|
|
if (!agent.child)
|
|
{
|
|
AddCapsHandler(agent.AgentID);
|
|
|
|
// Honor parcel landing type and position.
|
|
ILandObject land = LandChannel.GetLandObject(agent.startpos.X, agent.startpos.Y);
|
|
if (land != null)
|
|
{
|
|
if (land.landData.LandingType == (byte)1 && land.landData.UserLocation != Vector3.Zero)
|
|
{
|
|
agent.startpos = land.landData.UserLocation;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_authenticateHandler.AddNewCircuit(agent.circuitcode, agent);
|
|
// rewrite session_id
|
|
CachedUserInfo userinfo = CommsManager.UserProfileCacheService.GetUserDetails(agent.AgentID);
|
|
if (userinfo != null)
|
|
{
|
|
userinfo.SessionID = agent.SessionID;
|
|
}
|
|
else
|
|
{
|
|
m_log.WarnFormat("[USERINFO CACHE]: We couldn't find a User Info record for {0}. This is usually an indication that the UUID we're looking up is invalid", agent.AgentID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.WarnFormat(
|
|
"[CONNECTION DEBUGGING]: Skipping this region for welcoming avatar {0} [{1}] at {2}",
|
|
agent.AgentID, regionHandle, RegionInfo.RegionName);
|
|
}
|
|
}
|
|
|
|
public void UpdateCircuitData(AgentCircuitData data)
|
|
{
|
|
m_authenticateHandler.UpdateAgentData(data);
|
|
}
|
|
|
|
public bool ChangeCircuitCode(uint oldcc, uint newcc)
|
|
{
|
|
return m_authenticateHandler.TryChangeCiruitCode(oldcc, newcc);
|
|
}
|
|
|
|
protected void HandleLogOffUserFromGrid(ulong regionHandle, UUID AvatarID, UUID RegionSecret, string message)
|
|
{
|
|
if (RegionInfo.RegionHandle == regionHandle)
|
|
{
|
|
ScenePresence loggingOffUser = null;
|
|
loggingOffUser = GetScenePresence(AvatarID);
|
|
if (loggingOffUser != null)
|
|
{
|
|
if (RegionSecret == loggingOffUser.ControllingClient.SecureSessionId)
|
|
{
|
|
loggingOffUser.ControllingClient.Kick(message);
|
|
// Give them a second to receive the message!
|
|
System.Threading.Thread.Sleep(1000);
|
|
loggingOffUser.ControllingClient.Close(true);
|
|
}
|
|
else
|
|
{
|
|
m_log.Info("[USERLOGOFF]: System sending the LogOff user message failed to sucessfully authenticate");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_log.InfoFormat("[USERLOGOFF]: Got a logoff request for {0} but the user isn't here. The user might already have been logged out", AvatarID.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a caps handler for the given agent. If the CAPS handler already exists for this agent,
|
|
/// then it is replaced by a new CAPS handler.
|
|
///
|
|
/// FIXME: On login this is called twice, once for the login and once when the connection is made.
|
|
/// This is somewhat innefficient and should be fixed. The initial login creation is necessary
|
|
/// since the client asks for capabilities immediately after being informed of the seed.
|
|
/// </summary>
|
|
/// <param name="agentId"></param>
|
|
/// <param name="capsObjectPath"></param>
|
|
public void AddCapsHandler(UUID agentId)
|
|
{
|
|
if (RegionInfo.EstateSettings.IsBanned(agentId))
|
|
return;
|
|
String capsObjectPath = GetCapsPath(agentId);
|
|
|
|
m_log.DebugFormat(
|
|
"[CAPS]: Setting up CAPS handler for root agent {0} in {1}",
|
|
agentId, RegionInfo.RegionName);
|
|
|
|
Caps cap =
|
|
new Caps(AssetCache, m_httpListener, m_regInfo.ExternalHostName, m_httpListener.Port,
|
|
capsObjectPath, agentId, m_dumpAssetsToFile, RegionInfo.RegionName);
|
|
cap.RegisterHandlers();
|
|
|
|
EventManager.TriggerOnRegisterCaps(agentId, cap);
|
|
|
|
cap.AddNewInventoryItem = AddUploadedInventoryItem;
|
|
cap.ItemUpdatedCall = CapsUpdateInventoryItemAsset;
|
|
cap.TaskScriptUpdatedCall = CapsUpdateTaskInventoryScriptAsset;
|
|
cap.CAPSFetchInventoryDescendents = CommsManager.UserProfileCacheService.HandleFetchInventoryDescendentsCAPS;
|
|
cap.GetClient = m_innerScene.GetControllingClient;
|
|
m_capsHandlers[agentId] = cap;
|
|
}
|
|
|
|
public Caps GetCapsHandlerForUser(UUID agentId)
|
|
{
|
|
lock (m_capsHandlers)
|
|
{
|
|
if (m_capsHandlers.ContainsKey(agentId))
|
|
{
|
|
return m_capsHandlers[agentId];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove the caps handler for a given agent.
|
|
/// </summary>
|
|
/// <param name="agentId"></param>
|
|
public void RemoveCapsHandler(UUID agentId)
|
|
{
|
|
lock (m_capsHandlers)
|
|
{
|
|
if (m_capsHandlers.ContainsKey(agentId))
|
|
{
|
|
m_log.DebugFormat(
|
|
"[CAPS]: Removing CAPS handler for root agent {0} in {1}",
|
|
agentId, RegionInfo.RegionName);
|
|
|
|
m_capsHandlers[agentId].DeregisterHandlers();
|
|
EventManager.TriggerOnDeregisterCaps(agentId, m_capsHandlers[agentId]);
|
|
|
|
m_capsHandlers.Remove(agentId);
|
|
}
|
|
else
|
|
{
|
|
m_log.WarnFormat(
|
|
"[CAPS]: Received request to remove CAPS handler for root agent {0} in {1}, but no such CAPS handler found!",
|
|
agentId, RegionInfo.RegionName);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="regionHandle"></param>
|
|
/// <param name="agentID"></param>
|
|
/// <param name="position"></param>
|
|
/// <param name="isFlying"></param>
|
|
public virtual void AgentCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isFlying)
|
|
{
|
|
if (regionHandle == m_regInfo.RegionHandle)
|
|
{
|
|
lock (m_scenePresences)
|
|
{
|
|
if (m_scenePresences.ContainsKey(agentID))
|
|
{
|
|
try
|
|
{
|
|
m_scenePresences[agentID].MakeRootAgent(position, isFlying);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Info("[SCENE]: Unable to do Agent Crossing.");
|
|
m_log.Debug("[SCENE]: " + e.ToString());
|
|
}
|
|
//m_innerScene.SwapRootChildAgent(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool IncomingChildAgentDataUpdate(ulong regionHandle, ChildAgentDataUpdate cAgentData)
|
|
{
|
|
ScenePresence childAgentUpdate = GetScenePresence(new UUID(cAgentData.AgentID));
|
|
if (childAgentUpdate != null)
|
|
{
|
|
// I can't imagine *yet* why we would get an update if the agent is a root agent..
|
|
// however to avoid a race condition crossing borders..
|
|
if (childAgentUpdate.IsChildAgent)
|
|
{
|
|
uint rRegionX = (uint)(cAgentData.regionHandle >> 40);
|
|
uint rRegionY = (((uint)(cAgentData.regionHandle)) >> 8);
|
|
uint tRegionX = RegionInfo.RegionLocX;
|
|
uint tRegionY = RegionInfo.RegionLocY;
|
|
//Send Data to ScenePresence
|
|
childAgentUpdate.ChildAgentDataUpdate(cAgentData, tRegionX, tRegionY, rRegionX, rRegionY);
|
|
// Not Implemented:
|
|
//TODO: Do we need to pass the message on to one of our neighbors?
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tell a single agent to disconnect from the region.
|
|
/// </summary>
|
|
/// <param name="regionHandle"></param>
|
|
/// <param name="agentID"></param>
|
|
public bool CloseConnection(ulong regionHandle, UUID agentID)
|
|
{
|
|
if (regionHandle == m_regionHandle)
|
|
{
|
|
ScenePresence presence = m_innerScene.GetScenePresence(agentID);
|
|
if (presence != null)
|
|
{
|
|
// Nothing is removed here, so down count it as such
|
|
// if (presence.IsChildAgent)
|
|
// {
|
|
// m_innerScene.removeUserCount(false);
|
|
// }
|
|
// else
|
|
// {
|
|
// m_innerScene.removeUserCount(true);
|
|
// }
|
|
|
|
// Tell a single agent to disconnect from the region.
|
|
presence.ControllingClient.SendShutdownConnectionNotice();
|
|
|
|
presence.ControllingClient.Close(true);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tell neighboring regions about this agent
|
|
/// When the regions respond with a true value,
|
|
/// tell the agents about the region.
|
|
///
|
|
/// We have to tell the regions about the agents first otherwise it'll deny them access
|
|
///
|
|
/// </summary>
|
|
/// <param name="presence"></param>
|
|
public void InformClientOfNeighbours(ScenePresence presence)
|
|
{
|
|
m_sceneGridService.EnableNeighbourChildAgents(presence, m_neighbours);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tell a neighboring region about this agent
|
|
/// </summary>
|
|
/// <param name="presence"></param>
|
|
/// <param name="region"></param>
|
|
public void InformClientOfNeighbor(ScenePresence presence, RegionInfo region)
|
|
{
|
|
m_sceneGridService.InformNeighborChildAgent(presence, region, m_neighbours);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Requests information about this region from gridcomms
|
|
/// </summary>
|
|
/// <param name="regionHandle"></param>
|
|
/// <returns></returns>
|
|
public RegionInfo RequestNeighbouringRegionInfo(ulong regionHandle)
|
|
{
|
|
return m_sceneGridService.RequestNeighbouringRegionInfo(regionHandle);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Requests textures for map from minimum region to maximum region in world cordinates
|
|
/// </summary>
|
|
/// <param name="remoteClient"></param>
|
|
/// <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)
|
|
{
|
|
m_log.InfoFormat("[MAPBLOCK]: {0}-{1}, {2}-{3}", minX, minY, maxX, maxY);
|
|
m_sceneGridService.RequestMapBlocks(remoteClient, minX, minY, maxX, maxY);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to teleport agent to other region.
|
|
/// </summary>
|
|
/// <param name="remoteClient"></param>
|
|
/// <param name="regionName"></param>
|
|
/// <param name="position"></param>
|
|
/// <param name="lookAt"></param>
|
|
/// <param name="teleportFlags"></param>
|
|
public void RequestTeleportLocation(IClientAPI remoteClient, string regionName, Vector3 position,
|
|
Vector3 lookat, uint teleportFlags)
|
|
{
|
|
RegionInfo regionInfo = m_sceneGridService.RequestClosestRegion(regionName);
|
|
if (regionInfo == null)
|
|
{
|
|
// can't find the region: Tell viewer and abort
|
|
remoteClient.SendTeleportFailed("The region '" + regionName + "' could not be found.");
|
|
return;
|
|
}
|
|
RequestTeleportLocation(remoteClient, regionInfo.RegionHandle, position, lookat, teleportFlags);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to teleport agent to other region.
|
|
/// </summary>
|
|
/// <param name="remoteClient"></param>
|
|
/// <param name="regionHandle"></param>
|
|
/// <param name="position"></param>
|
|
/// <param name="lookAt"></param>
|
|
/// <param name="teleportFlags"></param>
|
|
public void RequestTeleportLocation(IClientAPI remoteClient, ulong regionHandle, Vector3 position,
|
|
Vector3 lookAt, uint teleportFlags)
|
|
{
|
|
lock (m_scenePresences)
|
|
{
|
|
if (m_scenePresences.ContainsKey(remoteClient.AgentId))
|
|
{
|
|
m_sceneGridService.RequestTeleportToLocation(m_scenePresences[remoteClient.AgentId], regionHandle,
|
|
position, lookAt, teleportFlags);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to teleport agent to landmark.
|
|
/// </summary>
|
|
/// <param name="remoteClient"></param>
|
|
/// <param name="regionHandle"></param>
|
|
/// <param name="position"></param>
|
|
public void RequestTeleportLandmark(IClientAPI remoteClient, UUID regionID, Vector3 position)
|
|
{
|
|
RegionInfo info = CommsManager.GridService.RequestNeighbourInfo(regionID);
|
|
|
|
if (info == null)
|
|
{
|
|
// can't find the region: Tell viewer and abort
|
|
remoteClient.SendTeleportFailed("The teleport destination could not be found.");
|
|
return;
|
|
}
|
|
|
|
lock (m_scenePresences)
|
|
{
|
|
if (m_scenePresences.ContainsKey(remoteClient.AgentId))
|
|
{
|
|
m_sceneGridService.RequestTeleportToLocation(m_scenePresences[remoteClient.AgentId], info.RegionHandle,
|
|
position, Vector3.Zero, (uint)(TPFlags.SetLastToTarget | TPFlags.ViaLandmark));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Agent is crossing the border into a neighbouring region. Tell the neighbour about it!
|
|
/// </summary>
|
|
/// <param name="regionHandle"></param>
|
|
/// <param name="agentID"></param>
|
|
/// <param name="position"></param>
|
|
/// <param name="isFlying"></param>
|
|
/// <returns></returns>
|
|
public bool InformNeighbourOfCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isFlying)
|
|
{
|
|
return m_sceneGridService.CrossToNeighbouringRegion(regionHandle, agentID, position, isFlying);
|
|
}
|
|
|
|
public void SendOutChildAgentUpdates(ChildAgentDataUpdate cadu, ScenePresence presence)
|
|
{
|
|
m_sceneGridService.SendChildAgentDataUpdate(cadu, presence);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Module Methods
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="module"></param>
|
|
public void AddModule(string name, IRegionModule module)
|
|
{
|
|
if (!Modules.ContainsKey(name))
|
|
{
|
|
Modules.Add(name, module);
|
|
}
|
|
}
|
|
|
|
public void RegisterModuleCommander(string name, ICommander commander)
|
|
{
|
|
lock (m_moduleCommanders)
|
|
{
|
|
m_moduleCommanders.Add(name, commander);
|
|
}
|
|
}
|
|
|
|
public ICommander GetCommander(string name)
|
|
{
|
|
lock (m_moduleCommanders)
|
|
{
|
|
return m_moduleCommanders[name];
|
|
}
|
|
}
|
|
|
|
public Dictionary<string, ICommander> GetCommanders()
|
|
{
|
|
return m_moduleCommanders;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register an interface to a region module. This allows module methods to be called directly as
|
|
/// well as via events. If there is already a module registered for this interface, it is not replaced
|
|
/// (is this the best behaviour?)
|
|
/// </summary>
|
|
/// <param name="mod"></param>
|
|
public void RegisterModuleInterface<M>(M mod)
|
|
{
|
|
if (!ModuleInterfaces.ContainsKey(typeof(M)))
|
|
{
|
|
List<Object> l = new List<Object>();
|
|
l.Add(mod);
|
|
ModuleInterfaces.Add(typeof(M), l);
|
|
}
|
|
}
|
|
|
|
public void StackModuleInterface<M>(M mod)
|
|
{
|
|
List<Object> l;
|
|
if (ModuleInterfaces.ContainsKey(typeof(M)))
|
|
l = ModuleInterfaces[typeof(M)];
|
|
else
|
|
l = new List<Object>();
|
|
|
|
if (l.Contains(mod))
|
|
return;
|
|
|
|
l.Add(mod);
|
|
ModuleInterfaces[typeof(M)] = l;
|
|
}
|
|
|
|
/// <summary>
|
|
/// For the given interface, retrieve the region module which implements it.
|
|
/// </summary>
|
|
/// <returns>null if there is no module implementing that interface</returns>
|
|
public override T RequestModuleInterface<T>()
|
|
{
|
|
if (ModuleInterfaces.ContainsKey(typeof(T)))
|
|
{
|
|
return (T)ModuleInterfaces[typeof(T)][0];
|
|
}
|
|
else
|
|
{
|
|
return default(T);
|
|
}
|
|
}
|
|
|
|
public override T[] RequestModuleInterfaces<T>()
|
|
{
|
|
if (ModuleInterfaces.ContainsKey(typeof(T)))
|
|
{
|
|
List<T> ret = new List<T>();
|
|
|
|
foreach (Object o in ModuleInterfaces[typeof(T)])
|
|
ret.Add((T)o);
|
|
return ret.ToArray();
|
|
}
|
|
else
|
|
{
|
|
return new T[] { default(T) };
|
|
}
|
|
}
|
|
|
|
public void SetObjectCapacity(int objects)
|
|
{
|
|
if (m_statsReporter != null)
|
|
{
|
|
m_statsReporter.SetObjectCapacity(objects);
|
|
}
|
|
objectCapacity = objects;
|
|
}
|
|
|
|
public List<FriendListItem> GetFriendList(UUID avatarID)
|
|
{
|
|
return CommsManager.GetUserFriendList(avatarID);
|
|
}
|
|
|
|
public Dictionary<UUID, FriendRegionInfo> GetFriendRegionInfos(List<UUID> uuids)
|
|
{
|
|
return CommsManager.GetFriendRegionInfos(uuids);
|
|
}
|
|
|
|
public List<UUID> InformFriendsInOtherRegion(UUID agentId, ulong destRegionHandle, List<UUID> friends, bool online)
|
|
{
|
|
return CommsManager.InformFriendsInOtherRegion(agentId, destRegionHandle, friends, online);
|
|
}
|
|
|
|
public bool TriggerTerminateFriend(ulong regionHandle, UUID agentID, UUID exFriendID)
|
|
{
|
|
return CommsManager.TriggerTerminateFriend(regionHandle, agentID, exFriendID);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Other Methods
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="phase"></param>
|
|
public void SetTimePhase(int phase)
|
|
{
|
|
m_timePhase = phase;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="avatarID"></param>
|
|
/// <param name="objectName"></param>
|
|
/// <param name="objectID"></param>
|
|
/// <param name="ownerID"></param>
|
|
/// <param name="groupOwned"></param>
|
|
/// <param name="message"></param>
|
|
/// <param name="url"></param>
|
|
public void SendUrlToUser(UUID avatarID, string objectName, UUID objectID, UUID ownerID, bool groupOwned,
|
|
string message, string url)
|
|
{
|
|
lock (m_scenePresences)
|
|
{
|
|
if (m_scenePresences.ContainsKey(avatarID))
|
|
{
|
|
m_scenePresences[avatarID].ControllingClient.SendLoadURL(objectName, objectID, ownerID, groupOwned,
|
|
message, url);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SendDialogToUser(UUID avatarID, string objectName, UUID objectID, UUID ownerID, string message, UUID TextureID, int ch, string[] buttonlabels)
|
|
{
|
|
lock (m_scenePresences)
|
|
{
|
|
if (m_scenePresences.ContainsKey(avatarID))
|
|
{
|
|
m_scenePresences[avatarID].ControllingClient.SendDialog(
|
|
objectName, objectID, ownerID, message, TextureID, ch, buttonlabels);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="url"></param>
|
|
/// <param name="type"></param>
|
|
/// <param name="body"></param>
|
|
/// <returns></returns>
|
|
public UUID MakeHttpRequest(string url, string type, string body)
|
|
{
|
|
if (m_httpRequestModule != null)
|
|
{
|
|
return m_httpRequestModule.MakeHttpRequest(url, type, body);
|
|
}
|
|
return UUID.Zero;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method is a way for the Friends Module to create an instant
|
|
/// message to the avatar and for Instant Messages that travel across
|
|
/// gridcomms to make it to the Instant Message Module.
|
|
///
|
|
/// Friendship establishment and groups are unfortunately tied with instant messaging and
|
|
/// there's no way to separate them completely.
|
|
/// </summary>
|
|
/// <param name="message">object containing the instant message data</param>
|
|
/// <returns>void</returns>
|
|
public void TriggerGridInstantMessage(GridInstantMessage message, InstantMessageReceiver options)
|
|
{
|
|
m_eventManager.TriggerGridInstantMessage(message, options);
|
|
}
|
|
|
|
public virtual void StoreAddFriendship(UUID ownerID, UUID friendID, uint perms)
|
|
{
|
|
// TODO: m_sceneGridService.DoStuff;
|
|
m_sceneGridService.AddNewUserFriend(ownerID, friendID, perms);
|
|
}
|
|
|
|
public virtual void StoreUpdateFriendship(UUID ownerID, UUID friendID, uint perms)
|
|
{
|
|
// TODO: m_sceneGridService.DoStuff;
|
|
m_sceneGridService.UpdateUserFriendPerms(ownerID, friendID, perms);
|
|
}
|
|
|
|
public virtual void StoreRemoveFriendship(UUID ownerID, UUID ExfriendID)
|
|
{
|
|
// TODO: m_sceneGridService.DoStuff;
|
|
m_sceneGridService.RemoveUserFriend(ownerID, ExfriendID);
|
|
}
|
|
|
|
public virtual List<FriendListItem> StoreGetFriendsForUser(UUID ownerID)
|
|
{
|
|
// TODO: m_sceneGridService.DoStuff;
|
|
return m_sceneGridService.GetUserFriendList(ownerID);
|
|
}
|
|
|
|
public void AddPacketStats(int inPackets, int outPackets, int unAckedBytes)
|
|
{
|
|
m_statsReporter.AddInPackets(inPackets);
|
|
m_statsReporter.AddOutPackets(outPackets);
|
|
m_statsReporter.AddunAckedBytes(unAckedBytes);
|
|
}
|
|
|
|
public void AddAgentTime(int ms)
|
|
{
|
|
m_statsReporter.addFrameMS(ms);
|
|
m_statsReporter.addAgentMS(ms);
|
|
}
|
|
|
|
public void AddAgentUpdates(int count)
|
|
{
|
|
m_statsReporter.AddAgentUpdates(count);
|
|
}
|
|
|
|
public void AddPendingDownloads(int count)
|
|
{
|
|
m_statsReporter.addPendingDownload(count);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Console Commands
|
|
|
|
#region Alert Methods
|
|
|
|
private void SendPermissionAlert(UUID user, string reason)
|
|
{
|
|
SendAlertToUser(user, reason, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send an alert messages to all avatars in this scene.
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
public void SendGeneralAlert(string message)
|
|
{
|
|
List<ScenePresence> presenceList = GetScenePresences();
|
|
|
|
foreach (ScenePresence presence in presenceList)
|
|
{
|
|
if (!presence.IsChildAgent)
|
|
presence.ControllingClient.SendAlertMessage(message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send an alert message to a particular agent.
|
|
/// </summary>
|
|
/// <param name="agentID"></param>
|
|
/// <param name="message"></param>
|
|
/// <param name="modal"></param>
|
|
public void SendAlertToUser(UUID agentID, string message, bool modal)
|
|
{
|
|
lock (m_scenePresences)
|
|
{
|
|
if (m_scenePresences.ContainsKey(agentID))
|
|
{
|
|
m_scenePresences[agentID].ControllingClient.SendAgentAlertMessage(message, modal);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle a request for admin rights
|
|
/// </summary>
|
|
/// <param name="agentID"></param>
|
|
/// <param name="sessionID"></param>
|
|
/// <param name="token"></param>
|
|
/// <param name="controllingClient"></param>
|
|
public void handleRequestGodlikePowers(UUID agentID, UUID sessionID, UUID token, bool godLike,
|
|
IClientAPI controllingClient)
|
|
{
|
|
lock (m_scenePresences)
|
|
{
|
|
// User needs to be logged into this sim
|
|
if (m_scenePresences.ContainsKey(agentID))
|
|
{
|
|
if (godLike == false)
|
|
{
|
|
m_scenePresences[agentID].GrantGodlikePowers(agentID, sessionID, token, godLike);
|
|
return;
|
|
}
|
|
|
|
// First check that this is the sim owner
|
|
if (ExternalChecks.ExternalChecksCanBeGodLike(agentID))
|
|
{
|
|
// Next we check for spoofing.....
|
|
UUID testSessionID = m_scenePresences[agentID].ControllingClient.SessionId;
|
|
if (sessionID == testSessionID)
|
|
{
|
|
if (sessionID == controllingClient.SessionId)
|
|
{
|
|
//m_log.Info("godlike: " + godLike.ToString());
|
|
m_scenePresences[agentID].GrantGodlikePowers(agentID, testSessionID, token, godLike);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_scenePresences[agentID].ControllingClient.SendAgentAlertMessage("Request for god powers denied", false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sends a Big Blue Box message on the upper right of the screen to the client
|
|
/// for all agents in the region
|
|
/// </summary>
|
|
/// <param name="FromAvatarID">The person sending the message</param>
|
|
/// <param name="fromSessionID">The session of the person sending the message</param>
|
|
/// <param name="FromAvatarName">The name of the person doing the sending</param>
|
|
/// <param name="Message">The Message being sent to the user</param>
|
|
public void SendRegionMessageFromEstateTools(UUID FromAvatarID, UUID fromSessionID, String FromAvatarName, String Message)
|
|
{
|
|
List<ScenePresence> presenceList = GetScenePresences();
|
|
|
|
foreach (ScenePresence presence in presenceList)
|
|
{
|
|
if (!presence.IsChildAgent)
|
|
presence.ControllingClient.SendBlueBoxMessage(FromAvatarID, FromAvatarName, Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sends a Big Blue Box message on the upper right of the screen to the client
|
|
/// for all agents in the estate
|
|
/// </summary>
|
|
/// <param name="FromAvatarID">The person sending the message</param>
|
|
/// <param name="fromSessionID">The session of the person sending the message</param>
|
|
/// <param name="FromAvatarName">The name of the person doing the sending</param>
|
|
/// <param name="Message">The Message being sent to the user</param>
|
|
public void SendEstateMessageFromEstateTools(UUID FromAvatarID, UUID fromSessionID, String FromAvatarName, String Message)
|
|
{
|
|
|
|
ClientManager.ForEachClient(delegate(IClientAPI controller)
|
|
{
|
|
controller.SendBlueBoxMessage(FromAvatarID, FromAvatarName, Message);
|
|
}
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Kicks User specified from the simulator. This logs them off of the grid
|
|
/// If the client gets the UUID: 44e87126e7944ded05b37c42da3d5cdb it assumes
|
|
/// that you're kicking it even if the avatar's UUID isn't the UUID that the
|
|
/// agent is assigned
|
|
/// </summary>
|
|
/// <param name="godID">The person doing the kicking</param>
|
|
/// <param name="sessionID">The session of the person doing the kicking</param>
|
|
/// <param name="agentID">the person that is being kicked</param>
|
|
/// <param name="kickflags">This isn't used apparently</param>
|
|
/// <param name="reason">The message to send to the user after it's been turned into a field</param>
|
|
public void HandleGodlikeKickUser(UUID godID, UUID sessionID, UUID agentID, uint kickflags, byte[] reason)
|
|
{
|
|
// For some reason the client sends this seemingly hard coded UUID for kicking everyone. Dun-know.
|
|
UUID kickUserID = new UUID("44e87126e7944ded05b37c42da3d5cdb");
|
|
lock (m_scenePresences)
|
|
{
|
|
if (m_scenePresences.ContainsKey(agentID) || agentID == kickUserID)
|
|
{
|
|
if (ExternalChecks.ExternalChecksCanBeGodLike(godID))
|
|
{
|
|
if (agentID == kickUserID)
|
|
{
|
|
ClientManager.ForEachClient(delegate(IClientAPI controller)
|
|
{
|
|
if (controller.AgentId != godID)
|
|
controller.Kick(Utils.BytesToString(reason));
|
|
}
|
|
);
|
|
|
|
// This is a bit crude. It seems the client will be null before it actually stops the thread
|
|
// The thread will kill itself eventually :/
|
|
// Is there another way to make sure *all* clients get this 'inter region' message?
|
|
ClientManager.ForEachClient(delegate(IClientAPI controller)
|
|
{
|
|
ScenePresence p = GetScenePresence(controller.AgentId);
|
|
bool childagent = p != null && p.IsChildAgent;
|
|
if (controller.AgentId != godID && !childagent)
|
|
// Do we really want to kick the initiator of this madness?
|
|
{
|
|
controller.Close(true);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
else
|
|
{
|
|
m_innerScene.removeUserCount(!m_scenePresences[agentID].IsChildAgent);
|
|
|
|
m_scenePresences[agentID].ControllingClient.Kick(Utils.BytesToString(reason));
|
|
m_scenePresences[agentID].ControllingClient.Close(true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_scenePresences.ContainsKey(godID))
|
|
m_scenePresences[godID].ControllingClient.SendAgentAlertMessage("Kick request denied", false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void HandleObjectPermissionsUpdate(IClientAPI controller, UUID agentID, UUID sessionID, byte field, uint localId, uint mask, byte set)
|
|
{
|
|
// Check for spoofing.. since this is permissions we're talking about here!
|
|
if ((controller.SessionId == sessionID) && (controller.AgentId == agentID))
|
|
{
|
|
// Tell the object to do permission update
|
|
if (localId != 0)
|
|
{
|
|
SceneObjectGroup chObjectGroup = GetGroupByPrim(localId);
|
|
if (chObjectGroup != null)
|
|
{
|
|
chObjectGroup.UpdatePermissions(agentID, field, localId, mask, set);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="firstName"></param>
|
|
/// <param name="lastName"></param>
|
|
/// <param name="message"></param>
|
|
/// <param name="modal"></param>
|
|
public void SendAlertToUser(string firstName, string lastName, string message, bool modal)
|
|
{
|
|
List<ScenePresence> presenceList = GetScenePresences();
|
|
|
|
foreach (ScenePresence presence in presenceList)
|
|
{
|
|
if (presence.Firstname == firstName && presence.Lastname == lastName)
|
|
{
|
|
presence.ControllingClient.SendAgentAlertMessage(message, modal);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle an alert command from the console.
|
|
/// FIXME: Command parsing code really shouldn't be in this core Scene class.
|
|
/// </summary>
|
|
/// <param name="commandParams"></param>
|
|
public void HandleAlertCommand(string[] commandParams)
|
|
{
|
|
if (commandParams[0] == "general")
|
|
{
|
|
string message = CombineParams(commandParams, 1);
|
|
SendGeneralAlert(message);
|
|
}
|
|
else
|
|
{
|
|
string message = CombineParams(commandParams, 2);
|
|
SendAlertToUser(commandParams[0], commandParams[1], message, false);
|
|
}
|
|
}
|
|
|
|
private string CombineParams(string[] commandParams, int pos)
|
|
{
|
|
string result = String.Empty;
|
|
for (int i = pos; i < commandParams.Length; i++)
|
|
{
|
|
result += commandParams[i] + " ";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Causes all clients to get a full object update on all of the objects in the scene.
|
|
/// </summary>
|
|
public void ForceClientUpdate()
|
|
{
|
|
List<EntityBase> EntityList = GetEntities();
|
|
|
|
foreach (EntityBase ent in EntityList)
|
|
{
|
|
if (ent is SceneObjectGroup)
|
|
{
|
|
((SceneObjectGroup)ent).ScheduleGroupForFullUpdate();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This is currently only used for scale (to scale to MegaPrim size)
|
|
/// There is a console command that calls this in OpenSimMain
|
|
/// </summary>
|
|
/// <param name="cmdparams"></param>
|
|
public void HandleEditCommand(string[] cmdparams)
|
|
{
|
|
Console.WriteLine("Searching for Primitive: '" + cmdparams[0] + "'");
|
|
|
|
List<EntityBase> EntityList = GetEntities();
|
|
|
|
foreach (EntityBase ent in EntityList)
|
|
{
|
|
if (ent is SceneObjectGroup)
|
|
{
|
|
SceneObjectPart part = ((SceneObjectGroup)ent).GetChildPart(((SceneObjectGroup)ent).UUID);
|
|
if (part != null)
|
|
{
|
|
if (part.Name == cmdparams[0])
|
|
{
|
|
part.Resize(
|
|
new Vector3(Convert.ToSingle(cmdparams[1]), Convert.ToSingle(cmdparams[2]),
|
|
Convert.ToSingle(cmdparams[3])));
|
|
|
|
Console.WriteLine("Edited scale of Primitive: " + part.Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shows various details about the sim based on the parameters supplied by the console command in openSimMain.
|
|
/// </summary>
|
|
/// <param name="showParams">What to show</param>
|
|
public void Show(string[] showParams)
|
|
{
|
|
switch (showParams[0])
|
|
{
|
|
case "users":
|
|
m_log.Error("Current Region: " + RegionInfo.RegionName);
|
|
m_log.ErrorFormat("{0,-16}{1,-16}{2,-25}{3,-25}{4,-16}{5,-16}{6,-16}", "Firstname", "Lastname",
|
|
"Agent ID", "Session ID", "Circuit", "IP", "World");
|
|
|
|
foreach (ScenePresence scenePresence in GetAvatars())
|
|
{
|
|
m_log.ErrorFormat("{0,-16}{1,-16}{2,-25}{3,-25}{4,-16},{5,-16}{6,-16}",
|
|
scenePresence.Firstname,
|
|
scenePresence.Lastname,
|
|
scenePresence.UUID,
|
|
scenePresence.ControllingClient.AgentId,
|
|
"Unknown",
|
|
"Unknown",
|
|
RegionInfo.RegionName);
|
|
}
|
|
break;
|
|
case "modules":
|
|
m_log.Error("The currently loaded modules in " + RegionInfo.RegionName + " are:");
|
|
foreach (IRegionModule module in Modules.Values)
|
|
{
|
|
if (!module.IsSharedModule)
|
|
{
|
|
m_log.Error("Region Module: " + module.Name);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Script Handling Methods
|
|
|
|
/// <summary>
|
|
/// Console command handler to send script command to script engine.
|
|
/// </summary>
|
|
/// <param name="args"></param>
|
|
public void SendCommandToPlugins(string[] args)
|
|
{
|
|
m_eventManager.TriggerOnPluginConsole(args);
|
|
}
|
|
|
|
public double GetLandHeight(int x, int y)
|
|
{
|
|
return Heightmap[x, y];
|
|
}
|
|
|
|
public UUID GetLandOwner(float x, float y)
|
|
{
|
|
ILandObject land = LandChannel.GetLandObject(x, y);
|
|
if (land == null)
|
|
{
|
|
return UUID.Zero;
|
|
}
|
|
else
|
|
{
|
|
return land.landData.OwnerID;
|
|
}
|
|
}
|
|
|
|
public LandData GetLandData(float x, float y)
|
|
{
|
|
return LandChannel.GetLandObject(x, y).landData;
|
|
}
|
|
|
|
public LandData GetLandData(uint x, uint y)
|
|
{
|
|
m_log.DebugFormat("[SCENE] returning land for {0},{1}", x, y);
|
|
return LandChannel.GetLandObject((int)x, (int)y).landData;
|
|
}
|
|
|
|
public void SetLandMusicURL(float x, float y, string url)
|
|
{
|
|
ILandObject land = LandChannel.GetLandObject(x, y);
|
|
if (land == null)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
land.landData.MusicURL = url;
|
|
land.sendLandUpdateToAvatarsOverMe();
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void SetLandMediaURL(float x, float y, string url)
|
|
{
|
|
ILandObject land = LandChannel.GetLandObject(x, y);
|
|
|
|
if (land == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
else
|
|
{
|
|
land.landData.MediaURL = url;
|
|
land.sendLandUpdateToAvatarsOverMe();
|
|
return;
|
|
}
|
|
}
|
|
|
|
public RegionInfo RequestClosestRegion(string name)
|
|
{
|
|
return m_sceneGridService.RequestClosestRegion(name);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Script Engine
|
|
|
|
private List<ScriptEngineInterface> ScriptEngines = new List<ScriptEngineInterface>();
|
|
private bool m_dumpAssetsToFile;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="scriptEngine"></param>
|
|
public void AddScriptEngine(ScriptEngineInterface scriptEngine)
|
|
{
|
|
ScriptEngines.Add(scriptEngine);
|
|
scriptEngine.InitializeEngine(this);
|
|
}
|
|
|
|
public void TriggerObjectChanged(uint localID, uint change)
|
|
{
|
|
m_eventManager.TriggerOnScriptChangedEvent(localID, change);
|
|
}
|
|
|
|
public void TriggerAtTargetEvent(uint localID, uint handle, Vector3 targetpos, Vector3 currentpos)
|
|
{
|
|
m_eventManager.TriggerAtTargetEvent(localID, handle, targetpos, currentpos);
|
|
}
|
|
|
|
public void TriggerNotAtTargetEvent(uint localID)
|
|
{
|
|
m_eventManager.TriggerNotAtTargetEvent(localID);
|
|
}
|
|
|
|
private bool ScriptDanger(SceneObjectPart part,Vector3 pos)
|
|
{
|
|
ILandObject parcel = LandChannel.GetLandObject(pos.X, pos.Y);
|
|
if (part != null)
|
|
{
|
|
if (parcel != null)
|
|
{
|
|
if ((parcel.landData.Flags & (uint)Parcel.ParcelFlags.AllowOtherScripts) != 0)
|
|
{
|
|
return true;
|
|
}
|
|
else if ((parcel.landData.Flags & (uint)Parcel.ParcelFlags.AllowGroupScripts) != 0)
|
|
{
|
|
if (part.OwnerID == parcel.landData.OwnerID || (parcel.landData.IsGroupOwned && part.GroupID == parcel.landData.GroupID) || ExternalChecks.ExternalChecksCanBeGodLike(part.OwnerID))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (part.OwnerID == parcel.landData.OwnerID)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if (pos.X > 0f && pos.X < Constants.RegionSize && pos.Y > 0f && pos.Y < Constants.RegionSize)
|
|
{
|
|
// The only time parcel != null when an object is inside a region is when
|
|
// there is nothing behind the landchannel. IE, no land plugin loaded.
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// The object is outside of this region. Stop piping events to it.
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool ScriptDanger(uint localID, Vector3 pos)
|
|
{
|
|
SceneObjectPart part = GetSceneObjectPart(localID);
|
|
if (part != null)
|
|
{
|
|
return ScriptDanger(part, pos);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool PipeEventsForScript(uint localID)
|
|
{
|
|
SceneObjectPart part = GetSceneObjectPart(localID);
|
|
if (part != null)
|
|
{
|
|
// Changed so that child prims of attachments return ScriptDanger for their parent, so that
|
|
// their scripts will actually run.
|
|
// -- Leaf, Tue Aug 12 14:17:05 EDT 2008
|
|
SceneObjectPart parent = part.ParentGroup.RootPart;
|
|
if (parent != null && parent.IsAttachment)
|
|
return ScriptDanger(parent, parent.GetWorldPosition());
|
|
else
|
|
return ScriptDanger(part, part.GetWorldPosition());
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InnerScene wrapper methods
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="localID"></param>
|
|
/// <returns></returns>
|
|
public UUID ConvertLocalIDToFullID(uint localID)
|
|
{
|
|
return m_innerScene.ConvertLocalIDToFullID(localID);
|
|
}
|
|
|
|
public void SwapRootAgentCount(bool rootChildChildRootTF)
|
|
{
|
|
m_innerScene.SwapRootChildAgent(rootChildChildRootTF);
|
|
}
|
|
|
|
public void AddPhysicalPrim(int num)
|
|
{
|
|
m_innerScene.AddPhysicalPrim(num);
|
|
}
|
|
|
|
public void RemovePhysicalPrim(int num)
|
|
{
|
|
m_innerScene.RemovePhysicalPrim(num);
|
|
}
|
|
|
|
//The idea is to have a group of method that return a list of avatars meeting some requirement
|
|
// ie it could be all m_scenePresences within a certain range of the calling prim/avatar.
|
|
|
|
/// <summary>
|
|
/// Return a list of all avatars in this region.
|
|
/// This list is a new object, so it can be iterated over without locking.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ScenePresence> GetAvatars()
|
|
{
|
|
return m_innerScene.GetAvatars();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a list of all ScenePresences in this region. This returns child agents as well as root agents.
|
|
/// This list is a new object, so it can be iterated over without locking.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<ScenePresence> GetScenePresences()
|
|
{
|
|
return m_innerScene.GetScenePresences();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Request a filtered list of ScenePresences in this region.
|
|
/// This list is a new object, so it can be iterated over without locking.
|
|
/// </summary>
|
|
/// <param name="filter"></param>
|
|
/// <returns></returns>
|
|
public List<ScenePresence> GetScenePresences(FilterAvatarList filter)
|
|
{
|
|
return m_innerScene.GetScenePresences(filter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Request a scene presence by UUID
|
|
/// </summary>
|
|
/// <param name="avatarID"></param>
|
|
/// <returns></returns>
|
|
public ScenePresence GetScenePresence(UUID avatarID)
|
|
{
|
|
return m_innerScene.GetScenePresence(avatarID);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Request an Avatar's Child Status - used by ClientView when a 'kick everyone' or 'estate message' occurs
|
|
/// </summary>
|
|
/// <param name="avatarID">AvatarID to lookup</param>
|
|
/// <returns></returns>
|
|
public override bool PresenceChildStatus(UUID avatarID)
|
|
{
|
|
ScenePresence cp = GetScenePresence(avatarID);
|
|
return cp.IsChildAgent;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="action"></param>
|
|
public void ForEachScenePresence(Action<ScenePresence> action)
|
|
{
|
|
// We don't want to try to send messages if there are no avatars.
|
|
if (m_scenePresences != null)
|
|
{
|
|
try
|
|
{
|
|
List<ScenePresence> presenceList = GetScenePresences();
|
|
foreach (ScenePresence presence in presenceList)
|
|
{
|
|
action(presence);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Info("[BUG]: " + e.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="action"></param>
|
|
// public void ForEachObject(Action<SceneObjectGroup> action)
|
|
// {
|
|
// List<SceneObjectGroup> presenceList;
|
|
//
|
|
// lock (m_sceneObjects)
|
|
// {
|
|
// presenceList = new List<SceneObjectGroup>(m_sceneObjects.Values);
|
|
// }
|
|
//
|
|
// foreach (SceneObjectGroup presence in presenceList)
|
|
// {
|
|
// action(presence);
|
|
// }
|
|
// }
|
|
|
|
/// <summary>
|
|
/// Get a named prim contained in this scene (will return the first
|
|
/// found, if there are more than one prim with the same name)
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
public SceneObjectPart GetSceneObjectPart(string name)
|
|
{
|
|
return m_innerScene.GetSceneObjectPart(name);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a prim via its local id
|
|
/// </summary>
|
|
/// <param name="localID"></param>
|
|
/// <returns></returns>
|
|
public SceneObjectPart GetSceneObjectPart(uint localID)
|
|
{
|
|
return m_innerScene.GetSceneObjectPart(localID);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a prim via its UUID
|
|
/// </summary>
|
|
/// <param name="fullID"></param>
|
|
/// <returns></returns>
|
|
public SceneObjectPart GetSceneObjectPart(UUID fullID)
|
|
{
|
|
return m_innerScene.GetSceneObjectPart(fullID);
|
|
}
|
|
|
|
internal bool TryGetAvatar(UUID avatarId, out ScenePresence avatar)
|
|
{
|
|
return m_innerScene.TryGetAvatar(avatarId, out avatar);
|
|
}
|
|
|
|
internal bool TryGetAvatarByName(string avatarName, out ScenePresence avatar)
|
|
{
|
|
return m_innerScene.TryGetAvatarByName(avatarName, out avatar);
|
|
}
|
|
|
|
internal void ForEachClient(Action<IClientAPI> action)
|
|
{
|
|
m_innerScene.ForEachClient(action);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a list of the entities in the scene. This is a new list so operations perform on the list itself
|
|
/// will not affect the original list of objects in the scene.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<EntityBase> GetEntities()
|
|
{
|
|
return m_innerScene.GetEntities();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BaseHTTPServer wrapper methods
|
|
|
|
public bool AddHTTPHandler(string method, GenericHTTPMethod handler)
|
|
{
|
|
return m_httpListener.AddHTTPHandler(method, handler);
|
|
}
|
|
|
|
public bool AddXmlRPCHandler(string method, XmlRpcMethod handler)
|
|
{
|
|
return m_httpListener.AddXmlRPCHandler(method, handler);
|
|
}
|
|
|
|
public void AddStreamHandler(IRequestHandler handler)
|
|
{
|
|
m_httpListener.AddStreamHandler(handler);
|
|
}
|
|
|
|
public bool AddLLSDHandler(string path, LLSDMethod handler)
|
|
{
|
|
return m_httpListener.AddLLSDHandler(path, handler);
|
|
}
|
|
|
|
public void RemoveStreamHandler(string httpMethod, string path)
|
|
{
|
|
m_httpListener.RemoveStreamHandler(httpMethod, path);
|
|
}
|
|
|
|
public void RemoveHTTPHandler(string httpMethod, string path)
|
|
{
|
|
m_httpListener.RemoveHTTPHandler(httpMethod, path);
|
|
}
|
|
|
|
public bool RemoveLLSDHandler(string path, LLSDMethod handler)
|
|
{
|
|
return m_httpListener.RemoveLLSDHandler(path, handler);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Avatar Appearance Default
|
|
|
|
public static void GetDefaultAvatarAppearance(out AvatarWearable[] wearables, out byte[] visualParams)
|
|
{
|
|
visualParams = GetDefaultVisualParams();
|
|
wearables = AvatarWearable.DefaultWearables;
|
|
}
|
|
|
|
private static byte[] GetDefaultVisualParams()
|
|
{
|
|
byte[] visualParams;
|
|
visualParams = new byte[218];
|
|
for (int i = 0; i < 218; i++)
|
|
{
|
|
visualParams[i] = 100;
|
|
}
|
|
return visualParams;
|
|
}
|
|
|
|
#endregion
|
|
|
|
public void ParcelMediaSetTime(float time)
|
|
{
|
|
//should be doing this by parcel, but as its only for testing
|
|
// The use of Thread.Sleep here causes the following compiler error under mono 1.2.4
|
|
// OpenSim/Region/Environment/Scenes/Scene.cs(3675,17): error CS0103: The name `Thread' does not exist
|
|
// in the context of `<>c__CompilerGenerated17'
|
|
// MW said it was okay to comment the body of this method out for now since the code is experimental
|
|
// and will be replaced anyway
|
|
// ForEachClient(delegate(IClientAPI client)
|
|
// {
|
|
// client.SendParcelMediaCommand((uint)(2), ParcelMediaCommandEnum.Pause, 0);
|
|
// Thread.Sleep(10);
|
|
// client.SendParcelMediaCommand((uint)(64), ParcelMediaCommandEnum.Time, time);
|
|
// Thread.Sleep(200);
|
|
// client.SendParcelMediaCommand((uint)(4), ParcelMediaCommandEnum.Play, 0);
|
|
// });
|
|
}
|
|
|
|
public void RegionHandleRequest(IClientAPI client, UUID regionID)
|
|
{
|
|
RegionInfo info;
|
|
if (regionID == RegionInfo.RegionID)
|
|
info = RegionInfo;
|
|
else
|
|
info = CommsManager.GridService.RequestNeighbourInfo(regionID);
|
|
|
|
if (info != null)
|
|
client.SendRegionHandle(regionID, info.RegionHandle);
|
|
}
|
|
|
|
public void TerrainUnAcked(IClientAPI client, int patchX, int patchY)
|
|
{
|
|
//Console.WriteLine("Terrain packet unacked, resending patch: " + patchX + " , " + patchY);
|
|
client.SendLayerData(patchX, patchY, Heightmap.GetFloatsSerialised());
|
|
}
|
|
|
|
public void SetRootAgentScene(UUID agentID)
|
|
{
|
|
IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
|
|
if (inv == null)
|
|
return;
|
|
|
|
inv.SetRootAgentScene(agentID, this);
|
|
}
|
|
|
|
public bool NeedSceneCacheClear(UUID agentID)
|
|
{
|
|
IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
|
|
if (inv == null)
|
|
return true;
|
|
|
|
return inv.NeedSceneCacheClear(agentID, this);
|
|
}
|
|
|
|
public void ObjectSaleInfo(IClientAPI client, UUID agentID, UUID sessionID, uint localID, byte saleType, int salePrice)
|
|
{
|
|
SceneObjectPart part = GetSceneObjectPart(localID);
|
|
if (part == null || part.ParentGroup == null)
|
|
return;
|
|
|
|
if (part.ParentGroup.RootPart == null)
|
|
return;
|
|
|
|
part = part.ParentGroup.RootPart;
|
|
|
|
part.ObjectSaleType = saleType;
|
|
part.SalePrice = salePrice;
|
|
|
|
part.ParentGroup.HasGroupChanged = true;
|
|
|
|
part.GetProperties(client);
|
|
}
|
|
|
|
public bool PerformObjectBuy(IClientAPI remoteClient, UUID categoryID,
|
|
uint localID, byte saleType)
|
|
{
|
|
SceneObjectPart part = GetSceneObjectPart(localID);
|
|
|
|
if (part == null)
|
|
return false;
|
|
|
|
if (part.ParentGroup == null)
|
|
return false;
|
|
|
|
SceneObjectGroup group = part.ParentGroup;
|
|
|
|
switch (saleType)
|
|
{
|
|
case 1: // Sell as original (in-place sale)
|
|
uint effectivePerms=group.GetEffectivePermissions();
|
|
|
|
if ((effectivePerms & (uint)PermissionMask.Transfer) == 0)
|
|
{
|
|
remoteClient.SendAgentAlertMessage("This item doesn't appear to be for sale", false);
|
|
return false;
|
|
}
|
|
|
|
group.SetOwnerId(remoteClient.AgentId);
|
|
group.SetRootPartOwner(part, remoteClient.AgentId,
|
|
remoteClient.ActiveGroupId);
|
|
|
|
List<SceneObjectPart> partList =
|
|
new List<SceneObjectPart>(group.Children.Values);
|
|
|
|
if (ExternalChecks.ExternalChecksPropagatePermissions())
|
|
{
|
|
foreach (SceneObjectPart child in partList)
|
|
{
|
|
child.ChangeInventoryOwner(remoteClient.AgentId);
|
|
child.ApplyNextOwnerPermissions();
|
|
}
|
|
}
|
|
|
|
part.ObjectSaleType = 0;
|
|
part.SalePrice = 10;
|
|
|
|
group.HasGroupChanged = true;
|
|
part.GetProperties(remoteClient);
|
|
part.ScheduleFullUpdate();
|
|
|
|
break;
|
|
|
|
case 2: // Sell a copy
|
|
string sceneObjectXml = group.ToXmlString();
|
|
|
|
CachedUserInfo userInfo =
|
|
CommsManager.UserProfileCacheService.GetUserDetails(remoteClient.AgentId);
|
|
|
|
if (userInfo != null)
|
|
{
|
|
uint perms=group.GetEffectivePermissions();
|
|
|
|
if ((perms & (uint)PermissionMask.Transfer) == 0)
|
|
{
|
|
remoteClient.SendAgentAlertMessage("This item doesn't appear to be for sale", false);
|
|
return false;
|
|
}
|
|
|
|
AssetBase asset = CreateAsset(
|
|
group.GetPartName(localID),
|
|
group.GetPartDescription(localID),
|
|
(sbyte)AssetType.Object,
|
|
Utils.StringToBytes(sceneObjectXml));
|
|
AssetCache.AddAsset(asset);
|
|
|
|
InventoryItemBase item = new InventoryItemBase();
|
|
item.Creator = part.CreatorID;
|
|
|
|
item.ID = UUID.Random();
|
|
item.Owner = remoteClient.AgentId;
|
|
item.AssetID = asset.FullID;
|
|
item.Description = asset.Description;
|
|
item.Name = asset.Name;
|
|
item.AssetType = asset.Type;
|
|
item.InvType = (int)InventoryType.Object;
|
|
item.Folder = categoryID;
|
|
|
|
uint nextPerms=(perms & 7) << 13;
|
|
if ((nextPerms & (uint)PermissionMask.Copy) == 0)
|
|
perms &= ~(uint)PermissionMask.Copy;
|
|
if ((nextPerms & (uint)PermissionMask.Transfer) == 0)
|
|
perms &= ~(uint)PermissionMask.Transfer;
|
|
if ((nextPerms & (uint)PermissionMask.Modify) == 0)
|
|
perms &= ~(uint)PermissionMask.Modify;
|
|
|
|
item.BasePermissions = perms & part.NextOwnerMask;
|
|
item.CurrentPermissions = perms & part.NextOwnerMask;
|
|
item.NextPermissions = part.NextOwnerMask;
|
|
item.EveryOnePermissions = part.EveryoneMask &
|
|
part.NextOwnerMask;
|
|
item.CurrentPermissions |= 8; // Slam!
|
|
item.CreationDate = Util.UnixTimeSinceEpoch();
|
|
|
|
userInfo.AddItem(item);
|
|
remoteClient.SendInventoryItemCreateUpdate(item);
|
|
}
|
|
else
|
|
{
|
|
remoteClient.SendAgentAlertMessage("Cannot buy now. Your inventory is unavailable", false);
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
case 3: // Sell contents
|
|
List<UUID> invList = part.GetInventoryList();
|
|
|
|
bool okToSell = true;
|
|
|
|
foreach (UUID invID in invList)
|
|
{
|
|
TaskInventoryItem item = part.GetInventoryItem(invID);
|
|
if ((item.CurrentPermissions &
|
|
(uint)PermissionMask.Transfer) == 0)
|
|
{
|
|
okToSell = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!okToSell)
|
|
{
|
|
remoteClient.SendAgentAlertMessage("This item's inventory doesn't appear to be for sale", false);
|
|
return false;
|
|
}
|
|
|
|
if (invList.Count > 0)
|
|
MoveTaskInventoryItems(remoteClient.AgentId, part.Name,
|
|
part, invList);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void CleanTempObjects()
|
|
{
|
|
List<EntityBase> objs = GetEntities();
|
|
|
|
foreach (EntityBase obj in objs)
|
|
{
|
|
if (obj is SceneObjectGroup)
|
|
{
|
|
SceneObjectGroup grp = (SceneObjectGroup)obj;
|
|
|
|
if (grp.RootPart != null)
|
|
{
|
|
if ((grp.RootPart.Flags & PrimFlags.TemporaryOnRez) != 0)
|
|
{
|
|
if (grp.RootPart.Expires <= DateTime.Now)
|
|
DeleteSceneObject(grp, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void DeleteFromStorage(UUID uuid)
|
|
{
|
|
m_storageManager.DataStore.RemoveObject(uuid, m_regInfo.RegionID);
|
|
}
|
|
|
|
public int GetHealth()
|
|
{
|
|
int health=1; // Start at 1, means we're up
|
|
|
|
// A login in the last 4 mins? We can't be doing too badly
|
|
//
|
|
if ((System.Environment.TickCount - m_LastLogin) < 240000)
|
|
health++;
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
}
|