This changeset is the step 1 of 2 in refactoring

OpenSim.Region.Environment into a "framework" part and a modules only
part. This first changeset refactors OpenSim.Region.Environment.Scenes,
OpenSim.Region.Environment.Interfaces, and OpenSim.Region.Interfaces
into OpenSim.Region.Framework.{Interfaces,Scenes} leaving only region
modules in OpenSim.Region.Environment.

The next step will be to move region modules up from
OpenSim.Region.Environment.Modules to OpenSim.Region.CoreModules and
then sort out which modules are really core modules and which should
move out to forge.

I've been very careful to NOT BREAK anything. i hope i've
succeeded. as this is the work of a whole week i hope i managed to
keep track with the applied patches of the last week --- could any of
you that did check in stuff have a look at whether it survived? thx!

1 files changed, 4239 insertions, 0 deletions

diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
new file mode 100644
index 0000000..f07391d
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -0,0 +1,4239 @@
+/*
+ * 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 copyrightD
+ *       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.Framework.Interfaces;
+using OpenSim.Region.Framework.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;
+using OSD = OpenMetaverse.StructuredData.OSD;
+
+namespace OpenSim.Region.Framework.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;
+
+        private const long DEFAULT_MIN_TIME_FOR_PERSISTENCE = 60L;
+        private const long DEFAULT_MAX_TIME_FOR_PERSISTENCE = 600L;
+
+        #region Fields
+
+        protected Timer m_restartWaitTimer = new Timer();
+
+        public SimStatsReporter StatsReporter;
+
+        protected List<RegionInfo> m_regionRestartNotifyList = new List<RegionInfo>();
+        protected List<RegionInfo> m_neighbours = new List<RegionInfo>();
+
+        /// <value>
+        /// The scene graph for this scene
+        /// </value>
+        /// TODO: Possibly stop other classes being able to manipulate this directly.
+        public SceneGraph m_sceneGraph;
+
+        /// <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_clampPrimSize = false;
+        public bool m_trustBinaries = false;
+        public bool m_allowScriptCrossings = false;
+
+        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; }
+        }
+
+        public IXfer XferManager;
+
+        protected IXMLRPC m_xmlrpcModule;
+        protected IWorldComm m_worldCommModule;
+        protected IAvatarFactory m_AvatarFactory;
+        protected IConfigSource m_config;
+        protected IRegionSerialiserModule m_serialiser;
+        protected IInterregionCommsOut m_interregionCommsOut;
+        protected IInterregionCommsIn m_interregionCommsIn;
+        protected IDialogModule m_dialogModule;
+
+        protected ICapabilitiesModule m_capsModule;
+        public ICapabilitiesModule CapsModule
+        {
+            get { return m_capsModule; }
+        }
+
+        // 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();
+
+        // the minimum time that must elapse before a changed object will be considered for persisted
+        public long m_dontPersistBefore = DEFAULT_MIN_TIME_FOR_PERSISTENCE * 10000000L;
+        // the maximum time that must elapse before a changed object will be considered for persisted
+        public long m_persistAfter = DEFAULT_MAX_TIME_FOR_PERSISTENCE * 10000000L;
+
+        #endregion
+
+        #region Properties
+
+        public AgentCircuitManager AuthenticateHandler
+        {
+            get { return m_authenticateHandler; }
+        }
+
+        public SceneGraph SceneContents
+        {
+            get { return m_sceneGraph; }
+        }
+
+        // an instance to the physics plugin's Scene object.
+        public PhysicsScene PhysicsScene
+        {
+            get { return m_sceneGraph.PhysicsScene; }
+            set
+            {
+                // If we're not doing the initial set
+                // Then we've got to remove the previous
+                // event handler
+                if (PhysicsScene != null && PhysicsScene.SupportsNINJAJoints)
+                {
+                    PhysicsScene.OnJointMoved -= jointMoved;
+                    PhysicsScene.OnJointDeactivated -= jointDeactivated;
+                    PhysicsScene.OnJointErrorMessage -= jointErrorMessage;
+                }
+
+                m_sceneGraph.PhysicsScene = value;
+
+                if (PhysicsScene != null && m_sceneGraph.PhysicsScene.SupportsNINJAJoints)
+                {
+                    // register event handlers to respond to joint movement/deactivation
+                    PhysicsScene.OnJointMoved += jointMoved;
+                    PhysicsScene.OnJointDeactivated += jointDeactivated;
+                    PhysicsScene.OnJointErrorMessage += jointErrorMessage;
+                }
+
+            }
+        }
+
+        // This gets locked so things stay thread safe.
+        public object SyncRoot
+        {
+            get { return m_sceneGraph.m_syncRoot; }
+        }
+
+        public float TimeDilation
+        {
+            get { return m_timedilation; }
+        }
+
+        /// <summary>
+        /// This is for llGetRegionFPS
+        /// </summary>
+        public float SimulatorFPS
+        {
+            get { return StatsReporter.getLastReportedSimFPS(); }
+        }
+
+        public string DefaultScriptEngine
+        {
+            get { return m_defaultScriptEngine; }
+        }
+
+        // Local reference to the objects in the scene (which are held in the scenegraph)
+        //        public Dictionary<UUID, SceneObjectGroup> Objects
+        //        {
+        //            get { return m_sceneGraph.SceneObjects; }
+        //        }
+
+        // Reference to all of the agents in the scene (root and child)
+        protected Dictionary<UUID, ScenePresence> m_scenePresences
+        {
+            get { return m_sceneGraph.ScenePresences; }
+            set { m_sceneGraph.ScenePresences = value; }
+        }
+
+        //        protected Dictionary<UUID, SceneObjectGroup> m_sceneObjects
+        //        {
+        //            get { return m_sceneGraph.SceneObjects; }
+        //            set { m_sceneGraph.SceneObjects = value; }
+        //        }
+
+        public EntityManager Entities
+        {
+            get { return m_sceneGraph.Entities; }
+        }
+
+        public Dictionary<UUID, ScenePresence> m_restorePresences
+        {
+            get { return m_sceneGraph.RestorePresences; }
+            set { m_sceneGraph.RestorePresences = value; }
+        }
+
+        public int objectCapacity = 45000;
+
+        #endregion
+
+        #region Constructors
+
+        public Scene(RegionInfo regInfo, AgentCircuitManager authen,
+                     CommunicationsManager commsMan, SceneCommunicationService sceneGridService,
+                     AssetCache assetCach, StorageManager storeManager,
+                     ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim,
+                     bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion)
+        {
+            m_config = config;
+
+            Random random = new Random();
+            m_lastAllocatedLocalId = (uint)(random.NextDouble() * (double)(uint.MaxValue/2))+(uint)(uint.MaxValue/4);
+            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_permissions = new ScenePermissions(this);
+
+            m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this);
+            m_asyncSceneObjectDeleter.Enabled = true;
+
+            // 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_sceneGraph = new SceneGraph(this, m_regInfo);
+
+            // If the scene graph 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_sceneGraph.UnRecoverableError += RestartNow;
+
+            RegisterDefaultSceneEvents();
+
+            DumpAssetsToFile = dumpAssetsToFile;
+
+            m_scripts_enabled = !RegionInfo.RegionSettings.DisableScripts;
+
+            m_physics_enabled = !RegionInfo.RegionSettings.DisablePhysics;
+
+            StatsReporter = new SimStatsReporter(this);
+            StatsReporter.OnSendStatsResult += SendSimStatsPackets;
+            StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats;
+
+            StatsReporter.SetObjectCapacity(objectCapacity);
+
+            m_simulatorVersion = simulatorVersion
+                + " (OS " + Util.GetOperatingSystemInformation() + ")"
+                + " ChilTasks:" + m_seeIntoRegionFromNeighbor.ToString()
+                + " PhysPrim:" + m_physicalPrim.ToString();
+
+            try
+            {
+                // Region config overrides global config
+                //
+                IConfig startupConfig = m_config.Configs["Startup"];
+                m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", 65536.0f);
+                if (RegionInfo.NonphysPrimMax > 0)
+                    m_maxNonphys = RegionInfo.NonphysPrimMax;
+
+                m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", 10.0f);
+
+                if (RegionInfo.PhysPrimMax > 0)
+                    m_maxPhys = RegionInfo.PhysPrimMax;
+
+                // Here, if clamping is requested in either global or
+                // local config, it will be used
+                //
+                m_clampPrimSize = startupConfig.GetBoolean("ClampPrimSize", false);
+                if (RegionInfo.ClampPrimSize)
+                    m_clampPrimSize = true;
+
+                m_trustBinaries = startupConfig.GetBoolean("TrustBinaries", false);
+                m_allowScriptCrossings = startupConfig.GetBoolean("AllowScriptCrossing", false);
+                m_dontPersistBefore =
+                  startupConfig.GetLong("MinimumTimeBeforePersistenceConsidered", DEFAULT_MIN_TIME_FOR_PERSISTENCE);
+                m_dontPersistBefore *= 10000000;
+                m_persistAfter =
+                  startupConfig.GetLong("MaximumTimeBeforePersistenceConsidered", DEFAULT_MAX_TIME_FOR_PERSISTENCE);
+                m_persistAfter *= 10000000;
+
+                m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "DotNetEngine");
+            }
+            catch
+            {
+                m_log.Warn("[SCENE]: Failed to load StartupConfig");
+            }
+        }
+
+        /// <summary>
+        /// Mock constructor for scene group persistency unit tests.
+        /// SceneObjectGroup RegionId property is delegated to Scene.
+        /// </summary>
+        /// <param name="regInfo"></param>
+        public Scene(RegionInfo regInfo)
+        {
+            m_regInfo = regInfo;
+            m_eventManager = new EventManager();
+        }
+
+        #endregion
+
+        #region Startup / Close Methods
+
+        public bool ShuttingDown
+        {
+            get { return shuttingdown; }
+        }
+
+        protected virtual void RegisterDefaultSceneEvents()
+        {
+            IDialogModule dm = RequestModuleInterface<IDialogModule>();
+
+            if (dm != null)
+                m_eventManager.OnPermissionError += dm.SendAlertToUser;
+        }
+
+        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();
+                m_dialogModule.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.Info("[REGION]: Restarting Region in " + (seconds / 60) + " minutes");
+                m_restartTimer.Start();
+                m_dialogModule.SendNotificationToUsersInRegion(
+                    UUID.Random(), String.Empty, 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)
+                    m_dialogModule.SendNotificationToUsersInRegion(
+                        UUID.Random(),
+                        String.Empty,
+                        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");
+                    foreach (EntityBase ent in Entities)
+                    {
+                        if (ent is SceneObjectGroup)
+                        {
+                            ((SceneObjectGroup) ent).RemoveScriptInstances();
+                        }
+                    }
+                }
+                else
+                {
+                    m_log.Info("Starting all Scripts in Scene");
+                    lock (Entities)
+                    {
+                        foreach (EntityBase ent in Entities)
+                        {
+                            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.KnownChildRegionHandles.Contains(RegionInfo.RegionHandle))
+                                         avatar.KnownChildRegionHandles.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;
+
+            m_log.Debug("[SCENE]: Persisting changed objects");
+            List<EntityBase> entities = GetEntities();
+            foreach (EntityBase entity in entities)
+            {
+                if (!entity.IsDeleted && entity is SceneObjectGroup && ((SceneObjectGroup)entity).HasGroupChanged)
+                {
+                    ((SceneObjectGroup)entity).ProcessBackup(m_storageManager.DataStore, false);
+                }
+            }
+
+            m_sceneGraph.Close();
+
+            // De-register with region communications (events cleanup)
+            UnRegisterRegionWithComms();
+
+            // 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_xmlrpcModule = RequestModuleInterface<IXMLRPC>();
+            m_worldCommModule = RequestModuleInterface<IWorldComm>();
+            XferManager = RequestModuleInterface<IXfer>();
+            m_AvatarFactory = RequestModuleInterface<IAvatarFactory>();
+            m_serialiser = RequestModuleInterface<IRegionSerialiserModule>();
+            m_interregionCommsOut = RequestModuleInterface<IInterregionCommsOut>();
+            m_interregionCommsIn = RequestModuleInterface<IInterregionCommsIn>();
+            m_dialogModule = RequestModuleInterface<IDialogModule>();
+            m_capsModule = RequestModuleInterface<ICapabilitiesModule>();
+        }
+
+        #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_sceneGraph.GetRootAgentCount() + m_sceneGraph.GetChildAgentCount();
+
+                if (agentsInScene > 21)
+                {
+                    if (m_update_entities == 1)
+                    {
+                        m_update_entities = 5;
+                        StatsReporter.SetUpdateMS(6000);
+                    }
+                }
+                else
+                {
+                    if (m_update_entities == 5)
+                    {
+                        m_update_entities = 1;
+                        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_sceneGraph.UpdatePreparePhysics();
+                    physicsMS2 = System.Environment.TickCount - physicsMS2;
+
+                    if (m_frame % m_update_entitymovement == 0)
+                        m_sceneGraph.UpdateEntityMovement();
+
+                    physicsMS = System.Environment.TickCount;
+                    if ((m_frame % m_update_physics == 0) && m_physics_enabled)
+                        physicsFPS = m_sceneGraph.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_sceneGraph.UpdateEntities();
+
+                    // run through entities that have scheduled themselves for
+                    // updates looking for updates(faster)
+                    if (m_frame % m_update_entitiesquick == 0)
+                        m_sceneGraph.ProcessUpdates();
+
+                    // Run through scenepresences looking for updates
+                    if (m_frame % m_update_presences == 0)
+                        m_sceneGraph.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();
+                        StatsReporter.AddPhysicsFPS(physicsFPS);
+                        StatsReporter.AddTimeDilation(m_timedilation);
+                        StatsReporter.AddFPS(1);
+                        StatsReporter.AddInPackets(0);
+                        StatsReporter.SetRootAgents(m_sceneGraph.GetRootAgentCount());
+                        StatsReporter.SetChildAgents(m_sceneGraph.GetChildAgentCount());
+                        StatsReporter.SetObjects(m_sceneGraph.GetTotalObjectsCount());
+                        StatsReporter.SetActiveObjects(m_sceneGraph.GetActiveObjectsCount());
+                        frameMS = System.Environment.TickCount - frameMS;
+                        StatsReporter.addFrameMS(frameMS);
+                        StatsReporter.addPhysicsMS(physicsMS);
+                        StatsReporter.addOtherMS(otherMS);
+                        StatsReporter.SetActiveScripts(m_sceneGraph.GetActiveScriptsCount());
+                        StatsReporter.addScriptLines(m_sceneGraph.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>
+        public 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()
+        {
+            lock (m_returns)
+            {
+                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.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 {3}", ret.Value.count, ret.Value.location.ToString(), RegionInfo.RegionName, ret.Value.reason);
+                    else
+                        msg.message = string.Format("Your object {0} was returned from {1} in region {2} due to {3}", ret.Value.objectName, ret.Value.location.ToString(), RegionInfo.RegionName, ret.Value.reason);
+
+                    IMessageTransferModule tr = RequestModuleInterface<IMessageTransferModule>();
+                    if (tr != null)
+                        tr.SendInstantMessage(msg, delegate(bool success) {} );
+                }
+                m_returns.Clear();
+            }
+        }
+
+        public void ForceSceneObjectBackup(SceneObjectGroup group)
+        {
+            if (group != null)
+            {
+                group.ProcessBackup(m_storageManager.DataStore, true);
+            }
+        }
+
+        public void AddReturn(UUID agentID, string objectName, Vector3 location, string reason)
+        {
+            lock (m_returns)
+            {
+                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;
+                    info.reason = reason;
+                    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(m_interregionCommsOut, 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_sceneGraph.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.Metadata.FullID = m_regInfo.RegionSettings.TerrainImageID;
+            asset.Data = data;
+            asset.Metadata.Name = "terrainImage_" + m_regInfo.RegionID.ToString() + "_" + lastMapRefresh.ToString();
+            asset.Metadata.Description = RegionInfo.RegionName;
+
+            asset.Metadata.Type = 0;
+            asset.Metadata.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_sceneGraph.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_sceneGraph.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, UUID groupID, 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 (Permissions.CanRezObject(1, ownerID, pos))
+            {
+                // rez ON the ground, not IN the ground
+                pos.Z += 0.25F;
+
+                AddNewPrim(ownerID, groupID, pos, rot, shape);
+            }
+        }
+
+        public virtual SceneObjectGroup AddNewPrim(
+            UUID ownerID, UUID groupID, Vector3 pos, Quaternion rot, PrimitiveBaseShape shape)
+        {
+            //m_log.DebugFormat(
+            //    "[SCENE]: Scene.AddNewPrim() pcode {0} called for {1} in {2}", shape.PCode, ownerID, RegionInfo.RegionName);
+
+            // If an entity creator has been registered for this prim type then use that
+            if (m_entityCreators.ContainsKey((PCode)shape.PCode))
+                return m_entityCreators[(PCode)shape.PCode].CreateEntity(ownerID, groupID, pos, rot, shape);
+
+            // Otherwise, use this default creation code;
+            SceneObjectGroup sceneObject = new SceneObjectGroup(ownerID, pos, rot, shape);
+            AddNewSceneObject(sceneObject, true);
+            sceneObject.SetGroup(groupID, null);
+
+            return sceneObject;
+        }
+
+        /// <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_sceneGraph.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_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup);
+        }
+
+        /// <summary>
+        /// Delete every object from the scene
+        /// </summary>
+        public void DeleteAllSceneObjects()
+        {
+            lock (Entities)
+            {
+                ICollection<EntityBase> entities = new List<EntityBase>(Entities);
+
+                foreach (EntityBase e in entities)
+                {
+                    if (e is SceneObjectGroup)
+                        DeleteSceneObject((SceneObjectGroup)e, false);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Synchronously delete the given object from the scene.
+        /// </summary>
+        /// <param name="group">Object Id</param>
+        /// <param name="silent">Suppress broadcasting changes to other clients.</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.IsJoint() && ((part.ObjectFlags&(uint)PrimFlags.Physics) != 0) )
+                {
+                    PhysicsScene.RequestJointDeletion(part.Name); // FIXME: what if the name changed?
+                }
+                else 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">Id of object.</param>
+        /// <returns>true if the object was in the scene, false if it was not</returns>
+        /// <param name="softDelete">If true, only deletes from scene, but keeps object in database.</param>
+        public bool UnlinkSceneObject(UUID uuid, bool softDelete)
+        {
+            if (m_sceneGraph.DeleteSceneObject(uuid, softDelete))
+            {
+                if (!softDelete)
+                {
+                    m_storageManager.DataStore.RemoveObject(uuid,
+                                                            m_regInfo.RegionID);
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <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.IsDeleted)
+                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);
+                grp.ScheduleGroupForFullUpdate();
+            }
+        }
+
+        /// <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)
+            {
+                string objectState = grp.GetStateSnapshot();
+
+                successYN
+                    = m_sceneGridService.PrimCrossToNeighboringRegion(
+                        newRegionHandle, grp.UUID, m_serialiser.SaveGroupToXml2(grp), primcrossingXMLmethod);
+                if (successYN && (objectState != "") && m_allowScriptCrossings)
+                {
+                    successYN = m_sceneGridService.PrimCrossToNeighboringRegion(
+                            newRegionHandle, grp.UUID, objectState, 100);
+                }
+
+                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.IsDeleted)
+                    {
+                        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(UUID primID, string objXMLData, int XMLMethod)
+        {
+
+            if (XMLMethod == 0)
+            {
+                m_log.DebugFormat("[INTERREGION]: A new prim {0} arrived from a neighbor", primID);
+                SceneObjectGroup sceneObject = m_serialiser.DeserializeGroupFromXml2(objXMLData);
+
+                // If the user is banned, we won't let any of their objects
+                // enter. Period.
+                //
+                if (m_regInfo.EstateSettings.IsBanned(sceneObject.OwnerID))
+                {
+                    m_log.Info("[INTERREGION]: Denied prim crossing for "+
+                            "banned avatar");
+
+                    return false;
+                }
+
+                // Force allocation of new LocalId
+                //
+                foreach (SceneObjectPart p in sceneObject.Children.Values)
+                    p.LocalId = 0;
+
+                if (sceneObject.RootPart.Shape.PCode == (byte)PCode.Prim)
+                {
+                    if (sceneObject.RootPart.Shape.State != 0)
+                    {
+                        // Fix up attachment Parent Local ID
+                        //
+                        ScenePresence sp = GetScenePresence(sceneObject.OwnerID);
+
+                        uint parentLocalID = 0;
+                        if (sp != null)
+                            parentLocalID = sp.LocalId;
+
+                        sceneObject.RootPart.IsAttachment = true;
+                        sceneObject.RootPart.SetParentLocalId(parentLocalID);
+
+                        AddRestoredSceneObject(sceneObject, false, false);
+
+                        // Handle attachment special case
+                        //
+                        SceneObjectPart RootPrim = GetSceneObjectPart(primID);
+
+                        if (RootPrim != null)
+                        {
+                            SceneObjectGroup grp = RootPrim.ParentGroup;
+
+                            RootPrim.SetParentLocalId(parentLocalID);
+
+                            if (grp != null)
+                            {
+                                m_log.DebugFormat("[ATTACHMENT]: Received "+
+                                        "attachment {0}, inworld asset id {1}",
+                                        grp.RootPart.LastOwnerID.ToString(),
+                                        grp.UUID.ToString());
+
+                                if (sp != null)
+                                {
+                                    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);
+                                    grp.SendGroupFullUpdate();
+                                }
+                                else
+                                {
+                                    RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
+                                    RootPrim.AddFlag(PrimFlags.TemporaryOnRez);
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        AddRestoredSceneObject(sceneObject, true, false);
+
+                        if (!Permissions.CanObjectEntry(sceneObject.UUID,
+                                true, sceneObject.AbsolutePosition))
+                        {
+                            // Deny non attachments based on parcel settings
+                            //
+                            m_log.Info("[INTERREGION]: Denied prim crossing "+
+                                    "because of parcel settings");
+
+                            DeleteSceneObject(sceneObject, false);
+
+                            return false;
+                        }
+                    }
+                }
+            }
+            else if ((XMLMethod == 100) && m_allowScriptCrossings)
+            {
+                m_log.Warn("[INTERREGION]: Prim state data arrived from a neighbor");
+                XmlDocument doc = new XmlDocument();
+                doc.LoadXml(objXMLData);
+
+                XmlNodeList rootL = doc.GetElementsByTagName("ScriptData");
+                if (rootL.Count == 1)
+                {
+                    XmlNode rootNode = rootL[0];
+                    if (rootNode != null)
+                    {
+                        XmlNodeList partL = rootNode.ChildNodes;
+
+                        foreach (XmlNode part in partL)
+                        {
+                            XmlNodeList nodeL = part.ChildNodes;
+
+                            switch (part.Name)
+                            {
+                            case "Assemblies":
+                                foreach (XmlNode asm in nodeL)
+                                {
+                                    string fn = asm.Attributes.GetNamedItem("Filename").Value;
+
+                                    Byte[] filedata = Convert.FromBase64String(asm.InnerText);
+                                    string path = Path.Combine("ScriptEngines", RegionInfo.RegionID.ToString());
+                                    path = Path.Combine(path, fn);
+
+                                    if (!File.Exists(path))
+                                    {
+                                        FileStream fs = File.Create(path);
+                                        fs.Write(filedata, 0, filedata.Length);
+                                        fs.Close();
+                                    }
+                                }
+                                break;
+                            case "ScriptStates":
+                                foreach (XmlNode st in nodeL)
+                                {
+                                    string id = st.Attributes.GetNamedItem("UUID").Value;
+                                    UUID uuid = new UUID(id);
+                                    XmlNode state = st.ChildNodes[0];
+
+                                    XmlDocument sdoc = new XmlDocument();
+                                    XmlNode sxmlnode = sdoc.CreateNode(
+                                            XmlNodeType.XmlDeclaration,
+                                            "", "");
+                                    sdoc.AppendChild(sxmlnode);
+
+                                    XmlNode newnode = sdoc.ImportNode(state, true);
+                                    sdoc.AppendChild(newnode);
+
+                                    string spath = Path.Combine("ScriptEngines", RegionInfo.RegionID.ToString());
+                                    spath = Path.Combine(spath, uuid.ToString());
+                                    FileStream sfs = File.Create(spath + ".state");
+                                    System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
+                                    Byte[] buf = enc.GetBytes(sdoc.InnerXml);
+                                    sfs.Write(buf, 0, buf.Length);
+                                    sfs.Close();
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                SceneObjectPart RootPrim = GetSceneObjectPart(primID);
+                RootPrim.ParentGroup.CreateScriptInstances(0, false, DefaultScriptEngine, 1);
+
+                return true;
+            }
+
+            return true;
+        }
+
+        #endregion
+
+        #region Add/Remove Avatar Methods
+
+        public override void AddNewClient(IClientAPI client)
+        {
+            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_sceneGraph.AddScenePresence(presence);
+
+                lock (m_restorePresences)
+                {
+                    Monitor.PulseAll(m_restorePresences);
+                }
+            }
+            else
+            {
+                m_log.DebugFormat(
+                    "[SCENE]: Adding new child agent for {0} in {1}",
+                    client.Name, RegionInfo.RegionName);
+
+                CommsManager.UserProfileCacheService.AddNewUser(client.AgentId);
+
+                CreateAndAddScenePresence(client);
+            }
+
+            m_LastLogin = System.Environment.TickCount;
+            EventManager.TriggerOnNewClient(client);
+        }
+
+        protected virtual void SubscribeToClientEvents(IClientAPI client)
+        {
+            client.OnRegionHandShakeReply += SendLayerData;
+            client.OnAddPrim += AddNewPrim;
+            client.OnUpdatePrimGroupPosition += m_sceneGraph.UpdatePrimPosition;
+            client.OnUpdatePrimSinglePosition += m_sceneGraph.UpdatePrimSinglePosition;
+            client.OnUpdatePrimGroupRotation += m_sceneGraph.UpdatePrimRotation;
+            client.OnUpdatePrimGroupMouseRotation += m_sceneGraph.UpdatePrimRotation;
+            client.OnUpdatePrimSingleRotation += m_sceneGraph.UpdatePrimSingleRotation;
+            client.OnUpdatePrimScale += m_sceneGraph.UpdatePrimScale;
+            client.OnUpdatePrimGroupScale += m_sceneGraph.UpdatePrimGroupScale;
+            client.OnUpdateExtraParams += m_sceneGraph.UpdateExtraParam;
+            client.OnUpdatePrimShape += m_sceneGraph.UpdatePrimShape;
+            client.OnUpdatePrimTexture += m_sceneGraph.UpdatePrimTexture;
+            client.OnTeleportLocationRequest += RequestTeleportLocation;
+            client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
+            client.OnObjectSelect += SelectPrim;
+            client.OnObjectDeselect += DeselectPrim;
+            client.OnGrabUpdate += m_sceneGraph.MoveObject;
+            client.OnDeRezObject += DeRezObject;
+            client.OnRezObject += RezObject;
+            client.OnRezSingleAttachmentFromInv += RezSingleAttachment;
+            client.OnDetachAttachmentIntoInv += DetachSingleAttachmentToInv;
+            client.OnObjectAttach += m_sceneGraph.AttachObject;
+            client.OnObjectDetach += m_sceneGraph.DetachObject;
+            client.OnObjectDrop += m_sceneGraph.DropObject;
+            client.OnNameFromUUIDRequest += CommsManager.HandleUUIDNameRequest;
+            client.OnObjectDescription += m_sceneGraph.PrimDescription;
+            client.OnObjectName += m_sceneGraph.PrimName;
+            client.OnObjectClickAction += m_sceneGraph.PrimClickAction;
+            client.OnObjectMaterial += m_sceneGraph.PrimMaterial;
+            client.OnLinkObjects += m_sceneGraph.LinkObjects;
+            client.OnDelinkObjects += m_sceneGraph.DelinkObjects;
+            client.OnObjectDuplicate += m_sceneGraph.DuplicateObject;
+            client.OnObjectDuplicateOnRay += doObjectDuplicateOnRay;
+            client.OnUpdatePrimFlags += m_sceneGraph.UpdatePrimFlags;
+            client.OnRequestObjectPropertiesFamily += m_sceneGraph.RequestObjectPropertiesFamily;
+            client.OnRequestGodlikePowers += handleRequestGodlikePowers;
+            client.OnGodKickUser += HandleGodlikeKickUser;
+            client.OnObjectPermissions += HandleObjectPermissionsUpdate;
+            client.OnCreateNewInventoryItem += CreateNewInventoryItem;
+            client.OnCreateNewInventoryFolder += HandleCreateInventoryFolder;
+            client.OnUpdateInventoryFolder += HandleUpdateInventoryFolder;
+            client.OnMoveInventoryFolder += HandleMoveInventoryFolder;
+            client.OnFetchInventoryDescendents += HandleFetchInventoryDescendents;
+            client.OnPurgeInventoryDescendents += HandlePurgeInventoryDescendents;
+            client.OnFetchInventory += 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_sceneGraph.MakeObjectSearchable;
+            client.OnTeleportHomeRequest += TeleportClientHome;
+            client.OnSetStartLocationRequest += SetHomeRezPoint;
+            client.OnUndo += m_sceneGraph.HandleUndo;
+            client.OnObjectGroupRequest += m_sceneGraph.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;
+
+            client.OnObjectOwner += ObjectOwner;
+
+            if (StatsReporter != null)
+                client.OnNetworkStatsUpdate += StatsReporter.AddPacketsFromClientStats;
+
+            // EventManager.TriggerOnNewClient(client);
+        }
+
+        /// <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);
+                    if (regionInfo != null) // home region can be away temporarily, too
+                    {
+                        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_sceneGraph.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_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
+                            m_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
+                            //obj.Rotation = worldRot;
+                            //obj.UpdateGroupRotation(worldRot);
+                        }
+                        else
+                        {
+                            m_sceneGraph.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.
+                m_dialogModule.SendAlertToUser(remoteClient, "Home position set.");
+            }
+            else
+            {
+                m_dialogModule.SendAlertToUser(remoteClient, "Set Home request Failed.");
+            }
+        }
+
+        /// <summary>
+        /// Create a child agent scene presence and add it to this scene.
+        /// </summary>
+        /// <param name="client"></param>
+        /// <returns></returns>
+        protected virtual ScenePresence CreateAndAddScenePresence(IClientAPI client)
+        {
+            AvatarAppearance appearance = null;
+            GetAvatarAppearance(client, out appearance);
+
+            ScenePresence avatar = m_sceneGraph.CreateAndAddChildScenePresence(client, appearance);
+            //avatar.KnownRegions = GetChildrenSeeds(avatar.UUID);
+            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);
+
+                m_sceneGraph.removeUserCount(!childagentYN);
+                CapsModule.RemoveCapsHandler(agentID);
+
+                if (avatar.Scene.NeedSceneCacheClear(avatar.UUID))
+                {
+                    CommsManager.UserProfileCacheService.RemoveUser(agentID);
+                }
+
+                if (!avatar.IsChildAgent)
+                {
+                    m_sceneGridService.LogOffUser(agentID, RegionInfo.RegionID, RegionInfo.RegionHandle, avatar.AbsolutePosition, avatar.Lookat);
+                    //List<ulong> childknownRegions = new List<ulong>();
+                    //List<ulong> ckn = avatar.KnownChildRegionHandles;
+                    //for (int i = 0; i < ckn.Count; i++)
+                    //{
+                    //    childknownRegions.Add(ckn[i]);
+                    //}
+                    List<ulong> regions = new List<ulong>(avatar.KnownChildRegionHandles);
+                    regions.Remove(RegionInfo.RegionHandle);
+                    m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
+
+                }
+                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_sceneGraph.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.KnownChildRegionHandles.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.IsDeleted) // 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 += IncomingCloseAgent;
+            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;
+
+            if (m_interregionCommsIn != null)
+            {
+                m_log.Debug("[SCENE]: Registering with InterregionCommsIn");
+                m_interregionCommsIn.OnChildAgentUpdate += IncomingChildAgentDataUpdate;
+            }
+            else
+                m_log.Debug("[SCENE]: Unable to register with InterregionCommsIn");
+
+        }
+
+        /// <summary>
+        /// Deregister this scene from receiving incoming region events
+        /// </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 -= IncomingCloseAgent;
+            m_sceneGridService.OnGetLandData -= GetLandData;
+
+            if (m_interregionCommsIn != null)
+                m_interregionCommsIn.OnChildAgentUpdate -= IncomingChildAgentDataUpdate;
+
+            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(AgentCircuitData agent)
+        {
+            CapsModule.NewUserConnection(agent);
+
+            ScenePresence sp = m_sceneGraph.GetScenePresence(agent.AgentID);
+            if (sp != null)
+            {
+                m_log.DebugFormat(
+                    "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
+                    agent.AgentID, RegionInfo.RegionName);
+
+                sp.AdjustKnownSeeds();
+
+                return;
+            }
+
+            // Don't disable this log message - it's too helpful
+            m_log.DebugFormat(
+                "[CONNECTION BEGIN]: Region {0} told of incoming client {1} {2} {3} (circuit code {4})",
+                RegionInfo.RegionName, agent.firstname, agent.lastname, agent.AgentID, agent.circuitcode);
+
+            if (m_regInfo.EstateSettings.IsBanned(agent.AgentID))
+            {
+                m_log.WarnFormat(
+               "[CONNECTION BEGIN]: Denied access to: {0} at {1} because the user is on the region banlist",
+               agent.AgentID, RegionInfo.RegionName);
+            }
+
+            CapsModule.AddCapsHandler(agent.AgentID);
+
+            if (!agent.child)
+            {
+                // 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(
+                    "[CONNECTION BEGIN]: 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);
+            }
+        }
+
+        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(UUID AvatarID, UUID RegionSecret, string message)
+        {
+            ScenePresence loggingOffUser = null;
+            loggingOffUser = GetScenePresence(AvatarID);
+            if (loggingOffUser != null)
+            {
+                UUID localRegionSecret = UUID.Zero;
+                bool parsedsecret = UUID.TryParse(m_regInfo.regionSecret, out localRegionSecret);
+
+                // Region Secret is used here in case a new sessionid overwrites an old one on the user server.
+                // Will update the user server in a few revisions to use it.
+
+                if (RegionSecret == loggingOffUser.ControllingClient.SecureSessionId || (parsedsecret && RegionSecret == localRegionSecret))
+                {
+                    m_sceneGridService.SendCloseChildAgentConnections(loggingOffUser.UUID, new List<ulong>(loggingOffUser.KnownRegions.Keys));
+                    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>
+        /// Triggered when an agent crosses into this sim.  Also happens on initial login.
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="position"></param>
+        /// <param name="isFlying"></param>
+        public virtual void AgentCrossing(UUID agentID, Vector3 position, bool isFlying)
+        {
+            ScenePresence presence;
+
+            lock (m_scenePresences)
+            {
+                m_scenePresences.TryGetValue(agentID, out presence);
+            }
+
+            if (presence != null)
+            {
+                try
+                {
+                    presence.MakeRootAgent(position, isFlying);
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("[SCENE]: Unable to do agent crossing, exception {0}", e);
+                }
+            }
+            else
+            {
+                m_log.ErrorFormat(
+                    "[SCENE]: Could not find presence for agent {0} crossing into scene {1}",
+                    agentID, RegionInfo.RegionName);
+            }
+        }
+
+        public virtual bool IncomingChildAgentDataUpdate(AgentData cAgentData)
+        {
+//            m_log.DebugFormat(
+//                "[SCENE]: Incoming child agent update for {0} in {1}", cAgentData.AgentID, RegionInfo.RegionName);
+
+            // We have to wait until the viewer contacts this region after receiving EAC.
+            // That calls AddNewClient, which finally creates the ScenePresence
+            ScenePresence childAgentUpdate = WaitGetScenePresence(cAgentData.AgentID);
+            if (childAgentUpdate != null)
+            {
+                childAgentUpdate.ChildAgentDataUpdate(cAgentData);
+                return true;
+            }
+
+            return false;
+        }
+
+        public virtual bool IncomingChildAgentDataUpdate(AgentPosition cAgentData)
+        {
+            //Console.WriteLine(" XXX Scene IncomingChildAgentDataUpdate POSITION in " + RegionInfo.RegionName);
+            ScenePresence childAgentUpdate = GetScenePresence(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;
+        }
+
+        protected virtual ScenePresence WaitGetScenePresence(UUID agentID)
+        {
+            int ntimes = 10;
+            ScenePresence childAgentUpdate = null;
+            while ((childAgentUpdate = GetScenePresence(agentID)) == null && (ntimes-- > 0))
+                Thread.Sleep(1000);
+            return childAgentUpdate;
+
+        }
+
+        public virtual bool IncomingReleaseAgent(UUID id)
+        {
+            return m_sceneGridService.ReleaseAgent(id);
+        }
+
+        public void SendReleaseAgent(ulong regionHandle, UUID id, string uri)
+        {
+            m_interregionCommsOut.SendReleaseAgent(regionHandle, id, uri);
+        }
+
+        /// <summary>
+        /// Tell a single agent to disconnect from the region.
+        /// </summary>
+        /// <param name="regionHandle"></param>
+        /// <param name="agentID"></param>
+        public bool IncomingCloseAgent(UUID agentID)
+        {
+            //m_log.DebugFormat("[SCENE]: Processing incoming close agent for {0}", agentID);
+
+            ScenePresence presence = m_sceneGraph.GetScenePresence(agentID);
+            if (presence != null)
+            {
+                // Nothing is removed here, so down count it as such
+                if (presence.IsChildAgent)
+                {
+                   m_sceneGraph.removeUserCount(false);
+                }
+                else
+                {
+                   m_sceneGraph.removeUserCount(true);
+                }
+
+                // Don't do this to root agents on logout, it's not nice for the viewer
+                if (presence.IsChildAgent)
+                {
+                    // Tell a single agent to disconnect from the region.
+                    IEventQueue eq = RequestModuleInterface<IEventQueue>();
+                    if (eq != null)
+                    {
+                        eq.DisableSimulator(RegionInfo.RegionHandle, agentID);
+                    }
+                    else
+                        presence.ControllingClient.SendShutdownConnectionNotice();
+                }
+
+                presence.ControllingClient.Close(true);
+                return true;
+            }
+
+            // Agent not here
+            return false;
+        }
+
+        /// <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)
+        {
+            ScenePresence sp = null;
+            lock (m_scenePresences)
+            {
+                if (m_scenePresences.ContainsKey(remoteClient.AgentId))
+                    sp = m_scenePresences[remoteClient.AgentId];
+            }
+
+            if (sp != null)
+            {
+                m_sceneGridService.RequestTeleportToLocation(sp, 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;
+            }
+
+            ScenePresence sp = null;
+            lock (m_scenePresences)
+            {
+                if (m_scenePresences.ContainsKey(remoteClient.AgentId))
+                    sp = m_scenePresences[remoteClient.AgentId];
+            }
+            if (sp != null)
+            {
+                m_sceneGridService.RequestTeleportToLocation(sp, 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(AgentPosition cadu, ScenePresence presence)
+        {
+            m_sceneGridService.SendChildAgentDataUpdate(cadu, presence);
+        }
+
+        #endregion
+
+        #region Other Methods
+        
+        public void SetObjectCapacity(int objects)
+        {
+            // Region specific config overrides global
+            //
+            if (RegionInfo.ObjectCapacity != 0)
+                objects = RegionInfo.ObjectCapacity;
+
+            if (StatsReporter != null)
+            {
+                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);
+        }
+
+        public virtual void StoreAddFriendship(UUID ownerID, UUID friendID, uint perms)
+        {
+            m_sceneGridService.AddNewUserFriend(ownerID, friendID, perms);
+        }
+
+        public virtual void StoreUpdateFriendship(UUID ownerID, UUID friendID, uint perms)
+        {
+            m_sceneGridService.UpdateUserFriendPerms(ownerID, friendID, perms);
+        }
+
+        public virtual void StoreRemoveFriendship(UUID ownerID, UUID ExfriendID)
+        {
+            m_sceneGridService.RemoveUserFriend(ownerID, ExfriendID);
+        }
+
+        public void AddPacketStats(int inPackets, int outPackets, int unAckedBytes)
+        {
+            StatsReporter.AddInPackets(inPackets);
+            StatsReporter.AddOutPackets(outPackets);
+            StatsReporter.AddunAckedBytes(unAckedBytes);
+        }
+
+        public void AddAgentTime(int ms)
+        {
+            StatsReporter.addFrameMS(ms);
+            StatsReporter.addAgentMS(ms);
+        }
+
+        public void AddAgentUpdates(int count)
+        {
+            StatsReporter.AddAgentUpdates(count);
+        }
+
+        public void AddPendingDownloads(int count)
+        {
+            StatsReporter.addPendingDownload(count);
+        }
+
+        #endregion
+
+        #region Alert Methods
+
+        /// <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)
+        {
+            ScenePresence sp = null;
+
+            lock (m_scenePresences)
+            {
+                // User needs to be logged into this sim
+                m_scenePresences.TryGetValue(agentID, out sp);
+            }
+
+            if (sp != null)
+            {
+                if (godLike == false)
+                {
+                    sp.GrantGodlikePowers(agentID, sessionID, token, godLike);
+                    return;
+                }
+
+                // First check that this is the sim owner
+                if (Permissions.IsGod(agentID))
+                {
+                    // Next we check for spoofing.....
+                    UUID testSessionID = sp.ControllingClient.SessionId;
+                    if (sessionID == testSessionID)
+                    {
+                        if (sessionID == controllingClient.SessionId)
+                        {
+                            //m_log.Info("godlike: " + godLike.ToString());
+                            sp.GrantGodlikePowers(agentID, testSessionID, token, godLike);
+                        }
+                    }
+                }
+                else
+                {
+                    m_dialogModule.SendAlertToUser(agentID, "Request for god powers denied");
+                }
+            }
+        }
+
+        /// <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 (Permissions.IsGod(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_sceneGraph.removeUserCount(!m_scenePresences[agentID].IsChildAgent);
+
+                            m_scenePresences[agentID].ControllingClient.Kick(Utils.BytesToString(reason));
+                            m_scenePresences[agentID].ControllingClient.Close(true);
+                        }
+                    }
+                    else
+                    {
+                        m_dialogModule.SendAlertToUser(godID, "Kick request denied");
+                    }
+                }
+            }
+        }
+
+        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>
+        /// 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);
+                m_dialogModule.SendGeneralAlert(message);
+            }
+            else
+            {
+                string message = CombineParams(commandParams, 2);
+                m_dialogModule.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);
+                        }
+                    }
+                }
+            }
+        }
+
+        public override void Show(string[] showParams)
+        {
+            base.Show(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;
+            }           
+        }
+
+        #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>();
+        public bool 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) || Permissions.IsGod(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 SceneGraph wrapper methods
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <returns></returns>
+        public UUID ConvertLocalIDToFullID(uint localID)
+        {
+            return m_sceneGraph.ConvertLocalIDToFullID(localID);
+        }
+
+        public void SwapRootAgentCount(bool rootChildChildRootTF)
+        {
+            m_sceneGraph.SwapRootChildAgent(rootChildChildRootTF);
+        }
+
+        public void AddPhysicalPrim(int num)
+        {
+            m_sceneGraph.AddPhysicalPrim(num);
+        }
+
+        public void RemovePhysicalPrim(int num)
+        {
+            m_sceneGraph.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_sceneGraph.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_sceneGraph.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_sceneGraph.GetScenePresences(filter);
+        }
+
+        /// <summary>
+        /// Request a scene presence by UUID
+        /// </summary>
+        /// <param name="avatarID"></param>
+        /// <returns></returns>
+        public ScenePresence GetScenePresence(UUID avatarID)
+        {
+            return m_sceneGraph.GetScenePresence(avatarID);
+        }
+
+        public override bool PresenceChildStatus(UUID avatarID)
+        {
+            ScenePresence cp = GetScenePresence(avatarID);
+
+            // FIXME: This is really crap - some logout code is relying on a NullReferenceException to halt its processing
+            // This needs to be fixed properly by cleaning up the logout code.
+            //if (cp != null)
+            //    return cp.IsChildAgent;
+
+            //return false;
+
+            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_sceneGraph.GetSceneObjectPart(name);
+        }
+
+        /// <summary>
+        /// Get a prim via its local id
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <returns></returns>
+        public SceneObjectPart GetSceneObjectPart(uint localID)
+        {
+            return m_sceneGraph.GetSceneObjectPart(localID);
+        }
+
+        /// <summary>
+        /// Get a prim via its UUID
+        /// </summary>
+        /// <param name="fullID"></param>
+        /// <returns></returns>
+        public SceneObjectPart GetSceneObjectPart(UUID fullID)
+        {
+            return m_sceneGraph.GetSceneObjectPart(fullID);
+        }
+
+        public bool TryGetAvatar(UUID avatarId, out ScenePresence avatar)
+        {
+            return m_sceneGraph.TryGetAvatar(avatarId, out avatar);
+        }
+
+        public bool TryGetAvatarByName(string avatarName, out ScenePresence avatar)
+        {
+            return m_sceneGraph.TryGetAvatarByName(avatarName, out avatar);
+        }
+
+        public void ForEachClient(Action<IClientAPI> action)
+        {
+            m_sceneGraph.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_sceneGraph.GetEntities();
+        }
+
+        #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);
+
+            EventManager.TriggerSetRootAgentScene(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.IsDeleted)
+                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)
+                {
+                    m_dialogModule.SendAlertToUser(remoteClient, "This item doesn't appear to be for sale");
+                    return false;
+                }
+
+                group.SetOwnerId(remoteClient.AgentId);
+                group.SetRootPartOwner(part, remoteClient.AgentId,
+                        remoteClient.ActiveGroupId);
+
+                List<SceneObjectPart> partList =
+                    new List<SceneObjectPart>(group.Children.Values);
+
+                if (Permissions.PropagatePermissions())
+                {
+                    foreach (SceneObjectPart child in partList)
+                    {
+                        child.Inventory.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)
+                    {
+                        m_dialogModule.SendAlertToUser(remoteClient, "This item doesn't appear to be for sale");
+                        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.Metadata.FullID;
+                    item.Description = asset.Metadata.Description;
+                    item.Name = asset.Metadata.Name;
+                    item.AssetType = asset.Metadata.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.GroupPermissions = part.GroupMask &
+                                               part.NextOwnerMask;
+                    item.CurrentPermissions |= 8; // Slam!
+                    item.CreationDate = Util.UnixTimeSinceEpoch();
+
+                    userInfo.AddItem(item);
+                    remoteClient.SendInventoryItemCreateUpdate(item);
+                }
+                else
+                {
+                    m_dialogModule.SendAlertToUser(remoteClient, "Cannot buy now. Your inventory is unavailable");
+                    return false;
+                }
+                break;
+
+            case 3: // Sell contents
+                List<UUID> invList = part.Inventory.GetInventoryList();
+
+                bool okToSell = true;
+
+                foreach (UUID invID in invList)
+                {
+                    TaskInventoryItem item = part.Inventory.GetInventoryItem(invID);
+                    if ((item.CurrentPermissions &
+                            (uint)PermissionMask.Transfer) == 0)
+                    {
+                        okToSell = false;
+                        break;
+                    }
+                }
+
+                if (!okToSell)
+                {
+                    m_dialogModule.SendAlertToUser(
+                        remoteClient, "This item's inventory doesn't appear to be for sale");
+                    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.IsDeleted)
+                    {
+                        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;
+        }
+
+        // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
+        // update non-physical objects like the joint proxy objects that represent the position
+        // of the joints in the scene.
+
+        // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
+        // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
+        // from within the OdePhysicsScene.
+
+        protected internal void jointMoved(PhysicsJoint joint)
+        {
+            // m_parentScene.PhysicsScene.DumpJointInfo(); // non-thread-locked version; we should already be in a lock (OdeLock) when this callback is invoked
+            // FIXME: this causes a sequential lookup of all objects in the scene; use a dictionary
+            SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
+            if (jointProxyObject == null)
+            {
+                jointErrorMessage(joint, "WARNING, joint proxy not found, name " + joint.ObjectNameInScene);
+                return;
+            }
+
+            // now update the joint proxy object in the scene to have the position of the joint as returned by the physics engine
+            SceneObjectPart trackedBody = GetSceneObjectPart(joint.TrackedBodyName); // FIXME: causes a sequential lookup
+            if (trackedBody == null) return; // the actor may have been deleted but the joint still lingers around a few frames waiting for deletion. during this time, trackedBody is NULL to prevent further motion of the joint proxy.
+            jointProxyObject.Velocity = trackedBody.Velocity;
+            jointProxyObject.RotationalVelocity = trackedBody.RotationalVelocity;
+            switch (joint.Type)
+            {
+                case PhysicsJointType.Ball:
+                    {
+                        PhysicsVector jointAnchor = PhysicsScene.GetJointAnchor(joint);
+                        Vector3 proxyPos = new Vector3(jointAnchor.X, jointAnchor.Y, jointAnchor.Z);
+                        jointProxyObject.ParentGroup.UpdateGroupPosition(proxyPos); // schedules the entire group for a terse update
+                    }
+                    break;
+
+                case PhysicsJointType.Hinge:
+                    {
+                        PhysicsVector jointAnchor = PhysicsScene.GetJointAnchor(joint);
+
+                        // Normally, we would just ask the physics scene to return the axis for the joint.
+                        // Unfortunately, ODE sometimes returns <0,0,0> for the joint axis, which should
+                        // never occur. Therefore we cannot rely on ODE to always return a correct joint axis.
+                        // Therefore the following call does not always work:
+                        //PhysicsVector phyJointAxis = _PhyScene.GetJointAxis(joint);
+
+                        // instead we compute the joint orientation by saving the original joint orientation
+                        // relative to one of the jointed bodies, and applying this transformation
+                        // to the current position of the jointed bodies (the tracked body) to compute the
+                        // current joint orientation.
+
+                        if (joint.TrackedBodyName == null)
+                        {
+                            jointErrorMessage(joint, "joint.TrackedBodyName is null, joint " + joint.ObjectNameInScene);
+                        }
+
+                        Vector3 proxyPos = new Vector3(jointAnchor.X, jointAnchor.Y, jointAnchor.Z);
+                        Quaternion q = trackedBody.RotationOffset * joint.LocalRotation;
+
+                        jointProxyObject.ParentGroup.UpdateGroupPosition(proxyPos); // schedules the entire group for a terse update
+                        jointProxyObject.ParentGroup.UpdateGroupRotation(q); // schedules the entire group for a terse update
+                    }
+                    break;
+            }
+        }
+
+        // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
+        // update non-physical objects like the joint proxy objects that represent the position
+        // of the joints in the scene.
+
+        // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
+        // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
+        // from within the OdePhysicsScene.
+        protected internal void jointDeactivated(PhysicsJoint joint)
+        {
+            //m_log.Debug("[NINJA] SceneGraph.jointDeactivated, joint:" + joint.ObjectNameInScene);
+            // FIXME: this causes a sequential lookup of all objects in the scene; use a dictionary
+            SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
+            if (jointProxyObject == null)
+            {
+                jointErrorMessage(joint, "WARNING, trying to deactivate (stop interpolation of) joint proxy, but not found, name " + joint.ObjectNameInScene);
+                return;
+            }
+
+            // turn the proxy non-physical, which also stops its client-side interpolation
+            bool wasUsingPhysics = ((jointProxyObject.ObjectFlags & (uint)PrimFlags.Physics) != 0);
+            if (wasUsingPhysics)
+            {
+                jointProxyObject.UpdatePrimFlags(false, false, true, false); // FIXME: possible deadlock here; check to make sure all the scene alterations set into motion here won't deadlock
+            }
+        }
+
+        // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
+        // alert the user of errors by using the debug channel in the same way that scripts alert
+        // the user of compile errors.
+
+        // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
+        // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
+        // from within the OdePhysicsScene.
+        public void jointErrorMessage(PhysicsJoint joint, string message)
+        {
+            // FIXME: this causes a sequential lookup of all objects in the scene; use a dictionary
+            if (joint != null)
+            {
+                if (joint.ErrorMessageCount > PhysicsJoint.maxErrorMessages)
+                    return;
+
+                SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
+                if (jointProxyObject != null)
+                {
+                    SimChat(Utils.StringToBytes("[NINJA] " + message),
+                        ChatTypeEnum.DebugChannel,
+                        2147483647,
+                        jointProxyObject.AbsolutePosition,
+                        jointProxyObject.Name,
+                        jointProxyObject.UUID,
+                        false);
+
+                    joint.ErrorMessageCount++;
+
+                    if (joint.ErrorMessageCount > PhysicsJoint.maxErrorMessages)
+                    {
+                        SimChat(Utils.StringToBytes("[NINJA] Too many messages for this joint, suppressing further messages."),
+                            ChatTypeEnum.DebugChannel,
+                            2147483647,
+                            jointProxyObject.AbsolutePosition,
+                            jointProxyObject.Name,
+                            jointProxyObject.UUID,
+                            false);
+                    }
+                }
+                else
+                {
+                    // couldn't find the joint proxy object; the error message is silently suppressed
+                }
+            }
+        }
+    }
+}