public void TestLabyrintConsolePrintWithSecondMatrix()
        {
            char[,] matrixToTest02 = {
               {'X','-','X','X','X','X','X'},
               {'X','-','X','X','X','X','X'},
               {'X','-','X','X','X','X','X'},
               {'X','-','-','-','-','-','X'},
               {'X','X','X','-','X','X','X'},
               {'X','X','X','X','X','X','X'},
               {'X','X','X','X','X','X','X'},
            };

            LabyrinthPlayer player = new LabyrinthPlayer(0, 1);
            LabyrinthMatrix lab = new LabyrinthMatrix(7, 7);
            lab.Matrix = matrixToTest02;
            LabyrinthRenderer renderer = new LabyrinthRenderer(player, lab);

            StringWriter writer = new StringWriter();
            string expected = String.Format(
                "{0}X*XXXXX{0}X-XXXXX{0}X-XXXXX{0}X-----X{0}XXX-XXX{0}XXXXXXX{0}XXXXXXX{0}",
                Environment.NewLine);

            using (writer)
            {
                Console.SetOut(writer);

                renderer.ConsoleDrawLabyrinth();

                string output = writer.ToString();

                Assert.AreEqual(expected, output);
            }
        }
Example #2
0
        /// <summary>
        /// Creates instance of the game engine object.
        /// </summary>
        /// <param name="player">Accepts any instance of IPlayer.</param>
        /// <param name="renderer">Accepts any instance of IRenderer.</param>
        /// <param name="scoreboard">Accepts any instance of IScoreBoardObserver.</param>
        /// <param name="matrix">Accepts instance of the class LabyrinthMatrix.</param>
        private GameEngine(IPlayer player, IRenderer renderer, IScoreBoardObserver scoreboard, LabyrinthMatrix matrix)
        {
            this.context = new Context(scoreboard, renderer, player, matrix);
            this.factory = new CommandFactory(this.context);

            this.Attach(this.context.ScoreboardHandler);
            this.context.StartNewGame();
        }
Example #3
0
        private void Restart()
        {
            Console.WriteLine();
            Console.WriteLine("Welcome to “Labirinth” game. Please try to escape. Use 'top' to view the top scoreboard, 'restart' to start a new game and 'exit' to quit the game.");

            this.matrix = new LabyrinthMatrix();
            moveCount   = 0;
        }
        public void LabyrinthWithExitCountTest()
        {
            LabyrinthMatrix test = new LabyrinthMatrix(7, 7);
            char P = test.PassableBlock;
            char U = test.UnPassableBlock;

            char[,] customMatrix01 = {
               {U,P,U,U,U,U,U},
               {U,P,U,U,U,U,U},
               {U,P,U,U,U,U,U},
               {U,P,P,P,P,U,U},
               {U,U,U,U,P,U,U},
               {U,U,U,U,P,U,U},
               {U,U,U,U,P,U,U},
            };

            int exitsCount = test.CountLabyrinthExits(7 / 2, 7 / 2, customMatrix01);
            Assert.AreEqual(2, exitsCount);

            char[,] customMatrix02 =  {
               {U,U,U,U,U,U,U},
               {U,P,P,P,P,P,P},
               {U,P,P,P,P,P,U},
               {U,P,P,P,P,P,U},
               {U,P,P,P,P,P,U},
               {U,P,P,P,P,P,U},
               {U,U,U,U,U,U,U},
            };

            exitsCount = test.CountLabyrinthExits(7 / 2, 7 / 2, customMatrix02);
            Assert.AreEqual(1, exitsCount);

            char[,] customMatrix03 =  {
               {P,U,U,U,U,U,U},
               {P,P,U,P,P,P,U},
               {P,P,P,P,P,P,U},
               {P,P,P,P,P,U,U},
               {P,P,P,P,P,P,U},
               {P,P,P,P,P,P,U},
               {P,U,U,U,U,U,U},
            };

            exitsCount = test.CountLabyrinthExits(7 / 2, 7 / 2, customMatrix03);
            Assert.AreEqual(5, exitsCount);

            char[,] customMatrix04 = {
               {U,U,U,P,U,U,U},
               {U,U,U,P,U,U,U},
               {U,U,U,P,U,U,U},
               {P,P,P,P,P,P,P},
               {U,U,U,P,U,U,U},
               {U,U,U,P,U,U,U},
               {U,U,U,P,U,U,U},
            };

            exitsCount = test.CountLabyrinthExits(7 / 2, 7 / 2, customMatrix04);
            Assert.AreEqual(4, exitsCount);
        }
Example #5
0
        /// <summary>
        /// Creates a thread safety Singleton instance of the GameEngine. 
        /// </summary>
        /// <param name="player">Accepts any instance of IPlayer.</param>
        /// <param name="renderer">Accepts any instance of IRenderer.</param>
        /// <param name="scoreboard">Accepts any instance of IScoreBoardObserver.</param>
        /// <param name="matrix">Accepts instance of the class LabyrinthMatrix.</param>
        /// <returns>Instance of the GameEngine class.</returns>
        public static GameEngine Instance(IPlayer player, IRenderer renderer, IScoreBoardObserver scoreboard, LabyrinthMatrix matrix)
        {
            if (gameInstance == null)
            {
                lock (syncLock)
                {
                    if (gameInstance == null)
                    {
                        gameInstance = new GameEngine(player, renderer, scoreboard, matrix);
                    }
                }
            }

            return gameInstance;
        }
Example #6
0
 public static void ShowLabyrinth(LabyrinthMatrix labyrinth)
 {
     Console.WriteLine();
     char[][] myMatrix = labyrinth.Matrix;
     for (int i = 0; i < myMatrix.Length; i++)
     {
         for (int j = 0; j < myMatrix[i].Length; j++)
         {
             if (i == labyrinth.MyPostionVertical && j == labyrinth.MyPostionHorizontal)
             {
                 Console.Write("*");
             }
             else
             {
                 Console.Write(myMatrix[j][i]);
             }
         }
         Console.WriteLine();
     }
 }
        public static void ShowLabyrinth(LabyrinthMatrix labyrinth)
        {
            Console.WriteLine();
            char[][] myMatrix = labyrinth.Matrix;
            for (int i = 0; i < myMatrix.Length; i++)
            {
                for (int j = 0; j < myMatrix[i].Length; j++)
                {
                    if (i == labyrinth.MyPostionVertical && j == labyrinth.MyPostionHorizontal)
                    {

                        Console.Write("*");
                    }
                    else
                    {
                        Console.Write(myMatrix[j][i]);
                    }
                }
                Console.WriteLine();
            }
        }
Example #8
0
        /// <summary>
        /// Creates a thread safety Singleton instance of the GameEngine.
        /// </summary>
        /// <param name="player">Accepts any instance of IPlayer.</param>
        /// <param name="renderer">Accepts any instance of IRenderer.</param>
        /// <param name="scoreboard">Accepts any instance of IScoreBoardObserver.</param>
        /// <param name="matrix">Accepts instance of the class LabyrinthMatrix.</param>
        /// <returns>Instance of the GameEngine class.</returns>
        public static GameEngine Instance(IPlayer player, IRenderer renderer, IScoreBoardObserver scoreboard, LabyrinthMatrix matrix)
        {
            if (gameInstance == null)
            {
                lock (syncLock)
                {
                    if (gameInstance == null)
                    {
                        gameInstance = new GameEngine(player, renderer, scoreboard, matrix);
                    }
                }
            }

            return(gameInstance);
        }
        private void Restart()
        {
            Console.WriteLine();
            Console.WriteLine("Welcome to “Labirinth” game. Please try to escape. Use 'top' to view the top scoreboard, 'restart' to start a new game and 'exit' to quit the game.");

            this.matrix = new LabyrinthMatrix();
            moveCount = 0;
        }
Example #10
0
        /// <summary>
        /// Creates instance of the game engine object.
        /// </summary>
        /// <param name="player">Accepts any instance of IPlayer.</param>
        /// <param name="renderer">Accepts any instance of IRenderer.</param>
        /// <param name="scoreboard">Accepts any instance of IScoreBoardObserver.</param>
        /// <param name="matrix">Accepts instance of the class LabyrinthMatrix.</param>
        private GameEngine(IPlayer player, IRenderer renderer, IScoreBoardObserver scoreboard, LabyrinthMatrix matrix)
        {
            this.context = new Context(scoreboard, renderer, player, matrix);
            this.factory = new CommandFactory(this.context);

            this.Attach(this.context.ScoreboardHandler);
            this.context.StartNewGame();
        }
 public LabyrinthMatrix(LabyrinthMatrix l)
 {
 }
        public void TestGenerateLabyrinthMatrix()
        {
            int matrixSize = 4;
            LabyrinthMatrix labyrinthMatrix = new LabyrinthMatrix(matrixSize, matrixSize);
            int numberOfGeneratedMatrix = 1000;
            if (numberOfGeneratedMatrix < 1000)
            {
                throw new Exception("The variable numberOfGeneratedMatrix must be minimum 1000");
            }

            // create matrix to count blocks type in the matrix
            int[,] passableBlocksCountMatrix = new int[matrixSize, matrixSize];
            int[,] unpassableBlocksCountMatrix = new int[matrixSize, matrixSize];
            passableBlocksCountMatrix = GenerateCounterMatrix(passableBlocksCountMatrix);
            unpassableBlocksCountMatrix = passableBlocksCountMatrix.Clone() as int[,];

            //generate N random matrix and infill the twoo counter matrices (passableBlocksCountMatrix and unpassableBlocksCountMatrix)
            for (int i = 0; i < numberOfGeneratedMatrix; i++)
            {
                labyrinthMatrix.GenerateLabyrinthMatrix();
                for (int col = 0; col < matrixSize; col++)
                {
                    for (int row = 0; row < matrixSize; row++)
                    {
                        if (labyrinthMatrix.Matrix[col, row] == '-')
                        {
                            passableBlocksCountMatrix[col, row]++;
                        }
                        else if (labyrinthMatrix.Matrix[col, row] == 'X')
                        {
                            unpassableBlocksCountMatrix[col, row]++;
                        }
                    }
                }
            }

            // test for count of random elements by two counter matrix
            bool isRandom = true;
            int propabilityOfCountOfBlocks = (int)(numberOfGeneratedMatrix * 0.40);
            int playerCoordinate = matrixSize / 2;
            for (int col = 0; col < matrixSize; col++)
            {
                for (int row = 0; row < matrixSize; row++)
                {
                    if (col == playerCoordinate && row == playerCoordinate)
                    {
                        continue;
                    }
                    if (passableBlocksCountMatrix[col, row] < propabilityOfCountOfBlocks ||
                        unpassableBlocksCountMatrix[col, row] < propabilityOfCountOfBlocks)
                    {
                        isRandom = false;
                    }
                }
            }
            Assert.IsTrue(isRandom);
        }
        private void Start(int maxRows,int maxCols)
        {
            this.player = new LabyrinthPlayer(maxRows/2, maxCols/2);
            this.labyrinth = new LabyrinthMatrix(maxRows, maxCols);
            this.labyrinth.GenerateLabyrinthMatrix();
            this.renderer = new LabyrinthRenderer(this.player, this.labyrinth);

            while (true)
            {
                // Old - DrawLabyrinth()
                this.renderer.ConsoleDrawLabyrinth();

                if (IsFinished())
                {
                    break;
                }

                PlayerControl();
            }

            Console.Clear();
        }
 public void Restart()
 {
     this.renderer.ShowMessage(Messenger.WelcomeMessage);
     this.matrix = new LabyrinthMatrix();
     this.player.Score = 0;
     this.player.PositionCol = StartPositionHorizontal;
     this.player.PositionRow = StartPositionVertical;
 }
 public LabyrinthMatrix(LabyrinthMatrix l)
 {
 }
        public void TestIsOutsideMatrix()
        {
            int matrixSize = 3;
            LabyrinthMatrix labyrinthMatrix = new LabyrinthMatrix(matrixSize, matrixSize);

            //testing inside of the matrix
            for (int row = 1; row < labyrinthMatrix.Matrix.GetLength(0) - 1; row++)
            {
                for (int col = 1; col < labyrinthMatrix.Matrix.GetLength(1) - 1; col++)
                {
                    Assert.IsFalse(labyrinthMatrix.IsOutsideMatrix(row, col),
                                    String.Format("Row: {0}; Col: {1}", col, col)
                                    );
                }
            }

            //testing outside of the matrix - horizontaly boundary
            int lastRow = labyrinthMatrix.Matrix.GetLength(0) - 1;
            for (int row = 0; row < labyrinthMatrix.Matrix.GetLength(0); row += lastRow)
            {
                for (int col = 0; col < labyrinthMatrix.Matrix.GetLength(1); col++)
                {
                    Assert.IsTrue(labyrinthMatrix.IsOutsideMatrix(row, col),
                                    String.Format("Row: {0}; Col: {1}", col, col)
                                    );
                }
            }

            //testing outside of the matrix - verticaly boundary
            int lastCol = labyrinthMatrix.Matrix.GetLength(1) - 1;
            for (int col = 0; col < labyrinthMatrix.Matrix.GetLength(1); col += lastCol)
            {
                for (int row = 0; row < labyrinthMatrix.Matrix.GetLength(1); row++)
                {
                    Assert.IsTrue(labyrinthMatrix.IsOutsideMatrix(row, col),
                                    String.Format("Row: {0}; Col: {1}", col, col)
                                    );
                }
            }
        }
        public void TestIsPassableWithUnpassableBlocks()
        {
            int matrixSize = 3;
            LabyrinthMatrix labyrinthMatrix = new LabyrinthMatrix(matrixSize, matrixSize);
            char blockBody = 'X';
            labyrinthMatrix = GenerateLabyrinthMatrix(labyrinthMatrix, blockBody);

            Assert.IsFalse(labyrinthMatrix.IsPassable(0, 1)); //go to up
            Assert.IsFalse(labyrinthMatrix.IsPassable(1, 2)); //go to right
            Assert.IsFalse(labyrinthMatrix.IsPassable(2, 1)); //go to down
            Assert.IsFalse(labyrinthMatrix.IsPassable(1, 0)); //go to left
        }
 private LabyrinthMatrix GenerateLabyrinthMatrix(LabyrinthMatrix matrix, char blockBody)
 {
     LabyrinthMatrix labyrinthMatrix = matrix;
     for (int row = 0; row < labyrinthMatrix.Matrix.GetLength(0); row++)
     {
         for (int col = 0; col < labyrinthMatrix.Matrix.GetLength(1); col++)
         {
             labyrinthMatrix.Matrix[row, col] = blockBody;
         }
     }
     return labyrinthMatrix;
 }
        public void TestLabyrinthMatrixConstructor()
        {
            int matrixSize = 3;
            LabyrinthMatrix labyrinthMatrix = new LabyrinthMatrix(matrixSize, matrixSize);

            Assert.AreEqual(matrixSize, labyrinthMatrix.Matrix.GetLength(0));
            Assert.AreEqual(matrixSize, labyrinthMatrix.Matrix.GetLength(1));
        }