Ejemplo n.º 1
0
 public void TestCopyTo_DestinationObjectNotValid_TrownException()
 {
     int row = 0;
     int column = 0;
     PlayerPosition target = new PlayerPosition(row, column);
     PlayerPosition destinationPlayerPosition = null;
     target.CopyTo(destinationPlayerPosition);
 }
Ejemplo n.º 2
0
 public void TestInitializeLabyrinthMapInitial_CreateGame7x7_LabyrinthIsSolvable()
 {
     Labyrinth_Accessor target = new Labyrinth_Accessor(7, 7, 3, 3);
     target.InitializeLabyrinthMap();
     PlayerPosition playerInitialPosition = new PlayerPosition(3,3);
     bool isLabirinthSolvable = GameUtilities_Accessor.IsLabyrinthSolvable(target.labyrinthMap, playerInitialPosition);
     Assert.IsTrue(isLabirinthSolvable);
 }
Ejemplo n.º 3
0
        public void CopyTo(PlayerPosition destinationPlayerPosition)
        {
            if (destinationPlayerPosition == null)
            {
                throw new ArgumentNullException("The destination item must be a valid object");
            }

            destinationPlayerPosition.Row = this.Row;
            destinationPlayerPosition.Column = this.Column;
        }
Ejemplo n.º 4
0
 public void TestCheckPlayerPositionValidityInLabyrinthMap_PlayerPositionOutOfRange_ThrownException()
 {
     int[,] labyrinthMap = new int[,]
     {
         { 0, 0, 0 },
         { 0, 0, 0 },
         { 0, 0, 0 },
     };
     PlayerPosition playerStartPosition = new PlayerPosition(3, 3);
     GameUtilities_Accessor.CheckPlayerPositionValidityInLabyrinthMap(labyrinthMap, playerStartPosition);
 }
Ejemplo n.º 5
0
 public void TestIsLabyrinthSolvable_LabitynthWithManyExits_ReturnsTrue()
 {
     int[,] labyrinthMap = new int[,]
     {
         { 0, 0, 0 },
         { 0, 0, 0 },
         { 0, 0, 0 },
     };
     PlayerPosition playerStartPosition = new PlayerPosition(1, 1);
     bool isLabyrinthSolvable = GameUtilities.IsLabyrinthSolvable(labyrinthMap, playerStartPosition);
     Assert.IsTrue(isLabyrinthSolvable);
 }
Ejemplo n.º 6
0
 public void TestIsLabyrinthSolvable_LabitynthIsNotSolvable_ReturnsFalse()
 {
     int[,] labyrinthMap = new int[,]
     {
         { 1, 1, 1 },
         { 1, 0, 1 },
         { 1, 1, 1 },
     };
     PlayerPosition playerStartPosition = new PlayerPosition(1, 1);
     bool isLabyrinthSolvable = GameUtilities.IsLabyrinthSolvable(labyrinthMap, playerStartPosition);
     Assert.IsFalse(isLabyrinthSolvable);
 }
Ejemplo n.º 7
0
        /// <summary>
        /// Verifies that given labyrinth map has at leas one possible solution
        /// </summary>
        /// <param name="labyrinthMap">Labyrinth map to check</param>
        /// <param name="playerPositionRow">Player's starting row position</param>
        /// <param name="playerPositionColumn">Player's starting column position</param>
        /// <returns>Returns true if there is at least one solution and false otherwise</returns>
        public static bool IsLabyrinthSolvable(
			int[,] labyrinthMap, PlayerPosition playerStartPosition)
        {
            CheckLabyrinthMapValidity(labyrinthMap);
            CheckPlayerPositionValidityInLabyrinthMap(labyrinthMap, playerStartPosition);

            int[,] labyrinthMapTestable = (int[,])labyrinthMap.Clone();
            int playerPositionRow = playerStartPosition.Row;
            int playerPositionColumn = playerStartPosition.Column;
            bool isSolvable =
                LabyrintExitExists(labyrinthMapTestable, playerPositionRow, playerPositionColumn);
            return isSolvable;
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Initialises the labyrinth game 
        /// setting information about the board size and the initial player position
        /// </summary>
        /// <param name="rows">Number of labyrinth rows</param>
        /// <param name="columns">Number of labyrinth columns</param>
        /// <param name="playerInitialPositionRow">Initial row position of the player</param>
        /// <param name="playerInitialPositionColumn">Initial column position of the player</param>
        public Labyrinth(int rows, int columns,
			int playerInitialPositionRow, int playerInitialPositionColumn)
        {
            this.VerifyLabyrinthSizeParameter(rows, columns);
            this.VerifyPlayerInitialPositionParameters(rows, columns,
                playerInitialPositionRow, playerInitialPositionColumn);

            this.labyrinthMap = new int[rows, columns];
            this.playerCurrentPosition =
                new PlayerPosition(playerInitialPositionRow, playerInitialPositionColumn);
            this.playerInitialPosition =
                new PlayerPosition(playerInitialPositionRow, playerInitialPositionColumn);
            this.InitializeUserCommadsParser();
            this.InitializeUserActionList();
            this.StartNewGame();
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Checks if the given player position is inside the labyrinth map
        /// </summary>
        /// <param name="labyrinthMap">Labyrinth map</param>
        /// <param name="playerPosition">Player's position</param>
        /// <returns>Returns true if the position is inside the labyrinth. 
        /// False - otherwise</returns>
        public static bool IsPlayerPositionInLabyrinthRange(int[,] labyrinthMap,
			PlayerPosition playerPosition)
        {
            CheckLabyrinthMapValidity(labyrinthMap);

            int labyrinthLastRowPosition = labyrinthMap.GetLength(0) - 1;
            int labyrinthLastColumnPosition = labyrinthMap.GetLength(1) - 1;
            bool isPlayerRowPositionInRange = playerPosition.Row >= 0 &&
                                              playerPosition.Row <=
                                              labyrinthLastRowPosition;
            bool isPlayerColumnPositionInRange = playerPosition.Column >= 0 &&
                                                 playerPosition.Column <=
                                                 labyrinthLastColumnPosition;
            bool isPlayerPositionInLabyrinthRange = isPlayerRowPositionInRange &&
                                                    isPlayerColumnPositionInRange;
            return isPlayerPositionInLabyrinthRange;
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Checks if the given player position is at the labyrinth's border
        /// </summary>
        /// <param name="labyrinthMap">Labyrinth map</param>
        /// <param name="playerPosition">Player's position</param>
        /// <returns>Returns true if the position is at one of the the labyrinth's borders. 
        ///False - otherwise</returns>
        public static bool IsPlayerPositionAtLabyrintBorder(int[,] labyrinthMap,
			PlayerPosition playerPosition)
        {
            CheckLabyrinthMapValidity(labyrinthMap);

            int labyrinthLastRowPosition = labyrinthMap.GetLength(0) - 1;
            int labyrinthLastColumnPosition = labyrinthMap.GetLength(1) - 1;
            bool isPlayerRowPositionAtBorder = playerPosition.Row == 0 ||
                                               playerPosition.Row ==
                                               labyrinthLastRowPosition;
            bool isPlayerColumnPositionAtBorder = playerPosition.Column == 0 ||
                                                  playerPosition.Column ==
                                                  labyrinthLastColumnPosition;
            bool isPlayerPositionAtLabyrintBorder = isPlayerRowPositionAtBorder ||
                                                    isPlayerColumnPositionAtBorder;
            return isPlayerPositionAtLabyrintBorder;
        }
Ejemplo n.º 11
0
 private bool IsPlayerPositionChanged(PlayerPosition playerPreviousPosition)
 {
     bool isPlayerPositionChanged = this.playerCurrentPosition.Row !=
                                    playerPreviousPosition.Row ||
                                    this.playerCurrentPosition.Column !=
                                    playerPreviousPosition.Column;
     return isPlayerPositionChanged;
 }
Ejemplo n.º 12
0
 public void TestIsPlayerPositionAtLabyrintBorder_PlayerPositionNotAtBorder_ReturnsFalse()
 {
     int[,] labyrinthMap = new int[,]
     {
         { 0, 0, 0 },
         { 0, 0, 0 },
         { 0, 0, 0 },
     };
     PlayerPosition playerStartPosition = new PlayerPosition(1, 1);
     bool isPlayerPositionAtRange = GameUtilities.IsPlayerPositionAtLabyrintBorder(labyrinthMap, playerStartPosition);
     Assert.IsFalse(isPlayerPositionAtRange);
 }
Ejemplo n.º 13
0
        private static void CheckPlayerPositionValidityInLabyrinthMap(int[,] labyrinthMap,
			PlayerPosition playerStartPosition)
        {
            if (playerStartPosition == null)
            {
                throw new ArgumentNullException("Player position should a valid object.");
            }
            if (!IsPlayerPositionInLabyrinthRange(labyrinthMap, playerStartPosition))
            {
                throw new ArgumentOutOfRangeException(
                    "Player position should be within the labyrinth range.");
            }
        }
Ejemplo n.º 14
0
        //The method works with integer positions instead of PlayerPosition object in order
        //to prevent stack overflow in case of big labyrinth maps
        private static bool LabyrintExitExists(int[,] labyrinthMap,
			int playerPositionRow, int playerPositionColumn)
        {
            PlayerPosition playerPosition =
                new PlayerPosition(playerPositionRow, playerPositionColumn);
            bool isPlayerPositionInLabyrinthRange =
                IsPlayerPositionInLabyrinthRange(labyrinthMap, playerPosition);
            bool isLabyrinthCellFree = labyrinthMap[playerPositionColumn, playerPositionRow] == 0;

            if (!isPlayerPositionInLabyrinthRange || !isLabyrinthCellFree)
            {
                bool labyrintExitExists = false;
                return labyrintExitExists;
            }
            else
            {
                bool isPlayerPositionAtLabyrinthBorder =
                    IsPlayerPositionAtLabyrintBorder(labyrinthMap, playerPosition);
                if (isPlayerPositionAtLabyrinthBorder)
                {
                    BlockVisitedLabyrinthCell(labyrinthMap, playerPositionColumn, playerPositionRow);
                    bool labyrintExitExists = true;
                    return labyrintExitExists;
                }
                else
                {
                    BlockVisitedLabyrinthCell(labyrinthMap, playerPositionColumn, playerPositionRow);
                    bool labyrintExitExistsInLeft = LabyrintExitExists(
                        labyrinthMap, playerPositionRow - 1, playerPositionColumn);
                    bool labyrintExitExistsInRight = LabyrintExitExists(
                        labyrinthMap, playerPositionRow + 1, playerPositionColumn);
                    bool labyrintExitExistsInUp = LabyrintExitExists(
                        labyrinthMap, playerPositionRow, playerPositionColumn - 1);
                    bool labyrintExitExistsInDown = LabyrintExitExists(
                        labyrinthMap, playerPositionRow, playerPositionColumn + 1);
                    bool labyrintExitExists = labyrintExitExistsInLeft ||
                                              labyrintExitExistsInRight ||
                                              labyrintExitExistsInUp ||
                                              labyrintExitExistsInDown;
                    return labyrintExitExists;
                }
            }
        }
Ejemplo n.º 15
0
 /// <summary>
 ///Plays the game using the user's commands 
 /// </summary>
 public void Play()
 {
     do
     {
         PlayerPosition playerPreviousPosition = new PlayerPosition(
             this.playerCurrentPosition.Row, this.playerCurrentPosition.Column);
         string enterMoveMessage = this.resourcesList.GetResourceValue("EnterMoveMessage");
         Console.Write(enterMoveMessage);
         string userInput = Console.ReadLine();
         try
         {
             UserCommand userCommand = this.ParseUserCommand(userInput);
             this.ExecuteUserCommand(userCommand);
         }
         catch (InvalidCommandException)
         {
             this.PrintInvalidCommandMessage();
             continue;
         }
         if (this.IsPlayerPositionChanged(playerPreviousPosition))
         {
             this.UpdateLabyrinthAfterMovement();
         }
     }
     while (this.isGameActive);
 }
Ejemplo n.º 16
0
 public void TestIsPlayerPositionInLabyrinthRange_PlayerPositionAtTopBorder_ReturnsTrue()
 {
     int[,] labyrinthMap = new int[,]
     {
         { 0, 0, 0 },
         { 0, 0, 0 },
         { 0, 0, 0 },
     };
     PlayerPosition playerStartPosition = new PlayerPosition(1, 0);
     bool isPlayerPositionInRange = GameUtilities.IsPlayerPositionInLabyrinthRange(labyrinthMap, playerStartPosition);
     Assert.IsTrue(isPlayerPositionInRange);
 }
Ejemplo n.º 17
0
 private void MoveUp()
 {
     PlayerPosition playerNextPosition = new PlayerPosition(0, 0);
     this.playerCurrentPosition.CopyTo(playerNextPosition);
     playerNextPosition.MoveUp();
     if (this.IsValidMovement(playerNextPosition))
     {
         this.playerCurrentPosition.MoveUp();
     }
     else
     {
         throw new InvalidCommandException("Invalid movement");
     }
 }
Ejemplo n.º 18
0
 private bool IsValidMovement(PlayerPosition playerNextPosition)
 {
     bool isPlayerPositionInRange =
         GameUtilities.IsPlayerPositionInLabyrinthRange(
             this.labyrinthMap, playerNextPosition);
     bool isValidMove = (isPlayerPositionInRange &&
                         this.labyrinthMap[playerNextPosition.Row,
                             playerNextPosition.Column] == 0);
     return isValidMove;
 }
Ejemplo n.º 19
0
 public void TestIsPlayerPositionInLabyrinthRange_PlayerPositionOutRange_ReturnsFalse()
 {
     int[,] labyrinthMap = new int[,]
     {
         { 0, 0, 0 },
         { 0, 0, 0 },
         { 0, 0, 0 },
     };
     PlayerPosition playerStartPosition = new PlayerPosition(3, 3);
     bool isPlayerPositionInRange = GameUtilities.IsPlayerPositionInLabyrinthRange(labyrinthMap, playerStartPosition);
     Assert.IsFalse(isPlayerPositionInRange);
 }