public void AddRegion(Scene scene) { m_scenes.Add(scene); scene.RegisterModuleInterface<IRexUDPPort>(this); if (m_config.Configs["realXtend"] != null && m_config.Configs["realXtend"].GetBoolean("enabled", false)) { scene.RegisterModuleInterface<LoginConfigurationManager>(this); } }
public void AddRegion(Scene scene) { if (!String.IsNullOrEmpty(m_serverUrl)) { scene.RegisterModuleInterface<IPresenceService>(this); scene.RegisterModuleInterface<IGridUserService>(this); m_activityDetector.AddRegion(scene); LogoutRegionAgents(scene.RegionInfo.RegionID); } }
public void AddRegion(Scene scene) { if (m_Enabled) { scene.RegisterModuleInterface<IPresenceService>(this); scene.RegisterModuleInterface<IGridUserService>(this); m_activityDetector.AddRegion(scene); LogoutRegionAgents(scene.RegionInfo.RegionID); } }
public void AddRegion(Scene scene) { if (!String.IsNullOrEmpty(m_serverUrl)) { scene.RegisterModuleInterface<IPresenceService>(this); scene.RegisterModuleInterface<IGridUserService>(this); scene.EventManager.OnMakeRootAgent += MakeRootAgentHandler; scene.EventManager.OnNewClient += NewClientHandler; scene.EventManager.OnSignificantClientMovement += SignificantClientMovementHandler; LogoutRegionAgents(scene.RegionInfo.RegionID); } }
public void Initialise(Scene scene, IConfigSource source) { if (m_scene == null) m_scene = scene; scene.RegisterModuleInterface<IJ2KDecoder>(this); }
public void AddRegion(Scene scene) { m_scene = scene; m_scene.EventManager.OnNewClient += NewClient; m_scene.RegisterModuleInterface<IXfer>(this); }
public void AddRegion(Scene scene) { m_scene = scene; scene.RegisterModuleInterface<IEventQueue>(this); scene.EventManager.OnClientClosed += ClientClosed; scene.EventManager.OnMakeChildAgent += MakeChildAgent; scene.EventManager.OnRegisterCaps += OnRegisterCaps; MainConsole.Instance.Commands.AddCommand( "Debug", false, "debug eq", "debug eq [0|1|2]", "Turn on event queue debugging\n" + " <= 0 - turns off all event queue logging\n" + " >= 1 - turns on outgoing event logging\n" + " >= 2 - turns on poll notification", HandleDebugEq); MainConsole.Instance.Commands.AddCommand( "Debug", false, "show eq", "show eq", "Show contents of event queues for logged in avatars. Used for debugging.", HandleShowEq); }
public virtual void Initialise(Scene scene, IConfigSource config) { m_gConfig = config; IConfig startupConfig = m_gConfig.Configs["Startup"]; ReadConfigAndPopulate(scene, startupConfig, "Startup"); if (enabledYN) { m_scene = scene; scene.RegisterModuleInterface<IEventQueue>(this); // Register fallback handler // Why does EQG Fail on region crossings! //scene.CommsManager.HttpServer.AddLLSDHandler("/CAPS/EQG/", EventQueueFallBack); scene.EventManager.OnNewClient += OnNewClient; // TODO: Leaving these open, or closing them when we // become a child is incorrect. It messes up TP in a big // way. CAPS/EQ need to be active as long as the UDP // circuit is there. scene.EventManager.OnClientClosed += ClientClosed; scene.EventManager.OnMakeChildAgent += MakeChildAgent; scene.EventManager.OnRegisterCaps += OnRegisterCaps; } else { m_gConfig = null; } }
public void AddRegion(Scene scene) { // m_log.InfoFormat("[XBakes]: Enabled for region {0}", scene.RegionInfo.RegionName); m_Scene = scene; scene.RegisterModuleInterface<IBakedTextureModule>(this); }
public void Initialise(Scene scene, IConfigSource config) { m_scene = scene; m_scene.RegisterModuleInterface<IRegionModule>(this); m_scene.EventManager.OnPluginConsole += EventManager_OnPluginConsole; // ini file settings try { m_enableWindlight = config.Configs["LightShare"].GetBoolean("enable_windlight", false); } catch (Exception) { m_log.Debug("[WINDLIGHT]: ini failure for enable_windlight - using default"); } if (m_enableWindlight) { m_scene.EventManager.OnMakeRootAgent += EventManager_OnMakeRootAgent; m_scene.EventManager.OnSaveNewWindlightProfile += EventManager_OnSaveNewWindlightProfile; m_scene.EventManager.OnSendNewWindlightProfileTargeted += EventManager_OnSendNewWindlightProfileTargeted; } InstallCommands(); m_log.Debug("[WINDLIGHT]: Initialised windlight module"); }
public void Initialise(Scene scene, IConfigSource config) { IConfig cloudConfig = config.Configs["Cloud"]; if (cloudConfig != null) { m_enabled = cloudConfig.GetBoolean("enabled", false); m_cloudDensity = cloudConfig.GetFloat("density", 0.5F); m_frameUpdateRate = cloudConfig.GetInt("cloud_update_rate", 1000); } if (m_enabled) { m_scene = scene; scene.EventManager.OnNewClient += CloudsToClient; scene.RegisterModuleInterface<ICloudModule>(this); scene.EventManager.OnFrame += CloudUpdate; GenerateCloudCover(); m_ready = true; } }
public void Initialise(Scene scene, IConfigSource source) { m_scene = scene; m_dialogModule = m_scene.RequestModuleInterface<IDialogModule>(); m_scene.RegisterModuleInterface<IGodsModule>(this); m_scene.EventManager.OnNewClient += SubscribeToClientEvents; }
public void AddRegion(Scene scene) { if (!m_Enabled) return; scene.RegisterModuleInterface<IXmlRpcRouter>(this); }
public void Initialise(Scene scene, IConfigSource source, ISimulationBase openSimBase) { m_config = source; m_scenes.Add(scene); //Register the interface scene.RegisterModuleInterface<IGridRegisterModule>(this); }
public virtual void Initialise(Scene scene, IConfigSource config) { IConfig cnf = config.Configs["Messaging"]; if (cnf != null && cnf.GetString( "MessageTransferModule", "MessageTransferModule") != "MessageTransferModule") { m_log.Debug("[MESSAGE TRANSFER]: Disabled by configuration"); return; } cnf = config.Configs["Startup"]; if (cnf != null) m_Gridmode = cnf.GetBoolean("gridmode", false); // m_Enabled = true; lock (m_Scenes) { if (m_Scenes.Count == 0) { MainServer.Instance.AddXmlRPCHandler( "grid_instant_message", processXMLRPCGridInstantMessage); } m_log.Debug("[MESSAGE TRANSFER]: Message transfer module active"); scene.RegisterModuleInterface<IMessageTransferModule>(this); m_Scenes.Add(scene); } }
public virtual void AddRegion(Scene scene) { if (!m_Enabled) return; scene.RegisterModuleInterface<IObjectCache>(this); }
public virtual void Initialize(Scene scene, IConfigSource config) { IConfig cnf = config.Configs["Messaging"]; if (cnf != null) { if (cnf.GetString("MessageTransferModule", "MessageTransferModule") != "MessageTransferModule") return; m_DebugLevel = cnf.GetInt("Debug", m_DebugLevel); } cnf = config.Configs["Startup"]; if (cnf != null) m_Gridmode = cnf.GetBoolean("gridmode", false); // m_Enabled = true; lock (m_Scenes) { if (m_Scenes.Count == 0) { scene.CommsManager.HttpServer.AddXmlRPCHandler("grid_instant_message", processXMLRPCGridInstantMessage); scene.CommsManager.HttpServer.AddXmlRPCHandler("gridwide_host_ban", processGridwideHostBan); // New Style scene.CommsManager.HttpServer.AddStreamHandler(new XmlRpcStreamHandler("POST", Util.XmlRpcRequestPrefix("grid_instant_message"), processXMLRPCGridInstantMessage)); scene.CommsManager.HttpServer.AddStreamHandler(new XmlRpcStreamHandler("POST", Util.XmlRpcRequestPrefix("gridwide_host_ban"), processGridwideHostBan)); } scene.RegisterModuleInterface<IMessageTransferModule>(this); m_Scenes.Add(scene); } }
public virtual void Initialise(Scene scene, IConfigSource config) { // wrap this in a try block so that defaults will work if // the config file doesn't specify otherwise. try { m_enabled = config.Configs["Chat"].GetBoolean("enabled", m_enabled); if (!m_enabled) return; m_whisperdistance = config.Configs["Chat"].GetInt("whisper_distance", m_whisperdistance); m_saydistance = config.Configs["Chat"].GetInt("say_distance", m_saydistance); m_shoutdistance = config.Configs["Chat"].GetInt("shout_distance", m_shoutdistance); } catch (Exception) { } lock (m_syncInit) { if (!m_scenes.Contains(scene)) { m_scenes.Add(scene); scene.EventManager.OnNewClient += OnNewClient; scene.EventManager.OnChatFromWorld += OnChatFromWorld; scene.EventManager.OnChatBroadcast += OnChatBroadcast; scene.RegisterModuleInterface<IChatModule>(this); } } m_log.InfoFormat("[CHAT]: Initialized for {0} w:{1} s:{2} S:{3}", scene.RegionInfo.RegionName, m_whisperdistance, m_saydistance, m_shoutdistance); }
public void Initialize(Scene scene, IConfigSource config) { lock (m_Scenes) { // This is a shared module; Initialize will be called for every region on this server. // Only check config once for the first region. if (m_Scenes.Count == 0) { IConfig cnf = config.Configs["Messaging"]; if (cnf != null && cnf.GetString( "PresenceModule", "PresenceModule") != "PresenceModule") return; cnf = config.Configs["Startup"]; if (cnf != null) m_Gridmode = cnf.GetBoolean("gridmode", false); m_Enabled = true; } if (m_Gridmode) NotifyMessageServerOfStartup(scene); m_Scenes.Add(scene); } scene.RegisterModuleInterface<IPresenceModule>(this); scene.EventManager.OnNewClient += OnNewClient; scene.EventManager.OnSetRootAgentScene += OnSetRootAgentScene; scene.EventManager.OnMakeChildAgent += OnMakeChildAgent; }
public void AddRegion(Scene scene) { enabledYN = Config.GetBoolean("Enabled", true); if (enabledYN) { m_scene = scene; scene.RegisterModuleInterface<IEventQueue>(this); // Register fallback handler // Why does EQG Fail on region crossings! //scene.CommsManager.HttpServer.AddLLSDHandler("/CAPS/EQG/", EventQueueFallBack); scene.EventManager.OnNewClient += OnNewClient; // TODO: Leaving these open, or closing them when we // become a child is incorrect. It messes up TP in a big // way. CAPS/EQ need to be active as long as the UDP // circuit is there. scene.EventManager.OnClientClosed += ClientClosed; scene.EventManager.OnMakeChildAgent += MakeChildAgent; scene.EventManager.OnRegisterCaps += OnRegisterCaps; } else { m_gConfig = null; } }
public void Initialize(Scene scene, IConfigSource config) { m_scene = scene; m_scene.RegisterModuleInterface<IRegionModule>(this); m_scene.AddCommand( this, "tree plant", "tree plant", "Start populating trees", HandleTreeConsoleCommand); m_scene.AddCommand( this, "tree active", "tree active <boolean>", "Change activity state for trees module", HandleTreeConsoleCommand); try { m_tree_density = config.Configs["Trees"].GetDouble("tree_density", m_tree_density); m_active_trees = config.Configs["Trees"].GetBoolean("active_trees", m_active_trees); } catch (Exception) { } m_trees = new List<UUID>(); if (m_active_trees) activeizeTreeze(true); m_log.Debug("[TREES]: Initialized tree module"); }
public void AddRegion(Scene scene) { m_scene = scene; m_scene.RegisterModuleInterface<IAttachmentsModule>(this); m_scene.EventManager.OnNewClient += SubscribeToClientEvents; // TODO: Should probably be subscribing to CloseClient too, but this doesn't yet give us IClientAPI }
public void AddRegion(Scene scene) { if (m_MarkerPath != String.Empty) File.Delete(Path.Combine(m_MarkerPath, scene.RegionInfo.RegionID.ToString())); m_Scene = scene; scene.RegisterModuleInterface<IRestartModule>(this); MainConsole.Instance.Commands.AddCommand("Regions", false, "region restart bluebox", "region restart bluebox <message> <delta seconds>+", "Schedule a region restart", "Schedule a region restart after a given number of seconds. If one delta is given then the region is restarted in delta seconds time. A time to restart is sent to users in the region as a dismissable bluebox notice. If multiple deltas are given then a notice is sent when we reach each delta.", HandleRegionRestart); MainConsole.Instance.Commands.AddCommand("Regions", false, "region restart notice", "region restart notice <message> <delta seconds>+", "Schedule a region restart", "Schedule a region restart after a given number of seconds. If one delta is given then the region is restarted in delta seconds time. A time to restart is sent to users in the region as a transient notice. If multiple deltas are given then a notice is sent when we reach each delta.", HandleRegionRestart); MainConsole.Instance.Commands.AddCommand("Regions", false, "region restart abort", "region restart abort [<message>]", "Abort a region restart", HandleRegionRestart); }
public void AddRegion(Scene scene) { if (!m_Enabled) return; scene.RegisterModuleInterface<IWComms>(this); m_scenes.Add(scene); }
public void Initialise(Scene scene, IConfigSource config) { m_scene = scene; m_scene.EventManager.OnNewClient += NewClient; m_scene.RegisterModuleInterface<IXfer>(this); }
public void AddRegion(Scene scene) { m_scene = scene; scene.EventManager.OnNewClient += OnNewClient; scene.EventManager.OnClientClosed += OnClientClosed; m_scene.RegisterModuleInterface<IDynamicFloaterModule>(this); }
public void Initialise(Scene scene, IConfigSource config) { if (config.Configs["Messaging"] != null) { // Allow disabling this module in config // if (config.Configs["Messaging"].GetString( "InventoryTransferModule", "InventoryTransferModule") != "InventoryTransferModule") return; } if (!m_Scenelist.Contains(scene)) { if (m_Scenelist.Count == 0) { m_TransferModule = scene.RequestModuleInterface<IMessageTransferModule>(); if (m_TransferModule == null) m_log.Error("[INVENTORY TRANSFER] No Message transfer module found, transfers will be local only"); } m_Scenelist.Add(scene); scene.RegisterModuleInterface<IInventoryTransferModule>(this); scene.EventManager.OnNewClient += OnNewClient; scene.EventManager.OnClientClosed += ClientLoggedOut; scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage; } }
public void AddRegion(Scene scene) { m_scene = scene; m_scene.RegisterModuleInterface<IBuySellModule>(this); m_scene.EventManager.OnNewClient += SubscribeToClientEvents; m_scene.EventManager.OnClosingClient += UnsubscribeFromClientEvents; }
public void Initialise(Scene scene, IConfigSource config) { if (!RegisteredScenes.ContainsKey(scene.RegionInfo.RegionID)) { // m_log.Debug("initialising AgentAssetTransactionModule"); RegisteredScenes.Add(scene.RegionInfo.RegionID, scene); scene.RegisterModuleInterface<IAgentAssetTransactions>(this); scene.EventManager.OnNewClient += NewClient; } if (m_scene == null) { m_scene = scene; if (config.Configs["StandAlone"] != null) { try { m_dumpAssetsToFile = config.Configs["StandAlone"].GetBoolean("dump_assets_to_file", false); } catch (Exception) { } } else { } } }