Esempio n. 1
0
        private void PossibleHorizontalDiagonalJumps(List <string> validMoves, int direction)
        {
            PlayerCoordinate playerCoordinate = GetCurrentPlayerCoodinate();
            PlayerCoordinate opponentCoord    = GetCurrentOpponentCoordinate();

            if (playerCoordinate.Row + 1 < 17 &&
                playerCoordinate.Col + 2 * direction < 17 &&
                playerCoordinate.Col + 2 * direction > -1 &&
                board[playerCoordinate.Row + 1, playerCoordinate.Col + 2 * direction] != WALL)
            {
                StringBuilder sb = new StringBuilder();

                sb.Append(Convert.ToChar(97 + (opponentCoord.Col / 2)));
                sb.Append(value: 9 - (opponentCoord.Row / 2) - 1 < 1 ? 1
                               : 9 - (opponentCoord.Row / 2) - 1);

                validMoves.Add(sb.ToString());
            }
            if (playerCoordinate.Row - 1 > -1 &&
                playerCoordinate.Col + 2 * direction < 17 &&
                playerCoordinate.Col + 2 * direction > -1 &&
                board[playerCoordinate.Row - 1, playerCoordinate.Col + 2 * direction] != WALL)
            {
                StringBuilder sb = new StringBuilder();

                sb.Append(Convert.ToChar(97 + (opponentCoord.Col / 2)));
                sb.Append(value: 9 - (opponentCoord.Row / 2) + 1 > 9 ? 9
                               : 9 - (opponentCoord.Row / 2) + 1);

                validMoves.Add(sb.ToString());
            }
        }
        public WallCoordinate(string str)
        {
            if (str.Length != 3 || !(str[2] == 'v' || str[2] == 'h'))
            {
                throw new Exception("Invalid input format");
            }

            if (str[2] == 'v')
            {
                Orientation = WallOrientation.Vertical;
            }
            else
            {
                Orientation = WallOrientation.Horizontal;
            }

            StandardNotationString = str;
            PlayerCoordinate referenceCoordinate = new PlayerCoordinate(StandardNotationString.Substring(0, 2));

            if (Orientation == WallOrientation.Vertical)
            {
                StartRow = referenceCoordinate.Row;
                StartCol = referenceCoordinate.Col + 1;
                EndRow   = StartRow - 2;
                EndCol   = StartCol;
            }
            else
            {
                StartRow = referenceCoordinate.Row - 1;
                StartCol = referenceCoordinate.Col;
                EndRow   = StartRow;
                EndCol   = StartCol + 2;
            }
        }
Esempio n. 3
0
        private void PossibleVerticalDiagonalJumps(List <string> validMoves, int direction)
        {
            PlayerCoordinate playerCoordinate = GetCurrentPlayerCoodinate();
            PlayerCoordinate opponentCoord    = GetCurrentOpponentCoordinate();

            if (playerCoordinate.Col + 1 < 17 &&
                playerCoordinate.Row + 2 * direction < 17 &&
                playerCoordinate.Row + 2 * direction > -1 &&
                board[playerCoordinate.Row + 2 * direction, playerCoordinate.Col + 1] != WALL)
            {
                StringBuilder sb = new StringBuilder();

                sb.Append(Convert.ToChar(value: 97 + (opponentCoord.Col / 2) + 1 > 105 ? 105
                                                  : 97 + (opponentCoord.Col / 2) + 1));
                sb.Append(9 - (opponentCoord.Row / 2));

                validMoves.Add(sb.ToString());
            }
            if (playerCoordinate.Col - 1 > -1 &&
                playerCoordinate.Row + 2 * direction < 17 &&
                playerCoordinate.Row + 2 * direction > -1 &&
                board[playerCoordinate.Row + 2 * direction, playerCoordinate.Col - 1] != WALL)
            {
                StringBuilder sb = new StringBuilder();

                sb.Append(Convert.ToChar(value: 97 + (opponentCoord.Col / 2) - 1 < 97 ? 97
                                              : 97 + (opponentCoord.Col / 2) - 1));
                sb.Append(9 - (opponentCoord.Row / 2));

                validMoves.Add(sb.ToString());
            }
        }
Esempio n. 4
0
        public GameBoard(GameBoard boardState)
        {
            gameOver     = false;
            playerOneWin = false;
            playerTwoWin = false;

            playerOneLocation = new PlayerCoordinate(boardState.playerOneLocation.Row, boardState.playerOneLocation.Col);
            playerTwoLocation = new PlayerCoordinate(boardState.playerTwoLocation.Row, boardState.playerTwoLocation.Col);

            board = new char[TOTAL_ROWS, TOTAL_COLS];
            for (int r = 0; r < TOTAL_ROWS; ++r)
            {
                for (int c = 0; c < TOTAL_COLS; ++c)
                {
                    if ((r % 2 == 0) && (c % 2 == 0))
                    {
                        board[r, c] = PLAYER_SPACE;
                    }
                    else
                    {
                        if (boardState.board[r, c].Equals(WALL))
                        {
                            board[r, c] = WALL;
                        }
                        else
                        {
                            board[r, c] = WALL_SPACE;
                        }
                    }
                }
            }
        }
Esempio n. 5
0
        private void PossibleVerticalJumps(List <string> validMoves, int direction)
        {
            PlayerCoordinate playerCoordinate = GetCurrentPlayerCoodinate();
            PlayerCoordinate opponentCoord    = GetCurrentOpponentCoordinate();

            if (playerCoordinate.Row + (3 * direction) < 17 && playerCoordinate.Row + (3 * direction) > -1)
            {
                if (board[playerCoordinate.Row + (3 * direction), playerCoordinate.Col] != WALL)
                {
                    StringBuilder sb = new StringBuilder();

                    sb.Append(Convert.ToChar(97 + (opponentCoord.Col / 2)));
                    sb.Append(value: 9 - (opponentCoord.Row / 2) - (1 * direction) > 9 ? 9
                                   : 9 - (opponentCoord.Row / 2) - (1 * direction) < 1 ? 1
                                   : 9 - (opponentCoord.Row / 2) - (1 * direction));

                    validMoves.Add(sb.ToString());
                }
                else
                {
                    PossibleVerticalDiagonalJumps(validMoves, direction);
                }
            }
            else
            {
                PossibleVerticalDiagonalJumps(validMoves, direction);
            }
        }
Esempio n. 6
0
        private bool IsDestinationAdjacent(PlayerCoordinate start, PlayerCoordinate destination)
        {
            bool verticalMove   = (Math.Abs(destination.Row - start.Row) == 2) && (Math.Abs(destination.Col - start.Col) == 0);
            bool horizontalMove = (Math.Abs(destination.Col - start.Col) == 2) && (Math.Abs(destination.Row - start.Row) == 0);

            return(verticalMove ^ horizontalMove); // Only north south east west are considered adjacent
        }
Esempio n. 7
0
        private bool IsMoveBlocked(PlayerCoordinate start, PlayerCoordinate destination)
        {
            bool blocked = false;

            if (start.Row == destination.Row)
            {
                if (start.Col < destination.Col)
                {
                    blocked = (board[start.Row, start.Col + 1] == WALL) || (board[destination.Row, destination.Col - 1] == WALL);
                }
                else
                {
                    blocked = (board[start.Row, start.Col - 1] == WALL) || (board[destination.Row, destination.Col + 1] == WALL);
                }
            }
            else if (start.Col == destination.Col)
            {
                if (start.Row < destination.Row)
                {
                    blocked = (board[start.Row + 1, start.Col] == WALL) || (board[destination.Row - 1, destination.Col] == WALL);
                }
                else
                {
                    blocked = (board[start.Row - 1, start.Col] == WALL) || (board[destination.Row + 1, destination.Col] == WALL);
                }
            }
            return(blocked);
        }
Esempio n. 8
0
        private void PossibleHorizontalJumps(List <string> validMoves, int direction)
        {
            PlayerCoordinate playerCoordinate = GetCurrentPlayerCoodinate();
            PlayerCoordinate opponentCoord    = GetCurrentOpponentCoordinate();

            if (playerCoordinate.Col + (3 * direction) < 17 && playerCoordinate.Col + (3 * direction) > -1)
            {
                if (board[playerCoordinate.Row, playerCoordinate.Col + (3 * direction)] != WALL)
                {
                    StringBuilder sb = new StringBuilder();

                    sb.Append(Convert.ToChar(97 + (opponentCoord.Col / 2) + (1 * direction) > 105 ? 105
                                            : 97 + (opponentCoord.Col / 2) + (1 * direction) < 97 ? 97
                                            : 97 + (opponentCoord.Col / 2) + (1 * direction)));
                    sb.Append(9 - (opponentCoord.Row / 2));

                    validMoves.Add(sb.ToString());
                }
                else
                {
                    PossibleHorizontalDiagonalJumps(validMoves, direction);
                }
            }
            else
            {
                PossibleHorizontalDiagonalJumps(validMoves, direction);
            }
        }
Esempio n. 9
0
        private void InitializeBoard(string playerOneStart, string playerTwoStart)
        {
            gameOver     = false;
            playerOneWin = false;
            playerTwoWin = false;

            lastMove = new List <string>();
            lastMove.Add(playerOneStart);
            lastMove.Add(playerTwoStart);

            lastStart = new List <string>();
            lastStart.Add(playerOneStart);
            lastStart.Add(playerTwoStart);

            possibleWalls     = new List <string>();
            playerOneLocation = new PlayerCoordinate(playerOneStart);
            playerTwoLocation = new PlayerCoordinate(playerTwoStart);
            walls             = new List <WallCoordinate>();
            possibleMoves     = new List <List <string> >();

            // Init gameboard
            board = new char[TOTAL_ROWS, TOTAL_COLS];
            for (int r = 0; r < TOTAL_ROWS; ++r)
            {
                for (int c = 0; c < TOTAL_COLS; ++c)
                {
                    if ((r % 2 == 0) && (c % 2 == 0))
                    {
                        board[r, c] = PLAYER_SPACE;
                    }
                    else
                    {
                        board[r, c] = WALL_SPACE;
                    }
                }
            }

            // Build list of possible walls
            for (int r = 0; r < 8; ++r)
            {
                for (int c = 0; c < 8; ++c)
                {
                    possibleWalls.Add((Convert.ToChar('a' + c)).ToString() + (Convert.ToChar('1' + r)) + 'h'.ToString());
                    possibleWalls.Add((Convert.ToChar('a' + c)).ToString() + (Convert.ToChar('1' + r)) + 'v'.ToString());
                }
            }

            PlayerEnum actualStartingPlayer = whoseTurn;

            whoseTurn = PlayerEnum.ONE;

            possibleMoves.Add(PossibleMovesFromPosition());

            whoseTurn = PlayerEnum.TWO;

            possibleMoves.Add(PossibleMovesFromPosition());

            whoseTurn = actualStartingPlayer;
        }
        private static string RandomNearbyRowMove(PlayerCoordinate player)
        {
            StringBuilder sb  = new StringBuilder();
            int           col = random.Next(minValue: player.Col == 0 ? 97 : (97 + (player.Col / 2) - 1), maxValue: player.Col == 16 ? 106 : 97 + (player.Col / 2) + 2);

            sb.Append(Convert.ToChar(col));
            sb.Append(9 - (player.Row / 2));
            return(sb.ToString());
        }
Esempio n. 11
0
        private bool PlayersAreAdjacent()
        {
            PlayerCoordinate playerCoordinate = (whoseTurn == 0 ? (playerOneLocation) : (playerTwoLocation));
            PlayerCoordinate opponentCoord    = (whoseTurn == 0 ? (playerTwoLocation) : (playerOneLocation));

            return(((whoseTurn == 0 ? playerOneLocation : playerTwoLocation).Row == (whoseTurn == 0 ? playerTwoLocation : playerOneLocation).Row && (whoseTurn == 0 ? playerOneLocation : playerTwoLocation).Col + 2 == (whoseTurn == 0 ? playerTwoLocation : playerOneLocation).Col && board[(whoseTurn == 0 ? playerOneLocation : playerTwoLocation).Row, (whoseTurn == 0 ? playerOneLocation : playerTwoLocation).Col + 1] != WALL) ||
                   (playerCoordinate.Row == opponentCoord.Row && playerCoordinate.Col - 2 == opponentCoord.Col && board[playerCoordinate.Row, (playerCoordinate.Col - 1)] != WALL) ||
                   (playerCoordinate.Row + 2 == opponentCoord.Row && playerCoordinate.Col == opponentCoord.Col && board[playerCoordinate.Row + 1, (playerCoordinate.Col)] != WALL) ||
                   (playerCoordinate.Row - 2 == opponentCoord.Row && playerCoordinate.Col == opponentCoord.Col && board[playerCoordinate.Row - 1, playerCoordinate.Col] != WALL));
        }
        private static string RandomNearbyColMove(PlayerCoordinate player)
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(Convert.ToChar(97 + (player.Col / 2)));
            int row = random.Next(minValue: player.Row == 16 ? 1 : (9 - (player.Row / 2) - 1), maxValue: player.Row == 0 ? 10 : (9 - (player.Row / 2) + 2));

            sb.Append(row);
            return(sb.ToString());
        }
        public static string GetRandomNearbyPlayerPieceMoveWeighted(PlayerCoordinate player, int weight)
        {
            StringBuilder sb  = new StringBuilder();
            int           col = random.Next((player.Col == 0 ? 97 : ((97 + (player.Col / 2) - 1)) < 97 ? 97 : 97 + (player.Col / 2) - 1), (player.Col == 16 ? 106 : 97 + (player.Col / 2) + 1) > 105 ? 106 : 97 + (player.Col / 2) + 2);

            sb.Append(Convert.ToChar(col));
            int row = random.Next(player.Row == 16 ? 1 : (9 - (player.Row / 2) - 1 < 1 ? 1 : 9 - (player.Row / 2) - 1), player.Row == 0 ? 10 : (9 - (player.Row / 2) + 1 > 9 ? 9 : 9 - (player.Row / 2) + 2));

            sb.Append(row);
            return(sb.ToString());
        }
        public static string GetRandomNearbyPlayerPieceMove(PlayerCoordinate player)
        {
            string move;

            if (random.Next(0, 2) == 0)
            {
                // Retrieves a move from the same column
                move = RandomNearbyColMove(player);
            }
            else
            {
                // Retrieves a move from the same row
                move = RandomNearbyRowMove(player);
            }

            return(move);
        }
Esempio n. 15
0
        public PlayerCoordinate GetPlayerCoordinate(PlayerEnum player)
        {
            PlayerCoordinate playerCoordinate = null;

            switch (player)
            {
            case PlayerEnum.ONE:
                playerCoordinate = playerOneLocation;
                break;

            case PlayerEnum.TWO:
                playerCoordinate = playerTwoLocation;
                break;
            }

            return(playerCoordinate);
        }
Esempio n. 16
0
        private bool IsMoveOnOpenSpace(PlayerEnum player, PlayerCoordinate destination)
        {
            bool onPlayerSpace = destination.Row % 2 == 0 && // odd rows are walls
                                 destination.Col % 2 == 0; // odd cols are walls

            bool isSpaceEmpty;

            if (player == PlayerEnum.ONE)
            {
                isSpaceEmpty = !(destination.Row == playerTwoLocation.Row && destination.Col == playerTwoLocation.Col);
            }
            else
            {
                isSpaceEmpty = !(destination.Row == playerOneLocation.Row && destination.Col == playerOneLocation.Col);
            }

            return(onPlayerSpace && isSpaceEmpty);
        }
Esempio n. 17
0
        public bool IsValidPlayerMove(PlayerEnum player, PlayerCoordinate start, PlayerCoordinate destination)
        {
            if (gameOver ||
                !IsMoveInBounds(destination.Row, destination.Col))
            {
                return(false);
            }

            bool onPlayerSpace = IsMoveOnOpenSpace(player, destination);
            bool blocked       = IsMoveBlocked(start, destination);
            bool canReach      = IsDestinationAdjacent(start, destination);

            if (!canReach)
            {
                canReach = IsValidJump(player, start, destination);
            }

            return(onPlayerSpace &&
                   !blocked &&
                   canReach);
        }
        public static bool IsMoveAdjacentToPosition(string move, PlayerCoordinate position)
        {
            string positionAsString = PlayerCoordinateToString(position);

            if (Convert.ToChar(positionAsString[1] + 1) == move[1] && positionAsString[0] == move[0])
            {
                return(true);
            }
            if (Convert.ToChar(positionAsString[0] + 1) == move[0] && positionAsString[1] == move[1])
            {
                return(true);
            }
            if (Convert.ToChar(positionAsString[1] - 1) == move[1] && positionAsString[0] == move[0])
            {
                return(true);
            }
            if (Convert.ToChar(positionAsString[0] - 1) == move[0] && positionAsString[1] == move[1])
            {
                return(true);
            }

            return(false);
        }
        public WallCoordinate(int x, int y, char c)
        {
            char orientation = char.ToLower(c);

            if (x < 0 || x >= GameBoard.TOTAL_ROWS || y < 0 || y >= GameBoard.TOTAL_COLS || !(orientation == 'h' || orientation == 'v'))
            {
                throw new Exception("Invalid input format");
            }

            if (orientation == 'h')
            {
                Orientation = WallOrientation.Horizontal;
            }
            else if (orientation == 'v')
            {
                Orientation = WallOrientation.Vertical;
            }

            StandardNotationString = x.ToString() + y.ToString() + c;

            PlayerCoordinate referenceCoordinate = new PlayerCoordinate(x, y);

            if (Orientation == WallOrientation.Vertical)
            {
                StartRow = referenceCoordinate.Row;
                StartCol = referenceCoordinate.Col + 1;
                EndRow   = StartRow - 2;
                EndCol   = StartCol;
            }
            else
            {
                StartRow = referenceCoordinate.Row - 1;
                StartCol = referenceCoordinate.Col;
                EndRow   = StartRow;
                EndCol   = StartCol + 2;
            }
        }
Esempio n. 20
0
 private Tuple <int, int> FindMidpoint(PlayerCoordinate start, PlayerCoordinate destination)
 {
     return(new Tuple <int, int>((start.Row + destination.Row) / 2, (start.Col + destination.Col) / 2));
 }
Esempio n. 21
0
        private bool IsValidJump(PlayerEnum player, PlayerCoordinate start, PlayerCoordinate destination)
        {
            // Jumping over?
            Tuple <int, int> midpoint = FindMidpoint(start, destination);
            int midRow = midpoint.Item1;
            int midCol = midpoint.Item2;
            int opponentRow, opponentCol;

            if (player == PlayerEnum.ONE)
            {
                opponentRow = playerTwoLocation.Row;
                opponentCol = playerTwoLocation.Col;
            }
            else
            {
                opponentRow = playerOneLocation.Row;
                opponentCol = playerOneLocation.Col;
            }
            bool overJump = midRow == opponentRow &&
                            midCol == opponentCol &&
                            (Math.Abs(destination.Row - start.Row) == 4 || Math.Abs(destination.Col - start.Col) == 4);

            // Diagonal jump?
            bool             diagonalJump = false;
            PlayerCoordinate opponent;

            if (player == PlayerEnum.ONE)
            {
                opponent = new PlayerCoordinate(playerTwoLocation.Row, playerTwoLocation.Col);
            }
            else
            {
                opponent = new PlayerCoordinate(playerOneLocation.Row, playerTwoLocation.Col);
            }

            if (start.Row != destination.Row && start.Col != destination.Col)
            {
                int targetOppRow, targetOppoCol;
                if (destination.Row == start.Row - 2 && destination.Col == start.Col + 2) // NE
                {
                    targetOppRow  = start.Row - 2;
                    targetOppoCol = start.Col + 2;
                    diagonalJump  =
                        ((opponent.Row == targetOppRow && opponent.Col == start.Col) || (opponent.Row == start.Row && opponent.Col == targetOppoCol)) &&
                        ((start.Row - 3 == -1 || start.Col + 3 == 17) || (board[start.Row - 3, start.Col] == WALL || board[start.Row, start.Col + 3] == WALL));
                }
                else if (destination.Row == start.Row - 2 && destination.Col == start.Col - 2) // NW
                {
                    targetOppRow  = start.Row - 2;
                    targetOppoCol = start.Col - 2;
                    diagonalJump  =
                        ((opponent.Row == targetOppRow && opponent.Col == start.Col) || (opponent.Row == start.Row && opponent.Col == targetOppoCol)) &&
                        ((start.Row - 3 == -1 || start.Col - 3 == -1) || (board[start.Row - 3, start.Col] == WALL || board[start.Row, start.Col - 3] == WALL));
                }
                else if (destination.Row == start.Row + 2 && destination.Col == start.Col - 2) // SW
                {
                    targetOppRow  = start.Row + 2;
                    targetOppoCol = start.Col - 2;
                    diagonalJump  =
                        ((opponent.Row == targetOppRow && opponent.Col == start.Col) || (opponent.Row == start.Row && opponent.Col == targetOppoCol)) &&
                        ((start.Row + 3 == 17 || start.Col - 3 == -1) || (board[start.Row + 3, start.Col] == WALL || board[start.Row, start.Col - 3] == WALL));
                }
                else if (destination.Row == start.Row + 2 && destination.Col == start.Col + 2) // SE
                {
                    targetOppRow  = start.Row + 2;
                    targetOppoCol = start.Col + 2;
                    diagonalJump  =
                        ((opponent.Row == targetOppRow && opponent.Col == start.Col) || (opponent.Row == start.Row && opponent.Col == targetOppoCol)) &&
                        ((start.Row + 3 == 17 || start.Col + 3 == 17) || (board[start.Row + 3, start.Col] == WALL || board[start.Row, start.Col + 3] == WALL));
                }
            }

            return(overJump || diagonalJump);
        }
Esempio n. 22
0
        private List <string> PossibleMovesFromPosition()
        {
            List <string>    validMoves       = new List <string>();
            PlayerCoordinate playerCoordinate = GetCurrentPlayerCoodinate();
            PlayerCoordinate opponentCoord    = GetCurrentOpponentCoordinate();

            if (PlayersAreAdjacent())
            {
                if (playerCoordinate.Row == opponentCoord.Row)
                {
                    if (playerCoordinate.Col < opponentCoord.Col)
                    {
                        PossibleHorizontalJumps(validMoves, 1);
                    }
                    else
                    {
                        PossibleHorizontalJumps(validMoves, -1);
                    }
                }
                else
                {
                    if (playerCoordinate.Row < opponentCoord.Row)
                    {
                        PossibleVerticalJumps(validMoves, 1);
                    }
                    else
                    {
                        PossibleVerticalJumps(validMoves, -1);
                    }
                }
            }
            if (playerCoordinate.Row + 1 < 17 && board[playerCoordinate.Row + 1, playerCoordinate.Col] != WALL &&
                (playerCoordinate.Row + 2 != opponentCoord.Row || playerCoordinate.Col != opponentCoord.Col))
            {
                //South
                StringBuilder sb = new StringBuilder();
                sb.Append(Convert.ToChar(97 + (playerCoordinate.Col / 2)));
                sb.Append(9 - (playerCoordinate.Row / 2) - 1 < 1 ? 1 : 9 - (playerCoordinate.Row / 2) - 1);
                validMoves.Add(sb.ToString());
            }
            if (playerCoordinate.Row - 1 > -1 && board[playerCoordinate.Row - 1, playerCoordinate.Col] != WALL &&
                (playerCoordinate.Row - 2 != opponentCoord.Row || playerCoordinate.Col != opponentCoord.Col))
            {
                //North
                StringBuilder sb = new StringBuilder();
                sb.Append(Convert.ToChar(97 + (playerCoordinate.Col / 2)));
                sb.Append(9 - (playerCoordinate.Row / 2) + 1 > 9 ? 9 : 9 - (playerCoordinate.Row / 2) + 1);
                validMoves.Add(sb.ToString());
            }
            if (playerCoordinate.Col + 1 < 17 && board[playerCoordinate.Row, playerCoordinate.Col + 1] != WALL &&
                (playerCoordinate.Row != opponentCoord.Row || playerCoordinate.Col + 2 != opponentCoord.Col))
            {
                //East
                StringBuilder sb = new StringBuilder();
                sb.Append(Convert.ToChar(97 + (playerCoordinate.Col / 2) + 1));
                sb.Append(9 - (playerCoordinate.Row / 2));
                validMoves.Add(sb.ToString());
            }
            if (playerCoordinate.Col - 1 > -1 && board[playerCoordinate.Row, playerCoordinate.Col - 1] != WALL &&
                (playerCoordinate.Row != opponentCoord.Row || playerCoordinate.Col - 2 != opponentCoord.Col))
            {
                //West
                StringBuilder sb = new StringBuilder();
                sb.Append(Convert.ToChar(97 + (playerCoordinate.Col / 2) - 1));
                sb.Append(9 - (playerCoordinate.Row / 2));
                validMoves.Add(sb.ToString());
            }


            validMoves.Sort(delegate(string lValue, string rValue)
            {
                if (lValue == rValue)
                {
                    return(0);
                }
                else
                {
                    return(lValue.CompareTo(rValue));
                }
            });

            return(validMoves);
        }
 public static string PlayerCoordinateToString(PlayerCoordinate location)
 {
     return(Convert.ToChar(97 + (location.Col / 2)).ToString() + (9 - (location.Row / 2)));
 }
Esempio n. 24
0
        public bool MovePiece(PlayerEnum player, PlayerCoordinate destinationCoordinate)
        {
            if (gameOver || player != whoseTurn)
            {
                return(false);
            }

            bool             retValue        = false;
            PlayerCoordinate startCoordinate = null;

            switch (player)
            {
            case PlayerEnum.ONE:
                startCoordinate = playerOneLocation;
                break;

            case PlayerEnum.TWO:
                startCoordinate = playerTwoLocation;
                break;
            }

            string move = Convert.ToChar(97 + (destinationCoordinate.Col / 2)).ToString() + (9 - destinationCoordinate.Row / 2).ToString();

            if (possibleMoves[whoseTurn == 0 ? 0 : 1].Contains(move) /*IsValidPlayerMove(player, startCoordinate, destinationCoordinate)*/)
            {
                board[startCoordinate.Row, startCoordinate.Col] = PLAYER_SPACE;
                switch (player)
                {
                case PlayerEnum.ONE:
                    playerOneLocation.Row = destinationCoordinate.Row;
                    playerOneLocation.Col = destinationCoordinate.Col;

                    lastStart[0] = lastMove[0];

                    if (BoardUtil.IsMoveAdjacentToPosition(move, playerOneLocation))
                    {
                        lastMove[0] = BoardUtil.PlayerCoordinateToString(playerTwoLocation);
                    }
                    else
                    {
                        lastMove[0] = BoardUtil.PlayerCoordinateToString(playerOneLocation);
                    }

                    possibleMoves[whoseTurn == 0 ? 0 : 1] = PossibleMovesFromPosition();
                    whoseTurn = PlayerEnum.TWO;
                    possibleMoves[whoseTurn == 0 ? 0 : 1] = PossibleMovesFromPosition();
                    break;

                case PlayerEnum.TWO:
                    playerTwoLocation.Row = destinationCoordinate.Row;
                    playerTwoLocation.Col = destinationCoordinate.Col;

                    lastStart[1] = lastMove[1];

                    if (BoardUtil.IsMoveAdjacentToPosition(move, playerTwoLocation))
                    {
                        lastMove[1] = BoardUtil.PlayerCoordinateToString(playerOneLocation);
                    }
                    else
                    {
                        lastMove[1] = BoardUtil.PlayerCoordinateToString(playerTwoLocation);
                    }


                    possibleMoves[whoseTurn == 0 ? 0 : 1] = PossibleMovesFromPosition();
                    whoseTurn = PlayerEnum.ONE;
                    possibleMoves[whoseTurn == 0 ? 0 : 1] = PossibleMovesFromPosition();
                    break;
                }
                retValue = true;
            }

            // check for win
            if (playerOneLocation.Row == 0)
            {
                playerOneWin = true;
            }
            if (playerTwoLocation.Row == (TOTAL_ROWS - 1))
            {
                playerTwoWin = true;
            }
            gameOver = playerOneWin || playerTwoWin;

            return(retValue);
        }