Ejemplo n.º 1
0
        /// <summary>
        /// Attempt to get a valid player move.
        /// If the player chooses a location that is taken, the CurrentRoundState remains unchanged,
        /// the player is given a message indicating so, and the game loop is cycled to allow the player
        /// to make a new choice.
        /// </summary>
        /// <param name="currentPlayerPiece">identify as either the X or O player</param>
        private void ManagePlayerTurn(Gameboard.PlayerPiece currentPlayerPiece)
        {
            int column = _gameView.PlayerCoordinateChoice();

            while (column == _gameboard.HELP_CODE)
            {
                _gameView.DisplayGameRules();
                _gameView.DisplayGameArea();
                column = _gameView.PlayerCoordinateChoice();
            }

            if (column == _gameboard.EXIT_ROUND_CODE)
            {
                _numberOfCatsGames++;
                _playingRound = false;
                _gameView.DisplayCurrentGameStatus(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames);
                return;
            }

            //
            // player chose an open position on the game board, add it to the game board
            //
            if (_gameboard.GameboardColumnAvailable(column - 1))
            {
                _gameboard.SetPlayerPiece(column, currentPlayerPiece);

                //
                // Evaluate and update the current game board state
                //
                _gameboard.UpdateGameboardState(column - 1, applause);
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Game Loop
        /// </summary>
        public void PlayGame()
        {
            _gameView.DisplayWelcomeScreen();
            _gameView.DisplayMenu(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames);

            while (_playingGame)
            {
                //
                // Round loop
                //
                while (_playingRound)
                {
                    //
                    // Perform the task associated with the current game and round state
                    //
                    ManageGameStateTasks();

                    //
                    // Evaluate and update the current game board state
                    //
                    _gameboard.UpdateGameboardState();
                }

                //
                // Round Complete: Display the results
                //
                _gameView.DisplayCurrentGameStatus(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames);

                //
                // Confirm no major user errors
                //
                if (_gameView.CurrentViewState != ConsoleView.ViewState.PlayerUsedMaxAttempts ||
                    _gameView.CurrentViewState != ConsoleView.ViewState.PlayerTimedOut)
                {
                    //
                    // Prompt user to play another round
                    //
                    if (_gameView.DisplayNewRoundPrompt())
                    {
                        _gameboard.InitializeGameboard();
                        _gameView.InitializeView();
                        _gameView.DisplayMenu(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames);
                        _playingRound = true;
                    }
                }
                //
                // Major user error recorded, end game
                //
                else
                {
                    _playingGame = false;
                }
            }

            _gameView.DisplayClosingScreen();
        }
        /// <summary>
        /// Game Loop
        /// </summary>
        public void PlayGame()
        {
            _gameView.DisplayWelcomeScreen();

            while (_playingGame)
            {
                //
                // Round loop
                //
                Gameboard.PlayerPiece winner = Gameboard.PlayerPiece.None;
                while (_playingRound)
                {
                    //
                    // Perform the task associated with the current game and round state
                    //
                    ManageGameStateTasks();

                    //
                    // Evaluate and update the current game board state
                    //

                    _gameboard.UpdateGameboardState(out winner);
                }

                //
                // Round Complete: Display the results
                //

                updateWinStreak(winner);
                _winningPlayer = winner;

                // TODO: Pass the win streak to the stats screen method
                _gameView.DisplayCurrentGameStatus(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames, _winStreak);

                //
                // Confirm no major user errors
                //
                if (_gameView.CurrentViewState != ConsoleView.ViewState.PlayerUsedMaxAttempts ||
                    _gameView.CurrentViewState != ConsoleView.ViewState.PlayerTimedOut)
                {
                    //
                    // Prompt user to play another round
                    //
                    if (_gameView.DisplayNewRoundPrompt())
                    {
                        _gameboard.InitializeGameboard();
                        _gameView.InitializeView();
                        _playingRound = true;
                    }
                    else
                    {
                        // end previous round stats
                        _playingRound        = false;
                        _playerONumberOfWins = 0;
                        _playerXNumberOfWins = 0;
                        _numberOfCatsGames   = 0;
                        _roundNumber         = 0;
                        _winStreak           = 0;
                        _winningPlayer       = Gameboard.PlayerPiece.None;

                        if (_gameView.DisplayExitGamePrompt())
                        {
                            _playingGame = false;
                        }
                        else
                        {
                            _gameboard.InitializeGameboard();
                            _gameView.InitializeView();
                            _playingRound = true;
                        }
                    }
                }
                //
                // Major user error recorded, end game
                //
                else
                {
                    _playingGame = false;
                }
            }

            _gameView.DisplayClosingScreen();
        }
        /// <summary>
        /// Game Loop
        /// </summary>
        public void PlayGame()
        {
            //
            // display splash screen
            //
            _playingGame = _gameView.DisplaySplashScreen();

            _gameView.DisplayWelcomeScreen();
            MenuOption userMenuChoice;

            while (_playingGame)
            {
                //
                // get a menu choice from the ConsoleView object
                //
                userMenuChoice = _gameView.DisplayGetUserMenuChoice();

                //
                // choose an action based on the user's menu choice
                //
                switch (userMenuChoice)
                {
                case MenuOption.None:
                    break;

                case MenuOption.PlayNewRound:
                    _gameView.DisplayGameArea();
                    //_playingRound = true;
                    break;

                case MenuOption.ViewRules:
                    _gameView.DisplayWelcomeScreen();
                    //_playingRound = false;
                    break;

                case MenuOption.ViewCurrentGameResults:
                    _gameView.DisplayGameStatus();
                    //_gameView.DisplayCurrentGameStatus(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames);
                    //_playingRound = false;
                    break;

                case MenuOption.Quit:
                    _gameView.DisplayExitPrompt();
                    //_playingRound = false;
                    //_playingGame = false;
                    break;

                default:
                    break;
                }
                //
                // Round loop
                //
                while (_playingRound)
                {
                    //
                    // Perform the task associated with the current game and round state
                    //
                    ManageGameStateTasks();

                    //
                    // Evaluate and update the current game board state
                    //
                    _gameboard.UpdateGameboardState();
                }

                //
                // Round Complete: Display the results
                //
                _gameView.DisplayCurrentGameStatus(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames);

                //
                // Confirm no major user errors
                //
                if (_gameView.CurrentViewState != ConsoleView.ViewState.PlayerUsedMaxAttempts ||
                    _gameView.CurrentViewState != ConsoleView.ViewState.PlayerTimedOut)
                {
                    //
                    // Prompt user to play another round
                    //
                    if (_gameView.DisplayNewRoundPrompt())
                    {
                        _gameboard.InitializeGameboard();
                        _gameView.InitializeView();
                        _playingRound = true;
                    }
                    else
                    {
                        _playingGame = false;
                    }
                }
                //
                // Major user error recorded, end game
                //
                else
                {
                    _playingGame = false;
                }

                //if (_gameboard.IsRoundComplete())
                //{

                //}
            }

            _gameView.DisplayClosingScreen();
        }
        /// <summary>
        /// Game Loop
        /// </summary>
        public void PlayGame()
        {
            try
            {
                _gameView.DisplaySplashScreen();
                _gameView.DisplayWelcomeScreen();
            }
            catch (InvalidKeystrokeException ivk)
            {
                Console.Clear();
                global::System.Console.WriteLine(ivk.Message + "\n\n Press any key to exit the application.");
                Console.ReadKey();
                _playingGame = false;
            }

            while (_playingGame)
            {
                //
                // Round loop
                //
                while (_playingRound)
                {
                    //
                    // Perform the task associated with the current game and round state
                    //
                    ManageGameStateTasks();

                    if (_gameView.CurrentViewState == ConsoleView.ViewState.ViewCurrentStats)
                    {
                        _gameView.DisplayCurrentGameStatus(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames);
                        _gameView.DisplayContinuePrompt();
                    }

                    //
                    // Evaluate and update the current game board state
                    //
                    _gameboard.UpdateGameboardState();


                    if (_gameView.CurrentViewState == ConsoleView.ViewState.ResetCurrentRound)
                    {
                        //Confirm that the user wants to reset the current round.
                        if (_gameView.DisplayResetRoundPrompt() == true)
                        {
                            //If the user wants to reset the round...

                            //End the round.
                            _roundNumber--;
                            _playingRound = false;
                        }
                        else
                        {
                            //If the user does not want to reset the round...

                            //Re-draw the game board.
                            _gameView.CurrentViewState   = ConsoleView.ViewState.Active;
                            _gameboard.CurrentRoundState = _currentPlayerTurn;
                        }
                    }
                }

                //
                // Round Complete: Display the results
                //
                if (_gameView.CurrentViewState != ConsoleView.ViewState.ResetCurrentRound)
                {
                    _gameView.DisplayCurrentGameStatus(_roundNumber, _playerXNumberOfWins, _playerONumberOfWins, _numberOfCatsGames);
                }

                //
                // Confirm no major user errors
                //
                if (_gameView.CurrentViewState != ConsoleView.ViewState.PlayerUsedMaxAttempts ||
                    _gameView.CurrentViewState != ConsoleView.ViewState.PlayerTimedOut)
                {
                    //Check to see if the current round is being reset.
                    if (_gameView.CurrentViewState != ConsoleView.ViewState.ResetCurrentRound)
                    {
                        //If the round is not being reset...

                        //
                        // Prompt user to play another round
                        //
                        if (_gameView.DisplayNewRoundPrompt())
                        {
                            _gameboard.InitializeGameboard();
                            _gameView.InitializeView();
                            _playingRound = true;
                        }
                        else
                        {
                            _playingGame = false;
                        }
                    }
                    else
                    {
                        //If the round is being reset...

                        //Start a new round.
                        _gameboard.InitializeGameboard();
                        _gameView.InitializeView();
                        _playingRound = true;
                    }
                }
                //
                // Major user error recorded, end game
                //
                else
                {
                    _playingGame = false;
                }
            }

            _gameView.DisplayClosingScreen();
        }