public static void SendMessage(string msg)
{
IChatManagerServer manager = null;
if (Util.chatManager == null)
{
ITorchSession currentSession = UpdateMePlugin.Instance.Torch.CurrentSession;
if (currentSession != null)
{
IDependencyManager managers = currentSession.Managers;
if (managers != null)
{
manager = DependencyProviderExtensions.GetManager <IChatManagerServer>(managers);
}
}
Util.chatManager = manager;
}
try
{
//Util.chatManager.DisplayMessageOnSelf("Server", msg);
Util.chatManager.SendMessageAsSelf(msg);
}
catch (Exception ex)
{
Util.Log(string.Concat("UpdateMe catched an exception!", ex, ex.StackTrace));
}
}
private void SessionManagerOnSessionStateChanged(ITorchSession session, TorchSessionState newstate)
{
switch (newstate)
{
case TorchSessionState.Loading:
break;
case TorchSessionState.Loaded:
Task.Run(async() => await Provider.Initialize());
_chat = Torch.CurrentSession.Managers.GetManager <IChatManagerServer>();
_commands = Torch.CurrentSession.Managers.GetManager <CommandManager>();
ChatService.Register();
ChatService.MessageReceived += ChatService_MessageReceived;
break;
case TorchSessionState.Unloading:
ChatService.Unregister();
ChatService.MessageReceived -= ChatService_MessageReceived;
break;
case TorchSessionState.Unloaded:
break;
default:
throw new ArgumentOutOfRangeException(nameof(newstate), newstate, null);
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
var mpMan = Torch.CurrentSession.Managers.GetManager <IMultiplayerManagerServer>();
switch (state)
{
case TorchSessionState.Loaded:
mpMan.PlayerJoined += MotdOnce;
mpMan.PlayerLeft += ResetMotdOnce;
MyEntities.OnEntityAdd += EntityAdded;
if (Config.StopShipsOnStart)
{
StopShips();
}
_control?.Dispatcher.Invoke(() =>
{
_control.IsEnabled = true;
_control.DataContext = Config;
});
AutoCommands.Instance.Start();
InfoModule.Init();
break;
case TorchSessionState.Unloading:
mpMan.PlayerLeft -= ResetMotdOnce;
mpMan.PlayerJoined -= MotdOnce;
MyEntities.OnEntityAdd -= EntityAdded;
_bagTracker.Clear();
_removalTracker.Clear();
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
switch (state)
{
case TorchSessionState.Loaded:
MySession.Static.Factions.OnPlayerJoined += PlayerJoinedFaction;
MySession.Static.Factions.OnPlayerLeft += PlayerLeftFaction;
MySession.Static.Factions.FactionCreated += FactionCreated;
MySession.Static.Factions.FactionStateChanged += FactionStateChanged;
MyVisualScriptLogicProvider.PlayerConnected += PlayerConnected;
MyVisualScriptLogicProvider.PlayerDisconnected += PlayerDisconnected;
break;
case TorchSessionState.Unloading:
MySession.Static.Factions.OnPlayerJoined -= PlayerJoinedFaction;
MySession.Static.Factions.OnPlayerLeft -= PlayerLeftFaction;
MySession.Static.Factions.FactionCreated -= FactionCreated;
MySession.Static.Factions.FactionStateChanged -= FactionStateChanged;
MyVisualScriptLogicProvider.PlayerConnected -= PlayerConnected;
MyVisualScriptLogicProvider.PlayerDisconnected -= PlayerDisconnected;
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
switch (state)
{
case TorchSessionState.Loaded:
Tebex.logInfo($"Game started....");
if (Instance.Config.Secret == "")
{
logError("You have not yet defined your secret key. Use !tebex:secret <secret> to define your key");
}
else
{
TebexInfoModule infoCommand = new TebexInfoModule();
infoCommand.TebexInfo();
}
// Create a timer with a two second interval.
aTimer = new System.Timers.Timer(60000);
// Hook up the Elapsed event for the timer.
aTimer.Elapsed += checkQueue;
aTimer.AutoReset = true;
aTimer.Enabled = true;
break;
case TorchSessionState.Unloading:
Tebex.logInfo($"Game ending....");
aTimer.Enabled = false;
aTimer.Dispose();
break;
}
}
public MultigridProjectorTorchAgent(ITorchSession torchSession)
{
var pluginManager = torchSession.Managers.GetManager <PluginManager>();
if (!pluginManager.Plugins.TryGetValue(PluginId, out var plugin))
{
return;
}
Api = plugin.GetType().GetProperty("Api")?.GetValue(plugin);
if (Api == null)
{
return;
}
var apiType = Api.GetType();
Version = (string)apiType.GetProperty("Version")?.GetValue(Api);
if (Version == null || !Version.StartsWith(CompatibleMajorVersion))
{
return;
}
_miGetSubgridCount = apiType.GetMethod("GetSubgridCount", BindingFlags.Instance | BindingFlags.Public);
_miGetOriginalGridBuilders = apiType.GetMethod("GetOriginalGridBuilders", BindingFlags.Instance | BindingFlags.Public);
_miGetPreviewGrid = apiType.GetMethod("GetPreviewGrid", BindingFlags.Instance | BindingFlags.Public);
_miGetBuiltGrid = apiType.GetMethod("GetBuiltGrid", BindingFlags.Instance | BindingFlags.Public);
_miGetBlockState = apiType.GetMethod("GetBlockState", BindingFlags.Instance | BindingFlags.Public);
_miGetBlockStates = apiType.GetMethod("GetBlockStates", BindingFlags.Instance | BindingFlags.Public);
_miGetBaseConnections = apiType.GetMethod("GetBaseConnections", BindingFlags.Instance | BindingFlags.Public);
_miGetTopConnections = apiType.GetMethod("GetTopConnections", BindingFlags.Instance | BindingFlags.Public);
Plugin = plugin;
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
RestartConfig config = RestartPlugin.Instance.Config;
switch (state)
{
case TorchSessionState.Unloading:
if (!config.Enabled)
{
Log.Warn("Restart Watchdog disabled! Will not attempt any restarts if server is stuck!");
return;
}
Log.Info("Start Unloading!!!");
int delayUnloading = config.DelayInSeconds;
Log.Info("Wait for " + delayUnloading + " seconds before force Restart!");
/* Delay is in Seconds We need Milliseconds so * 1000 */
Task.Delay(delayUnloading * 1000).ContinueWith((t) => {
CheckRestart(session);
});
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
switch (state)
{
case TorchSessionState.Loaded:
multiplayerManagerBase = Torch.CurrentSession.Managers.GetManager <IMultiplayerManagerBase>();
if (multiplayerManagerBase != null)
{
multiplayerManagerBase.PlayerJoined += PlayerJoined;
multiplayerManagerBase.PlayerLeft += PlayerLeft;
}
else
{
Log.Warn("No multiplayer manager loaded!");
}
RemoveGpsFromAllPlayers();
break;
case TorchSessionState.Unloading:
if (multiplayerManagerBase != null)
{
multiplayerManagerBase.PlayerJoined -= PlayerJoined;
multiplayerManagerBase.PlayerLeft -= PlayerLeft;
}
break;
}
}
private void SessionStateChanged(ITorchSession session, TorchSessionState state)
{
switch (state)
{
case TorchSessionState.Loading:
Dispatcher.InvokeAsync(() => ChatItems.Inlines.Clear());
break;
case TorchSessionState.Loaded:
{
var chatMgr = session.Managers.GetManager <IChatManagerClient>();
if (chatMgr != null)
{
chatMgr.MessageRecieved += OnMessageRecieved;
}
}
break;
case TorchSessionState.Unloading:
{
var chatMgr = session.Managers.GetManager <IChatManagerClient>();
if (chatMgr != null)
{
chatMgr.MessageRecieved -= OnMessageRecieved;
}
}
break;
case TorchSessionState.Unloaded:
break;
default:
throw new ArgumentOutOfRangeException(nameof(state), state, null);
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
ServerRunning = state == TorchSessionState.Loaded;
switch (state)
{
case TorchSessionState.Loaded:
IsRunning = true;
MP = Torch.CurrentSession.Managers.GetManager <MultiplayerManagerBase>();
ChatManager = Torch.CurrentSession.Managers.GetManager <ChatManagerServer>();
PluginManager Plugins = Torch.CurrentSession.Managers.GetManager <PluginManager>();
BlockLimiterConnection(Plugins);
GridBackupConnection(Plugins);
Tracker.ServerStarted(Config.FolderDirectory);
if (Config.GridMarketEnabled)
{
Market.InitilizeComms(ChatManager, MP);
}
AutoHangarStamp = DateTime.Now;
break;
case TorchSessionState.Unloading:
PluginDispose();
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
switch (state)
{
case TorchSessionState.Loaded:
MyEntities.OnEntityAdd += MotdOnce;
if (Sync.Players != null)
{
Sync.Players.PlayerCharacterDied += ResetMotdOnce;
}
break;
case TorchSessionState.Unloading:
MyEntities.OnEntityAdd -= MotdOnce;
if (Sync.Players != null)
{
Sync.Players.PlayerCharacterDied -= ResetMotdOnce;
}
break;
default:
// ignore
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
switch (state)
{
case TorchSessionState.Loading:
Hangar.Config.RefreshModel();
break;
case TorchSessionState.Loaded:
//MP = Torch.CurrentSession.Managers.GetManager<MultiplayerManagerBase>();
//ChatManager = Torch.CurrentSession.Managers.GetManager<ChatManagerServer>();
PluginManager Plugins = Torch.CurrentSession.Managers.GetManager <PluginManager>();
PluginDependencies.InitPluginDependencies(Plugins);
ServerRunning = true;
AutoHangar.StartAutoHangar();
Controller?.ServerStarted();
break;
case TorchSessionState.Unloading:
ServerRunning = false;
PluginDispose();
break;
}
}
private void SessionManagerOnSessionStateChanged(ITorchSession session, TorchSessionState newState)
{
var mgr = session.Managers.GetManager <CommandManager>();
if (mgr == null)
{
return;
}
switch (newState)
{
case TorchSessionState.Loaded:
foreach (ITorchPlugin plugin in _plugins.Values)
{
mgr.RegisterPluginCommands(plugin);
}
return;
case TorchSessionState.Unloading:
foreach (ITorchPlugin plugin in _plugins.Values)
{
mgr.UnregisterPluginCommands(plugin);
}
return;
case TorchSessionState.Loading:
case TorchSessionState.Unloaded:
default:
return;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
switch (state)
{
case TorchSessionState.Loaded:
_multibase = Torch.CurrentSession.Managers.GetManager <IMultiplayerManagerBase>();
if (_multibase != null)
{
_multibase.PlayerJoined += _multibase_PlayerJoined;
MyEntities.OnEntityAdd += MyEntities_OnEntityAdd;
_multibase.PlayerLeft += _multibase_PlayerLeft;
}
else
{
Log.Warn("No join/leave manager loaded!");
}
_chatmanager = Torch.CurrentSession.Managers.GetManager <ChatManagerServer>();
if (_chatmanager != null)
{
_chatmanager.MessageRecieved += MessageRecieved;
}
else
{
Log.Warn("No chat manager loaded!");
}
Log.Warn("Starting Discord Bridge!");
DDBridge = new DiscordBridge(this);
//send status
if (Config.UseStatus)
{
StartTimer();
}
break;
case TorchSessionState.Unloading:
if (DDBridge != null)
{
if (Config.Stopped.Length > 0)
{
DDBridge.SendStatusMessage(null, Config.Stopped);
}
DDBridge.Stopdiscord();
}
Log.Warn("Discord Bridge Unloaded!");
Dispose();
break;
default:
// ignore
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
//Do something here in the future
Log.Info("Session-State is now " + newState);
if (newState == TorchSessionState.Loaded)
{
}
}
void SessionStateChanged(ITorchSession session, TorchSessionState newState)
{
if (newState != TorchSessionState.Unloading)
{
return;
}
// todo
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
if (newState == TorchSessionState.Loaded)
{
MyCubeGridPatch.Patch(ctx);
patchManager.Commit();
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
var mpMan = Torch.CurrentSession.Managers.GetManager <IMultiplayerManagerServer>();
var cmdMan = Torch.CurrentSession.Managers.GetManager <CommandManager>();
switch (state)
{
case TorchSessionState.Loading:
string homeData = File.ReadAllText(homeDataPath);
if (!string.IsNullOrEmpty(homeData))
{
PlayerAccountModule.PlayersAccounts = JsonConvert.DeserializeObject <List <PlayerAccountModule.PlayerAccountData> >(File.ReadAllText(homeDataPath));
}
string rankdata = File.ReadAllText(rankDataPath);
if (!string.IsNullOrEmpty(rankdata))
{
RanksAndPermissionsModule.Ranks = JsonConvert.DeserializeObject <List <RanksAndPermissionsModule.RankData> >(File.ReadAllText(rankDataPath));
}
break;
case TorchSessionState.Loaded:
mpMan.PlayerJoined += AccModule.GenerateAccount;
mpMan.PlayerJoined += MotdOnce;
if (Config.EnableRanks)
{
RanksAndPermissions.GenerateRank(Config.DefaultRank);
mpMan.PlayerJoined += RanksAndPermissions.RegisterInheritedRanks;
}
mpMan.PlayerLeft += ResetMotdOnce;
cmdMan.OnCommandExecuting += RanksAndPermissions.HasCommandPermission;
MyEntities.OnEntityAdd += EntityAdded;
if (Config.StopShipsOnStart)
{
StopShips();
}
_control?.Dispatcher.Invoke(() =>
{
_control.IsEnabled = true;
_control.DataContext = Config;
});
AutoCommands.Instance.Start();
InfoModule.Init();
break;
case TorchSessionState.Unloading:
mpMan.PlayerLeft -= ResetMotdOnce;
mpMan.PlayerJoined -= MotdOnce;
MyEntities.OnEntityAdd -= EntityAdded;
_bagTracker.Clear();
_removalTracker.Clear();
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
PublishChange(new HiveChangeEvent
{
type = EVENT_TYPE_SERVER_STATE_CHANGED,
raw = new JavaScriptSerializer().Serialize(new ServerStateChanged
{
State = newState.ToString(),
}),
});
}
private void SessionStateChanged(ITorchSession session, TorchSessionState newState)
{
switch (newState)
{
case TorchSessionState.Loaded:
Dispatcher.InvokeAsync(() => DataContext = _server?.CurrentSession?.Managers.GetManager <MultiplayerManagerDedicated>());
break;
case TorchSessionState.Unloading:
Dispatcher.InvokeAsync(() => DataContext = null);
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
if (newState == TorchSessionState.Loaded)
{
stopWatch.Start();
Log.Info("Session loaded, start backup timer!");
}
else if (newState == TorchSessionState.Unloading)
{
stopWatch.Stop();
Log.Info("Session Unloading, suspend backup timer!");
}
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
if (newState == TorchSessionState.Loading)
{
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_CREATED, ReceivedFactionCreated);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_EDITED, ReceivedFactionEdited);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_AUTO_ACCEPT_CHANGED, ReceivedFactionAutoAcceptChanged);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_REMOVED, ReceivedFactionRemoved);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_MEMBER_SEND_JOIN, ReceivedFactionMemberSendJoin);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_MEMBER_CANCEL_JOIN, ReceivedFactionMemberCancelJoin);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_MEMBER_ACCEPT_JOIN, ReceivedFactionMemberAcceptJoin);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_MEMBER_PROMOTE, ReceivedFactionMemberPromote);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_MEMBER_DEMOTE, ReceivedFactionMemberDemote);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_MEMBER_KICK, ReceivedFactionMemberKick);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_MEMBER_LEAVE, ReceivedFactionMemberLeave);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_SEND_PEACE_REQUEST, ReceivedFactionSendPeaceRequest);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_CANCEL_PEACE_REQUEST, ReceivedFactionCancelPeaceRequest);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_ACCEPT_PEACE, ReceivedFactionAcceptPeace);
_uplinkManager.RegisterChangeListener(EVENT_TYPE_FACTION_DECLARE_WAR, ReceivedFactionDeclareWar);
}
else if (newState == TorchSessionState.Loaded)
{
MySession.Static.Factions.FactionCreated += NotifyFactionCreated;
MySession.Static.Factions.FactionAutoAcceptChanged += NotifyFactionAutoAcceptChanged;
MySession.Static.Factions.FactionEdited += NotifyFactionEdited;
MySession.Static.Factions.FactionStateChanged += Factions_FactionStateChanged;
}
else if (newState == TorchSessionState.Unloading)
{
MySession.Static.Factions.FactionCreated -= NotifyFactionCreated;
MySession.Static.Factions.FactionAutoAcceptChanged -= NotifyFactionAutoAcceptChanged;
MySession.Static.Factions.FactionEdited -= NotifyFactionEdited;
MySession.Static.Factions.FactionStateChanged -= Factions_FactionStateChanged;
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_CREATED, ReceivedFactionCreated);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_EDITED, ReceivedFactionEdited);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_AUTO_ACCEPT_CHANGED, ReceivedFactionAutoAcceptChanged);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_REMOVED, ReceivedFactionRemoved);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_MEMBER_SEND_JOIN, ReceivedFactionMemberSendJoin);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_MEMBER_CANCEL_JOIN, ReceivedFactionMemberCancelJoin);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_MEMBER_ACCEPT_JOIN, ReceivedFactionMemberAcceptJoin);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_MEMBER_PROMOTE, ReceivedFactionMemberPromote);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_MEMBER_DEMOTE, ReceivedFactionMemberDemote);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_MEMBER_KICK, ReceivedFactionMemberKick);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_MEMBER_LEAVE, ReceivedFactionMemberLeave);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_SEND_PEACE_REQUEST, ReceivedFactionSendPeaceRequest);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_CANCEL_PEACE_REQUEST, ReceivedFactionCancelPeaceRequest);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_ACCEPT_PEACE, ReceivedFactionAcceptPeace);
_uplinkManager.UnregisterChangeListener(EVENT_TYPE_FACTION_DECLARE_WAR, ReceivedFactionDeclareWar);
}
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
// ReSharper disable once ConvertIfStatementToSwitchStatement
if (newState == TorchSessionState.Loaded)
{
StartBot();
Config.SessionLoaded = true;
}
else if (newState == TorchSessionState.Unloading)
{
Config.SessionLoaded = false;
StopBot();
}
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
//Log.Info("Session-State is now " + newState);
switch (newState)
{
case TorchSessionState.Loaded:
{
MyAPIGateway.ContractSystem.CustomActivateContract += ContractSystem_CustomActivateContract;
MyAPIGateway.ContractSystem.CustomFailFor += ContractSystem_CustomFailFor;
MyAPIGateway.ContractSystem.CustomFinish += ContractSystem_CustomFinish;
MyAPIGateway.Session.DamageSystem.RegisterBeforeDamageHandler(0, DamageApplied);
break;
}
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
switch (state)
{
case TorchSessionState.Loaded:
Task.Delay(3000).ContinueWith((t) =>
{
Log.Debug("Patching MyLargeTurretBasePatch");
_ctx.GetPattern(MyLargeTurretBasePatch._updateAfterSimulation).Prefixes.Add(MyLargeTurretBasePatch._throttler1);
_ctx.GetPattern(MyLargeTurretBasePatch._updateAfterSimulation10).Prefixes.Add(MyLargeTurretBasePatch._throttler10);
_patchManager.Commit();
});
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
_running = state == TorchSessionState.Loaded;
switch (state)
{
case TorchSessionState.Loading:
var storageDir = Path.Combine(Torch.CurrentSession.KeenSession.CurrentPath, "Storage");
if (!Directory.Exists(storageDir))
{
Directory.CreateDirectory(storageDir);
}
timeDataPath = Path.Combine(storageDir, "BLPlayerTime.json");
if (!File.Exists(timeDataPath))
{
var stream = File.Create(timeDataPath);
Log.Warn($"Creating Player Time data at {timeDataPath}");
stream.Dispose();
}
break;
case TorchSessionState.Loaded:
var data = File.ReadAllText(timeDataPath);
if (!string.IsNullOrEmpty(data))
{
PlayerTimeModule.PlayerTimes =
JsonConvert.DeserializeObject <List <PlayerTimeModule.PlayerTimeData> >(data);
}
Torch.CurrentSession.Managers.GetManager <IMultiplayerManagerServer>().PlayerJoined +=
PlayerTimeModule.LogTime;
DoInit();
EnableControl();
GetVanillaLimits();
if (BlockLimiterConfig.Instance.EnableLimits)
{
Activate();
}
break;
case TorchSessionState.Unloading:
break;
default:
return;
}
}
public void SessionChanged(ITorchSession session, TorchSessionState state)
{
if (!Config.Enabled)
{
return;
}
switch (state)
{
case TorchSessionState.Loaded:
//load
LoadSEDB();
if (DDBridge != null)
{
DDBridge.SendStatusMessage(null, Config.Started);
}
break;
case TorchSessionState.Unloading:
if (IsRestart)
{
if (Config.Restarted.Length > 0)
{
DDBridge.SendStatusMessage(null, Config.Restarted);
}
}
else
{
if (Config.Stopped.Length > 0)
{
DDBridge.SendStatusMessage(null, Config.Stopped);
}
}
break;
case TorchSessionState.Unloaded:
//unload
UnloadSEDB();
break;
default:
// ignore
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState state)
{
var mpMan = Torch.CurrentSession.Managers.GetManager <IMultiplayerManagerServer>();
switch (state)
{
case TorchSessionState.Loaded:
mpMan.PlayerLeft += ResetMotdOnce;
MyEntities.OnEntityAdd += MotdOnce;
break;
case TorchSessionState.Unloading:
mpMan.PlayerLeft -= ResetMotdOnce;
MyEntities.OnEntityAdd -= MotdOnce;
break;
}
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
//Do something here in the future
Log.Info("Session-State is now " + newState);
if (newState == TorchSessionState.Loaded)
{
derp = TorchSessionState.Loaded;
MySession.Static.Factions.FactionStateChanged += FactionLogging.StateChange;
MyBankingSystem.Static.OnAccountBalanceChanged += BankPatch.BalanceChangedMethod2;
if (Torch.Managers.GetManager <PluginManager>().Plugins.TryGetValue(Guid.Parse("74796707-646f-4ebd-8700-d077a5f47af3"), out ITorchPlugin Alliances))
{
AlliancesInstalled = true;
}
// session.Managers.GetManager<IMultiplayerManagerBase>().PlayerJoined += test;
MyAPIGateway.Session.DamageSystem.RegisterBeforeDamageHandler(0, DamageCheck);
}
}
private void SessionChanged(ITorchSession session, TorchSessionState newState)
{
if (newState == TorchSessionState.Loaded)
{
MySession.Static.Factions.FactionCreated += Factions_FactionCreated;
MySession.Static.Factions.FactionAutoAcceptChanged += Factions_FactionAutoAcceptChanged;
MySession.Static.Factions.FactionEdited += Factions_FactionEdited;
MySession.Static.Factions.FactionStateChanged += Factions_FactionStateChanged;
}
else if (newState == TorchSessionState.Unloading)
{
MySession.Static.Factions.FactionCreated -= Factions_FactionCreated;
MySession.Static.Factions.FactionAutoAcceptChanged -= Factions_FactionAutoAcceptChanged;
MySession.Static.Factions.FactionEdited -= Factions_FactionEdited;
MySession.Static.Factions.FactionStateChanged -= Factions_FactionStateChanged;
}
}
