//////////////////////////////////////////////////////////////////////////////
        protected override void OnStateChanged(State oldState, State newState)
        {
            switch (newState)
            {
                case State.RoundStart:
                {
                    StartScreen(new BlockingScreen("Starting round..."));
                    break;
                }

                case State.Playing:
                {
                    Debug.Assert(m_localPlayer != null);
                    Debug.Assert(m_localPlayer.IsReady);
                    Debug.Assert(m_localPlayer.connection != null);

                    gameScreen = new GameScreen();
                    StartScreen(gameScreen);

                    m_localPlayer.ResetNetworkState();
                    m_localPlayer.IsReady = true;

                    gameScreen.AddDebugView(new NetworkTraceView(m_localPlayer.connection));
                    gameScreen.AddDebugView(new LocalPlayerView(m_localPlayer));
                    break;
                }

                case State.RoundEnd:
                {
                    SetPlayersReady(false);
                    StartScreen(new BlockingScreen("Waiting round results..."));
                    break;
                }

                default:
                {
                    Debug.Fail("Unexpected state: " + newState);
                    break;
                }
            }
        }
        protected override void OnStart()
        {
            base.OnStart();

            game = new Game(MultiplayerMode.None);

            GameSettings.InputEntry[] entries = settings.inputEntries;
            for (int i = 0; i < entries.Length; ++i)
            {
                Player player = new Player(entries[i].playerIndex);
                player.SetPlayerInput(entries[i].input);
                game.AddPlayer(player);
            }

            LoadField(settings.scheme);

            gameScreen = new GameScreen();

            StartScreen(gameScreen);

            GetConsole().TryExecuteCommand("exec game.cfg");
        }
        protected override void OnStateChanged(State oldState, State newState)
        {
            switch (newState)
            {
                case State.RoundStart:
                {
                    Debug.Assert(oldState == State.RoundEnd || oldState == State.Undefined,
                        "Unexpected old state: " + oldState);

                    StartScreen(new BlockingScreen("Waiting for clients..."));

                    if (game != null)
                    {
                        List<Player> players = game.GetPlayersList();
                        for (int i = 0; i < players.Count; ++i)
                        {
                            Player p = players[i];
                            p.IsReady = !p.IsNetworkPlayer;
                        }
                    }

                    break;
                }

                case State.Playing:
                {
                    Debug.Assert(oldState == State.RoundStart, "Unexpected old state: " + oldState);
                    Debug.Assert(!(CurrentScreen() is GameScreen));

                    gameScreen = new GameScreen();
                    StartScreen(gameScreen);
                    break;
                }

                case State.RoundEnd:
                {
                    Debug.Assert(oldState == State.Playing, "Unexpected old state: " + oldState);

                    Restart();
                    StartRoundResultScreen();
                    break;
                }

                default:
                {
                    Debug.Fail("Unexpected old state: " + newState);
                    break;
                }
            }
        }
        protected virtual void RoundResultScreenAccepted(RoundResultScreen screen)
        {
            StartNextRound();

            gameScreen = new GameScreen();
            StartScreen(gameScreen);
        }