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); } }
/// <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(); }
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); }
/// <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; }
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(); } }
/// <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; }
/// <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)); }