예제 #1
0
        public void CalculateNeighbourCoordinates_ForCentralPoint_ReturnsCorrectCoordinates()
        {
            var expected = new List <int[]>
            {
                new int[2] {
                    3, 3
                },
                new int[2] {
                    3, 2
                },
                new int[2] {
                    3, 1
                },
                new int[2] {
                    2, 3
                },
                new int[2] {
                    2, 1
                },
                new int[2] {
                    1, 3
                },
                new int[2] {
                    1, 2
                },
                new int[2] {
                    1, 1
                }
            };

            var actual = GridPointHelper.CalculateNeighbourCoordinates(2, 2, 5, 5);

            Assert.Equal(8, actual.Count);
            Assert.True(actual.IsDeepEqual(expected));
        }
예제 #2
0
        public void CalculateNeighbourCoordinates_ForHorizontalEdge_ReturnsCorrectCoordinates()
        {
            var expected = new List <int[]>
            {
                new int[2] {
                    3, 1
                },
                new int[2] {
                    3, 0
                },
                new int[2] {
                    2, 1
                },
                new int[2] {
                    1, 1
                },
                new int[2] {
                    1, 0
                }
            };

            var actual = GridPointHelper.CalculateNeighbourCoordinates(2, 0, 5, 5);

            Assert.Equal(5, actual.Count);
            Assert.True(actual.IsDeepEqual(expected));
        }
예제 #3
0
        public void CalculateNeighbourCoordinates_ForVerticalEdge_ReturnsCorrectCoordinates()
        {
            var expected = new List <int[]>
            {
                new int[2] {
                    1, 3
                },
                new int[2] {
                    1, 2
                },
                new int[2] {
                    1, 1
                },
                new int[2] {
                    0, 3
                },
                new int[2] {
                    0, 1
                }
            };

            var actual = GridPointHelper.CalculateNeighbourCoordinates(0, 2, 5, 5);

            Assert.Equal(5, actual.Count);
            Assert.True(actual.IsDeepEqual(expected));
        }
예제 #4
0
        public void GridPoint_SetDisplayCharacter_SetsCorrectCharacter(bool hidden, bool isMine, int adjacentMines, string displayed)
        {
            var point = new GridPoint
            {
                IsHidden          = hidden,
                IsMine            = isMine,
                AdjacentMineCount = adjacentMines,
            };

            GridPointHelper.SetDisplayCharacter(point);

            Assert.Equal(displayed, point.DisplayCharacter);
        }
예제 #5
0
        public static GridPoint[,] CreateNewBoard(int width, int height, int minesToPlace)
        {
            GridPoint[,] board = new GridPoint[width, height];
            board.AddGridPointsToBoard();
            board.AddMinesToBoard(minesToPlace);
            board.CalculateAdjacentMineCount();

            foreach (var point in board)
            {
                GridPointHelper.SetDisplayCharacter(point);
            }

            return(board);
        }