public void Create_MapCreatedWithRandomRoomsMapCreationStrategy_ExpectedMap()
        {
            int     expectedWidth  = 17;
            int     expectedHeight = 10;
            IRandom random         = new DotNetRandom(13);
            IMapCreationStrategy <LibtcodMap> mapCreationStrategy = new RandomRoomsMapCreationStrategy <LibtcodMap>(expectedWidth, expectedHeight, 30, 5, 3, random);
            string expectedMapRepresentation = @"#################
                                              #################
                                              ##...#######...##
                                              ##.............##
                                              ###.###....#...##
                                              ###...##.#####.##
                                              ###...##...###..#
                                              ####............#
                                              ##############..#
                                              #################";

            IMap actualMap = LibtcodMap.Create(mapCreationStrategy);

            Trace.Write(actualMap);

            Assert.AreEqual(expectedWidth, actualMap.Width);
            Assert.AreEqual(expectedHeight, actualMap.Height);
            Assert.AreEqual(expectedMapRepresentation.Replace(" ", string.Empty), actualMap.ToString());
        }
        public void Create_MapCreatedWithWidth40Height20BorderOnlyStrategy_ExpectedMap()
        {
            int expectedWidth  = 40;
            int expectedHeight = 20;
            IMapCreationStrategy <LibtcodMap> mapCreationStrategy = new BorderOnlyMapCreationStrategy <LibtcodMap>(expectedWidth, expectedHeight);

            IMap map = LibtcodMap.Create(mapCreationStrategy);

            Trace.Write(map);

            Assert.AreEqual(expectedWidth, map.Width);
            Assert.AreEqual(expectedHeight, map.Height);

            for (int x = 0; x < map.Width; x++)
            {
                Assert.IsFalse(map.IsTransparent(x, 0));
                Assert.IsFalse(map.IsWalkable(x, 0));
                Assert.IsFalse(map.IsTransparent(x, map.Height - 1));
                Assert.IsFalse(map.IsWalkable(x, map.Height - 1));
            }

            for (int y = 0; y < map.Height; y++)
            {
                Assert.IsFalse(map.IsTransparent(0, y));
                Assert.IsFalse(map.IsWalkable(0, y));
                Assert.IsFalse(map.IsTransparent(map.Width - 1, y));
                Assert.IsFalse(map.IsWalkable(map.Width - 1, y));
            }
        }
        public void ComputeFov_X6Y1CellRadius20_ExpectedFovMap()
        {
            string mapRepresentation = @"####################################
                                      #..................................#
                                      #..###.########....................#
                                      #....#.#......#....................#
                                      #....#.#......#....................#
                                      #.............#....................#
                                      #....#.#......######################
                                      #....#.#...........................#
                                      #....#.#...........................#
                                      #..................................#
                                      ####################################";
            IMapCreationStrategy <LibtcodMap> mapCreationStrategy = new StringDeserializeMapCreationStrategy <LibtcodMap>(mapRepresentation);
            IMap map = LibtcodMap.Create(mapCreationStrategy);

            map.ComputeFov(6, 1, 20, true);

            string expectedFovMap = @"###########################%%%%%%%%%
                                   #..........................%%%%%%%%%
                                   #..###.########%%.........%%%%%%%%%%
                                   #%%%%#.#%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                   %%%%%#.#%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                   %%%%%%.%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                   %%%%%#.#%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                   %%%%%#.#%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                   %%%%%#.#%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                   %%%%%%.%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                   %%%%%###%%%%%%%%%%%%%%%%%%%%%%%%%%%%";

            Assert.AreEqual(expectedFovMap.Replace(" ", string.Empty), map.ToString(true));
        }
        public void Create_StringDeserializeMapCreationStrategy_ExpectedMap()
        {
            string expectedMapRepresentation = @"####
                                              #..#
                                              #so#
                                              ####";

            IMapCreationStrategy <LibtcodMap> mapCreationStrategy = new StringDeserializeMapCreationStrategy <LibtcodMap>(expectedMapRepresentation);
            IMap actualMap = LibtcodMap.Create(mapCreationStrategy);

            Assert.AreEqual(expectedMapRepresentation.Replace(" ", string.Empty), actualMap.ToString());
        }
        public void Clone_SmallMap_MapAndCloneHaveDifferentReferencesButSameValues()
        {
            string mapRepresentation = @"####
                                      #..#
                                      #so#
                                      ####";
            IMapCreationStrategy <LibtcodMap> mapCreationStrategy = new StringDeserializeMapCreationStrategy <LibtcodMap>(mapRepresentation);
            IMap originalMap = LibtcodMap.Create(mapCreationStrategy);

            IMap clonedMap = originalMap.Clone();

            Assert.AreNotEqual(originalMap, clonedMap);
            Assert.AreEqual(originalMap.ToString(), clonedMap.ToString());
        }
        public void GetCellsAlongLine_ThirdRowRightToLeft_ExpectedCells()
        {
            string mapRepresentation = @"####
                                      #..#
                                      #so#
                                      ####";
            IMapCreationStrategy <LibtcodMap> mapCreationStrategy = new StringDeserializeMapCreationStrategy <LibtcodMap>(mapRepresentation);
            IMap   map          = LibtcodMap.Create(mapCreationStrategy);
            string expectedPath = "#os#";

            StringBuilder actualPath = new StringBuilder();

            foreach (Cell cell in map.GetCellsAlongLine(3, 2, 0, 2))
            {
                actualPath.Append(cell.ToString());
            }

            Assert.AreEqual(expectedPath, actualPath.ToString());
        }
        public void Copy_SmallSourceMapIntoSpecificPostionOfDestinationMap_ExpectedDestinationMap()
        {
            string sourceMapRepresentation = @"..";
            IMapCreationStrategy <LibtcodMap> sourceMapCreationStrategy = new StringDeserializeMapCreationStrategy <LibtcodMap>(sourceMapRepresentation);
            IMap   sourceMap = LibtcodMap.Create(sourceMapCreationStrategy);
            string destinationMapRepresentation = @"####
                                                 #..#
                                                 #so#
                                                 ####";
            IMapCreationStrategy <LibtcodMap> destinationMapCreationStrategy = new StringDeserializeMapCreationStrategy <LibtcodMap>(destinationMapRepresentation);
            IMap   destinationMap = LibtcodMap.Create(destinationMapCreationStrategy);
            string expectedRepresentationAfterCopy = @"####
                                                    #..#
                                                    #..#
                                                    ####";

            destinationMap.Copy(sourceMap, 1, 2);

            Assert.AreEqual(expectedRepresentationAfterCopy.Replace(" ", string.Empty), destinationMap.ToString());
        }
        //[TestMethod]
        public void ComputeFovTest()
        {
            string mapRepresentation = @"####################################
                                      #..................................#
                                      #..###.########....................#
                                      #....#.#......#....................#
                                      #....#.#......#....................#
                                      #.............#....................#
                                      #....#.#......######################
                                      #....#.#...........................#
                                      #....#.#...........................#
                                      #..................................#
                                      ####################################";
            IMapCreationStrategy <LibtcodMap> mapCreationStrategy1 = new StringDeserializeMapCreationStrategy <LibtcodMap>(mapRepresentation);
            IMap   libtcodMap = LibtcodMap.Create(mapCreationStrategy1);
            double libtcodTime;

            libtcodTime = StopwatchHelper.AverageTime(() => libtcodMap.ComputeFov(6, 1, 20, true), 100);

            long libtcodElapsed;

            libtcodElapsed = StopwatchHelper.ElapsedTime(() => libtcodMap.ComputeFov(6, 1, 20, true), 100);

            Debug.WriteLine(string.Format("Libtcod Average: {0} Elapsed: {1}", libtcodTime, libtcodElapsed));

            IMapCreationStrategy <Map> mapCreationStrategy2 = new StringDeserializeMapCreationStrategy <Map>(mapRepresentation);
            IMap   map = Map.Create(mapCreationStrategy2);
            double rogueSharpTime;

            rogueSharpTime = StopwatchHelper.AverageTime(() => map.ComputeFov(6, 1, 20, true), 100);

            double rogueSharpElapsed;

            rogueSharpElapsed = StopwatchHelper.ElapsedTime(() => map.ComputeFov(6, 1, 20, true), 100);

            Debug.WriteLine(string.Format("RogueSharp Average: {0} Elapsed: {1}", rogueSharpTime, rogueSharpElapsed));

            Assert.IsTrue(rogueSharpElapsed <= libtcodElapsed, string.Format("Elapsed R#: {0} Lib: {1}", rogueSharpElapsed, libtcodElapsed));
            Assert.IsTrue(rogueSharpTime <= libtcodTime, string.Format("Average R#: {0} Lib: {1}", rogueSharpTime, libtcodTime));
        }