C# GameStates类代码示例

 public void Win()
 {
     if(gameState == GameStates.Playing) {
         gameState = GameStates.Won;
         winScreen.SetActive(true);
     }
 }

    private void destroyGameState(GameStates pState)
    {
        switch (pState)
        {
            case GameStates.menu:
                {
                    if (_menu != null) { _menu.Destroy(); }
                    break;
                }
            case GameStates.level:
                {
                    //if (_level != null) { _level.Destroy(); }
                    break;
                }
            case GameStates.bossarena:
                {
                    if (_bossArena != null) { _bossArena.Destroy(); }
                    break;
                }
            case GameStates.nameinput:
                {
                    if (_nameinput != null) { _nameinput.Destroy(); }
                    break;
                }
            case GameStates.endscreen:
                {
                    if (_endscreen != null) { _endscreen.Destroy(); }
                    break;
                }

        }
    }

        public void EnterMenu(GameStates stateWhenEntering, GameStates menuTypeToEnter)
        {
            previousGameState = stateWhenEntering;
            currentSelectionIndex = 0;
            prevSelectionIndex = 0;
            menuType = menuTypeToEnter;

            if (menuType == GameStates.MainMenu)
            {
                Game.SoundManager.PlaySong("LOD", true);
                foreach (MenuEntry entry in MainMenuEntries.Keys)
                {
                    entry.SetUnselected();
                }
                MainMenuEntries.ElementAt(currentSelectionIndex).Key.SetSelected();
            }
            else if (menuType == GameStates.PAUSE)
            {
                foreach (MenuEntry entry in PauseMenuEntries.Keys)
                {
                    entry.SetUnselected();
                }
                PauseMenuEntries.ElementAt(currentSelectionIndex).Key.SetSelected();
            }
        }

 public static void ChangeToState(GameStates state)
 {
     switch (state)
     {
         case GameStates.MainMenuState:
             CurrentState = new MainMenuState(currentScreenSize);
             break;
         case GameStates.LevelOneState:
             CurrentState = new LevelOneState(content, currentScreenSize);
             break;
         case GameStates.LevelTwoState:
             CurrentState = new LevelTwoState(content, currentScreenSize);
             break;
         case GameStates.LevelThreeState:
             CurrentState = new LevelThreeState(content, currentScreenSize);
             break;
         case GameStates.FinalLevel:
             CurrentState = new FinalLevel(content, currentScreenSize);
             break;
         case GameStates.Quit:
             CurrentState = new QuitState(currentScreenSize);
             break;
         case GameStates.PickName:
             CurrentState = new PickNameState(currentScreenSize);
             break;
             case GameStates.HighScore:
             CurrentState = new HighScoreState(currentScreenSize);
             break;
     }
     if (UnSeriousEngine.isInitialized)
     {
         CurrentState.LoadContent(Content);
     }
 }

 // Event
 public void FirstEvent()
 {
     eventManager.firstEvent -= FirstEvent;
     state = GameStates.Stop;
     Vector3 cameraPos = Camera.main.gameObject.transform.position;
     Instantiate (bossList[0], new Vector3(cameraPos.x, cameraPos.y + 12f, 0f), Quaternion.identity);
 }

 private void inputHandler()
 {
     if (Input.GetKeyDown("p")) {
         state = state == GameStates.Run ? GameStates.Pause : GameStates.Run;
         Time.timeScale = Time.timeScale == 0f ? 1f : 0f;
     }
 }

        //  The GameClass constructor.  Here we create, but not show, the GameSettings form.
        // The
        public GameClass(MainClass mainClass, Control owner)
        {
            gameState = GameStates.Loading;
            this.owner = owner;
            this.mainClass = mainClass;
            splash = new SplashScreen(this);
            splash.ShowDialog();
            gameSettings = new SpaceWar.GameSettings(this);
            gameSettings.Location = new Point(owner.Bounds.Right,owner.Bounds.Top);
            gravity = gameSettings.Gravity;
            gameSpeed = gameSettings.GameSpeed;
            bounceBack = gameSettings.Bounce;
            inverseGravity = gameSettings.InverseGravity;
            blackHole = gameSettings.BlackHole;

            localDevice = new Microsoft.DirectX.DirectDraw.Device();
            localDevice.SetCooperativeLevel(owner, Microsoft.DirectX.DirectDraw.CooperativeLevelFlags.Normal);

            DXUtil.Timer(DirectXTimer.Start);

            SpaceWar.RotatableShape.CreateShapes();

            input = new InputClass(this.owner);

            soundHandler = new SoundHandler(this.owner);

            try {
                netPeer = new PlayClass(this);
            }
            catch(DirectXException e) {
                MessageBox.Show(owner,e.ToString());
            }
        }

 public void Update(GameTime gameTime, ref GameStates gameState)
 {
     if (_mControls.IsBackPressed(false))
         gameState = GameStates.Exit;
     if (_mControls.IsStartPressed(false) || _mControls.IsAPressed(false))
         gameState = GameStates.MainMenu;
 }

        public ReflexGameWindow(string userName, int initialGameTime)
        {
            InitializeComponent();
            SetMouseForm(gameWindow, CHART_WIDTH, CHART_HEIGHT, timeLabel);
            setTimeOutMethod(timedOut);
            setQuestionTime((double)initialGameTime);

            CoordsList = new List<TimePoint>();

            greenBrush = new SolidBrush(Color.Green);
            blueBrush = new SolidBrush(Color.Blue);
            redBrush = new SolidBrush(Color.Red);

            this.maxGameTime = INITIAL_GAME_TIME = initialGameTime;
            graphics = gameWindow.CreateGraphics();
            gameState = GameStates.OutOfGame;
            this.userName = userName;
            rnd = new Random();

            scoreLabel.Text = "";
            timeLabel.Text = "";

            stopRButton.Enabled = false;
            stopLButton.Enabled = false;
        }

 public void setGameState(GameStates pState)
 {
     if (pState == _state) return;
     destroyGameState(_state);
     _state = pState;
     newGameState(pState);
 }

    public static void ChangeState(GameStates newState)
    {
        if (instance.state == newState)
            return;

        // Before change
        switch (instance.state) {
            case GameStates.Login:
                break;
            case GameStates.Playing:
                instance.highscoreCanvas.gameObject.SetActive(false);
                break;
            case GameStates.Paused:
                instance.pauseCanvas.gameObject.SetActive(false);
                break;
        }

        instance.state = newState;

        // After change
        switch (instance.state) {
            case GameStates.Login:
                break;
            case GameStates.Playing:
                instance.highscoreCanvas.gameObject.SetActive(true);
                break;
            case GameStates.Paused:
                instance.pauseCanvas.gameObject.SetActive(true);
                break;
        }
    }

 public void StartGame()
 {
     currentGameState = GameStates.Play;
     gamesFirstTouch = false;
     //turns off all button menus
     menuManager.SwitchMenu (MenuManager.MenuTypes.None);
 }

    public void Restart()
    {
        theGameState = GameStates.GS_USER_INPUT;

        //reset the target's height
        if (theTarget != null && theHill != null)
        {
            Vector3 targetNewPosistion = new Vector3(theHill.transform.position.x, theHill.transform.position.y, theHill.transform.position.z);
            float hillXRotRadians = -Mathf.Deg2Rad * theHill.transform.rotation.eulerAngles.x;
            float distUpHill = UnityEngine.Random.Range(-1.0f, 1.0f) * HILL_UNSCALED_HALF_WIDTH * theHill.transform.localScale.z;

            //use polar coordinates & the hill's angle to randomly select a distance up the hill for the target
            targetNewPosistion.x += UnityEngine.Random.Range(-HILL_HALF_WIDTH, HILL_HALF_WIDTH) / 2.0f;
            targetNewPosistion.y += distUpHill * Mathf.Sin(hillXRotRadians);
            targetNewPosistion.z += distUpHill * Mathf.Cos(hillXRotRadians);
            /*print("targetNewPosition = " + targetNewPosistion + ", distUpHill = " + distUpHill + " hillXRotRadians = " + hillXRotRadians +
                  "euler.x = " + theHill.transform.rotation.eulerAngles.x);*/
            theTarget.transform.Translate(targetNewPosistion - theTarget.transform.position);
        }

        //reset the ball
        if (theBall != null)
        {
            theBall.Restart();
        }

        //reset the ballista
        if (theBallista != null)
        {
            theBallista.Restart();
        }
    }

 public void SwitchState(GameStates newState)
 {
     if (_currentState == newState)
         return;
     
     //run code
 }

 public void SetGameState(GameStates newState)
 {
     Debug.Log("Setting GameState :" + newState.ToString());
     if (newState == GameStates.GameOverLoss) {
         RestartGame();
     }
 }