public void BadExit()
        {
            var mymod = ResetModeMod.Instance;

            if (Main.netMode == 1)
            {
                throw new ModHelpersException("Single or server only.");
            }

            if (mymod.Session.IsExiting)
            {
                return;
            }
            mymod.Session.IsExiting = true;

            if (mymod.Config.DebugModeInfo)
            {
                LogHelpers.Alert();
            }

            string msg = "World not valid for reset mode. Exiting...";

            if (Main.netMode == 0)
            {
                //TmlHelpers.ExitToMenu( false );
                TimeLimitAPI.TimerStart("exit", 4, false);
                Main.NewText(msg, Color.Red);
            }
            else
            {
                //TmlHelpers.ExitToDesktop( false );
                TimeLimitAPI.TimerStart("serverclose", 4, false);
                NetMessage.BroadcastChatMessage(NetworkText.FromLiteral(msg), Color.Red);
            }
        }
Exemple #2
0
        ////////////////

        public void BeginResetTimer()
        {
            var mymod = ResetModeMod.Instance;

            if (mymod.Config.DebugModeInfo)
            {
                LogHelpers.Alert();
            }

            if (TimeLimitAPI.GetTimersOf("reset").Count > 0)
            {
                LogHelpers.Alert("Existing reset timers halted.");
                Main.NewText("Warning: Existing reset timers removed.");
            }
            TimeLimitAPI.TimerStop("reset");                    // Stop regardless? API failure perhaps?

            if (!this.Data.AwaitingNextWorld)
            {
                TimeLimitAPI.TimerStart("reset", mymod.Config.SecondsUntilResetInitially, false);
            }
            else
            {
                TimeLimitAPI.TimerStart("reset", mymod.Config.SecondsUntilResetSubsequently, false);
            }
        }
        public void GoodExit()
        {
            var mymod = ResetModeMod.Instance;

            if (Main.netMode == 1)
            {
                throw new ModHelpersException("Single or server only.");
            }

            if (mymod.Session.IsExiting)
            {
                return;
            }
            mymod.Session.IsExiting = true;

            if (mymod.Config.DebugModeInfo)
            {
                LogHelpers.Alert();
            }

            string msg = "This world is now expired. Please switch to the next world to continue.";

            if (Main.netMode == 0)
            {
                Main.NewText(msg, Color.Red);

                TimeLimitAPI.TimerStart("exit", 5, false);
            }
            else if (Main.netMode == 2)
            {
                NetMessage.BroadcastChatMessage(NetworkText.FromLiteral(msg), Color.Red, -1);

                TimeLimitAPI.TimerStart("serverclose", 7, false);
            }
        }
Exemple #4
0
        public void ResetCurrentWorldForSession()
        {
            this.Data.PlayersValidated.Clear();
            this.Data.CurrentSessionedWorldId = "";

            TimeLimitAPI.TimerStop("reset");
        }
        internal void OnModLoad()
        {
            LoadHooks.AddPostModLoadHook(() => {
                var hook = new CustomTimerAction(delegate() {
                    if (Main.netMode == 1)
                    {
                        return;
                    }
                    this.ExpireCurrentWorldInSession(ResetModeMod.Instance);
                });

                TimeLimitAPI.AddCustomAction("reset", hook);

                this.Load();
                this.LoadRewards();
            });


            LoadHooks.AddPostWorldLoadEachHook(delegate {
                var mymod = ResetModeMod.Instance;

                if (mymod.Config.AutoStartSession)
                {
                    if (Main.netMode == 0 || Main.netMode == 2)
                    {
                        this.StartSession();
                    }
                }

                this.IsWorldInPlay = true;
            });


            LoadHooks.AddWorldUnloadEachHook(() => {
                this.IsWorldInPlay = false;
            });


            LoadHooks.AddPostWorldUnloadEachHook(() => {
                var mymod = ResetModeMod.Instance;

                if (mymod.Config.DebugModeInfo)
                {
                    LogHelpers.Alert("(In promise) - Unloading world...");
                }

                this.IsExiting = false;

                if (mymod.CurrentNetMode == 0 || mymod.CurrentNetMode == 2)
                {
                    if (mymod.Config.DeleteAllWorldsBetweenGames)
                    {
                        if (this.Data.AwaitingNextWorld)
                        {
                            this.ClearAllWorlds();
                        }
                    }

                    this.Save();
                }

                CustomLoadHooks.TriggerHook(ResetModeMod.WorldExitValidator, ResetModeMod.MyValidatorKey);
            });
        }