Esempio n. 1
0
 /// <summary>
 /// Thread safe, isn't handled until next tick.
 /// </summary>
 /// <param name="next"></param>
 private void EnqueueGotoState(FreeSOMazeStates next)
 {
     if (!next.Equals(GameState))
     {
         NextState = next;
     }
 }
Esempio n. 2
0
 public VMEODMazeTwoPlugin(VMEODServer server) : base(server)
 {
     NextState = FreeSOMazeStates.Invalid;
     ThankU    = new Random();
     BinaryHandlers["FreeSOMaze_choose_difficulty"] = ChooseDifficultyHandler;
     BinaryHandlers["FreeSOMaze_loaded"]            = FirstLoadHandler;
     BinaryHandlers["FreeSOMaze_partner_failsafe"]  = FirstLoadHandler;
     BinaryHandlers["FreeSOMaze_move_request"]      = MoveRequestHandler;
 }
Esempio n. 3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="state"></param>
        private void GotoState(FreeSOMazeStates state)
        {
            GameState = state;
            Tock      = 0;
            switch (state)
            {
            case FreeSOMazeStates.Lobby:
            {
                ChosenMazeDifficulty = FreeSOMazeDifficulties.Unselected;
                CharismaPlayer?.Reset();
                if (CharismaPlayer?.IsLoaded ?? false)
                {
                    SendLobbyInfoEvent(CharismaPlayer, LogicPlayer);
                }
                LogicPlayer?.Reset();
                if (LogicPlayer?.IsLoaded ?? false)
                {
                    SendLobbyInfoEvent(LogicPlayer, CharismaPlayer);
                }

                if (CurrentMaze != null)
                {
                    CurrentMaze.OnMazeGenerated       -= MazeGeneratedHandler;
                    CurrentMaze.OnFinalProcessingCell -= OnProcessedCellHandler;
                    CurrentMaze.OnDeadEndCreation     -= OnDeadEndHandler;
                    Solution          = null;
                    RawMaze           = null;
                    MazeTimeRemaining = 0;
                    BroadcastSharedEvent("FreeSOMaze_time", BitConverter.GetBytes(MazeTimeRemaining));
                }
                else
                {
                    EveryDeadEndCell = new List <AbstractMazeCell <FreeSOMazeData> >();
                }
                break;
            }

            case FreeSOMazeStates.GeneratingMaze:
            {
                CurrentMaze = AbstractMazeGenerator <FreeSOMazeData> .GetEmptyMaze(MazeSizes[ChosenMazeDifficulty], MazeSizes[ChosenMazeDifficulty]);

                CurrentMaze.OnMazeGenerated       += MazeGeneratedHandler;
                CurrentMaze.OnFinalProcessingCell += OnProcessedCellHandler;
                CurrentMaze.OnDeadEndCreation     += OnDeadEndHandler;
                var origin = ThankU.Next(0, (int)BuildFromOrigins.Dead_Center + 1);
                CurrentMaze.BuildFromOrigin(origin);
                BroadcastSharedEvent("FreeSOMaze_goto_maze", BitConverter.GetBytes((int)ChosenMazeDifficulty));
                break;
            }

            case FreeSOMazeStates.LoadingMaze:
            {
                MazeTimeRemaining = 0;
                int cardinal = 0;
                if (CharismaPlayer != null)
                {
                    cardinal = GetSolutionCardinal(CharismaPlayer);
                    CharismaPlayer.CurrentFacingCardinal = (FreeSOMazeCardinals)Enum.ToObject(typeof(FreeSOMazeCardinals), cardinal);
                    CharismaPlayer.Send("FreeSOMaze_show_maze", CharismaPlayer.GetLocationData((int)FreeSOMazeCardinals.Invalid));
                }
                if (LogicPlayer != null)
                {
                    cardinal = GetSolutionCardinal(LogicPlayer);
                    LogicPlayer.CurrentFacingCardinal = (FreeSOMazeCardinals)Enum.ToObject(typeof(FreeSOMazeCardinals), cardinal);
                    LogicPlayer.Send("FreeSOMaze_show_maze", LogicPlayer.GetLocationData((int)FreeSOMazeCardinals.Invalid));
                }
                break;
            }

            case FreeSOMazeStates.NavigatingMaze:
            {
                CharismaPlayer.Cooldown = GLOBAL_COOLDOWN;
                LogicPlayer.Cooldown    = GLOBAL_COOLDOWN;
                SendAllowMazeEvent(CharismaPlayer, false);
                SendAllowMazeEvent(LogicPlayer, false);
                MazeTimeRemaining = RoundTimes[ChosenMazeDifficulty];
                BroadcastSharedEvent("FreeSOMaze_time", BitConverter.GetBytes(MazeTimeRemaining));
                break;
            }

            case FreeSOMazeStates.Gameover:
            {
                MazeTimeRemaining = 0;
                break;
            }
            }
        }
Esempio n. 4
0
        public override void Tick()
        {
            if (!NextState.Equals(FreeSOMazeStates.Invalid))
            {
                var state = NextState;
                NextState = FreeSOMazeStates.Invalid;
                GotoState(state);
            }
            switch (GameState)
            {
            case FreeSOMazeStates.LoadingMaze:
            {
                if (++Tock > 30)
                {
                    Tock = 0;
                    if (++MazeTimeRemaining >= GLOBAL_COOLDOWN)
                    {
                        EnqueueGotoState(FreeSOMazeStates.NavigatingMaze);
                    }
                }
                break;
            }

            case FreeSOMazeStates.NavigatingMaze:
            {
                if (++Tock > 30)
                {
                    Tock = 0;
                    BroadcastSharedEvent("FreeSOMaze_time", BitConverter.GetBytes(--MazeTimeRemaining));
                    if (MazeTimeRemaining <= 0)
                    {
                        DoTimeExpired();
                    }
                    else
                    {
                        if (CharismaPlayer != null)
                        {
                            CharismaPlayer.Cooldown++;
                        }
                        if (LogicPlayer != null)
                        {
                            LogicPlayer.Cooldown++;
                        }
                    }
                }
                break;
            }

            case FreeSOMazeStates.Gameover:
            {
                if (++Tock > 30)
                {
                    Tock = 0;

                    if (++MazeTimeRemaining >= GLOBAL_COOLDOWN * 2)
                    {
                        EnqueueGotoState(FreeSOMazeStates.Lobby);
                    }
                    else
                    {
                        if (LogicPlayer != null && ++LogicPlayer.Cooldown >= GLOBAL_COOLDOWN)
                        {
                            LogicPlayer.ProcessPayout();
                        }
                        if (CharismaPlayer != null && ++CharismaPlayer.Cooldown >= GLOBAL_COOLDOWN)
                        {
                            CharismaPlayer.ProcessPayout();
                        }
                    }
                }
                break;
            }
            }
            base.Tick();
        }