Ejemplo n.º 1
0
        private ShotStatus TorpedoHit(BoardCoordinates torpedo)
        {
            ShotStatus shotStatus = ShotStatus.Miss;

            for (int i = 0; i < GameBoard.Ships.Count; i++)
            {
                var ship            = GameBoard.Ships[i];
                var boardCellStatus = (ShotTypes)Enum.Parse(typeof(ShotTypes), GameBoard.DisplayBoard[torpedo.Row, torpedo.Column]);
                if (CheckShipHit(ship, torpedo) && (boardCellStatus != ShotTypes.Hit && boardCellStatus != ShotTypes.Sink))
                {
                    if (ship.HitCount < ship.Size)
                    {
                        ship.HitCount++;
                    }
                    if (ship.HitCount == ship.Size)
                    {
                        ship.Sunk  = true;
                        shotStatus = ShotStatus.Sink;
                    }
                    else
                    {
                        shotStatus = ShotStatus.Hit;
                    }
                }
            }

            return(shotStatus);
        }
Ejemplo n.º 2
0
        public void shotResult(Position position, ShotStatus status)
        {
            Shots.Add(position, status);

            ConsoleGraphics.showShootedField(Shots, 90);

            string str = null;

            switch (status)
            {
            case ShotStatus.HIT:
                str = "Попадание";
                break;

            case ShotStatus.MISS:
                str = "Промах";
                break;

            case ShotStatus.SUNK:
                str = "Потопил";
                break;
            }
            Console.WriteLine($"{position.getX()},{position.getY()} {str}");
            Console.ReadLine();
        }
Ejemplo n.º 3
0
        public void DisplayShotStatus(ShotStatus shot)
        {
            switch (shot)
            {
            case ShotStatus.Victory:
                break;

            case ShotStatus.HitAndSunk:
                //HitAndSunkMessage(ShipType);
                Console.ReadKey();
                break;

            case ShotStatus.Duplicate:
                //DuplicateMessage();
                Console.ReadKey();
                break;

            case ShotStatus.Hit:
                HitMessage();
                Console.ReadKey();
                break;

            case ShotStatus.Miss:
                MissMessage();
                Console.ReadKey();
                break;

            default:
                break;
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Check if a ship is hit
        /// </summary>
        /// <param name="coordinate"></param>
        /// /// <param name="response"></param>
        private void CheckShipsForHit(Coordinate coordinate, FireShotResponse response)
        {
            response.ShotStatus = ShotStatus.Miss;
            ShotStatus status = Ships[0].FireAtShip(coordinate);

            switch (status)
            {
            case ShotStatus.HitAndSunk:
                response.ShotStatus   = ShotStatus.HitAndSunk;
                response.ShipImpacted = Ships[0].ShipName;
                ShotHistory.Add(coordinate, Responses.ShotHistory.Hit);
                break;

            case ShotStatus.Hit:
                response.ShotStatus   = ShotStatus.Hit;
                response.ShipImpacted = Ships[0].ShipName;
                ShotHistory.Add(coordinate, Responses.ShotHistory.Hit);
                break;
            }

            if (response.ShotStatus == ShotStatus.Miss)
            {
                ShotHistory.Add(coordinate, Responses.ShotHistory.Miss);
            }
        }
Ejemplo n.º 5
0
        // What do I want the gameflow to do?
        // 1) Manages players turns (bool isp1Turn)
        // 2) Alternate FireShot () at enemy board
        // 3) Shot history and track board
        // 4) Check Coordinate()
        public void PlayGame(GameState state)
        {
            ShotStatus lastShot = ShotStatus.Invalid;

            /*
             * if (!state.IsPlayer1Turn)
             * {
             *  ConsoleInput.WhoseTurn(state.P2);
             * }
             * else
             * {
             *  ConsoleInput.WhoseTurn(state.P1);
             * }
             */
            while (lastShot != ShotStatus.Victory)
            {
                ConsoleInput.DrawBoard(state);
                // prompt user for coordinate
                lastShot = FireShot(state);
                if (lastShot == ShotStatus.Duplicate || lastShot == ShotStatus.Invalid)
                {
                    continue;
                }
                //ConsoleOutput.DrawBoard(state);
                state.IsPlayer1Turn = !state.IsPlayer1Turn;
                ConsoleOutput.ToNextTurn();
            }
        }
Ejemplo n.º 6
0
        public void ReceveStatus(ShotStatus shotStatus)
        {
            if (gameState == GameState.WaitOtherPlayerStatus && programState == ProgramState.game)
            {
                // View shot on field
                fieldEnemy.Shot(lastShotPos, shotStatus);
                // handle shot status here
                MessageBox.Show(shotStatus.ToString());

                if (shotStatus == ShotStatus.miss)
                {
                    setGameState(GameState.WaitOtherPlayerPos);
                }
                else if (shotStatus == ShotStatus.killEverybody)
                {
                    MessageBox.Show("You win!");
                    setProgramState(ProgramState.end);
                }

                else
                {
                    setGameState(GameState.WaitPlayerChoise);
                }
            }
        }
Ejemplo n.º 7
0
        public static ShotStatus FireShotAtEnemey(Player player)
        {
            Coordinate coordToShoot = ConsoleInput.GetCoordinateFromUser();
            ShotStatus returnvValue = player.board.FireShot(coordToShoot).ShotStatus;

            //use return returnValue istead of if else
            if (returnvValue == ShotStatus.Hit)
            {
                Console.WriteLine(ShotStatus.Hit);
                return(ShotStatus.Hit);
            }
            else if (returnvValue == ShotStatus.HitAndSunk)
            {
                Console.WriteLine(ShotStatus.HitAndSunk);
                return(ShotStatus.HitAndSunk);
            }
            else if (returnvValue == ShotStatus.Duplicate)
            {
                Console.WriteLine(ShotStatus.Duplicate);
                return(ShotStatus.Duplicate);
            }
            else if (returnvValue == ShotStatus.Miss)
            {
                Console.WriteLine(ShotStatus.Miss);
                return(ShotStatus.Miss);
            }
            else
            {
                return(ShotStatus.Victory);
            }
        }
Ejemplo n.º 8
0
        private void CheckShipsForHit(Coordinates coordinate, FireShotResponse response)
        {
            response.ShotStatus = ShotStatus.Miss;

            foreach (var ship in Ships)
            {
                if (ship.IsSunk)
                {
                    continue;
                }

                ShotStatus status = ship.FireAtShip(coordinate);

                switch (status)
                {
                case ShotStatus.Hit:
                    response.ShotStatus   = ShotStatus.Hit;
                    response.ShipImpacted = ship.ShipName;
                    ShotHistorys.Add(coordinate, ShotHistory.Hit);
                    break;
                }

                if (status != ShotStatus.Miss)
                {
                    break;
                }
            }

            if (response.ShotStatus == ShotStatus.Miss)
            {
                response.ShotStatus = ShotStatus.Miss;
                ShotHistorys.Add(coordinate, ShotHistory.Miss);
            }
        }
Ejemplo n.º 9
0
        public TurnResult handleShot()
        {
            if (shotStatus != ShotStatus.none)
            {
                return(TurnResult.fail);
            }


            if (ship != null)
            {
                var result = ship.HandleShot();
                shotStatus = ShotStatus.damagedShip;
                if (result == Ship.ShotResult.killed)
                {
                    return(TurnResult.kill);
                }
                else
                {
                    return(TurnResult.hit);
                }
            }
            else
            {
                shotStatus = ShotStatus.miss;
                return(TurnResult.miss);
            }
        }
Ejemplo n.º 10
0
        // Visualize shot on enemy field
        public void Shot(Point pos, ShotStatus shotStatus)
        {
            if (player == Player.ally)
            {
                throw new ConstraintException("Can't view a shot on the ally field");
            }
            FieldButtonState state;
            var buttonsPos = new List <Point>();

            buttonsPos.Add(pos);
            if (shotStatus == ShotStatus.miss)
            {
                state = FieldButtonState.miss;
            }
            else if (shotStatus == ShotStatus.hurt)
            {
                state = FieldButtonState.hit;
            }
            else if (shotStatus == ShotStatus.kill ||
                     shotStatus == ShotStatus.killEverybody)
            {
                state = FieldButtonState.kill;
                FindComleteShip(buttonsPos);
            }
            else
            {
                state = FieldButtonState.blocked;
            }
            foreach (var p in buttonsPos)
            {
                getFB(p).setState(state);
            }
        }
Ejemplo n.º 11
0
        public void GameStart()
        {
            string again     = "y";
            bool   playAgain = true;

            while (playAgain == true)
            {
                ConsoleIO.DisplayTitle();

                Players player1 = new Players();
                setUpPlayer(player1);


                Players player2 = new Players();
                setUpPlayer(player2);

                Random     number = new Random();
                ShotStatus shot   = new ShotStatus();


                int whoseTurn = number.Next(1, 2);

                while (shot != ShotStatus.Victory)
                {
                    if (whoseTurn == 1)
                    {
                        ConsoleIO.PlayerBoard(player1, player2);
                        shot      = ConsoleIO.DisplayShot(player1);
                        whoseTurn = 2;
                    }
                    else if (whoseTurn == 2)
                    {
                        ConsoleIO.PlayerBoard(player2, player1);
                        shot      = ConsoleIO.DisplayShot(player2);
                        whoseTurn = 1;
                    }
                }


                Console.Write("Wanna to play again? (y/n): ");
                again = Console.ReadLine();

                if (again == "y")
                {
                    playAgain = true;
                    Console.Clear();
                }
                else if (again == "n")
                {
                    Console.Write("Thank you for playing!");
                    playAgain = false;
                    Console.ReadKey();
                }
                else
                {
                    Console.Write("error message");
                }
            }
        }
Ejemplo n.º 12
0
        public void ReceveStatus(ShotStatus shotStatus)
        {
            var data = status + separator + ((int)shotStatus).ToString();
            var msg  = Encoding.ASCII.GetBytes(data);

            // Send the data through the socket.
            int bytesSent = sender.Send(msg);
        }
Ejemplo n.º 13
0
        public void WhenShotItReturnsCorrectStatus(int remainingLife, ShotStatus expectedStatus)
        {
            var ship = new Ship(remainingLife);

            var shotStatus = ship.Shoot();

            shotStatus.ShouldBe(expectedStatus);
        }
Ejemplo n.º 14
0
        public void Start(Board b1, Board b2, Player[] playerArray)
        {
            int[]             shot           = new int[2];
            FireShotResponse  response       = new FireShotResponse();
            ResponseDisplayer ResponseWriter = new ResponseDisplayer();

            setPlayers(playerArray);

            do
            {
                ShotStatus responseType = new ShotStatus();
                if (TurnCounter % 2 == 0)
                {
                    do
                    {
                        showShotHistory(player2, b1);
                        shot     = getUserShot(player2);
                        response = firePlayerShot(shot, b1);
                        Console.Clear();
                        showShotHistory(player2, b1);
                        responseType = ResponseWriter.DisplayResponse(response);
                    } while (responseType == ShotStatus.Invalid || responseType == ShotStatus.Duplicate);
                    TurnCounter++;
                }
                else
                {
                    do
                    {
                        showShotHistory(player1, b2);
                        shot     = getUserShot(player1);
                        response = firePlayerShot(shot, b2);
                        Console.Clear();
                        showShotHistory(player1, b2);
                        responseType = ResponseWriter.DisplayResponse(response);
                    } while (responseType == ShotStatus.Invalid || responseType == ShotStatus.Duplicate);
                    TurnCounter++;
                }
            } while (response.ShotStatus != ShotStatus.Victory);
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Game Over. Would you like to play again? (y/n)");
            Console.ForegroundColor = ConsoleColor.Gray;
            string playagain = Console.ReadLine();

            if (playagain == "y")
            {
                Console.Clear();
                Program p = new Program();
                p.playAgain();
            }
            else
            {
                Console.WriteLine("Thanks for playing. Bye.");
                Thread.Sleep(3000);
            }
        }
Ejemplo n.º 15
0
    private void ShotFailedOnFireEffectActive(ShotStatus status)
    {
        if (status != ShotStatus.FAILED)
        {
            return;
        }


        InterruptCoroutine(ref m_DecreaseSliderOnFireEffect);
        InterruptOnFireEffect();
    }
Ejemplo n.º 16
0
        public void Play()
        {
            var playerTurn = _setup.Player1GoesFirst;

            bool playOn = true;

            while (playOn)
            {
                ShotStatus status = new ShotStatus();

                Console.Clear();

                if (playerTurn)
                {
                    status = FireShotPrompt(_setup.Player2Board, _setup.Player1Name);
                }

                else
                {
                    status = FireShotPrompt(_setup.Player1Board, _setup.Player2Name);
                }

                if (status == ShotStatus.Invalid || status == ShotStatus.Duplicate)
                {
                    playerTurn = !playerTurn;
                }

                playerTurn = !playerTurn;

                if (status != ShotStatus.Victory)
                {
                    playOn = true;
                }

                else
                {
                    playOn = false;

                    Console.WriteLine("Press ENTER to play again or press Q to quit.");

                    if (Console.ReadKey().Key == ConsoleKey.Q)
                    {
                        return;
                    }

                    else
                    {
                        SetupWorkflow restart = new SetupWorkflow();
                        restart.Start();
                    }
                }
            }
        }
Ejemplo n.º 17
0
    private void SetThrowParameters(ShotStatus stauts)
    {
        if (stauts == ShotStatus.FAILED)
        {
            m_BallThrower.RepeatShot();
            return;
        }

        ShotData currentThrowData = m_ShootingSpots[m_SpotsCounter].GetShotData(m_TrDestinationPoint.position);

        m_BallThrower.SetNextShot(currentThrowData);
        m_SpotsCounter = m_SpotsCounter + 1 <= m_ShootingSpots.Length - 1 ? m_SpotsCounter + 1 : 0;
    }
Ejemplo n.º 18
0
        public void Start()
        {
            string Again     = "y";
            bool   playagain = true;

            while (playagain)
            {
                ConsoleIO.Welcome();

                Player player1 = new Player();
                Player.setUpPlayer(player1);

                Player player2 = new Player();
                Player.setUpPlayer(player2);

                ShotStatus shooting     = new ShotStatus();
                Random     PlayerRandom = new Random();
                int        random       = PlayerRandom.Next(1, 2);

                while (shooting != ShotStatus.Victory)
                {
                    if (random == 1)
                    {
                        Player.PlayerBoard(player1, player2);
                        shooting = Player.ShootShip(player2);
                        random   = 2;
                    }
                    else
                    {
                        Player.PlayerBoard(player2, player1);
                        shooting = Player.ShootShip(player1);
                        random   = 1;
                    }
                }

                Console.WriteLine("Want to play again? y or n");
                Again = Console.ReadLine();
                if (Again == "y")
                {
                    playagain = true;
                }
                else
                {
                    Console.WriteLine("Good Game!!!!");
                }
                playagain = false;
            }
        }
Ejemplo n.º 19
0
        private void CheckShipsForHit(Coordinate coordinate, FireShotResponse response)
        {
            response.ShotStatus = ShotStatus.Miss;

            foreach (var ship in _ships)
            {
                // no need to check sunk ships
                // *** next2 del
                if (ship == null)
                {
                    continue;
                }
                if (ship.IsSunk)
                {
                    continue;
                }

                ShotStatus status = ship.FireAtShip(coordinate);

                switch (status)
                {
                case ShotStatus.HitAndSunk:
                    response.ShotStatus   = ShotStatus.HitAndSunk;
                    response.ShipImpacted = ship.ShipName;
                    ShotHistory.Add(coordinate, Responses.ShotHistory.Hit);
                    break;

                case ShotStatus.Hit:
                    response.ShotStatus   = ShotStatus.Hit;
                    response.ShipImpacted = ship.ShipName;
                    ShotHistory.Add(coordinate, Responses.ShotHistory.Hit);
                    break;
                }

                // if they hit something, no need to continue looping
                if (status != ShotStatus.Miss)
                {
                    break;
                }
            }

            if (response.ShotStatus == ShotStatus.Miss)
            {
                ShotHistory.Add(coordinate, Responses.ShotHistory.Miss);
            }
        }
Ejemplo n.º 20
0
        public static void DisplayShot()
        {
            ShotStatus result = new ShotStatus();

            FireShotResponse response = new FireShotResponse();


            while (true)
            {
                Console.WriteLine("Place your fireshot. ");
                ConsoleIO.GetCoord();

                switch (result)
                {
                case ShotStatus.Invalid:
                    DisplayInvalid();
                    break;

                case ShotStatus.Duplicate:
                    DisplayDuplicate();
                    break;

                case ShotStatus.Miss:
                    DisplayMiss();
                    break;

                case ShotStatus.Hit:
                    DisplayHit();
                    break;

                case ShotStatus.HitAndSunk:
                    DisplayHitAndSunk();
                    break;

                case ShotStatus.Victory:
                    DisplayVictory();
                    break;

                default:
                    break;
                }
                Console.ReadKey();
            }
        }
Ejemplo n.º 21
0
        public void Update(ShotStatus status)
        {
            switch (status)
            {
            case ShotStatus.Victory:
                IsVictorious = true;
                ShotsHit++;
                break;

            case ShotStatus.Hit:
            case ShotStatus.HitAndSunk:
                ShotsHit++;
                break;

            case ShotStatus.Miss:
                ShotsMissed++;
                break;
            }
        }
Ejemplo n.º 22
0
    private int GetScoreFromStatus(ShotStatus shotStauts)
    {
        if (shotStauts == ShotStatus.FAILED)
        {
            return(0);
        }

        if (shotStauts == ShotStatus.PERFECT)
        {
            return((int)Constant.ShotScores.PERFECT);
        }

        if (shotStauts == ((ShotStatus.BONUS | ShotStatus.NORMAL)))
        {
            return((int)BackBoardEntity.GetCurrentScoreBonus);
        }

        return((int)Constant.ShotScores.NORMAL);
    }
Ejemplo n.º 23
0
        public GameFlow(Player Attacker, Player Receiver)
        {
            FireShotResponse ShotResponse;

            while (true)
            {
                ConsoleOutput.PromptPlayerTurn(Attacker);
                var shot = ConsoleInput.GetCoordinateFromUser();
                ShotResponse = Receiver.PlayerBoard.FireShot(shot);
                ShotStatus result  = ShotResponse.ShotStatus;
                string     ShipHit = ShotResponse.ShipImpacted;

                if (result == ShotStatus.Miss)
                {
                    ConsoleOutput.Miss(Attacker.Name);
                    break;
                }
                else if (result == ShotStatus.Hit)
                {
                    ConsoleOutput.Hit(Attacker.Name);
                    break;
                }
                else if (result == ShotStatus.HitAndSunk)
                {
                    ConsoleOutput.HitAndSunk(Attacker.Name, Receiver.Name, ShipHit);
                    break;
                }
                else if (result == ShotStatus.Victory)
                {
                    ConsoleOutput.DeclareVictory(Attacker.Name, Receiver.Name);
                    GameOver = true;
                    break;
                }
                else if (result == ShotStatus.Duplicate)
                {
                    ConsoleOutput.Duplicate(Attacker.Name);
                }
                else
                {
                    ConsoleOutput.InvalidShot(Attacker.Name);
                }
            }
        }
Ejemplo n.º 24
0
        private ShotStatus FireShot(GameState state)
        {
            // ShipType ship = ShipType.Battleship;
            Board            toFire    = state.IsPlayer1Turn ? state.P2.PlayerBoard : state.P1.PlayerBoard;
            ShotStatus       isVictory = ShotStatus.Miss;
            Coordinate       FireAt    = ConsoleInput.GetCoordinate();
            FireShotResponse response  = toFire.FireShot(FireAt);

            switch (response.ShotStatus)
            {
            case ShotStatus.Invalid:
                ConsoleOutput.IvalidResponse();
                isVictory = ShotStatus.Invalid;
                return(isVictory);

            case ShotStatus.Duplicate:
                ConsoleOutput.DuplicateResponse();
                isVictory = ShotStatus.Duplicate;
                return(isVictory);

            case ShotStatus.Hit:
                ConsoleOutput.HitResponse();
                isVictory = ShotStatus.Hit;
                return(isVictory);

            case ShotStatus.HitAndSunk:
                ConsoleOutput.HitAndSunkResponse(response.ShipImpacted);
                isVictory = ShotStatus.HitAndSunk;
                return(isVictory);

            case ShotStatus.Miss:
                ConsoleOutput.MissResponse();
                isVictory = ShotStatus.Miss;
                return(isVictory);

            case ShotStatus.Victory:
                ConsoleOutput.VictoryResponse();
                isVictory = ShotStatus.Victory;
                return(isVictory);
            }
            return(isVictory);
        }
Ejemplo n.º 25
0
 public bool DisplayFireShotResponse(ShotStatus currentShot, FireShotResponse shotResponse)
 {
     if (currentShot == ShotStatus.Invalid)
     {
         Console.WriteLine("Your coordinate is invalid");
         return(false);
     }
     else if (currentShot == ShotStatus.Duplicate)
     {
         Console.ForegroundColor = ConsoleColor.Cyan;
         Console.WriteLine("You have already fired at that coordinate {0} \nplease enter another coordinate:", WorkFlow.OtherPlayer.PlayerName);
         Console.ResetColor();
         return(false);
     }
     else if (currentShot == ShotStatus.Miss)
     {
         Console.ForegroundColor = ConsoleColor.Yellow;
         Console.WriteLine("You have missed!");
         Console.ResetColor();
         return(true);
     }
     else if (currentShot == ShotStatus.Hit)
     {
         Console.ForegroundColor = ConsoleColor.Red;
         Console.WriteLine("You have landed at hit!!");
         Console.ResetColor();
         return(true);
     }
     else if (currentShot == ShotStatus.HitAndSunk)
     {
         Console.WriteLine("You have hit and sunk the {0}!", shotResponse.ShipImpacted);
         return(true);
     }
     else if (currentShot == ShotStatus.Victory)
     {
         Console.WriteLine("VICTORY!!!");
         Console.ReadKey();
         StartGame();
     }
     return(true);
 }
Ejemplo n.º 26
0
        public void DisplayShotResult(ShotStatus shotResult)
        {
            switch (shotResult)
            {
            case ShotStatus.Hit:
                _output.WriteLine("HIT!");
                break;

            case ShotStatus.Miss:
                _output.WriteLine("Miss :(");
                break;

            case ShotStatus.Repeated:
                _output.WriteLine("This square was already shot");
                break;

            case ShotStatus.Sink:
                _output.WriteLine("Ship sinked!");
                break;
            }
        }
Ejemplo n.º 27
0
        public void HandlePlayerTurn()
        {
            ShotStatus status = ShotStatus.Invalid;

            while (status != ShotStatus.Victory)
            {
                for (int i = 0; i < 2; i++)
                {
                    if (i == 0)
                    {
                        status = TakeTurn(p1, p2);
                    }
                    else
                    {
                        status = TakeTurn(p2, p1);
                    }

                    if (status == ShotStatus.Victory)
                    {
                        break;
                    }
                }
            }
        }
Ejemplo n.º 28
0
 public void shotResult(Position position, ShotStatus status)
 {
 }
Ejemplo n.º 29
0
        public void Run()
        {
            Output           output       = new Output();
            Input            input        = new Input();
            Board            board1       = new Board();
            Board            board2       = new Board();
            PlaceShipRequest shipRequest  = new PlaceShipRequest();
            PlaceShipRequest shipRequest2 = new PlaceShipRequest();
            char             Winner       = 'n';



            output.StartScreen();
            if (input.Play())
            {
                output.AskName1();
                string P1 = input.GetName1();
                output.AskName2();
                string P2 = input.GetName2();

                // player 1 place ships
                output.CreateBoard1();
                output.ShowBoard1();
                while (true)
                {
                    output.PlaceBattleship(P1);
                    var valuesB = input.GetCoordinate();
                    int x       = valuesB.Item1;
                    int y       = valuesB.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest.Coordinate = coordinate;
                    shipRequest.Direction  = direction;
                    shipRequest.ShipType   = ShipType.Battleship;
                    if (board1.PlaceShip(shipRequest) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }
                while (true)
                {
                    output.PlaceCarrier(P1);
                    var valuesC = input.GetCoordinate();
                    int x       = valuesC.Item1;
                    int y       = valuesC.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest.Coordinate = coordinate;
                    shipRequest.Direction  = direction;
                    shipRequest.ShipType   = ShipType.Carrier;
                    if (board1.PlaceShip(shipRequest) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }
                while (true)
                {
                    output.PlaceCruiser(P1);
                    var valuesCr = input.GetCoordinate();
                    int x        = valuesCr.Item1;
                    int y        = valuesCr.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest.Coordinate = coordinate;
                    shipRequest.Direction  = direction;
                    shipRequest.ShipType   = ShipType.Cruiser;
                    if (board1.PlaceShip(shipRequest) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }
                while (true)
                {
                    output.PlaceDestroyer(P1);
                    var valuesD = input.GetCoordinate();
                    int x       = valuesD.Item1;
                    int y       = valuesD.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest.Coordinate = coordinate;
                    shipRequest.Direction  = direction;
                    shipRequest.ShipType   = ShipType.Destroyer;
                    if (board1.PlaceShip(shipRequest) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }
                while (true)
                {
                    output.PlaceSubmarine(P1);
                    var valuesS = input.GetCoordinate();
                    int x       = valuesS.Item1;
                    int y       = valuesS.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest.Coordinate = coordinate;
                    shipRequest.Direction  = direction;
                    shipRequest.ShipType   = ShipType.Submarine;
                    if (board1.PlaceShip(shipRequest) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }

                output.ChangeTurns(P1, P2);

                //player 2 place ships
                output.CreateBoard2();
                output.ShowBoard2();
                while (true)
                {
                    output.PlaceBattleship(P2);
                    var valuesB = input.GetCoordinate();
                    int x       = valuesB.Item1;
                    int y       = valuesB.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest2.Coordinate = coordinate;
                    shipRequest2.Direction  = direction;
                    shipRequest2.ShipType   = ShipType.Battleship;
                    if (board2.PlaceShip(shipRequest2) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }
                while (true)
                {
                    output.PlaceCarrier(P2);
                    var valuesC = input.GetCoordinate();
                    int x       = valuesC.Item1;
                    int y       = valuesC.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest2.Coordinate = coordinate;
                    shipRequest2.Direction  = direction;
                    shipRequest2.ShipType   = ShipType.Carrier;
                    if (board2.PlaceShip(shipRequest2) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }
                while (true)
                {
                    output.PlaceCruiser(P2);
                    var valuesCr = input.GetCoordinate();
                    int x        = valuesCr.Item1;
                    int y        = valuesCr.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest2.Coordinate = coordinate;
                    shipRequest2.Direction  = direction;
                    shipRequest2.ShipType   = ShipType.Cruiser;
                    if (board2.PlaceShip(shipRequest2) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }
                while (true)
                {
                    output.PlaceDestroyer(P2);
                    var valuesD = input.GetCoordinate();
                    int x       = valuesD.Item1;
                    int y       = valuesD.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest2.Coordinate = coordinate;
                    shipRequest2.Direction  = direction;
                    shipRequest2.ShipType   = ShipType.Destroyer;
                    if (board2.PlaceShip(shipRequest2) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }
                while (true)
                {
                    output.PlaceSubmarine(P2);
                    var valuesS = input.GetCoordinate();
                    int x       = valuesS.Item1;
                    int y       = valuesS.Item2;
                    output.ShipDirection();
                    ShipDirection direction  = input.ShipPlacement();
                    Coordinate    coordinate = new Coordinate(x, y);
                    shipRequest2.Coordinate = coordinate;
                    shipRequest2.Direction  = direction;
                    shipRequest2.ShipType   = ShipType.Submarine;
                    if (board2.PlaceShip(shipRequest2) != ShipPlacement.Ok)
                    {
                        output.InvalidEntry();
                    }
                    else
                    {
                        break;
                    }
                }

                output.ChangeTurns(P2, P1);
                Random random = new Random();
                int    order  = random.Next(1, 10);
                if (order % 2 == 0)                   //PLAYER 1 GOES FIRST
                {
                    output.InitiateGame(P1);
                    while (Winner != 'y')
                    {
                        while (true)
                        {
                            output.ShowBoard1();
                            output.AskCoordinates(P1);
                            var        values     = input.GetCoordinate();
                            int        x          = values.Item1;
                            int        y          = values.Item2;
                            Coordinate coordinate = new Coordinate(x, y);
                            var        shot       = board2.FireShot(coordinate);
                            ShotStatus shotStatus = shot.ShotStatus;
                            string     ship       = shot.ShipImpacted;
                            if (shotStatus == ShotStatus.Hit)
                            {
                                output.Hit();
                                output.gameBoard1[y - 1, x - 1] = 'H';
                                break;
                            }
                            else if (shotStatus == ShotStatus.Miss)
                            {
                                output.Miss();
                                output.gameBoard1[y - 1, x - 1] = 'M';

                                break;
                            }
                            else if (shotStatus == ShotStatus.HitAndSunk)
                            {
                                output.HitAndSink(ship);
                                output.gameBoard1[y - 1, x - 1] = 'H';

                                break;
                            }
                            else if (shotStatus == ShotStatus.Victory)
                            {
                                output.Victory(P1);
                                output.gameBoard1[y - 1, x - 1] = 'H';
                                Winner = 'y';
                                break;
                            }
                        }


                        output.ChangeTurns(P1, P2);
                        while (true)
                        {
                            output.ShowBoard2();
                            output.AskCoordinates(P2);
                            var        values2     = input.GetCoordinate();
                            int        x2          = values2.Item1;
                            int        y2          = values2.Item2;
                            Coordinate coordinate2 = new Coordinate(x2, y2);
                            var        shot2       = board1.FireShot(coordinate2);
                            ShotStatus shotStatus2 = shot2.ShotStatus;
                            string     ship2       = shot2.ShipImpacted;
                            if (shotStatus2 == ShotStatus.Hit)
                            {
                                output.Hit();
                                output.gameBoard2[y2 - 1, x2 - 1] = 'H';
                                break;
                            }
                            else if (shotStatus2 == ShotStatus.Miss)
                            {
                                output.Miss();
                                output.gameBoard2[y2 - 1, x2 - 1] = 'M';

                                break;
                            }
                            else if (shotStatus2 == ShotStatus.HitAndSunk)
                            {
                                output.HitAndSink(ship2);
                                output.gameBoard2[y2 - 1, x2 - 1] = 'H';
                                break;
                            }
                            else if (shotStatus2 == ShotStatus.Victory)
                            {
                                output.Victory(P2);
                                Winner = 'y';
                                break;
                            }
                            else
                            {
                                output.InvalidEntry();
                            }
                            output.ChangeTurns(P2, P1);
                        }
                    }
                }
                else                             // PLAYER 2 GOES FIRST
                {
                    while (Winner != 'y')
                    {
                        while (true)
                        {
                            output.InitiateGame(P2);
                            output.ShowBoard2();
                            output.AskCoordinates(P2);
                            var        values     = input.GetCoordinate();
                            int        x          = values.Item1;
                            int        y          = values.Item2;
                            Coordinate coordinate = new Coordinate(x, y);
                            var        shot       = board1.FireShot(coordinate);
                            ShotStatus shotStatus = shot.ShotStatus;
                            string     ship       = shot.ShipImpacted;
                            if (shotStatus == ShotStatus.Hit)
                            {
                                output.Hit();
                                output.gameBoard2[y - 1, x - 1] = 'H';
                                break;
                            }
                            else if (shotStatus == ShotStatus.Miss)
                            {
                                output.Miss();
                                output.gameBoard2[y - 1, x - 1] = 'M';
                                break;
                            }
                            else if (shotStatus == ShotStatus.HitAndSunk)
                            {
                                output.HitAndSink(ship);
                                output.gameBoard2[y - 1, x - 1] = 'H';
                                break;
                            }
                            else if (shotStatus == ShotStatus.Victory)
                            {
                                output.Victory(P2);
                                Winner = 'y';
                                break;
                            }
                        }


                        output.ChangeTurns(P2, P1);
                        while (true)
                        {
                            output.ShowBoard1();
                            output.AskCoordinates(P1);
                            var        values2     = input.GetCoordinate();
                            int        x2          = values2.Item1;
                            int        y2          = values2.Item2;
                            Coordinate coordinate2 = new Coordinate(x2, y2);
                            var        shot2       = board2.FireShot(coordinate2);
                            ShotStatus shotStatus2 = shot2.ShotStatus;
                            string     ship2       = shot2.ShipImpacted;
                            if (shotStatus2 == ShotStatus.Hit)
                            {
                                output.Hit();
                                output.gameBoard1[y2 - 1, x2 - 1] = 'H';
                                break;
                            }
                            else if (shotStatus2 == ShotStatus.Miss)
                            {
                                output.Miss();
                                output.gameBoard1[y2 - 1, x2 - 1] = 'M';
                                break;
                            }
                            else if (shotStatus2 == ShotStatus.HitAndSunk)
                            {
                                output.HitAndSink(ship2);
                                output.gameBoard1[y2 - 1, x2 - 1] = 'H';
                                break;
                            }
                            else if (shotStatus2 == ShotStatus.Victory)
                            {
                                output.Victory(P1);
                                Winner = 'y';
                                break;
                            }
                            else
                            {
                                output.InvalidEntry();
                            }
                        }
                        output.ChangeTurns(P1, P2);
                    }
                }
            }
            else
            {
                output.ExitGame();
            }
            Console.ReadLine();
        }
Ejemplo n.º 30
0
 protected void CallThrowerReady(ShotStatus status)
 {
     CallEvent(OnThrowEntityReady, status);
 }