//The method runs the multi-player game
        private static void multiPlayer(ref char[,] io_multiGameBoard, ref PlayerDetails io_p1, ref PlayerDetails io_p2)
        {
            m_NumOfTurns = 0;

            Console.WriteLine("\n{0} begins, follow the orders in every level\n" +
                              "to quit at any point press 'Q', " +
                              "press 'Enter to start the game!'\n", io_p1.m_Name);
            Console.ReadKey();
            Screen.Clear();

            m_GameRunning = true;

            while (m_GameRunning && m_NumOfTurns != io_multiGameBoard.Length)
            {
                drawTable(io_multiGameBoard); //draws the table
                m_GameRunning = playerInput(m_Symbols[m_NumOfTurns % 2], io_multiGameBoard,
                                            (m_NumOfTurns % 2 == 0) ? io_p1 : io_p2);

                if (!m_GameRunning)
                {
                    Screen.Clear();
                    Console.WriteLine("You left the game, see you soon");
                    return;
                }
                bool isPlayerLost = TicTacToeLogic.checkforStraight(io_multiGameBoard, m_Symbols[m_NumOfTurns % 2], m_NumOfTurns);

                //if player lost
                if (isPlayerLost)
                {
                    string winner = TicTacToeLogic.findWinner(ref io_p1, ref io_p2, m_Symbols[m_NumOfTurns % 2]);

                    Screen.Clear();
                    drawTable(io_multiGameBoard);
                    Console.WriteLine("\n" +
                                      "==========================\n" +
                                      "   {0} won the game\n" +
                                      "==========================", winner);
                    break;
                }

                m_NumOfTurns++;
                if (m_NumOfTurns == io_multiGameBoard.Length)
                {
                    Screen.Clear();
                    drawTable(io_multiGameBoard);
                    Console.WriteLine("\n" +
                                      "==========================\n" +
                                      "      You got draw!!\n" +
                                      "==========================");
                    break;
                }

                Screen.Clear();
            }

            displayMatchesResult(io_p1, io_p2);
        }
        private void playerVsComputerGame()
        {
            Console.WriteLine();
            string playerName = enterPlayerName();

            GameBoard.eSymbols playerSymbol   = enterPlayerSymbol();
            GameBoard.eSymbols computerSymbol = (playerSymbol == GameBoard.eSymbols.Symbol1) ? GameBoard.eSymbols.Symbol2 : GameBoard.eSymbols.Symbol1;
            PlayerDetails      player1        = new PlayerDetails(playerName, playerSymbol);
            PlayerDetails      computer       = new PlayerDetails("Computer", computerSymbol);

            m_Game = new TicTacToeLogic(player1, computer);
            m_Game.SetNewBoard(m_BoardGameLenght, m_BoardGameLenght);
            play((int)eGameMode.PlayerVSComputer);
            printGoodbyeMsg();
        }
示例#3
0
        //The method runs the single-player game
        private static void singlePlayer(ref char[,] io_singleGameBoard, ref PlayerDetails human, ref PlayerDetails comp)
        {
            m_NumOfTurns  = 0;
            m_GameRunning = true;
            Console.WriteLine("\nYou Begin, follow the orders in every level\n" +
                              "to quit at any point press 'Q', " +
                              "press 'Enter to start the game!'\n");
            Console.ReadKey();
            Screen.Clear();

            while (m_GameRunning && m_NumOfTurns != io_singleGameBoard.Length)
            {
                drawTable(io_singleGameBoard); //draws the table

                if (m_Symbols[m_NumOfTurns % 2] == human.m_PlayerSymbol)
                {
                    m_GameRunning = playerInput(human.m_PlayerSymbol, io_singleGameBoard, human);
                    if (!m_GameRunning)
                    {
                        Screen.Clear();
                        //TODO Change to call for method - chooseOption
                        Console.WriteLine("You left the game, see you soon");
                        return;
                    }
                }
                else if (m_Symbols[m_NumOfTurns % 2] == comp.m_PlayerSymbol)
                {
                    TicTacToeLogic.computerMove(ref io_singleGameBoard, comp);
                }

                bool isPlayerLost =
                    TicTacToeLogic.checkforStraight(io_singleGameBoard, m_Symbols[m_NumOfTurns % 2], m_NumOfTurns);
                if (isPlayerLost)
                {
                    TicTacToeLogic.findWinner(ref human, ref comp, m_Symbols[m_NumOfTurns % 2]);
                    m_GameRunning = false;
                    continue;
                }

                m_NumOfTurns++;
                Screen.Clear();
            }

            Screen.Clear();
            drawTable(io_singleGameBoard);
            displayResults(human, comp);
        }
        private void playerVsPlayerGame()
        {
            Console.Write("{0}Player 1 - ", Environment.NewLine);
            string player1Name = enterPlayerName();

            Console.Write("Player 2 - ");
            string player2Name = enterPlayerName();

            Console.Write("{0}{1} : ", Environment.NewLine, player1Name);
            GameBoard.eSymbols player1Symbol = enterPlayerSymbol();
            GameBoard.eSymbols player2Symbol = (player1Symbol == GameBoard.eSymbols.Symbol1) ? GameBoard.eSymbols.Symbol2 : GameBoard.eSymbols.Symbol1;
            PlayerDetails      player1       = new PlayerDetails(player1Name, player1Symbol);
            PlayerDetails      Player2       = new PlayerDetails(player2Name, player2Symbol);

            m_Game = new TicTacToeLogic(player1, Player2);
            m_Game.SetNewBoard(m_BoardGameLenght, m_BoardGameLenght);
            play((int)eGameMode.PlayerVSPlayer);
            printGoodbyeMsg();
        }
        //The method inserts player's move and returns true when move accepted, false if he choose to end match
        private static bool playerInput(char i_symbol, char[,] io_table, PlayerDetails io_player)
        {
            bool isInteger    = false;
            bool isInsertable = false;

            Console.WriteLine("{0}, Please make your move", io_player.m_Name);
            do
            {
                try
                {
                    Console.Write("please enter row selection: ");
                    string input1 = Console.ReadLine();
                    if (string.IsNullOrEmpty(input1))
                    {
                        Console.WriteLine("You didn't enter a value!");
                        continue;
                    }
                    char rowInput = char.Parse(input1);

                    Console.Write("Please enter collumn selection: ");
                    string input2 = Console.ReadLine();
                    if (string.IsNullOrEmpty(input2))
                    {
                        Console.WriteLine("You didn't enter a value!");
                        continue;
                    }

                    char colInput = char.Parse(input2);

                    // Checks if player wants to end match
                    if (colInput == 'Q' || rowInput == 'Q' || colInput == 'q' || rowInput == 'q')
                    {
                        return(false);
                    }

                    int indexRow;
                    int indexCol;
                    isInteger = int.TryParse(rowInput.ToString(), out indexRow);
                    isInteger = int.TryParse(colInput.ToString(), out indexCol);

                    if (!isInteger)
                    {
                        throw new InvalidOperationException("please enter numbers of rows and cols");
                    }

                    isInsertable = TicTacToeLogic.TryInsert(i_symbol, ref io_table, indexRow - 1, indexCol - 1);
                    if (!isInsertable)
                    {
                        throw new InvalidOperationException("There is no space in this spot, please try again");
                    }
                }
                catch (InvalidOperationException ex)
                {
                    Console.WriteLine(ex.Message);
                }
                catch (Exception)
                {
                    Console.WriteLine("Your input is invalid, please try again");
                }
            } while (!isInteger || !isInsertable);

            return(true); //Returns that io_player made his move
        }